kloader.c revision 1.30
1 /* $NetBSD: kloader.c,v 1.30 2021/10/11 14:14:40 rin 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.30 2021/10/11 14:14:40 rin 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_extern.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 sh[i].sh_offset = 0; 270 } 271 } 272 273 if (symndx < 0 || strndx < 0) { 274 if (symndx < 0) 275 PRINTF("no .symtab section\n"); 276 if (strndx < 0) 277 PRINTF("no .strtab section\n"); 278 ksymsz = SELFMAG; /* just a bad magic */ 279 } else { 280 ksymsz = sizeof(Elf_Ehdr) 281 + eh.e_shentsize * eh.e_shnum 282 + shstrsz /* rounded to 4 bytes */ 283 + sh[symndx].sh_size 284 + sh[strndx].sh_size; 285 DPRINTF("ksyms size = 0x%zx\n", ksymsz); 286 } 287 sz += ROUND4(ksymsz); 288 289 /* boot info for the new kernel */ 290 sz += sizeof(struct kloader_bootinfo); 291 292 /* get memory for new kernel */ 293 if (kloader_alloc_memory(sz) != 0) 294 goto err; 295 296 /* 297 * Copy new kernel in. 298 */ 299 kv = 0; /* XXX: -Wuninitialized */ 300 for (i = 0, p = ph; i < eh.e_phnum; i++, p++) { 301 if (p->p_type == PT_LOAD) { 302 kloader_load_segment(p); 303 kv = p->p_vaddr + ROUND4(p->p_memsz); 304 } 305 } 306 307 /* 308 * Construct symbol table for ksyms. 309 */ 310 if (symndx < 0 || strndx < 0) { 311 kloader_zero(kv, SELFMAG); 312 kv += SELFMAG; 313 } else { 314 Elf_Off eoff; 315 off_t symoff, stroff; 316 317 /* save offsets of .symtab and .strtab before we change them */ 318 symoff = sh[symndx].sh_offset; 319 stroff = sh[strndx].sh_offset; 320 321 /* no loadable segments */ 322 eh.e_entry = 0; 323 eh.e_phnum = 0; 324 eh.e_phoff = 0; 325 326 /* change offsets to reflect new layout */ 327 eoff = sizeof(Elf_Ehdr); 328 eh.e_shoff = eoff; 329 330 eoff += eh.e_shentsize * eh.e_shnum; 331 sh[eh.e_shstrndx].sh_offset = eoff; 332 333 eoff += shstrsz; 334 sh[symndx].sh_offset = eoff; 335 336 eoff += sh[symndx].sh_size; 337 sh[strndx].sh_offset = eoff; 338 339 /* local copies massaged, can serve them now */ 340 DPRINTF("ksyms ELF header\n"); 341 kloader_copy(kv, &eh, sizeof(Elf_Ehdr)); 342 kv += sizeof(Elf_Ehdr); 343 344 DPRINTF("ksyms section headers\n"); 345 kloader_copy(kv, sh, eh.e_shentsize * eh.e_shnum); 346 kv += eh.e_shentsize * eh.e_shnum; 347 348 DPRINTF("ksyms .shstrtab\n"); 349 kloader_copy(kv, shstrtab, shstrsz); 350 kv += shstrsz; 351 352 DPRINTF("ksyms .symtab\n"); 353 kloader_from_file(kv, symoff, sh[symndx].sh_size); 354 kv += sh[symndx].sh_size; 355 356 DPRINTF("ksyms .strtab\n"); 357 kloader_from_file(kv, stroff, ROUND4(sh[strndx].sh_size)); 358 kv += ROUND4(sh[strndx].sh_size); 359 } 360 361 /* 362 * Create boot info to pass to the new kernel. 363 * All pointers in it are *not* valid until the new kernel runs! 364 */ 365 366 /* get a private copy of current bootinfo to vivisect */ 367 memcpy(&nbi, kloader.bootinfo, sizeof(struct kloader_bootinfo)); 368 369 /* new kernel entry point */ 370 nbi.entry = entry; 371 372 /* where args currently are, see kloader_bootinfo_set() */ 373 oldbuf = &kloader.bootinfo->_argbuf[0]; 374 375 /* where args *will* be after boot code copied them */ 376 newbuf = (char *)(void *)kv 377 + offsetof(struct kloader_bootinfo, _argbuf); 378 379 DPRINTF("argv: old %p -> new %p\n", oldbuf, newbuf); 380 381 /* not a valid pointer in this kernel! */ 382 nbi.argv = (void *)newbuf; 383 384 /* local copy that we populate with new (not yet valid) pointers */ 385 ap = (char **)(void *)nbi._argbuf; 386 387 for (i = 0; i < kloader.bootinfo->argc; ++i) { 388 DPRINTFN(1, " [%d]: %p -> ", i, kloader.bootinfo->argv[i]); 389 ap[i] = newbuf + 390 (kloader.bootinfo->argv[i] - oldbuf); 391 _DPRINTFN(1, "%p\n", ap[i]); 392 } 393 394 /* arrange for the new bootinfo to get copied */ 395 DPRINTF("bootinfo\n"); 396 kloader_copy(kv, &nbi, sizeof(struct kloader_bootinfo)); 397 398 /* will be valid by the time the new kernel starts */ 399 kloader.rebootinfo = (void *)kv; 400 /* kv += sizeof(struct kloader_bootinfo); */ 401 402 /* 403 * Copy loader code 404 */ 405 KDASSERT(kloader.cur_pg); 406 kloader.loader = (void *)PG_VADDR(kloader.cur_pg); 407 memcpy(kloader.loader, kloader.ops->boot, PAGE_SIZE); 408 409 /* loader stack starts at the bottom of that page */ 410 kloader.loader_sp = (vaddr_t)kloader.loader + PAGE_SIZE; 411 412 DPRINTF("[loader] addr=%p sp=%p [kernel] entry=%p\n", 413 kloader.loader, (void *)kloader.loader_sp, (void *)nbi.entry); 414 415 return (0); 416 err: 417 if (ph != NULL) 418 free(ph, M_TEMP); 419 if (sh != NULL) 420 free(sh, M_TEMP); 421 if (shstrtab != NULL) 422 free(shstrtab, M_TEMP); 423 424 return 1; 425 } 426 427 428 int 429 kloader_alloc_memory(size_t sz) 430 { 431 int n, error; 432 433 n = (sz + BUCKET_SIZE - 1) / BUCKET_SIZE /* kernel &co */ 434 + 1; /* 2nd loader */ 435 436 error = uvm_pglistalloc(n * PAGE_SIZE, avail_start, avail_end, 437 PAGE_SIZE, 0, &kloader.pg_head, n, 0); 438 if (error) { 439 PRINTF("can't allocate memory.\n"); 440 return (1); 441 } 442 DPRINTF("allocated %d pages.\n", n); 443 444 kloader.cur_pg = TAILQ_FIRST(&kloader.pg_head); 445 kloader.tagstart = (void *)PG_VADDR(kloader.cur_pg); 446 kloader.cur_tag = NULL; 447 448 return (0); 449 } 450 451 452 struct kloader_page_tag * 453 kloader_get_tag(vaddr_t dst) 454 { 455 struct vm_page *pg; 456 vaddr_t addr; 457 struct kloader_page_tag *tag; 458 459 tag = kloader.cur_tag; 460 if (tag != NULL /* has tag */ 461 && tag->sz < BUCKET_SIZE /* that has free space */ 462 && tag->dst + tag->sz == dst) /* and new data are contiguous */ 463 { 464 DPRINTFN(1, "current tag %x/%x ok\n", tag->dst, tag->sz); 465 return (tag); 466 } 467 468 pg = kloader.cur_pg; 469 KDASSERT(pg != NULL); 470 kloader.cur_pg = TAILQ_NEXT(pg, pageq.queue); 471 472 addr = PG_VADDR(pg); 473 tag = (void *)addr; 474 475 /* 476 * 2nd loader uses simple word-by-word copy, so destination 477 * address of a tag must be properly aligned. 478 */ 479 KASSERT(ALIGNED_POINTER(dst, register_t)); 480 481 tag->src = addr + sizeof(struct kloader_page_tag); 482 tag->dst = dst; 483 tag->sz = 0; 484 tag->next = 0; /* Terminate. this member may overwrite after. */ 485 if (kloader.cur_tag) 486 kloader.cur_tag->next = addr; 487 kloader.cur_tag = tag; 488 489 return (tag); 490 } 491 492 493 /* 494 * Operations to populate kloader_page_tag's with data. 495 */ 496 497 void 498 kloader_from_file(vaddr_t dst, off_t ofs, size_t sz) 499 { 500 struct kloader_page_tag *tag; 501 size_t freesz; 502 503 while (sz > 0) { 504 tag = kloader_get_tag(dst); 505 KDASSERT(tag != NULL); 506 freesz = BUCKET_SIZE - tag->sz; 507 if (freesz > sz) 508 freesz = sz; 509 510 DPRINTFN(1, "0x%08"PRIxVADDR" + 0x%zx <- 0x%lx\n", dst, freesz, 511 (unsigned long)ofs); 512 kloader_read(ofs, freesz, (void *)(tag->src + tag->sz)); 513 514 tag->sz += freesz; 515 sz -= freesz; 516 ofs += freesz; 517 dst += freesz; 518 } 519 } 520 521 522 void 523 kloader_copy(vaddr_t dst, const void *src, size_t sz) 524 { 525 struct kloader_page_tag *tag; 526 size_t freesz; 527 528 while (sz > 0) { 529 tag = kloader_get_tag(dst); 530 KDASSERT(tag != NULL); 531 freesz = BUCKET_SIZE - tag->sz; 532 if (freesz > sz) 533 freesz = sz; 534 535 DPRINTFN(1, "0x%08"PRIxVADDR" + 0x%zx <- %p\n", dst, freesz, src); 536 memcpy((void *)(tag->src + tag->sz), src, freesz); 537 538 tag->sz += freesz; 539 sz -= freesz; 540 src = (const char *)src + freesz; 541 dst += freesz; 542 } 543 } 544 545 546 void 547 kloader_zero(vaddr_t dst, size_t sz) 548 { 549 struct kloader_page_tag *tag; 550 size_t freesz; 551 552 while (sz > 0) { 553 tag = kloader_get_tag(dst); 554 KDASSERT(tag != NULL); 555 freesz = BUCKET_SIZE - tag->sz; 556 if (freesz > sz) 557 freesz = sz; 558 559 DPRINTFN(1, "0x%08"PRIxVADDR" + 0x%zx\n", dst, freesz); 560 memset((void *)(tag->src + tag->sz), 0, freesz); 561 562 tag->sz += freesz; 563 sz -= freesz; 564 dst += freesz; 565 } 566 } 567 568 569 void 570 kloader_load_segment(Elf_Phdr *p) 571 { 572 573 DPRINTF("memory 0x%08x 0x%x <- file 0x%x 0x%x\n", 574 p->p_vaddr, p->p_memsz, p->p_offset, p->p_filesz); 575 576 kloader_from_file(p->p_vaddr, p->p_offset, p->p_filesz); 577 #ifdef KLOADER_ZERO_BSS 578 kloader_zero(p->p_vaddr + p->p_filesz, p->p_memsz - p->p_filesz); 579 #endif 580 } 581 582 583 /* 584 * file access 585 */ 586 struct vnode * 587 kloader_open(const char *filename) 588 { 589 struct pathbuf *pb; 590 struct nameidata nid; 591 struct vnode *vp; 592 int error; 593 594 pb = pathbuf_create(filename); 595 if (pb == NULL) { 596 PRINTF("%s: pathbuf_create failed\n", filename); 597 return (NULL); 598 } 599 600 /* 601 * XXX why does this call both namei and vn_open? 602 */ 603 604 NDINIT(&nid, LOOKUP, FOLLOW, pb); 605 error = namei(&nid); 606 if (error != 0) { 607 PRINTF("%s: namei failed, errno=%d\n", filename, error); 608 pathbuf_destroy(pb); 609 return (NULL); 610 } 611 612 error = vn_open(NULL, pb, 0, FREAD, 0, &vp, NULL, NULL); 613 if (error != 0) { 614 PRINTF("%s: open failed, errno=%d\n", filename, error); 615 pathbuf_destroy(pb); 616 return (NULL); 617 } 618 619 pathbuf_destroy(pb); 620 return vp; 621 } 622 623 void 624 kloader_close(void) 625 { 626 struct lwp *l = KLOADER_LWP; 627 struct vnode *vp = kloader.vp; 628 629 VOP_UNLOCK(vp); 630 vn_close(vp, FREAD, l->l_cred); 631 } 632 633 int 634 kloader_read(size_t ofs, size_t size, void *buf) 635 { 636 struct lwp *l = KLOADER_LWP; 637 struct vnode *vp = kloader.vp; 638 size_t resid; 639 int error; 640 641 error = vn_rdwr(UIO_READ, vp, buf, size, ofs, UIO_SYSSPACE, 642 IO_NODELOCKED | IO_SYNC, l->l_cred, &resid, NULL); 643 644 if (error) 645 PRINTF("read error.\n"); 646 647 return (error); 648 } 649 650 651 /* 652 * bootinfo 653 */ 654 void 655 kloader_bootinfo_set(struct kloader_bootinfo *kbi, int argc, char *argv[], 656 struct bootinfo *bi, int printok) 657 { 658 char *p, *pend, *buf; 659 int i; 660 661 kloader.bootinfo = kbi; 662 buf = kbi->_argbuf; 663 if (bi != NULL) 664 memcpy(&kbi->bootinfo, bi, sizeof(struct bootinfo)); 665 kbi->argc = argc; 666 kbi->argv = (char **)buf; 667 668 p = &buf[argc * sizeof(char **)]; 669 pend = &buf[KLOADER_KERNELARGS_MAX - 1]; 670 671 for (i = 0; i < argc; i++) { 672 char *q = argv[i]; 673 int len = strlen(q) + 1; 674 if ((p + len) > pend) { 675 kloader.bootinfo = NULL; 676 if (printok) 677 PRINTF("buffer insufficient.\n"); 678 return; 679 } 680 kbi->argv[i] = p; 681 memcpy(p, q, len); 682 p += len; 683 } 684 } 685 686 687 #ifdef KLOADER_DEBUG 688 void 689 kloader_pagetag_dump(void) 690 { 691 struct kloader_page_tag *tag = kloader.tagstart; 692 struct kloader_page_tag *p, *op; 693 bool print; 694 int i, n; 695 696 p = tag; 697 op = NULL; 698 i = 0, n = 15; 699 700 PRINTF("[page tag chain]\n"); 701 do { 702 print = FALSE; 703 if (i < n) 704 print = TRUE; 705 if ((uint32_t)p & 3) { 706 printf("tag alignment error\n"); 707 break; 708 } 709 if ((p->src & 3) || (p->dst & 3)) { 710 printf("data alignment error.\n"); 711 print = TRUE; 712 } 713 714 if (print) { 715 printf("[%2d] next 0x%08x src 0x%08x dst 0x%08x" 716 " sz 0x%x\n", i, p->next, p->src, p->dst, p->sz); 717 } else if (i == n) { 718 printf("[...]\n"); 719 } 720 op = p; 721 i++; 722 } while ((p = (struct kloader_page_tag *)(p->next)) != 0); 723 724 if (op != NULL) 725 printf("[%d(last)] next 0x%08x src 0x%08x dst 0x%08x sz 0x%x\n", 726 i - 1, op->next, op->src, op->dst, op->sz); 727 } 728 729 #endif /* KLOADER_DEBUG */ 730
Indexes created Tue Oct 07 21:09:53 GMT 2025