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