1 /* $NetBSD: exec_multiboot2.c,v 1.8 2025/06/28 18:52:04 joe Exp $ */ 2 3 /* 4 * Copyright (c) 2019 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/param.h> 30 #include <sys/reboot.h> 31 #include <sys/types.h> 32 33 #include <i386/multiboot2.h> 34 35 #include <dev/acpi/acpica.h> 36 #include <x86/acpi_machdep.h> 37 #include <dev/smbiosvar.h> 38 #include <x86/smbios_machdep.h> 39 40 #include <lib/libsa/stand.h> 41 #include <lib/libkern/libkern.h> 42 43 44 #include "loadfile.h" 45 #include "libi386.h" 46 #include "biosdisk.h" 47 #include "bootinfo.h" 48 #include "bootmod.h" 49 #include "vbe.h" 50 #ifdef EFIBOOT 51 #include "efiboot.h" 52 #endif 53 54 #define CGA_BUF 0xb8000 /* From isa_machdep.h */ 55 56 extern const char bootprog_name[], bootprog_rev[], bootprog_kernrev[]; 57 extern const uint8_t rasops_cmap[]; 58 extern struct btinfo_framebuffer btinfo_framebuffer; 59 extern struct btinfo_modulelist *btinfo_modulelist; 60 #ifdef EFIBOOT 61 extern struct btinfo_efimemmap *btinfo_efimemmap; 62 #else 63 extern struct btinfo_memmap *btinfo_memmap; 64 #endif 65 66 67 struct multiboot_package_priv { 68 struct multiboot_tag *mpp_mbi; 69 size_t mpp_mbi_len; 70 struct multiboot_header_tag_information_request*mpp_info_req; 71 struct multiboot_header_tag_address *mpp_address; 72 struct multiboot_header_tag_entry_address *mpp_entry; 73 struct multiboot_header_tag_console_flags *mpp_console; 74 struct multiboot_header_tag_framebuffer *mpp_framebuffer; 75 struct multiboot_header_tag *mpp_module_align; 76 struct multiboot_header_tag *mpp_efi_bs; 77 struct multiboot_header_tag_entry_address *mpp_entry_elf32; 78 struct multiboot_header_tag_entry_address *mpp_entry_elf64; 79 struct multiboot_header_tag_relocatable *mpp_relocatable; 80 }; 81 82 #ifndef NO_MULTIBOOT2 83 84 #ifdef MULTIBOOT2_DEBUG 85 static void 86 mbi_hexdump(char *addr, size_t len) 87 { 88 int i,j; 89 90 for (i = 0; i < len; i += 16) { 91 printf(" %p ", addr + i); 92 for (j = 0; j < 16 && i + j < len; j++) { 93 char *cp = addr + i + j; 94 printf("%s%s%x", 95 (i+j) % 4 ? "" : " ", 96 (unsigned char)*cp < 0x10 ? "0" : "", 97 (unsigned char)*cp); 98 } 99 printf("\n"); 100 } 101 102 return; 103 } 104 105 static const char * 106 mbi_tag_name(uint32_t type) 107 { 108 const char *tag_name; 109 110 switch (type) { 111 case MULTIBOOT_TAG_TYPE_END: 112 tag_name = "END"; break; 113 case MULTIBOOT_TAG_TYPE_CMDLINE: 114 tag_name = "CMDLINE"; break; 115 case MULTIBOOT_TAG_TYPE_BOOT_LOADER_NAME: 116 tag_name = "BOOT_LOADER_NAME"; break; 117 case MULTIBOOT_TAG_TYPE_MODULE: 118 tag_name = "MODULE"; break; 119 case MULTIBOOT_TAG_TYPE_BASIC_MEMINFO: 120 tag_name = "BASIC_MEMINFO"; break; 121 case MULTIBOOT_TAG_TYPE_BOOTDEV: 122 tag_name = "BOOTDEV"; break; 123 case MULTIBOOT_TAG_TYPE_MMAP: 124 tag_name = "MMAP"; break; 125 case MULTIBOOT_TAG_TYPE_VBE: 126 tag_name = "VBE"; break; 127 case MULTIBOOT_TAG_TYPE_FRAMEBUFFER: 128 tag_name = "FRAMEBUFFER"; break; 129 case MULTIBOOT_TAG_TYPE_ELF_SECTIONS: 130 tag_name = "ELF_SECTIONS"; break; 131 case MULTIBOOT_TAG_TYPE_APM: 132 tag_name = "APM"; break; 133 case MULTIBOOT_TAG_TYPE_EFI32: 134 tag_name = "EFI32"; break; 135 case MULTIBOOT_TAG_TYPE_EFI64: 136 tag_name = "EFI64"; break; 137 case MULTIBOOT_TAG_TYPE_SMBIOS: 138 tag_name = "SMBIOS"; break; 139 case MULTIBOOT_TAG_TYPE_ACPI_OLD: 140 tag_name = "ACPI_OLD"; break; 141 case MULTIBOOT_TAG_TYPE_ACPI_NEW: 142 tag_name = "ACPI_NEW"; break; 143 case MULTIBOOT_TAG_TYPE_NETWORK: 144 tag_name = "NETWORK"; break; 145 case MULTIBOOT_TAG_TYPE_EFI_MMAP: 146 tag_name = "EFI_MMAP"; break; 147 case MULTIBOOT_TAG_TYPE_EFI_BS: 148 tag_name = "EFI_BS"; break; 149 case MULTIBOOT_TAG_TYPE_EFI32_IH: 150 tag_name = "EFI32_IH"; break; 151 case MULTIBOOT_TAG_TYPE_EFI64_IH: 152 tag_name = "EFI64_IH"; break; 153 case MULTIBOOT_TAG_TYPE_LOAD_BASE_ADDR: 154 tag_name = "LOAD_BASE_ADDR"; break; 155 default: 156 tag_name = "unknown"; break; 157 } 158 159 return tag_name; 160 } 161 162 static void 163 multiboot2_info_dump(uint32_t magic, char *mbi) 164 { 165 struct multiboot_tag *mbt; 166 char *cp; 167 uint32_t total_size; 168 uint32_t actual_size; 169 uint32_t reserved; 170 int i = 0; 171 172 printf("=== multiboot2 info dump start ===\n"); 173 174 if (magic != MULTIBOOT2_BOOTLOADER_MAGIC) { 175 printf("Unexpected multiboot2 magic number: 0x%x\n", magic); 176 goto out; 177 } 178 179 if (mbi != (char *)rounddown((vaddr_t)mbi, MULTIBOOT_TAG_ALIGN)) { 180 printf("mbi at %p is not properly aligned\n", mbi); 181 goto out; 182 } 183 184 total_size = *(uint32_t *)mbi; 185 reserved = *(uint32_t *)mbi + 1; 186 mbt = (struct multiboot_tag *)(uint32_t *)mbi + 2; 187 actual_size = (char *)mbt - mbi; 188 printf("mbi.total_size = %d\n", total_size); 189 printf("mbi.reserved = %d\n", reserved); 190 191 for (cp = mbi + sizeof(total_size) + sizeof(reserved); 192 cp - mbi < total_size; 193 cp = cp + roundup(mbt->size, MULTIBOOT_TAG_ALIGN)) { 194 mbt = (struct multiboot_tag *)cp; 195 actual_size += roundup(mbt->size, MULTIBOOT_TAG_ALIGN); 196 197 printf("mbi[%d].type = %d(%s), .size = %d ", 198 i++, mbt->type, mbi_tag_name(mbt->type), mbt->size); 199 200 switch (mbt->type) { 201 case MULTIBOOT_TAG_TYPE_CMDLINE: 202 printf(".string = \"%s\"\n", 203 ((struct multiboot_tag_string *)mbt)->string); 204 break; 205 case MULTIBOOT_TAG_TYPE_BOOT_LOADER_NAME: 206 printf(".string = \"%s\"\n", 207 ((struct multiboot_tag_string *)mbt)->string); 208 break; 209 case MULTIBOOT_TAG_TYPE_MODULE: 210 printf(".mod_start = 0x%x, mod_end = 0x%x, " 211 "string = \"%s\"\n", 212 ((struct multiboot_tag_module *)mbt)->mod_start, 213 ((struct multiboot_tag_module *)mbt)->mod_end, 214 ((struct multiboot_tag_module *)mbt)->cmdline); 215 break; 216 case MULTIBOOT_TAG_TYPE_BASIC_MEMINFO: { 217 struct multiboot_tag_basic_meminfo *meminfo; 218 219 meminfo = (struct multiboot_tag_basic_meminfo *)mbt; 220 printf(".mem_lower = %uKB, .mem_upper = %uKB\n", 221 meminfo->mem_lower, meminfo->mem_upper); 222 break; 223 } 224 case MULTIBOOT_TAG_TYPE_BOOTDEV: 225 printf (".biosdev = 0x%x, .slice = %d, .part = %d\n", 226 ((struct multiboot_tag_bootdev *)mbt)->biosdev, 227 ((struct multiboot_tag_bootdev *)mbt)->slice, 228 ((struct multiboot_tag_bootdev *)mbt)->part); 229 break; 230 case MULTIBOOT_TAG_TYPE_MMAP: { 231 struct multiboot_tag_mmap *memmap; 232 multiboot_memory_map_t *mmap; 233 uint32_t entry_size; 234 uint32_t entry_version; 235 int j = 0; 236 237 memmap = (struct multiboot_tag_mmap *)mbt; 238 entry_size = memmap->entry_size; 239 entry_version = memmap->entry_version; 240 printf (".entry_size = %d, .entry_version = %d\n", 241 entry_size, entry_version); 242 243 for (mmap = ((struct multiboot_tag_mmap *)mbt)->entries; 244 (char *)mmap - (char *)mbt < mbt->size; 245 mmap = (void *)((char *)mmap + entry_size)) 246 printf(" entry[%d].addr = 0x%"PRIx64",\t" 247 ".len = 0x%"PRIx64",\t.type = 0x%x\n", 248 j++, (uint64_t)mmap->addr, 249 (uint64_t)mmap->len, 250 mmap->type); 251 break; 252 } 253 case MULTIBOOT_TAG_TYPE_FRAMEBUFFER: { 254 struct multiboot_tag_framebuffer *fb = (void *)mbt; 255 256 printf ("%dx%dx%d at 0x%"PRIx64"\n", 257 fb->common.framebuffer_width, 258 fb->common.framebuffer_height, 259 fb->common.framebuffer_bpp, 260 (uint64_t)fb->common.framebuffer_addr); 261 mbi_hexdump((char *)mbt, mbt->size); 262 break; 263 } 264 case MULTIBOOT_TAG_TYPE_ELF_SECTIONS: 265 printf(".num = %d, .entsize = %d, .shndx = %d\n", 266 ((struct multiboot_tag_elf_sections *)mbt)->num, 267 ((struct multiboot_tag_elf_sections *)mbt)->entsize, 268 ((struct multiboot_tag_elf_sections *)mbt)->shndx); 269 mbi_hexdump((char *)mbt, mbt->size); 270 break; 271 case MULTIBOOT_TAG_TYPE_APM: 272 printf(".version = %d, .cseg = 0x%x, .offset = 0x%x, " 273 ".cseg_16 = 0x%x, .dseg = 0x%x, .flags = 0x%x, " 274 ".cseg_len = %d, .cseg_16_len = %d, " 275 ".dseg_len = %d\n", 276 ((struct multiboot_tag_apm *)mbt)->version, 277 ((struct multiboot_tag_apm *)mbt)->cseg, 278 ((struct multiboot_tag_apm *)mbt)->offset, 279 ((struct multiboot_tag_apm *)mbt)->cseg_16, 280 ((struct multiboot_tag_apm *)mbt)->dseg, 281 ((struct multiboot_tag_apm *)mbt)->flags, 282 ((struct multiboot_tag_apm *)mbt)->cseg_len, 283 ((struct multiboot_tag_apm *)mbt)->cseg_16_len, 284 ((struct multiboot_tag_apm *)mbt)->dseg_len); 285 break; 286 case MULTIBOOT_TAG_TYPE_EFI32: 287 printf(".pointer = 0x%x\n", 288 ((struct multiboot_tag_efi32 *)mbt)->pointer); 289 break; 290 case MULTIBOOT_TAG_TYPE_EFI64: 291 printf(".pointer = 0x%"PRIx64"\n", (uint64_t) 292 ((struct multiboot_tag_efi64 *)mbt)->pointer); 293 break; 294 case MULTIBOOT_TAG_TYPE_SMBIOS: 295 printf(".major = %d, .minor = %d\n", 296 ((struct multiboot_tag_smbios *)mbt)->major, 297 ((struct multiboot_tag_smbios *)mbt)->minor); 298 mbi_hexdump((char *)mbt, mbt->size); 299 break; 300 case MULTIBOOT_TAG_TYPE_ACPI_OLD: 301 printf("\n"); 302 mbi_hexdump((char *)mbt, mbt->size); 303 break; 304 case MULTIBOOT_TAG_TYPE_ACPI_NEW: 305 printf("\n"); 306 mbi_hexdump((char *)mbt, mbt->size); 307 break; 308 case MULTIBOOT_TAG_TYPE_NETWORK: 309 printf("\n"); 310 mbi_hexdump((char *)mbt, mbt->size); 311 break; 312 case MULTIBOOT_TAG_TYPE_EFI_MMAP: 313 printf("\n"); 314 mbi_hexdump((char *)mbt, mbt->size); 315 break; 316 case MULTIBOOT_TAG_TYPE_EFI_BS: 317 printf("\n"); 318 break; 319 case MULTIBOOT_TAG_TYPE_EFI32_IH: 320 printf(".pointer = 0x%"PRIx32"\n", 321 ((struct multiboot_tag_efi32_ih *)mbt)->pointer); 322 break; 323 case MULTIBOOT_TAG_TYPE_EFI64_IH: 324 printf(".pointer = 0x%"PRIx64"\n", (uint64_t) 325 ((struct multiboot_tag_efi64_ih *)mbt)->pointer); 326 break; 327 case MULTIBOOT_TAG_TYPE_LOAD_BASE_ADDR: { 328 struct multiboot_tag_load_base_addr *ld = (void *)mbt; 329 printf(".load_base_addr = 0x%x\n", ld->load_base_addr); 330 break; 331 } 332 case MULTIBOOT_TAG_TYPE_END: 333 break; 334 default: 335 printf("\n"); 336 mbi_hexdump((char *)mbt, mbt->size); 337 break; 338 } 339 } 340 341 if (total_size != actual_size) 342 printf("Size mismatch: announded %d, actual %d\n", 343 total_size, actual_size); 344 345 out: 346 printf("=== multiboot2 info dump start ===\n"); 347 return; 348 } 349 350 #define MPP_OPT(flags) \ 351 (flags & MULTIBOOT_HEADER_TAG_OPTIONAL) ? " (opt)" : " (req)" 352 353 static 354 void multiboot2_header_dump(struct multiboot_package *mbp) 355 { 356 struct multiboot_package_priv *mpp = mbp->mbp_priv; 357 358 printf("=== multiboot2 header dump start ===\n"); 359 if (mpp->mpp_info_req) { 360 struct multiboot_header_tag_information_request *info_req; 361 size_t nreq; 362 int i; 363 364 info_req = mpp->mpp_info_req; 365 366 nreq = (info_req->size - sizeof(*info_req)) 367 / sizeof(info_req->requests[0]); 368 369 printf("Information tag request%s: ", 370 MPP_OPT(info_req->flags)); 371 for (i = 0; i < nreq; i++) 372 printf("%d(%s) ", 373 info_req->requests[i], 374 mbi_tag_name(info_req->requests[i])); 375 printf("\n"); 376 } 377 378 if (mpp->mpp_address) 379 printf("Addresses%s: header = %"PRIx32", load = %"PRIx32", " 380 "end = %"PRIx32", bss = %"PRIx32"\n", 381 MPP_OPT(mpp->mpp_address->flags), 382 mpp->mpp_address->header_addr, 383 mpp->mpp_address->load_addr, 384 mpp->mpp_address->load_end_addr, 385 mpp->mpp_address->bss_end_addr); 386 387 if (mpp->mpp_entry) 388 printf("Entry point%s: %"PRIx32"\n", 389 MPP_OPT(mpp->mpp_entry->flags), 390 mpp->mpp_entry->entry_addr); 391 392 if (mpp->mpp_console) { 393 int flags = mpp->mpp_console->console_flags; 394 char *req_flag = ""; 395 char *ega_flag = ""; 396 397 if (flags & MULTIBOOT_CONSOLE_FLAGS_EGA_TEXT_SUPPORTED) 398 ega_flag = " EGA"; 399 if (flags & MULTIBOOT_CONSOLE_FLAGS_CONSOLE_REQUIRED) 400 req_flag = " required"; 401 402 printf("Console flags%s: %s %s\n", 403 MPP_OPT(mpp->mpp_console->flags), 404 ega_flag, req_flag); 405 } 406 407 if (mpp->mpp_framebuffer) 408 printf("Framebuffer%s: width = %d, height = %d, depth = %d\n", 409 MPP_OPT(mpp->mpp_framebuffer->flags), 410 mpp->mpp_framebuffer->width, 411 mpp->mpp_framebuffer->height, 412 mpp->mpp_framebuffer->depth); 413 414 if (mpp->mpp_module_align) 415 printf("Module alignmenet%s\n", 416 MPP_OPT(mpp->mpp_module_align->flags)); 417 418 if (mpp->mpp_efi_bs) 419 printf("Do not call EFI Boot service exit%s\n", 420 MPP_OPT(mpp->mpp_efi_bs->flags)); 421 422 if (mpp->mpp_entry_elf32) 423 printf("EFI32 entry point%s: %"PRIx32"\n", 424 MPP_OPT(mpp->mpp_entry_elf32->flags), 425 mpp->mpp_entry_elf32->entry_addr); 426 427 if (mpp->mpp_entry_elf64) 428 printf("EFI64 entry point%s: %"PRIx32"\n", 429 MPP_OPT(mpp->mpp_entry_elf64->flags), 430 mpp->mpp_entry_elf64->entry_addr); 431 432 if (mpp->mpp_relocatable) { 433 char *pref; 434 435 switch (mpp->mpp_relocatable->preference) { 436 case MULTIBOOT_LOAD_PREFERENCE_NONE: pref = "none"; break; 437 case MULTIBOOT_LOAD_PREFERENCE_LOW: pref = "low"; break; 438 case MULTIBOOT_LOAD_PREFERENCE_HIGH: pref = "high"; break; 439 default: 440 pref = "(unknown)"; break; 441 } 442 printf("Relocatable%s: min_addr = %"PRIx32", " 443 "max_addr = %"PRIx32", align = %"PRIx32", pref %s\n", 444 MPP_OPT(mpp->mpp_relocatable->flags), 445 mpp->mpp_relocatable->min_addr, 446 mpp->mpp_relocatable->max_addr, 447 mpp->mpp_relocatable->align, pref); 448 } 449 450 printf("=== multiboot2 header dump end ===\n"); 451 return; 452 } 453 #endif /* MULTIBOOT2_DEBUG */ 454 455 static size_t 456 mbi_cmdline(struct multiboot_package *mbp, void *buf) 457 { 458 struct multiboot_tag_string *mbt = buf; 459 size_t cmdlen; 460 size_t len; 461 const char fmt[] = "%s %s"; 462 463 /* +1 for trailing \0 */ 464 cmdlen = snprintf(NULL, SIZE_T_MAX, fmt, mbp->mbp_file, mbp->mbp_args) 465 + 1; 466 len = sizeof(*mbt) + cmdlen; 467 468 if (mbt) { 469 mbt->type = MULTIBOOT_TAG_TYPE_CMDLINE; 470 mbt->size = len; 471 (void)snprintf(mbt->string, cmdlen, fmt, 472 mbp->mbp_file, mbp->mbp_args); 473 } 474 475 return roundup(len, MULTIBOOT_TAG_ALIGN); 476 } 477 478 static size_t 479 mbi_boot_loader_name(struct multiboot_package *mbp, void *buf) 480 { 481 struct multiboot_tag_string *mbt = buf; 482 size_t len; 483 size_t strlen; 484 const char fmt[] = "%s, Revision %s (from NetBSD %s)"; 485 486 487 /* +1 for trailing \0 */ 488 strlen = snprintf(NULL, SIZE_T_MAX, fmt, 489 bootprog_name, bootprog_rev, bootprog_kernrev) 490 + 1; 491 len = sizeof(*mbt) + strlen; 492 493 if (mbt) { 494 mbt->type = MULTIBOOT_TAG_TYPE_BOOT_LOADER_NAME; 495 mbt->size = len; 496 (void)snprintf(mbt->string, strlen, fmt, bootprog_name, 497 bootprog_rev, bootprog_kernrev); 498 } 499 500 return roundup(len, MULTIBOOT_TAG_ALIGN); 501 } 502 503 static size_t 504 mbi_modules(struct multiboot_package *mbp, void *buf) 505 { 506 struct multiboot_tag_module *mbt = buf; 507 struct bi_modulelist_entry *bim; 508 size_t len; 509 int i; 510 511 if (btinfo_modulelist == NULL) 512 return 0; 513 514 len = 0; 515 516 bim = (struct bi_modulelist_entry *)(btinfo_modulelist + 1); 517 for (i = 0; i < btinfo_modulelist->num; i++) { 518 size_t pathlen = strlen(bim->path) + 1; 519 size_t mbt_len = sizeof(*mbt) + pathlen; 520 size_t mbt_len_align = roundup(mbt_len, MULTIBOOT_TAG_ALIGN); 521 len += mbt_len_align; 522 523 if (mbt) { 524 mbt->type = MULTIBOOT_TAG_TYPE_MODULE; 525 mbt->size = mbt_len; 526 mbt->mod_start = bim->base; 527 mbt->mod_end = bim->base + bim->len; 528 strncpy(mbt->cmdline, bim->path, pathlen); 529 530 mbt = (struct multiboot_tag_module *) 531 ((char *)mbt + mbt_len_align); 532 } 533 } 534 535 return len; 536 } 537 538 static size_t 539 mbi_basic_meminfo(struct multiboot_package *mbp, void *buf) 540 { 541 struct multiboot_tag_basic_meminfo *mbt = buf; 542 size_t len; 543 544 len = sizeof(*mbt); 545 546 if (mbt) { 547 mbt->type = MULTIBOOT_TAG_TYPE_BASIC_MEMINFO; 548 mbt->size = len; 549 mbt->mem_lower = mbp->mbp_basemem; 550 mbt->mem_upper = mbp->mbp_extmem; 551 } 552 553 return roundup(len, MULTIBOOT_TAG_ALIGN); 554 } 555 556 static size_t 557 mbi_bootdev(struct multiboot_package *mbp, void *buf) 558 { 559 struct multiboot_tag_bootdev *mbt = buf; 560 size_t len; 561 562 len = sizeof(*mbt); 563 564 /* 565 * According to the specification: 566 * - sub_partition is used for BSD disklabel. 567 * - Extendded MBR partitions are counted from 4 and increasing, 568 * with no subpartition. 569 */ 570 if (mbt) { 571 mbt->type = MULTIBOOT_TAG_TYPE_BOOTDEV; 572 mbt->size = len; 573 mbt->biosdev = bi_disk.biosdev; 574 mbt->slice = bi_disk.partition; 575 mbt->part = 0xFFFFFFFF; /* aka sub_partition, for disklabel */ 576 } 577 578 return roundup(len, MULTIBOOT_TAG_ALIGN); 579 return 0; 580 } 581 582 static size_t 583 mbi_mmap(struct multiboot_package *mbp, void *buf) 584 { 585 size_t len = 0; 586 struct multiboot_tag_mmap *mbt = buf; 587 struct bi_memmap_entry *memmap; 588 size_t num; 589 590 #ifndef EFIBOOT 591 bi_getmemmap(); 592 593 if (btinfo_memmap == NULL) 594 goto out; 595 596 memmap = btinfo_memmap->entry; 597 num = btinfo_memmap->num; 598 #else 599 if (efi_memory_get_memmap(&memmap, &num) != 0) 600 goto out; 601 #endif 602 603 len = sizeof(*mbt) + num * sizeof(mbt->entries[0]); 604 605 if (mbt) { 606 int i; 607 struct multiboot_mmap_entry *mbte; 608 609 mbt->type = MULTIBOOT_TAG_TYPE_MMAP; 610 mbt->size = len; 611 mbt->entry_size = sizeof(mbt->entries[0]); 612 mbt->entry_version = 0; 613 614 mbte = (struct multiboot_mmap_entry *)(mbt + 1); 615 for (i = 0; i < num; i++) { 616 mbte[i].addr = memmap[i].addr; 617 mbte[i].len = memmap[i].size; 618 switch(memmap[i].type) { 619 case BIM_Memory: 620 mbte[i].type = MULTIBOOT_MEMORY_AVAILABLE; 621 break; 622 case BIM_Reserved: 623 mbte[i].type = MULTIBOOT_MEMORY_RESERVED; 624 break; 625 case BIM_ACPI: 626 mbte[i].type = 627 MULTIBOOT_MEMORY_ACPI_RECLAIMABLE; 628 break; 629 case BIM_NVS: 630 mbte[i].type = MULTIBOOT_MEMORY_NVS; 631 break; 632 case BIM_Unusable: 633 mbte[i].type = MULTIBOOT_MEMORY_BADRAM; 634 break; 635 default: 636 mbte[i].type = MULTIBOOT_MEMORY_RESERVED; 637 break; 638 } 639 mbte[i].zero = 0; 640 } 641 } 642 #ifdef EFIBOOT 643 dealloc(memmap, num * sizeof(memmap)); 644 #endif 645 out: 646 return roundup(len, MULTIBOOT_TAG_ALIGN); 647 } 648 649 static size_t 650 mbi_vbe(struct multiboot_package *mbp, void *buf) 651 { 652 size_t len = 0; 653 654 #ifndef EFIBOOT 655 struct multiboot_tag_vbe *mbt = buf; 656 657 len = sizeof(*mbt); 658 659 if (mbt) { 660 mbt->type = MULTIBOOT_TAG_TYPE_VBE; 661 mbt->size = len; 662 mbt->vbe_mode = btinfo_framebuffer.vbemode; 663 mbt->vbe_interface_seg = 0; 664 mbt->vbe_interface_off = 0; 665 mbt->vbe_interface_len = 0; 666 biosvbe_info((struct vbeinfoblock *)&mbt->vbe_control_info); 667 biosvbe_get_mode_info(mbt->vbe_mode, 668 (struct modeinfoblock *)&mbt->vbe_mode_info); 669 } 670 #endif 671 return roundup(len, MULTIBOOT_TAG_ALIGN); 672 } 673 674 static size_t 675 mbi_framebuffer(struct multiboot_package *mbp, void *buf) 676 { 677 size_t len = 0; 678 struct multiboot_tag_framebuffer *mbt = buf; 679 struct btinfo_framebuffer *fb = &btinfo_framebuffer; 680 681 #ifndef EFIBOOT 682 struct modeinfoblock mi; 683 684 if (fb->physaddr != 0) { 685 int ret; 686 687 ret = biosvbe_get_mode_info(fb->vbemode, &mi); 688 if (ret != 0x004f) 689 return 0; 690 } 691 #endif 692 693 len = sizeof(*mbt); 694 695 if (mbt) { 696 mbt->common.type = MULTIBOOT_TAG_TYPE_FRAMEBUFFER; 697 mbt->common.size = len; 698 mbt->common.reserved = 0; 699 700 /* 701 * No framebuffer, default to 80x25 console 702 */ 703 if (fb->physaddr == 0) { 704 int width = 80; 705 int height = 25; 706 int charlen = 2; 707 mbt->common.framebuffer_addr = CGA_BUF; 708 mbt->common.framebuffer_width = width; 709 mbt->common.framebuffer_height = height; 710 mbt->common.framebuffer_bpp = charlen * 8; 711 mbt->common.framebuffer_pitch = width * charlen; 712 mbt->common.framebuffer_type = 713 MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT; 714 } else { 715 mbt->common.framebuffer_addr = fb->physaddr; 716 mbt->common.framebuffer_pitch = fb->stride; 717 mbt->common.framebuffer_width = fb->width; 718 mbt->common.framebuffer_height = fb->height; 719 mbt->common.framebuffer_bpp = fb->depth; 720 mbt->common.framebuffer_type = 721 MULTIBOOT_FRAMEBUFFER_TYPE_RGB; 722 #ifndef EFIBOOT 723 if (mi.MemoryModel == 0x04) 724 mbt->common.framebuffer_type = 725 MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED; 726 #endif 727 } 728 729 switch (mbt->common.framebuffer_type) { 730 #ifndef EFIBOOT 731 case MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED: 732 mbt->framebuffer_palette_num_colors = 256; 733 734 for (int i = 0; i < 256; i++) { 735 mbt->framebuffer_palette[i].red = 736 rasops_cmap[3 * i]; 737 mbt->framebuffer_palette[i].green = 738 rasops_cmap[(3 * i) + 1]; 739 mbt->framebuffer_palette[i].blue = 740 rasops_cmap[(3 * i) + 2]; 741 } 742 break; 743 #endif 744 case MULTIBOOT_FRAMEBUFFER_TYPE_RGB: 745 mbt->framebuffer_red_field_position = fb->rpos; 746 mbt->framebuffer_red_mask_size = fb->rnum; 747 mbt->framebuffer_green_field_position = fb->gpos; 748 mbt->framebuffer_green_mask_size = fb->gnum; 749 mbt->framebuffer_blue_field_position = fb->bpos; 750 mbt->framebuffer_blue_mask_size = fb->bnum; 751 break; 752 default: 753 break; 754 } 755 } 756 757 return roundup(len, MULTIBOOT_TAG_ALIGN); 758 } 759 760 static size_t 761 mbi_acpi_old(struct multiboot_package *mbp, void *buf) 762 { 763 size_t len = 0; 764 struct multiboot_tag_old_acpi *mbt = buf; 765 ACPI_PHYSICAL_ADDRESS rsdp_phys = -1; 766 ACPI_RSDP_COMMON rsdp; 767 #ifdef EFIBOOT 768 const EFI_GUID acpi_table_guid = ACPI_TABLE_GUID; 769 int i; 770 771 if (ST == NULL) 772 goto out; 773 774 for (i = 0; i < ST->NumberOfTableEntries; i++) { 775 if (memcmp(&ST->ConfigurationTable[i].VendorGuid, 776 &acpi_table_guid, sizeof(acpi_table_guid)) == 0) { 777 rsdp_phys = (ACPI_PHYSICAL_ADDRESS) 778 ST->ConfigurationTable[i].VendorTable; 779 break; 780 } 781 } 782 #else 783 #ifdef notyet 784 rsdp_phys = acpi_md_OsGetRootPointer(); 785 pvbcopy((void *)(vaddr_t)rsdp_phys, &rsdp, sizeof(rsdp)); 786 787 /* Check ACPI 1.0 */ 788 if (rsdp.Revision != 0) 789 rsdp_phys = -1; 790 #endif 791 #endif 792 793 if (rsdp_phys == -1) 794 goto out; 795 796 len = sizeof(*mbt) + sizeof(rsdp); 797 if (mbt) { 798 mbt->type = MULTIBOOT_TAG_TYPE_ACPI_OLD; 799 mbt->size = len; 800 pvbcopy((void *)(vaddr_t)rsdp_phys, mbt->rsdp, sizeof(rsdp)); 801 } 802 out: 803 return roundup(len, MULTIBOOT_TAG_ALIGN); 804 } 805 806 static size_t 807 mbi_acpi_new(struct multiboot_package *mbp, void *buf) 808 { 809 size_t len = 0; 810 struct multiboot_tag_new_acpi *mbt = buf; 811 ACPI_PHYSICAL_ADDRESS rsdp_phys = -1; 812 ACPI_TABLE_RSDP rsdp; 813 #ifdef EFIBOOT 814 const EFI_GUID acpi_20_table_guid = ACPI_20_TABLE_GUID; 815 int i; 816 817 if (ST == NULL) 818 goto out; 819 820 for (i = 0; i < ST->NumberOfTableEntries; i++) { 821 if (memcmp(&ST->ConfigurationTable[i].VendorGuid, 822 &acpi_20_table_guid, sizeof(acpi_20_table_guid)) == 0) { 823 rsdp_phys = (ACPI_PHYSICAL_ADDRESS) 824 ST->ConfigurationTable[i].VendorTable; 825 break; 826 } 827 } 828 #else 829 #ifdef notyet 830 rsdp_phys = acpi_md_OsGetRootPointer(); 831 pvbcopy((void *)(vaddr_t)rsdp_phys, &rsdp, sizeof(rsdp)); 832 833 /* Check ACPI 2.0 */ 834 if (rsdp.Revision != 2) 835 rsdp_phys = -1; 836 #endif 837 #endif 838 if (rsdp_phys == -1) 839 goto out; 840 841 len = sizeof(*mbt) + sizeof(rsdp); 842 if (mbt) { 843 mbt->type = MULTIBOOT_TAG_TYPE_ACPI_NEW; 844 mbt->size = len; 845 pvbcopy((void *)(vaddr_t)rsdp_phys, mbt->rsdp, sizeof(rsdp)); 846 } 847 out: 848 return roundup(len, MULTIBOOT_TAG_ALIGN); 849 } 850 851 static size_t 852 mbi_apm(struct multiboot_package *mbp, void *buf) 853 { 854 size_t len = 0; 855 #ifdef notyet 856 struct multiboot_tag_apm *mbt = buf; 857 858 len = sizeof(*mbt): 859 860 if (mbt) { 861 mbt->type = MULTIBOOT_TAG_TYPE_A; 862 mbt->size = len; 863 mbt->version = 0; 864 mbt->cseg = 0; 865 mbt->offset = 0; 866 mbt->cseg_16 = 0; 867 mbt->dseg = 0; 868 mbt->flags = 0; 869 mbt->cseg_len = 0; 870 mbt->cseg_16_len = 0; 871 mbt->dseg_len = 0; 872 } 873 out: 874 #endif 875 return roundup(len, MULTIBOOT_TAG_ALIGN); 876 } 877 878 static size_t 879 mbi_smbios(struct multiboot_package *mbp, void *buf) 880 { 881 size_t len = 0; 882 struct multiboot_tag_smbios *mbt = buf; 883 void *smbios_phys; 884 struct smb3hdr *smbios3_phys = NULL; 885 struct smb3hdr smbios3; 886 struct smbhdr *smbios21_phys = NULL; 887 struct smbhdr smbios21; 888 size_t smbios_len; 889 int major; 890 int minor; 891 #ifdef EFIBOOT 892 const EFI_GUID smbios3_guid = SMBIOS3_TABLE_GUID; 893 const EFI_GUID smbios21_guid = SMBIOS_TABLE_GUID; 894 int i; 895 896 if (ST == NULL) 897 goto out; 898 899 for (i = 0; i < ST->NumberOfTableEntries; i++) { 900 if (memcmp(&ST->ConfigurationTable[i].VendorGuid, 901 &smbios3_guid, sizeof(smbios3_guid)) == 0) 902 smbios3_phys = ST->ConfigurationTable[i].VendorTable; 903 904 if (memcmp(&ST->ConfigurationTable[i].VendorGuid, 905 &smbios21_guid, sizeof(smbios21_guid)) == 0) 906 smbios21_phys = ST->ConfigurationTable[i].VendorTable; 907 } 908 #else 909 char *cp; 910 char line[16]; 911 const char *smbios21_anchor = "_SM_"; 912 const char *smbios3_anchor = "_SM3_"; 913 914 for (cp = (char *)SMBIOS_START; 915 cp < (char *)SMBIOS_END; 916 cp += sizeof(buf)) { 917 pvbcopy(cp, line, sizeof(line)); 918 if (memcmp(line, smbios3_anchor, strlen(smbios3_anchor)) == 0) 919 smbios3_phys = (struct smb3hdr *)cp; 920 if (memcmp(line, smbios21_anchor, strlen(smbios21_anchor)) == 0) 921 smbios21_phys = (struct smbhdr *)cp; 922 } 923 #endif 924 if (smbios3_phys != NULL) { 925 pvbcopy(smbios3_phys, &smbios3, sizeof(smbios3)); 926 smbios_len = smbios3.len; 927 major = smbios3.majrev; 928 minor = smbios3.minrev; 929 smbios_phys = smbios3_phys; 930 } else if (smbios21_phys != NULL) { 931 pvbcopy(smbios21_phys, &smbios21, sizeof(smbios21)); 932 smbios_len = smbios21.len; 933 major = smbios21.majrev; 934 minor = smbios21.minrev; 935 smbios_phys = smbios21_phys; 936 } else { 937 goto out; 938 } 939 940 len = sizeof(*mbt) + smbios_len; 941 if (mbt) { 942 mbt->type = MULTIBOOT_TAG_TYPE_SMBIOS; 943 mbt->size = len; 944 mbt->major = major; 945 mbt->minor = minor; 946 pvbcopy(smbios_phys, mbt->tables, smbios_len); 947 } 948 out: 949 return roundup(len, MULTIBOOT_TAG_ALIGN); 950 } 951 952 static size_t 953 mbi_network(struct multiboot_package *mbp, void *buf) 954 { 955 size_t len = 0; 956 #ifdef notyet 957 struct multiboot_tag_network *mbt = buf; 958 959 if (saved_dhcpack == NULL || saved_dhcpack_len == 0) 960 goto out; 961 962 len = sizeof(*mbt) + saved_dhcpack_len; 963 964 if (mbt) { 965 mbt->type = MULTIBOOT_TAG_TYPE_NETWORK; 966 mbt->size = len; 967 memcpy(mbt->dhcpack, saved_dhcpack, saved_dhcpack_len); 968 } 969 out: 970 #endif 971 return roundup(len, MULTIBOOT_TAG_ALIGN); 972 } 973 974 static size_t 975 mbi_elf_sections(struct multiboot_package *mbp, void *buf) 976 { 977 size_t len = 0; 978 struct multiboot_tag_elf_sections *mbt = buf; 979 union { 980 Elf32_Ehdr e32; 981 Elf64_Ehdr e64; 982 } ehdr; 983 int class; 984 Elf32_Ehdr *ehdr32 = NULL; 985 Elf64_Ehdr *ehdr64 = NULL; 986 uint64_t shnum, shentsize, shstrndx, shoff; 987 size_t shdr_len; 988 989 if (mbp->mbp_marks[MARK_SYM] == 0) 990 goto out; 991 992 pvbcopy((void *)mbp->mbp_marks[MARK_SYM], &ehdr, sizeof(ehdr)); 993 994 /* 995 * Check this is a ELF header 996 */ 997 if (memcmp(&ehdr.e32.e_ident, ELFMAG, SELFMAG) != 0) 998 goto out; 999 1000 class = ehdr.e32.e_ident[EI_CLASS]; 1001 1002 switch (class) { 1003 case ELFCLASS32: 1004 ehdr32 = &ehdr.e32; 1005 shnum = ehdr32->e_shnum; 1006 shentsize = ehdr32->e_shentsize; 1007 shstrndx = ehdr32->e_shstrndx; 1008 shoff = ehdr32->e_shoff; 1009 break; 1010 case ELFCLASS64: 1011 ehdr64 = &ehdr.e64; 1012 shnum = ehdr64->e_shnum; 1013 shentsize = ehdr64->e_shentsize; 1014 shstrndx = ehdr64->e_shstrndx; 1015 shoff = ehdr64->e_shoff; 1016 break; 1017 default: 1018 goto out; 1019 } 1020 1021 shdr_len = shnum * shentsize; 1022 if (shdr_len == 0) 1023 goto out; 1024 1025 len = sizeof(*mbt) + shdr_len; 1026 if (mbt) { 1027 char *shdr = (char *)mbp->mbp_marks[MARK_SYM] + shoff; 1028 1029 mbt->type = MULTIBOOT_TAG_TYPE_ELF_SECTIONS; 1030 mbt->size = len; 1031 mbt->num = shnum; 1032 mbt->entsize = shentsize; 1033 mbt->shndx = shstrndx; 1034 1035 pvbcopy((void *)shdr, mbt + 1, shdr_len); 1036 1037 /* 1038 * Adjust sh_addr for symtab and strtab 1039 * section that have been loaded. 1040 */ 1041 ksyms_addr_set(&ehdr, mbt + 1, 1042 (void *)mbp->mbp_marks[MARK_SYM]); 1043 } 1044 1045 out: 1046 return roundup(len, MULTIBOOT_TAG_ALIGN); 1047 } 1048 1049 static size_t 1050 mbi_end(struct multiboot_package *mbp, void *buf) 1051 { 1052 struct multiboot_tag *mbt = buf; 1053 size_t len = sizeof(*mbt); 1054 1055 if (mbt) { 1056 mbt->type = MULTIBOOT_TAG_TYPE_END; 1057 mbt->size = len; 1058 } 1059 1060 return roundup(len, MULTIBOOT_TAG_ALIGN); 1061 } 1062 1063 static size_t 1064 mbi_load_base_addr(struct multiboot_package *mbp, void *buf) 1065 { 1066 size_t len = 0; 1067 struct multiboot_tag_load_base_addr *mbt = buf; 1068 1069 len = sizeof(*mbt); 1070 1071 if (mbt) { 1072 mbt->type = MULTIBOOT_TAG_TYPE_LOAD_BASE_ADDR; 1073 mbt->size = len; 1074 mbt->load_base_addr = mbp->mbp_marks[MARK_START]; 1075 } 1076 return roundup(len, MULTIBOOT_TAG_ALIGN); 1077 } 1078 1079 #ifdef EFIBOOT 1080 /* Set if EFI ExitBootServices was not called */ 1081 static size_t 1082 mbi_efi_bs(struct multiboot_package *mbp, void *buf) 1083 { 1084 size_t len = 0; 1085 struct multiboot_tag *mbt = buf; 1086 1087 if (mbp->mbp_priv->mpp_efi_bs == NULL) 1088 goto out; 1089 1090 len = sizeof(*mbt); 1091 1092 if (mbt) { 1093 mbt->type = MULTIBOOT_TAG_TYPE_EFI_BS; 1094 mbt->size = len; 1095 } 1096 1097 out: 1098 return roundup(len, MULTIBOOT_TAG_ALIGN); 1099 } 1100 1101 1102 static size_t 1103 mbi_efi_mmap(struct multiboot_package *mbp, void *buf) 1104 { 1105 size_t len = 0; 1106 struct multiboot_tag_efi_mmap *mbt = buf; 1107 size_t memmap_len; 1108 1109 if (btinfo_efimemmap == NULL) 1110 goto out; 1111 1112 memmap_len = btinfo_efimemmap->num * btinfo_efimemmap->size; 1113 len = sizeof(*mbt) + memmap_len; 1114 1115 if (mbt) { 1116 mbt->type = MULTIBOOT_TAG_TYPE_EFI_MMAP; 1117 mbt->size = len; 1118 mbt->descr_size = btinfo_efimemmap->size; 1119 mbt->descr_vers = btinfo_efimemmap->version; 1120 memcpy(mbt + 1, btinfo_efimemmap->memmap, memmap_len); 1121 } 1122 1123 out: 1124 return roundup(len, MULTIBOOT_TAG_ALIGN); 1125 } 1126 1127 1128 1129 #ifndef __LP64__ 1130 static size_t 1131 mbi_efi32_ih(struct multiboot_package *mbp, void *buf) 1132 { 1133 size_t len = 0; 1134 struct multiboot_tag_efi32_ih *mbt = buf; 1135 1136 len = sizeof(*mbt); 1137 1138 if (mbt) { 1139 mbt->type = MULTIBOOT_TAG_TYPE_EFI32_IH; 1140 mbt->size = len; 1141 mbt->pointer = (multiboot_uint32_t)IH; 1142 } 1143 return roundup(len, MULTIBOOT_TAG_ALIGN); 1144 } 1145 1146 static size_t 1147 mbi_efi32(struct multiboot_package *mbp, void *buf) 1148 { 1149 size_t len = 0; 1150 struct multiboot_tag_efi32 *mbt = buf; 1151 1152 len = sizeof(*mbt); 1153 1154 if (mbt) { 1155 mbt->type = MULTIBOOT_TAG_TYPE_EFI32; 1156 mbt->size = len; 1157 mbt->pointer = (multiboot_uint32_t)ST; 1158 } 1159 return roundup(len, MULTIBOOT_TAG_ALIGN); 1160 } 1161 #endif 1162 1163 #ifdef __LP64__ 1164 static size_t 1165 mbi_efi64_ih(struct multiboot_package *mbp, void *buf) 1166 { 1167 size_t len = 0; 1168 struct multiboot_tag_efi64_ih *mbt = buf; 1169 1170 len = sizeof(*mbt); 1171 1172 if (mbt) { 1173 mbt->type = MULTIBOOT_TAG_TYPE_EFI64_IH; 1174 mbt->size = len; 1175 mbt->pointer = (multiboot_uint64_t)IH; 1176 } 1177 return roundup(len, MULTIBOOT_TAG_ALIGN); 1178 } 1179 1180 static size_t 1181 mbi_efi64(struct multiboot_package *mbp, void *buf) 1182 { 1183 size_t len = 0; 1184 struct multiboot_tag_efi64 *mbt = buf; 1185 1186 len = sizeof(*mbt); 1187 1188 if (mbt) { 1189 mbt->type = MULTIBOOT_TAG_TYPE_EFI64; 1190 mbt->size = len; 1191 mbt->pointer = (multiboot_uint64_t)ST; 1192 } 1193 return roundup(len, MULTIBOOT_TAG_ALIGN); 1194 } 1195 #endif /* __LP64__ */ 1196 #endif /* EFIBOOT */ 1197 1198 static bool 1199 is_tag_required(struct multiboot_package *mbp, uint16_t tag) 1200 { 1201 bool ret = false; 1202 int i; 1203 struct multiboot_header_tag_information_request *info_req; 1204 size_t nreq; 1205 1206 info_req = mbp->mbp_priv->mpp_info_req; 1207 1208 if (info_req == NULL) 1209 goto out; 1210 1211 if (info_req->flags & MULTIBOOT_HEADER_TAG_OPTIONAL) 1212 goto out; 1213 1214 nreq = (info_req->size - sizeof(*info_req)) 1215 / sizeof(info_req->requests[0]); 1216 1217 for (i = 0; i < nreq; i++) { 1218 if (info_req->requests[i] == tag) { 1219 ret = true; 1220 break; 1221 } 1222 } 1223 1224 out: 1225 return ret; 1226 } 1227 1228 static int 1229 mbi_dispatch(struct multiboot_package *mbp, uint16_t type, 1230 char *bp, size_t *total_len) 1231 { 1232 int ret = 0; 1233 size_t len = 0; 1234 1235 switch (type) { 1236 case MULTIBOOT_TAG_TYPE_END: 1237 len = mbi_end(mbp, bp); 1238 break; 1239 case MULTIBOOT_TAG_TYPE_CMDLINE: 1240 len = mbi_cmdline(mbp, bp); 1241 break; 1242 case MULTIBOOT_TAG_TYPE_BOOT_LOADER_NAME: 1243 len = mbi_boot_loader_name(mbp, bp); 1244 break; 1245 case MULTIBOOT_TAG_TYPE_MODULE: 1246 len = mbi_modules(mbp, bp); 1247 break; 1248 case MULTIBOOT_TAG_TYPE_BASIC_MEMINFO: 1249 len = mbi_basic_meminfo(mbp, bp); 1250 break; 1251 case MULTIBOOT_TAG_TYPE_BOOTDEV: 1252 len = mbi_bootdev(mbp, bp); 1253 break; 1254 case MULTIBOOT_TAG_TYPE_MMAP: 1255 len = mbi_mmap(mbp, bp); 1256 break; 1257 case MULTIBOOT_TAG_TYPE_VBE: 1258 len = mbi_vbe(mbp, bp); 1259 break; 1260 case MULTIBOOT_TAG_TYPE_FRAMEBUFFER: 1261 len = mbi_framebuffer(mbp, bp); 1262 break; 1263 case MULTIBOOT_TAG_TYPE_ACPI_OLD: 1264 len = mbi_acpi_old(mbp, bp); 1265 break; 1266 case MULTIBOOT_TAG_TYPE_ACPI_NEW: 1267 len = mbi_acpi_new(mbp, bp); 1268 break; 1269 case MULTIBOOT_TAG_TYPE_ELF_SECTIONS: 1270 len = mbi_elf_sections(mbp, bp); 1271 break; 1272 case MULTIBOOT_TAG_TYPE_APM: 1273 len = mbi_apm(mbp, bp); 1274 break; 1275 case MULTIBOOT_TAG_TYPE_SMBIOS: 1276 len = mbi_smbios(mbp, bp); 1277 break; 1278 case MULTIBOOT_TAG_TYPE_NETWORK: 1279 len = mbi_network(mbp, bp); 1280 break; 1281 #ifdef EFIBOOT 1282 case MULTIBOOT_TAG_TYPE_EFI_MMAP: 1283 len = mbi_efi_mmap(mbp, bp); 1284 break; 1285 case MULTIBOOT_TAG_TYPE_EFI_BS: 1286 len = mbi_efi_bs(mbp, bp); 1287 break; 1288 #ifndef __LP64__ 1289 case MULTIBOOT_TAG_TYPE_EFI32_IH: 1290 len = mbi_efi32_ih(mbp, bp); 1291 break; 1292 case MULTIBOOT_TAG_TYPE_EFI32: 1293 len = mbi_efi32(mbp, bp); 1294 break; 1295 #else /* __LP64__ */ 1296 case MULTIBOOT_TAG_TYPE_EFI64_IH: 1297 len = mbi_efi64_ih(mbp, bp); 1298 break; 1299 case MULTIBOOT_TAG_TYPE_EFI64: 1300 len = mbi_efi64(mbp, bp); 1301 break; 1302 #endif /* __LP64__ */ 1303 #endif /* EFIBOOT */ 1304 case MULTIBOOT_TAG_TYPE_LOAD_BASE_ADDR: 1305 len = mbi_load_base_addr(mbp, bp); 1306 break; 1307 default: 1308 len = 0; 1309 break; 1310 } 1311 1312 if (len == 0 && is_tag_required(mbp, type)) 1313 ret = -1; 1314 1315 *total_len += len; 1316 return ret; 1317 } 1318 1319 static int 1320 exec_multiboot2(struct multiboot_package *mbp) 1321 { 1322 size_t len, alen; 1323 char *mbi = NULL; 1324 struct multiboot_package_priv *mpp = mbp->mbp_priv; 1325 uint16_t tags[] = { 1326 MULTIBOOT_TAG_TYPE_CMDLINE, 1327 MULTIBOOT_TAG_TYPE_BOOT_LOADER_NAME, 1328 MULTIBOOT_TAG_TYPE_MODULE, 1329 MULTIBOOT_TAG_TYPE_BASIC_MEMINFO, 1330 MULTIBOOT_TAG_TYPE_BOOTDEV, 1331 MULTIBOOT_TAG_TYPE_VBE, 1332 MULTIBOOT_TAG_TYPE_FRAMEBUFFER, 1333 MULTIBOOT_TAG_TYPE_ELF_SECTIONS, 1334 MULTIBOOT_TAG_TYPE_APM, 1335 MULTIBOOT_TAG_TYPE_SMBIOS, 1336 MULTIBOOT_TAG_TYPE_ACPI_OLD, 1337 MULTIBOOT_TAG_TYPE_ACPI_NEW, 1338 MULTIBOOT_TAG_TYPE_NETWORK, 1339 MULTIBOOT_TAG_TYPE_LOAD_BASE_ADDR, 1340 #ifdef EFIBOOT 1341 MULTIBOOT_TAG_TYPE_EFI_BS, 1342 #ifndef __LP64__ 1343 MULTIBOOT_TAG_TYPE_EFI32, 1344 MULTIBOOT_TAG_TYPE_EFI32_IH, 1345 #else 1346 MULTIBOOT_TAG_TYPE_EFI64, 1347 MULTIBOOT_TAG_TYPE_EFI64_IH, 1348 #endif /* __LP64__ */ 1349 /* 1350 * EFI_MMAP and MMAP at the end so that they 1351 * catch page allocation made for other tags. 1352 */ 1353 MULTIBOOT_TAG_TYPE_EFI_MMAP, 1354 #endif /* EFIGOOT */ 1355 MULTIBOOT_TAG_TYPE_MMAP, 1356 MULTIBOOT_TAG_TYPE_END, /* Must be last */ 1357 }; 1358 physaddr_t entry; 1359 int i; 1360 1361 BI_ALLOC(BTINFO_MAX); 1362 1363 /* set new video mode if text mode was not requested */ 1364 if (mpp->mpp_framebuffer == NULL || 1365 mpp->mpp_framebuffer->depth != 0) 1366 vbe_commit(); 1367 1368 len = 2 * sizeof(multiboot_uint32_t); 1369 for (i = 0; i < sizeof(tags) / sizeof(*tags); i++) { 1370 if (mbi_dispatch(mbp, tags[i], NULL, &len) != 0) 1371 goto fail; 1372 } 1373 1374 mpp->mpp_mbi_len = len + MULTIBOOT_TAG_ALIGN; 1375 mpp->mpp_mbi = alloc(mpp->mpp_mbi_len); 1376 mbi = (char *)roundup((vaddr_t)mpp->mpp_mbi, MULTIBOOT_TAG_ALIGN); 1377 1378 alen = 2 * sizeof(multiboot_uint32_t); 1379 for (i = 0; i < sizeof(tags) / sizeof(*tags); i++) { 1380 if (mbi_dispatch(mbp, tags[i], mbi + alen, &alen) != 0) 1381 goto fail; 1382 1383 /* 1384 * It may shrink because of failure when filling 1385 * structures, but it should not grow. 1386 */ 1387 if (alen > len) 1388 panic("multiboot2 info size mismatch"); 1389 } 1390 1391 1392 ((multiboot_uint32_t *)mbi)[0] = alen; /* total size */ 1393 ((multiboot_uint32_t *)mbi)[1] = 0; /* reserved */ 1394 1395 #if 0 1396 for (i = 0; i < len; i += 16) { 1397 printf("%p ", mbi + i); 1398 for (int j = 0; j < 16; j++) 1399 printf("%s%s%x", 1400 (i+j) % 4 ? "" : " ", 1401 (unsigned char)mbi[i+j] < 0x10 ? "0" : "", 1402 (unsigned char)(mbi[i+j])); 1403 printf("\n"); 1404 } 1405 #endif 1406 1407 printf("Start @ 0x%lx [%ld=0x%lx-0x%lx]...\n", 1408 mbp->mbp_marks[MARK_ENTRY], 1409 mbp->mbp_marks[MARK_NSYM], 1410 mbp->mbp_marks[MARK_SYM], 1411 mbp->mbp_marks[MARK_END]); 1412 1413 #ifdef MULTIBOOT2_DEBUG 1414 multiboot2_info_dump(MULTIBOOT2_BOOTLOADER_MAGIC, mbi); 1415 #endif /* MULTIBOOT2_DEBUG */ 1416 1417 entry = mbp->mbp_marks[MARK_ENTRY]; 1418 1419 if (mpp->mpp_entry) 1420 entry = mpp->mpp_entry->entry_addr; 1421 #ifdef EFIBOOT 1422 #ifdef __LP64__ 1423 if (mpp->mpp_entry_elf64) 1424 entry = mpp->mpp_entry_elf64->entry_addr 1425 + efi_loadaddr; 1426 #else 1427 if (mpp->mpp_entry_elf32) 1428 entry = mpp->mpp_entry_elf32->entry_addr 1429 + efi_loadaddr; 1430 #endif /* __LP64__ */ 1431 if (mpp->mpp_efi_bs == NULL) 1432 efi_cleanup(); 1433 #endif /* EFIBOOT */ 1434 1435 /* Does not return */ 1436 multiboot(entry, vtophys(mbi), 1437 x86_trunc_page(mbp->mbp_basemem * 1024), 1438 MULTIBOOT2_BOOTLOADER_MAGIC); 1439 fail: 1440 return -1; 1441 } 1442 1443 static void 1444 cleanup_multiboot2(struct multiboot_package *mbp) 1445 { 1446 if (mbp->mbp_header) 1447 dealloc(mbp->mbp_header, mbp->mbp_header->header_length); 1448 if (mbp->mbp_priv && mbp->mbp_priv->mpp_mbi) 1449 dealloc(mbp->mbp_priv->mpp_mbi, mbp->mbp_priv->mpp_mbi_len); 1450 if (mbp->mbp_priv) 1451 dealloc(mbp->mbp_priv, sizeof(*mbp->mbp_priv)); 1452 1453 dealloc(mbp, sizeof(*mbp)); 1454 1455 return; 1456 } 1457 1458 static bool 1459 is_header_required(struct multiboot_header_tag *mbt) 1460 { 1461 bool ret = false; 1462 1463 if (mbt == NULL) 1464 goto out; 1465 1466 if (mbt->flags & MULTIBOOT_HEADER_TAG_OPTIONAL) 1467 goto out; 1468 1469 ret = true; 1470 out: 1471 return ret; 1472 } 1473 1474 #define NEXT_HEADER(mbt) ((struct multiboot_header_tag *) \ 1475 ((char *)mbt + roundup(mbt->size, MULTIBOOT_HEADER_ALIGN))) 1476 1477 struct multiboot_package * 1478 probe_multiboot2(const char *path) 1479 { 1480 int fd = -1; 1481 size_t i; 1482 char buf[MULTIBOOT_SEARCH + sizeof(struct multiboot_header)]; 1483 ssize_t readen; 1484 struct multiboot_package *mbp = NULL; 1485 struct multiboot_header *mbh; 1486 struct multiboot_header_tag *mbt; 1487 size_t mbh_len = 0; 1488 1489 if ((fd = open(path, 0)) == -1) 1490 goto out; 1491 1492 readen = read(fd, buf, sizeof(buf)); 1493 if (readen < sizeof(struct multiboot_header)) 1494 goto out; 1495 1496 for (i = 0; i < readen; i += MULTIBOOT_HEADER_ALIGN) { 1497 mbh = (struct multiboot_header *)(buf + i); 1498 1499 if (mbh->magic != MULTIBOOT2_HEADER_MAGIC) 1500 continue; 1501 1502 if (mbh->architecture != MULTIBOOT_ARCHITECTURE_I386) 1503 continue; 1504 1505 if (mbh->magic + mbh->architecture + 1506 mbh->header_length + mbh->checksum) 1507 continue; 1508 mbh_len = mbh->header_length; 1509 1510 mbp = alloc(sizeof(*mbp)); 1511 mbp->mbp_version = 2; 1512 mbp->mbp_file = path; 1513 mbp->mbp_header = alloc(mbh_len); 1514 mbp->mbp_priv = alloc(sizeof(*mbp->mbp_priv)); 1515 memset(mbp->mbp_priv, 0, sizeof (*mbp->mbp_priv)); 1516 mbp->mbp_probe = *probe_multiboot2; 1517 mbp->mbp_exec = *exec_multiboot2; 1518 mbp->mbp_cleanup = *cleanup_multiboot2; 1519 1520 break; 1521 } 1522 1523 if (mbp == NULL) 1524 goto out; 1525 1526 if (lseek(fd, i, SEEK_SET) != i) { 1527 printf("lseek failed"); 1528 mbp->mbp_cleanup(mbp); 1529 mbp = NULL; 1530 goto out; 1531 } 1532 1533 mbh = mbp->mbp_header; 1534 if (read(fd, mbh, mbh_len) != mbh_len) { 1535 printf("read failed"); 1536 mbp->mbp_cleanup(mbp); 1537 mbp = NULL; 1538 goto out; 1539 } 1540 1541 for (mbt = (struct multiboot_header_tag *)(mbh + 1); 1542 (char *)mbt - (char *)mbh < mbh_len; 1543 mbt = NEXT_HEADER(mbt)) { 1544 1545 switch(mbt->type) { 1546 case MULTIBOOT_HEADER_TAG_INFORMATION_REQUEST: 1547 mbp->mbp_priv->mpp_info_req = (void *)mbt; 1548 break; 1549 case MULTIBOOT_HEADER_TAG_ADDRESS: 1550 mbp->mbp_priv->mpp_address = (void *)mbt; 1551 break; 1552 case MULTIBOOT_HEADER_TAG_ENTRY_ADDRESS: 1553 mbp->mbp_priv->mpp_entry = (void *)mbt; 1554 break; 1555 case MULTIBOOT_HEADER_TAG_CONSOLE_FLAGS: 1556 mbp->mbp_priv->mpp_console = (void *)mbt; 1557 break; 1558 case MULTIBOOT_HEADER_TAG_FRAMEBUFFER: 1559 mbp->mbp_priv->mpp_framebuffer = (void *)mbt; 1560 break; 1561 case MULTIBOOT_HEADER_TAG_MODULE_ALIGN: 1562 mbp->mbp_priv->mpp_module_align = (void *)mbt; 1563 break; 1564 #ifdef EFIBOOT 1565 case MULTIBOOT_HEADER_TAG_EFI_BS: 1566 mbp->mbp_priv->mpp_efi_bs = (void *)mbt; 1567 break; 1568 case MULTIBOOT_HEADER_TAG_ENTRY_ADDRESS_EFI32: 1569 mbp->mbp_priv->mpp_entry_elf32 = (void *)mbt; 1570 break; 1571 case MULTIBOOT_HEADER_TAG_ENTRY_ADDRESS_EFI64: 1572 mbp->mbp_priv->mpp_entry_elf64 = (void *)mbt; 1573 break; 1574 #endif 1575 case MULTIBOOT_HEADER_TAG_RELOCATABLE: 1576 mbp->mbp_priv->mpp_relocatable = (void *)mbt; 1577 break; 1578 case MULTIBOOT_HEADER_TAG_END: /* FALLTHROUGH */ 1579 default: 1580 break; 1581 } 1582 } 1583 1584 #ifdef MULTIBOOT2_DEBUG 1585 multiboot2_header_dump(mbp); 1586 #endif /* MULTIBOOT2_DEBUG */ 1587 1588 /* 1589 * multiboot header fully supported 1590 * MULTIBOOT_HEADER_TAG_INFORMATION_REQUEST 1591 * MULTIBOOT_HEADER_TAG_ENTRY_ADDRESS 1592 * MULTIBOOT_HEADER_TAG_MODULE_ALIGN (we always load as page aligned) 1593 * MULTIBOOT_HEADER_TAG_EFI_BS 1594 * MULTIBOOT_HEADER_TAG_ENTRY_ADDRESS_EFI32 1595 * MULTIBOOT_HEADER_TAG_ENTRY_ADDRESS_EFI64 1596 * MULTIBOOT_HEADER_TAG_CONSOLE_FLAGS (we always have a console) 1597 * 1598 * Not supported: 1599 * MULTIBOOT_HEADER_TAG_ADDRESS 1600 * MULTIBOOT_HEADER_TAG_FRAMEBUFFER (but spec says it is onty a hint) 1601 * MULTIBOOT_HEADER_TAG_RELOCATABLE 1602 */ 1603 1604 if (is_header_required((void *)mbp->mbp_priv->mpp_address)) { 1605 printf("Unsupported multiboot address header\n"); 1606 mbp->mbp_cleanup(mbp); 1607 mbp = NULL; 1608 goto out; 1609 } 1610 1611 #ifdef EFIBOOT 1612 /* 1613 * We do not fully support the relocatable header, but 1614 * at least we honour the alignment request. Xen requires 1615 * that to boot. 1616 */ 1617 struct multiboot_header_tag_relocatable *reloc = 1618 mbp->mbp_priv->mpp_relocatable; 1619 if (reloc) 1620 efi_loadaddr = roundup(efi_loadaddr, reloc->align); 1621 #endif 1622 1623 if (is_header_required((void *)mbp->mbp_priv->mpp_relocatable)) { 1624 printf("Unsupported multiboot relocatable header\n"); 1625 mbp->mbp_cleanup(mbp); 1626 mbp = NULL; 1627 goto out; 1628 } 1629 1630 out: 1631 1632 if (fd != -1) 1633 close(fd); 1634 1635 return mbp; 1636 } 1637 1638 #endif /* NO_MULTIBOOT2 */ 1639
Indexes created Sun Sep 21 20:09:37 GMT 2025