Home | History | Annotate | Line # | Download | only in dev
kloader.c revision 1.25 
      1 /*	$NetBSD: kloader.c,v 1.25 2010/11/19 09:08:26 dholland Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2001, 2002, 2004 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  *
     16  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     17  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     18  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     19  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     20  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     26  * POSSIBILITY OF SUCH DAMAGE.
     27  */
     28 
     29 #include <sys/cdefs.h>
     30 __KERNEL_RCSID(0, "$NetBSD: kloader.c,v 1.25 2010/11/19 09:08:26 dholland Exp $");
     31 
     32 #include "debug_kloader.h"
     33 
     34 #include <sys/param.h>
     35 #include <sys/systm.h>
     36 #include <sys/malloc.h>
     37 #include <sys/proc.h>
     38 #include <sys/vnode.h>
     39 #include <sys/namei.h>
     40 #include <sys/fcntl.h>
     41 #define	ELFSIZE	32
     42 #include <sys/exec_elf.h>
     43 
     44 #include <uvm/uvm.h>
     45 
     46 #include <machine/kloader.h>
     47 
     48 #define	PRINTF(fmt, args...)	printf("kloader: " fmt, ##args)
     49 
     50 #ifdef KLOADER_DEBUG
     51 int	kloader_debug = 1;
     52 #define	DPRINTF(fmt, args...)						\
     53 	if (kloader_debug)						\
     54 		printf("%s: " fmt, __func__ , ##args)
     55 #define	_DPRINTF(fmt, args...)						\
     56 	if (kloader_debug)						\
     57 		printf(fmt, ##args)
     58 #define	DPRINTFN(n, fmt, args...)					\
     59 	if (kloader_debug > (n))					\
     60 		printf("%s: " fmt, __func__ , ##args)
     61 #define	_DPRINTFN(n, fmt, args...)					\
     62 	if (kloader_debug > (n))					\
     63 		printf(fmt, ##args)
     64 #define	STATIC
     65 #else
     66 #define	DPRINTF(fmt, args...)		((void)0)
     67 #define	_DPRINTF(fmt, args...)		((void)0)
     68 #define	DPRINTFN(n, fmt, args...)	((void)0)
     69 #define	_DPRINTFN(n, fmt, args...)	((void)0)
     70 #define	STATIC	static
     71 #endif
     72 
     73 struct kloader {
     74 	struct pglist pg_head;
     75 	struct vm_page *cur_pg;		/* XXX use bus_dma(9) */
     76 	struct kloader_page_tag *cur_tag;
     77 	struct vnode *vp;
     78 	struct kloader_page_tag *tagstart;
     79 	struct kloader_bootinfo *bootinfo;
     80 	struct kloader_bootinfo *rebootinfo;
     81 	vaddr_t loader_sp;
     82 	kloader_bootfunc_t *loader;
     83 	int setuped;
     84 	int called;
     85 	struct kloader_ops *ops;
     86 };
     87 
     88 #define	BUCKET_SIZE	(PAGE_SIZE - sizeof(struct kloader_page_tag))
     89 #define	KLOADER_LWP	(&lwp0)
     90 STATIC struct kloader kloader;
     91 
     92 #define	ROUND4(x)	(((x) + 3) & ~3)
     93 
     94 STATIC int kloader_load(void);
     95 
     96 STATIC int kloader_alloc_memory(size_t);
     97 STATIC struct kloader_page_tag *kloader_get_tag(vaddr_t);
     98 STATIC void kloader_from_file(vaddr_t, off_t, size_t);
     99 STATIC void kloader_copy(vaddr_t, const void *, size_t);
    100 STATIC void kloader_zero(vaddr_t, size_t);
    101 
    102 STATIC void kloader_load_segment(Elf_Phdr *);
    103 
    104 STATIC struct vnode *kloader_open(const char *);
    105 STATIC void kloader_close(void);
    106 STATIC int kloader_read(size_t, size_t, void *);
    107 
    108 #ifdef KLOADER_DEBUG
    109 STATIC void kloader_pagetag_dump(void);
    110 #endif
    111 
    112 void
    113 __kloader_reboot_setup(struct kloader_ops *ops, const char *filename)
    114 {
    115 
    116 	if (kloader.bootinfo == NULL) {
    117 		PRINTF("No bootinfo.\n");
    118 		return;
    119 	}
    120 
    121 	if (ops == NULL || ops->jump == NULL || ops->boot == NULL) {
    122 		PRINTF("No boot operations.\n");
    123 		return;
    124 	}
    125 	kloader.ops = ops;
    126 
    127 	if (kloader.called++ == 0) {
    128 		PRINTF("kernel file name: %s\n", filename);
    129 		kloader.vp = kloader_open(filename);
    130 		if (kloader.vp == NULL)
    131 			return;
    132 
    133 		if (kloader_load() == 0) {
    134 			kloader.setuped = TRUE;
    135 #ifdef KLOADER_DEBUG
    136 			kloader_pagetag_dump();
    137 #endif
    138 		}
    139 		kloader_close();
    140 	} else {
    141 		/* Fatal case. reboot from DDB etc. */
    142 		kloader_reboot();
    143 	}
    144 }
    145 
    146 
    147 void
    148 kloader_reboot(void)
    149 {
    150 
    151 	if (kloader.setuped) {
    152 		PRINTF("Rebooting...\n");
    153 		(*kloader.ops->jump)(kloader.loader, kloader.loader_sp,
    154 		    kloader.rebootinfo, kloader.tagstart);
    155 	}
    156 
    157 	if (kloader.ops->reset != NULL) {
    158 		PRINTF("Resetting...\n");
    159 		(*kloader.ops->reset)();
    160 	}
    161 	while (/*CONSTCOND*/1)
    162 		continue;
    163 	/* NOTREACHED */
    164 }
    165 
    166 
    167 int
    168 kloader_load(void)
    169 {
    170 	Elf_Ehdr eh;
    171 	Elf_Phdr *ph, *p;
    172 	Elf_Shdr *sh;
    173 	Elf_Addr entry;
    174 	vaddr_t kv;
    175 	size_t sz;
    176 	size_t shstrsz;
    177 	char *shstrtab;
    178 	int symndx, strndx;
    179 	size_t ksymsz;
    180 	struct kloader_bootinfo nbi; /* new boot info */
    181 	char *oldbuf, *newbuf;
    182 	char **ap;
    183 	int i;
    184 
    185 	ph = NULL;
    186 	sh = NULL;
    187 	shstrtab = NULL;
    188 
    189 	/* read kernel's ELF header */
    190 	kloader_read(0, sizeof(Elf_Ehdr), &eh);
    191 
    192 	if (eh.e_ident[EI_MAG0] != ELFMAG0 ||
    193 	    eh.e_ident[EI_MAG1] != ELFMAG1 ||
    194 	    eh.e_ident[EI_MAG2] != ELFMAG2 ||
    195 	    eh.e_ident[EI_MAG3] != ELFMAG3) {
    196 		PRINTF("not an ELF file\n");
    197 		goto err;
    198 	}
    199 
    200 	/* read program headers */
    201 	sz = eh.e_phentsize * eh.e_phnum;
    202 	if ((ph = malloc(sz, M_TEMP, M_NOWAIT)) == NULL) {
    203 		PRINTF("can't allocate program header table.\n");
    204 		goto err;
    205 	}
    206 	if (kloader_read(eh.e_phoff, sz, ph) != 0) {
    207 		PRINTF("program header read error.\n");
    208 		goto err;
    209 	}
    210 
    211 	/* read section headers */
    212 	sz = eh.e_shentsize * eh.e_shnum;
    213 	if ((sh = malloc(sz, M_TEMP, M_NOWAIT)) == NULL) {
    214 		PRINTF("can't allocate section header table.\n");
    215 		goto err;
    216 	}
    217 	if (kloader_read(eh.e_shoff, eh.e_shentsize * eh.e_shnum, sh) != 0) {
    218 		PRINTF("section header read error.\n");
    219 		goto err;
    220 	}
    221 
    222 	/* read section names */
    223 	shstrsz = ROUND4(sh[eh.e_shstrndx].sh_size);
    224 	shstrtab = malloc(shstrsz, M_TEMP, M_NOWAIT);
    225 	if (shstrtab == NULL) {
    226 		PRINTF("unable to allocate memory for .shstrtab\n");
    227 		goto err;
    228 	}
    229 	DPRINTF("reading 0x%x bytes of .shstrtab at 0x%x\n",
    230 	    sh[eh.e_shstrndx].sh_size, sh[eh.e_shstrndx].sh_offset);
    231 	kloader_read(sh[eh.e_shstrndx].sh_offset, sh[eh.e_shstrndx].sh_size,
    232 	    shstrtab);
    233 
    234 	/* save entry point, code to construct symbol table overwrites it */
    235 	entry = eh.e_entry;
    236 
    237 	/*
    238 	 * Calculate memory size
    239 	 */
    240 	sz = 0;
    241 
    242 	/* loadable segments */
    243 	for (i = 0; i < eh.e_phnum; i++) {
    244 		if (ph[i].p_type == PT_LOAD) {
    245 			DPRINTF("segment %d size = file 0x%x memory 0x%x\n",
    246 			    i, ph[i].p_filesz, ph[i].p_memsz);
    247 #ifdef KLOADER_ZERO_BSS
    248 			sz += round_page(ph[i].p_memsz);
    249 #else
    250 			sz += round_page(ph[i].p_filesz);
    251 #endif
    252 			sz += PAGE_SIZE; /* compensate for partial last tag */
    253 		}
    254 	}
    255 
    256 	if (sz == 0)		/* nothing to load? */
    257 		goto err;
    258 
    259 	/* symbols/strings sections */
    260 	symndx = strndx = -1;
    261 	for (i = 0; i < eh.e_shnum; i++) {
    262 		if (strcmp(shstrtab + sh[i].sh_name, ".symtab") == 0)
    263 			symndx = i;
    264 		else if (strcmp(shstrtab + sh[i].sh_name, ".strtab") == 0)
    265 			strndx = i;
    266 		else if (i != eh.e_shstrndx)
    267 			/* while here, mark all other sections as unused */
    268 			sh[i].sh_type = SHT_NULL;
    269 	}
    270 
    271 	if (symndx < 0 || strndx < 0) {
    272 		if (symndx < 0)
    273 			PRINTF("no .symtab section\n");
    274 		if (strndx < 0)
    275 			PRINTF("no .strtab section\n");
    276 		ksymsz = SELFMAG; /* just a bad magic */
    277 	} else {
    278 		ksymsz = sizeof(Elf_Ehdr)
    279 		    + eh.e_shentsize * eh.e_shnum
    280 		    + shstrsz		/* rounded to 4 bytes */
    281 		    + sh[symndx].sh_size
    282 		    + sh[strndx].sh_size;
    283 		DPRINTF("ksyms size = 0x%zx\n", ksymsz);
    284 	}
    285 	sz += ROUND4(ksymsz);
    286 
    287 	/* boot info for the new kernel */
    288 	sz += sizeof(struct kloader_bootinfo);
    289 
    290 	/* get memory for new kernel */
    291 	if (kloader_alloc_memory(sz) != 0)
    292 		goto err;
    293 
    294 	/*
    295 	 * Copy new kernel in.
    296 	 */
    297 	kv = 0;			/* XXX: -Wuninitialized */
    298 	for (i = 0, p = ph; i < eh.e_phnum; i++, p++) {
    299 		if (p->p_type == PT_LOAD) {
    300 			kloader_load_segment(p);
    301 			kv = p->p_vaddr + ROUND4(p->p_memsz);
    302 		}
    303 	}
    304 
    305 	/*
    306 	 * Construct symbol table for ksyms.
    307 	 */
    308 	if (symndx < 0 || strndx < 0) {
    309 		kloader_zero(kv, SELFMAG);
    310 		kv += SELFMAG;
    311 	} else {
    312 		Elf_Off eoff;
    313 		off_t symoff, stroff;
    314 
    315 		/* save offsets of .symtab and .strtab before we change them */
    316 		symoff = sh[symndx].sh_offset;
    317 		stroff = sh[strndx].sh_offset;
    318 
    319 		/* no loadable segments */
    320 		eh.e_entry = 0;
    321 		eh.e_phnum = 0;
    322 		eh.e_phoff = 0;
    323 
    324 		/* change offsets to reflect new layout */
    325 		eoff = sizeof(Elf_Ehdr);
    326 		eh.e_shoff = eoff;
    327 
    328 		eoff += eh.e_shentsize * eh.e_shnum;
    329 		sh[eh.e_shstrndx].sh_offset = eoff;
    330 
    331 		eoff += shstrsz;
    332 		sh[symndx].sh_offset = eoff;
    333 
    334 		eoff += sh[symndx].sh_size;
    335 		sh[strndx].sh_offset = eoff;
    336 
    337 		/* local copies massaged, can serve them now */
    338 		DPRINTF("ksyms ELF header\n");
    339 		kloader_copy(kv, &eh, sizeof(Elf_Ehdr));
    340 		kv += sizeof(Elf_Ehdr);
    341 
    342 		DPRINTF("ksyms section headers\n");
    343 		kloader_copy(kv, sh, eh.e_shentsize * eh.e_shnum);
    344 		kv += eh.e_shentsize * eh.e_shnum;
    345 
    346 		DPRINTF("ksyms .shstrtab\n");
    347 		kloader_copy(kv, shstrtab, shstrsz);
    348 		kv += shstrsz;
    349 
    350 		DPRINTF("ksyms .symtab\n");
    351 		kloader_from_file(kv, symoff, sh[symndx].sh_size);
    352 		kv += sh[symndx].sh_size;
    353 
    354 		DPRINTF("ksyms .strtab\n");
    355 		kloader_from_file(kv, stroff, ROUND4(sh[strndx].sh_size));
    356 		kv += ROUND4(sh[strndx].sh_size);
    357 	}
    358 
    359 	/*
    360 	 * Create boot info to pass to the new kernel.
    361 	 * All pointers in it are *not* valid until the new kernel runs!
    362 	 */
    363 
    364 	/* get a private copy of current bootinfo to vivisect */
    365 	memcpy(&nbi, kloader.bootinfo, sizeof(struct kloader_bootinfo));
    366 
    367 	/* new kernel entry point */
    368 	nbi.entry = entry;
    369 
    370 	/* where args currently are, see kloader_bootinfo_set() */
    371 	oldbuf = &kloader.bootinfo->_argbuf[0];
    372 
    373 	/* where args *will* be after boot code copied them */
    374 	newbuf = (char *)(void *)kv
    375 	    + offsetof(struct kloader_bootinfo, _argbuf);
    376 
    377 	DPRINTF("argv: old %p -> new %p\n", oldbuf, newbuf);
    378 
    379 	/* not a valid pointer in this kernel! */
    380 	nbi.argv = (void *)newbuf;
    381 
    382 	/* local copy that we populate with new (not yet valid) pointers */
    383 	ap = (char **)(void *)nbi._argbuf;
    384 
    385 	for (i = 0; i < kloader.bootinfo->argc; ++i) {
    386 		DPRINTFN(1, " [%d]: %p -> ", i, kloader.bootinfo->argv[i]);
    387 		ap[i] = newbuf +
    388 		    (kloader.bootinfo->argv[i] - oldbuf);
    389 		_DPRINTFN(1, "%p\n", ap[i]);
    390 	}
    391 
    392 	/* arrange for the new bootinfo to get copied */
    393 	DPRINTF("bootinfo\n");
    394 	kloader_copy(kv, &nbi, sizeof(struct kloader_bootinfo));
    395 
    396 	/* will be valid by the time the new kernel starts */
    397 	kloader.rebootinfo = (void *)kv;
    398 	/* kv += sizeof(struct kloader_bootinfo); */
    399 
    400 	/*
    401 	 * Copy loader code
    402 	 */
    403 	KDASSERT(kloader.cur_pg);
    404 	kloader.loader = (void *)PG_VADDR(kloader.cur_pg);
    405 	memcpy(kloader.loader, kloader.ops->boot, PAGE_SIZE);
    406 
    407 	/* loader stack starts at the bottom of that page */
    408 	kloader.loader_sp = (vaddr_t)kloader.loader + PAGE_SIZE;
    409 
    410 	DPRINTF("[loader] addr=%p sp=%p [kernel] entry=%p\n",
    411 	    kloader.loader, (void *)kloader.loader_sp, (void *)nbi.entry);
    412 
    413 	return (0);
    414  err:
    415 	if (ph != NULL)
    416 		free(ph, M_TEMP);
    417 	if (sh != NULL)
    418 		free(sh, M_TEMP);
    419 	if (shstrtab != NULL)
    420 		free(shstrtab, M_TEMP);
    421 
    422 	return 1;
    423 }
    424 
    425 
    426 int
    427 kloader_alloc_memory(size_t sz)
    428 {
    429 	extern paddr_t avail_start, avail_end;
    430 	int n, error;
    431 
    432 	n = (sz + BUCKET_SIZE - 1) / BUCKET_SIZE	/* kernel &co */
    433 	    + 1;					/* 2nd loader */
    434 
    435 	error = uvm_pglistalloc(n * PAGE_SIZE, avail_start, avail_end,
    436 	    PAGE_SIZE, 0, &kloader.pg_head, n, 0);
    437 	if (error) {
    438 		PRINTF("can't allocate memory.\n");
    439 		return (1);
    440 	}
    441 	DPRINTF("allocated %d pages.\n", n);
    442 
    443 	kloader.cur_pg = TAILQ_FIRST(&kloader.pg_head);
    444 	kloader.tagstart = (void *)PG_VADDR(kloader.cur_pg);
    445 	kloader.cur_tag = NULL;
    446 
    447 	return (0);
    448 }
    449 
    450 
    451 struct kloader_page_tag *
    452 kloader_get_tag(vaddr_t dst)
    453 {
    454 	struct vm_page *pg;
    455 	vaddr_t addr;
    456 	struct kloader_page_tag *tag;
    457 
    458 	tag = kloader.cur_tag;
    459 	if (tag != NULL		/* has tag */
    460 	    && tag->sz < BUCKET_SIZE /* that has free space */
    461 	    && tag->dst + tag->sz == dst) /* and new data are contiguous */
    462 	{
    463 		DPRINTFN(1, "current tag %x/%x ok\n", tag->dst, tag->sz);
    464 		return (tag);
    465 	}
    466 
    467 	pg = kloader.cur_pg;
    468 	KDASSERT(pg != NULL);
    469 	kloader.cur_pg = TAILQ_NEXT(pg, pageq.queue);
    470 
    471 	addr = PG_VADDR(pg);
    472 	tag = (void *)addr;
    473 
    474 	/*
    475 	 * 2nd loader uses simple word-by-word copy, so destination
    476 	 * address of a tag must be properly aligned.
    477 	 */
    478 	KASSERT(ALIGNED_POINTER(dst, register_t));
    479 
    480 	tag->src = addr + sizeof(struct kloader_page_tag);
    481 	tag->dst = dst;
    482 	tag->sz = 0;
    483 	tag->next = 0;	/* Terminate. this member may overwrite after. */
    484 	if (kloader.cur_tag)
    485 		kloader.cur_tag->next = addr;
    486 	kloader.cur_tag = tag;
    487 
    488 	return (tag);
    489 }
    490 
    491 
    492 /*
    493  * Operations to populate kloader_page_tag's with data.
    494  */
    495 
    496 void
    497 kloader_from_file(vaddr_t dst, off_t ofs, size_t sz)
    498 {
    499 	struct kloader_page_tag *tag;
    500 	size_t freesz;
    501 
    502 	while (sz > 0) {
    503 		tag = kloader_get_tag(dst);
    504 		KDASSERT(tag != NULL);
    505 		freesz = BUCKET_SIZE - tag->sz;
    506 		if (freesz > sz)
    507 			freesz = sz;
    508 
    509 		DPRINTFN(1, "0x%08"PRIxVADDR" + 0x%zx <- 0x%lx\n", dst, freesz,
    510 		    (unsigned long)ofs);
    511 		kloader_read(ofs, freesz, (void *)(tag->src + tag->sz));
    512 
    513 		tag->sz += freesz;
    514 		sz -= freesz;
    515 		ofs += freesz;
    516 		dst += freesz;
    517 	}
    518 }
    519 
    520 
    521 void
    522 kloader_copy(vaddr_t dst, const void *src, size_t sz)
    523 {
    524 	struct kloader_page_tag *tag;
    525 	size_t freesz;
    526 
    527 	while (sz > 0) {
    528 		tag = kloader_get_tag(dst);
    529 		KDASSERT(tag != NULL);
    530 		freesz = BUCKET_SIZE - tag->sz;
    531 		if (freesz > sz)
    532 			freesz = sz;
    533 
    534 		DPRINTFN(1, "0x%08"PRIxVADDR" + 0x%zx <- %p\n", dst, freesz, src);
    535 		memcpy((void *)(tag->src + tag->sz), src, freesz);
    536 
    537 		tag->sz += freesz;
    538 		sz -= freesz;
    539 		src = (const char *)src + freesz;
    540 		dst += freesz;
    541 	}
    542 }
    543 
    544 
    545 void
    546 kloader_zero(vaddr_t dst, size_t sz)
    547 {
    548 	struct kloader_page_tag *tag;
    549 	size_t freesz;
    550 
    551 	while (sz > 0) {
    552 		tag = kloader_get_tag(dst);
    553 		KDASSERT(tag != NULL);
    554 		freesz = BUCKET_SIZE - tag->sz;
    555 		if (freesz > sz)
    556 			freesz = sz;
    557 
    558 		DPRINTFN(1, "0x%08"PRIxVADDR" + 0x%zx\n", dst, freesz);
    559 		memset((void *)(tag->src + tag->sz), 0, freesz);
    560 
    561 		tag->sz += freesz;
    562 		sz -= freesz;
    563 		dst += freesz;
    564 	}
    565 }
    566 
    567 
    568 void
    569 kloader_load_segment(Elf_Phdr *p)
    570 {
    571 
    572 	DPRINTF("memory 0x%08x 0x%x <- file 0x%x 0x%x\n",
    573 	    p->p_vaddr, p->p_memsz, p->p_offset, p->p_filesz);
    574 
    575 	kloader_from_file(p->p_vaddr, p->p_offset, p->p_filesz);
    576 #ifdef KLOADER_ZERO_BSS
    577 	kloader_zero(p->p_vaddr + p->p_filesz, p->p_memsz - p->p_filesz);
    578 #endif
    579 }
    580 
    581 
    582 /*
    583  * file access
    584  */
    585 struct vnode *
    586 kloader_open(const char *filename)
    587 {
    588 	struct pathbuf *pb;
    589 	struct nameidata nid;
    590 	int error;
    591 
    592 	pb = pathbuf_create(filename);
    593 	if (pb == NULL) {
    594 		PRINTF("%s: pathbuf_create failed\n", filename);
    595 		return (NULL);
    596 	}
    597 
    598 	NDINIT(&nid, LOOKUP, FOLLOW, pb);
    599 
    600 	error = namei(&nid);
    601 	if (error != 0) {
    602 		PRINTF("%s: namei failed, errno=%d\n", filename, error);
    603 		pathbuf_destroy(pb);
    604 		return (NULL);
    605 	}
    606 
    607 	error = vn_open(&nid, FREAD, 0);
    608 	if (error != 0) {
    609 		PRINTF("%s: open failed, errno=%d\n", filename, error);
    610 		pathbuf_destroy(pb);
    611 		return (NULL);
    612 	}
    613 
    614 	pathbuf_destroy(pb);
    615 	return (nid.ni_vp);
    616 }
    617 
    618 void
    619 kloader_close(void)
    620 {
    621 	struct lwp *l = KLOADER_LWP;
    622 	struct vnode *vp = kloader.vp;
    623 
    624 	VOP_UNLOCK(vp);
    625 	vn_close(vp, FREAD, l->l_cred);
    626 }
    627 
    628 int
    629 kloader_read(size_t ofs, size_t size, void *buf)
    630 {
    631 	struct lwp *l = KLOADER_LWP;
    632 	struct vnode *vp = kloader.vp;
    633 	size_t resid;
    634 	int error;
    635 
    636 	error = vn_rdwr(UIO_READ, vp, buf, size, ofs, UIO_SYSSPACE,
    637 	    IO_NODELOCKED | IO_SYNC, l->l_cred, &resid, NULL);
    638 
    639 	if (error)
    640 		PRINTF("read error.\n");
    641 
    642 	return (error);
    643 }
    644 
    645 
    646 /*
    647  * bootinfo
    648  */
    649 void
    650 kloader_bootinfo_set(struct kloader_bootinfo *kbi, int argc, char *argv[],
    651     struct bootinfo *bi, int printok)
    652 {
    653 	char *p, *pend, *buf;
    654 	int i;
    655 
    656 	kloader.bootinfo = kbi;
    657 	buf = kbi->_argbuf;
    658 	if (bi != NULL)
    659 		memcpy(&kbi->bootinfo, bi, sizeof(struct bootinfo));
    660 	kbi->argc = argc;
    661 	kbi->argv = (char **)buf;
    662 
    663 	p = &buf[argc * sizeof(char **)];
    664 	pend = &buf[KLOADER_KERNELARGS_MAX - 1];
    665 
    666 	for (i = 0; i < argc; i++) {
    667 		char *q = argv[i];
    668 		int len = strlen(q) + 1;
    669 		if ((p + len) > pend) {
    670 			kloader.bootinfo = NULL;
    671 			if (printok)
    672 				PRINTF("buffer insufficient.\n");
    673 			return;
    674 		}
    675 		kbi->argv[i] = p;
    676 		memcpy(p, q, len);
    677 		p += len;
    678 	}
    679 }
    680 
    681 
    682 #ifdef KLOADER_DEBUG
    683 void
    684 kloader_pagetag_dump(void)
    685 {
    686 	struct kloader_page_tag *tag = kloader.tagstart;
    687 	struct kloader_page_tag *p, *op;
    688 	bool print;
    689 	int i, n;
    690 
    691 	p = tag;
    692 	op = NULL;
    693 	i = 0, n = 15;
    694 
    695 	PRINTF("[page tag chain]\n");
    696 	do  {
    697 		print = FALSE;
    698 		if (i < n)
    699 			print = TRUE;
    700 		if ((uint32_t)p & 3) {
    701 			printf("tag alignment error\n");
    702 			break;
    703 		}
    704 		if ((p->src & 3) || (p->dst & 3)) {
    705 			printf("data alignement error.\n");
    706 			print = TRUE;
    707 		}
    708 
    709 		if (print) {
    710 			printf("[%2d] next 0x%08x src 0x%08x dst 0x%08x"
    711 			    " sz 0x%x\n", i, p->next, p->src, p->dst, p->sz);
    712 		} else if (i == n) {
    713 			printf("[...]\n");
    714 		}
    715 		op = p;
    716 		i++;
    717 	} while ((p = (struct kloader_page_tag *)(p->next)) != 0);
    718 
    719 	if (op != NULL)
    720 		printf("[%d(last)] next 0x%08x src 0x%08x dst 0x%08x sz 0x%x\n",
    721 		    i - 1, op->next, op->src, op->dst, op->sz);
    722 }
    723 
    724 #endif /* KLOADER_DEBUG */
    725