FreeBSD/Linux Kernel Cross Reference
sys/dev/kloader.c
1 /* $NetBSD: kloader.c,v 1.2 2004/09/17 14:11:24 skrll 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.2 2004/09/17 14:11:24 skrll 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_PROC (&proc0)
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("Reseting...\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 * Calcurate 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%x\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%x <- 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%x <- %p\n", dst, freesz, src);
546 memcpy((void *)(tag->src + tag->sz), src, freesz);
547
548 tag->sz += freesz;
549 sz -= freesz;
550 src = (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%x\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 proc *p = KLOADER_PROC;
600 struct nameidata nid;
601
602 NDINIT(&nid, LOOKUP, FOLLOW, UIO_SYSSPACE, filename, p);
603
604 if (namei(&nid) != 0) {
605 PRINTF("namei failed (%s)\n", filename);
606 return (0);
607 }
608
609 if (vn_open(&nid, FREAD, 0) != 0) {
610 PRINTF("%s open failed\n", filename);
611 return (0);
612 }
613
614 return (nid.ni_vp);
615 }
616
617 void
618 kloader_close()
619 {
620 struct proc *p = KLOADER_PROC;
621 struct vnode *vp = kloader.vp;
622
623 VOP_UNLOCK(vp, 0);
624 vn_close(vp, FREAD, p->p_ucred, p);
625 }
626
627 int
628 kloader_read(size_t ofs, size_t size, void *buf)
629 {
630 struct proc *p = KLOADER_PROC;
631 struct vnode *vp = kloader.vp;
632 size_t resid;
633 int error;
634
635 error = vn_rdwr(UIO_READ, vp, buf, size, ofs, UIO_SYSSPACE,
636 IO_NODELOCKED | IO_SYNC, p->p_ucred, &resid, NULL);
637
638 if (error)
639 PRINTF("read error.\n");
640
641 return (error);
642 }
643
644
645 /*
646 * bootinfo
647 */
648 void
649 kloader_bootinfo_set(struct kloader_bootinfo *kbi, int argc, char *argv[],
650 struct bootinfo *bi, int printok)
651 {
652 char *p, *pend, *buf;
653 int i;
654
655 kloader.bootinfo = kbi;
656 buf = kbi->_argbuf;
657 if (bi != NULL)
658 memcpy(&kbi->bootinfo, bi, sizeof(struct bootinfo));
659 kbi->argc = argc;
660 kbi->argv = (char **)buf;
661
662 p = &buf[argc * sizeof(char **)];
663 pend = &buf[KLOADER_KERNELARGS_MAX - 1];
664
665 for (i = 0; i < argc; i++) {
666 char *q = argv[i];
667 int len = strlen(q) + 1;
668 if ((p + len) > pend) {
669 kloader.bootinfo = NULL;
670 if (printok)
671 PRINTF("buffer insufficient.\n");
672 return;
673 }
674 kbi->argv[i] = p;
675 memcpy(p, q, len);
676 p += len;
677 }
678 }
679
680
681 #ifdef KLOADER_DEBUG
682 void
683 kloader_pagetag_dump()
684 {
685 struct kloader_page_tag *tag = kloader.tagstart;
686 struct kloader_page_tag *p, *op;
687 boolean_t print;
688 int i, n;
689
690 p = tag;
691 op = NULL;
692 i = 0, n = 15;
693
694 PRINTF("[page tag chain]\n");
695 do {
696 print = FALSE;
697 if (i < n)
698 print = TRUE;
699 if ((u_int32_t)p & 3) {
700 printf("tag alignment error\n");
701 break;
702 }
703 if ((p->src & 3) || (p->dst & 3)) {
704 printf("data alignement error.\n");
705 print = TRUE;
706 }
707
708 if (print) {
709 printf("[%2d] next 0x%08x src 0x%08x dst 0x%08x"
710 " sz 0x%x\n", i, p->next, p->src, p->dst, p->sz);
711 } else if (i == n) {
712 printf("[...]\n");
713 }
714 op = p;
715 i++;
716 } while ((p = (struct kloader_page_tag *)(p->next)) != 0);
717
718 if (op != NULL)
719 printf("[%d(last)] next 0x%08x src 0x%08x dst 0x%08x sz 0x%x\n",
720 i - 1, op->next, op->src, op->dst, op->sz);
721 }
722
723 #endif /* KLOADER_DEBUG */
Cache object: ef7f1b83f4d647d2bd6b2ea385f47d6d
|