1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 26 /* 27 * This file contains the functions for performing Fast Reboot -- a 28 * reboot which bypasses the firmware and bootloader, considerably 29 * reducing downtime. 30 * 31 * fastboot_load_kernel(): This function is invoked by mdpreboot() in the 32 * reboot path. It loads the new kernel and boot archive into memory, builds 33 * the data structure containing sufficient information about the new 34 * kernel and boot archive to be passed to the fast reboot switcher 35 * (see fb_swtch_src.s for details). When invoked the switcher relocates 36 * the new kernel and boot archive to physically contiguous low memory, 37 * similar to where the boot loader would have loaded them, and jumps to 38 * the new kernel. 39 * 40 * If fastreboot_onpanic is enabled, fastboot_load_kernel() is called 41 * by fastreboot_post_startup() to load the back up kernel in case of 42 * panic. 43 * 44 * The physical addresses of the memory allocated for the new kernel, boot 45 * archive and their page tables must be above where the boot archive ends 46 * after it has been relocated by the switcher, otherwise the new files 47 * and their page tables could be overridden during relocation. 48 * 49 * fast_reboot(): This function is invoked by mdboot() once it's determined 50 * that the system is capable of fast reboot. It jumps to the fast reboot 51 * switcher with the data structure built by fastboot_load_kernel() as the 52 * argument. 53 */ 54 55 #include <sys/types.h> 56 #include <sys/param.h> 57 #include <sys/segments.h> 58 #include <sys/sysmacros.h> 59 #include <sys/vm.h> 60 61 #include <sys/proc.h> 62 #include <sys/buf.h> 63 #include <sys/kmem.h> 64 65 #include <sys/reboot.h> 66 #include <sys/uadmin.h> 67 68 #include <sys/cred.h> 69 #include <sys/vnode.h> 70 #include <sys/file.h> 71 72 #include <sys/cmn_err.h> 73 #include <sys/dumphdr.h> 74 #include <sys/bootconf.h> 75 #include <sys/ddidmareq.h> 76 #include <sys/varargs.h> 77 #include <sys/promif.h> 78 #include <sys/modctl.h> 79 80 #include <vm/hat.h> 81 #include <vm/as.h> 82 #include <vm/page.h> 83 #include <vm/seg.h> 84 #include <vm/hat_i86.h> 85 #include <sys/vm_machparam.h> 86 #include <sys/archsystm.h> 87 #include <sys/machsystm.h> 88 #include <sys/mman.h> 89 #include <sys/x86_archext.h> 90 #include <sys/smp_impldefs.h> 91 #include <sys/spl.h> 92 93 #include <sys/fastboot_impl.h> 94 #include <sys/machelf.h> 95 #include <sys/kobj.h> 96 #include <sys/multiboot.h> 97 #include <sys/kobj_lex.h> 98 99 /* 100 * Macro to determine how many pages are needed for PTEs to map a particular 101 * file. Allocate one extra page table entry for terminating the list. 102 */ 103 #define FASTBOOT_PTE_LIST_SIZE(fsize) \ 104 P2ROUNDUP((((fsize) >> PAGESHIFT) + 1) * sizeof (x86pte_t), PAGESIZE) 105 106 /* 107 * Data structure containing necessary information for the fast reboot 108 * switcher to jump to the new kernel. 109 */ 110 fastboot_info_t newkernel = { 0 }; 111 char fastboot_args[OBP_MAXPATHLEN]; 112 113 static char fastboot_filename[2][OBP_MAXPATHLEN] = { { 0 }, { 0 }}; 114 static x86pte_t ptp_bits = PT_VALID | PT_REF | PT_USER | PT_WRITABLE; 115 static x86pte_t pte_bits = 116 PT_VALID | PT_REF | PT_MOD | PT_NOCONSIST | PT_WRITABLE; 117 static uint_t fastboot_shift_amt_pae[] = {12, 21, 30, 39}; 118 119 /* Index into Fast Reboot not supported message array */ 120 static uint32_t fastreboot_nosup_id = FBNS_DEFAULT; 121 122 /* Fast Reboot not supported message array */ 123 static const char * const fastreboot_nosup_desc[FBNS_END] = { 124 #define fastboot_nosup_msg(id, str) str, 125 #include <sys/fastboot_msg.h> 126 }; 127 128 int fastboot_debug = 0; 129 int fastboot_contig = 0; 130 131 /* 132 * Fake starting va for new kernel and boot archive. 133 */ 134 static uintptr_t fake_va = FASTBOOT_FAKE_VA; 135 136 /* 137 * Reserve memory below PA 1G in preparation of fast reboot. 138 * 139 * This variable is only checked when fastreboot_capable is set, but 140 * fastreboot_onpanic is not set. The amount of memory reserved 141 * is negligible, but just in case we are really short of low memory, 142 * this variable will give us a backdoor to not consume memory at all. 143 */ 144 int reserve_mem_enabled = 1; 145 146 /* 147 * Mutex to protect fastreboot_onpanic. 148 */ 149 kmutex_t fastreboot_config_mutex; 150 151 /* 152 * Amount of memory below PA 1G to reserve for constructing the multiboot 153 * data structure and the page tables as we tend to run out of those 154 * when more drivers are loaded. 155 */ 156 static size_t fastboot_mbi_size = 0x2000; /* 8K */ 157 static size_t fastboot_pagetable_size = 0x5000; /* 20K */ 158 159 /* 160 * Minimum system uptime in clock_t before Fast Reboot should be used 161 * on panic. Will be initialized in fastboot_post_startup(). 162 */ 163 clock_t fastreboot_onpanic_uptime = LONG_MAX; 164 165 /* 166 * lbolt value when the system booted. This value will be used if the system 167 * panics to calculate how long the system has been up. If the uptime is less 168 * than fastreboot_onpanic_uptime, a reboot through BIOS will be performed to 169 * avoid a potential panic/reboot loop. 170 */ 171 clock_t lbolt_at_boot = LONG_MAX; 172 173 /* 174 * Use below 1G for page tables as 175 * 1. we are only doing 1:1 mapping of the bottom 1G of physical memory. 176 * 2. we are using 2G as the fake virtual address for the new kernel and 177 * boot archive. 178 */ 179 static ddi_dma_attr_t fastboot_below_1G_dma_attr = { 180 DMA_ATTR_V0, 181 0x0000000008000000ULL, /* dma_attr_addr_lo: 128MB */ 182 0x000000003FFFFFFFULL, /* dma_attr_addr_hi: 1G */ 183 0x00000000FFFFFFFFULL, /* dma_attr_count_max */ 184 0x0000000000001000ULL, /* dma_attr_align: 4KB */ 185 1, /* dma_attr_burstsize */ 186 1, /* dma_attr_minxfer */ 187 0x00000000FFFFFFFFULL, /* dma_attr_maxxfer */ 188 0x00000000FFFFFFFFULL, /* dma_attr_seg */ 189 1, /* dma_attr_sgllen */ 190 0x1000ULL, /* dma_attr_granular */ 191 0, /* dma_attr_flags */ 192 }; 193 194 static ddi_dma_attr_t fastboot_dma_attr = { 195 DMA_ATTR_V0, 196 0x0000000008000000ULL, /* dma_attr_addr_lo: 128MB */ 197 0xFFFFFFFFFFFFFFFFULL, /* dma_attr_addr_hi: 2^64B */ 198 0x00000000FFFFFFFFULL, /* dma_attr_count_max */ 199 0x0000000000001000ULL, /* dma_attr_align: 4KB */ 200 1, /* dma_attr_burstsize */ 201 1, /* dma_attr_minxfer */ 202 0x00000000FFFFFFFFULL, /* dma_attr_maxxfer */ 203 0x00000000FFFFFFFFULL, /* dma_attr_seg */ 204 1, /* dma_attr_sgllen */ 205 0x1000ULL, /* dma_attr_granular */ 206 0, /* dma_attr_flags */ 207 }; 208 209 /* 210 * Various information saved from the previous boot to reconstruct 211 * multiboot_info. 212 */ 213 extern multiboot_info_t saved_mbi; 214 extern mb_memory_map_t saved_mmap[FASTBOOT_SAVED_MMAP_COUNT]; 215 extern uint8_t saved_drives[FASTBOOT_SAVED_DRIVES_SIZE]; 216 extern char saved_cmdline[FASTBOOT_SAVED_CMDLINE_LEN]; 217 extern int saved_cmdline_len; 218 extern size_t saved_file_size[]; 219 220 extern void* contig_alloc(size_t size, ddi_dma_attr_t *attr, 221 uintptr_t align, int cansleep); 222 extern void contig_free(void *addr, size_t size); 223 224 225 /* PRINTLIKE */ 226 extern void vprintf(const char *, va_list); 227 228 229 /* 230 * Need to be able to get boot_archives from other places 231 */ 232 #define BOOTARCHIVE64 "/platform/i86pc/amd64/boot_archive" 233 #define BOOTARCHIVE32 "/platform/i86pc/boot_archive" 234 #define BOOTARCHIVE32_FAILSAFE "/boot/x86.miniroot-safe" 235 #define BOOTARCHIVE64_FAILSAFE "/boot/amd64/x86.miniroot-safe" 236 #define FAILSAFE_BOOTFILE32 "/boot/platform/i86pc/kernel/unix" 237 #define FAILSAFE_BOOTFILE64 "/boot/platform/i86pc/kernel/amd64/unix" 238 239 static uint_t fastboot_vatoindex(fastboot_info_t *, uintptr_t, int); 240 static void fastboot_map_with_size(fastboot_info_t *, uintptr_t, 241 paddr_t, size_t, int); 242 static void fastboot_build_pagetables(fastboot_info_t *); 243 static int fastboot_build_mbi(char *, fastboot_info_t *); 244 static void fastboot_free_file(fastboot_file_t *); 245 246 static const char fastboot_enomem_msg[] = "!Fastboot: Couldn't allocate 0x%" 247 PRIx64" bytes below %s to do fast reboot"; 248 249 static void 250 dprintf(char *fmt, ...) 251 { 252 va_list adx; 253 254 if (!fastboot_debug) 255 return; 256 257 va_start(adx, fmt); 258 vprintf(fmt, adx); 259 va_end(adx); 260 } 261 262 263 /* 264 * Return the index corresponding to a virt address at a given page table level. 265 */ 266 static uint_t 267 fastboot_vatoindex(fastboot_info_t *nk, uintptr_t va, int level) 268 { 269 return ((va >> nk->fi_shift_amt[level]) & (nk->fi_ptes_per_table - 1)); 270 } 271 272 273 /* 274 * Add mapping from vstart to pstart for the specified size. 275 * vstart, pstart and size should all have been aligned at 2M boundaries. 276 */ 277 static void 278 fastboot_map_with_size(fastboot_info_t *nk, uintptr_t vstart, paddr_t pstart, 279 size_t size, int level) 280 { 281 x86pte_t pteval, *table; 282 uintptr_t vaddr; 283 paddr_t paddr; 284 int index, l; 285 286 table = (x86pte_t *)(nk->fi_pagetable_va); 287 288 for (l = nk->fi_top_level; l >= level; l--) { 289 290 index = fastboot_vatoindex(nk, vstart, l); 291 292 if (l == level) { 293 /* 294 * Last level. Program the page table entries. 295 */ 296 for (vaddr = vstart, paddr = pstart; 297 vaddr < vstart + size; 298 vaddr += (1ULL << nk->fi_shift_amt[l]), 299 paddr += (1ULL << nk->fi_shift_amt[l])) { 300 301 uint_t index = fastboot_vatoindex(nk, vaddr, l); 302 303 if (l > 0) 304 pteval = paddr | pte_bits | PT_PAGESIZE; 305 else 306 pteval = paddr | pte_bits; 307 308 table[index] = pteval; 309 } 310 } else if (table[index] & PT_VALID) { 311 312 table = (x86pte_t *) 313 ((uintptr_t)(((paddr_t)table[index] & MMU_PAGEMASK) 314 - nk->fi_pagetable_pa) + nk->fi_pagetable_va); 315 } else { 316 /* 317 * Intermediate levels. 318 * Program with either valid bit or PTP bits. 319 */ 320 if (l == nk->fi_top_level) { 321 ASSERT(nk->fi_top_level == 3); 322 table[index] = nk->fi_next_table_pa | ptp_bits; 323 } else { 324 table[index] = nk->fi_next_table_pa | ptp_bits; 325 } 326 table = (x86pte_t *)(nk->fi_next_table_va); 327 nk->fi_next_table_va += MMU_PAGESIZE; 328 nk->fi_next_table_pa += MMU_PAGESIZE; 329 } 330 } 331 } 332 333 /* 334 * Build page tables for the lower 1G of physical memory using 2M 335 * pages, and prepare page tables for mapping new kernel and boot 336 * archive pages using 4K pages. 337 */ 338 static void 339 fastboot_build_pagetables(fastboot_info_t *nk) 340 { 341 /* 342 * Map lower 1G physical memory. Use large pages. 343 */ 344 fastboot_map_with_size(nk, 0, 0, ONE_GIG, 1); 345 346 /* 347 * Map one 4K page to get the middle page tables set up. 348 */ 349 fake_va = P2ALIGN_TYPED(fake_va, nk->fi_lpagesize, uintptr_t); 350 fastboot_map_with_size(nk, fake_va, 351 nk->fi_files[0].fb_pte_list_va[0] & MMU_PAGEMASK, PAGESIZE, 0); 352 } 353 354 355 /* 356 * Sanity check. Look for dboot offset. 357 */ 358 static int 359 fastboot_elf64_find_dboot_load_offset(void *img, off_t imgsz, uint32_t *offp) 360 { 361 Elf64_Ehdr *ehdr = (Elf64_Ehdr *)img; 362 Elf64_Phdr *phdr; 363 uint8_t *phdrbase; 364 int i; 365 366 if ((ehdr->e_phoff + ehdr->e_phnum * ehdr->e_phentsize) >= imgsz) 367 return (-1); 368 369 phdrbase = (uint8_t *)img + ehdr->e_phoff; 370 371 for (i = 0; i < ehdr->e_phnum; i++) { 372 phdr = (Elf64_Phdr *)(phdrbase + ehdr->e_phentsize * i); 373 374 if (phdr->p_type == PT_LOAD) { 375 if (phdr->p_vaddr == phdr->p_paddr && 376 phdr->p_vaddr == DBOOT_ENTRY_ADDRESS) { 377 ASSERT(phdr->p_offset <= UINT32_MAX); 378 *offp = (uint32_t)phdr->p_offset; 379 return (0); 380 } 381 } 382 } 383 384 return (-1); 385 } 386 387 388 /* 389 * Initialize text and data section information for 32-bit kernel. 390 * sectcntp - is both input/output parameter. 391 * On entry, *sectcntp contains maximum allowable number of sections; 392 * on return, it contains the actual number of sections filled. 393 */ 394 static int 395 fastboot_elf32_find_loadables(void *img, off_t imgsz, fastboot_section_t *sectp, 396 int *sectcntp, uint32_t *offp) 397 { 398 Elf32_Ehdr *ehdr = (Elf32_Ehdr *)img; 399 Elf32_Phdr *phdr; 400 uint8_t *phdrbase; 401 int i; 402 int used_sections = 0; 403 const int max_sectcnt = *sectcntp; 404 405 if ((ehdr->e_phoff + ehdr->e_phnum * ehdr->e_phentsize) >= imgsz) 406 return (-1); 407 408 phdrbase = (uint8_t *)img + ehdr->e_phoff; 409 410 for (i = 0; i < ehdr->e_phnum; i++) { 411 phdr = (Elf32_Phdr *)(phdrbase + ehdr->e_phentsize * i); 412 413 if (phdr->p_type == PT_INTERP) 414 return (-1); 415 416 if (phdr->p_type != PT_LOAD) 417 continue; 418 419 if (phdr->p_vaddr == phdr->p_paddr && 420 phdr->p_paddr == DBOOT_ENTRY_ADDRESS) { 421 *offp = (uint32_t)phdr->p_offset; 422 } else { 423 if (max_sectcnt <= used_sections) 424 return (-1); 425 426 sectp[used_sections].fb_sec_offset = phdr->p_offset; 427 sectp[used_sections].fb_sec_paddr = phdr->p_paddr; 428 sectp[used_sections].fb_sec_size = phdr->p_filesz; 429 sectp[used_sections].fb_sec_bss_size = 430 (phdr->p_filesz < phdr->p_memsz) ? 431 (phdr->p_memsz - phdr->p_filesz) : 0; 432 433 /* Extra sanity check for the input object file */ 434 if (sectp[used_sections].fb_sec_paddr + 435 sectp[used_sections].fb_sec_size + 436 sectp[used_sections].fb_sec_bss_size >= 437 DBOOT_ENTRY_ADDRESS) 438 return (-1); 439 440 used_sections++; 441 } 442 } 443 444 *sectcntp = used_sections; 445 return (0); 446 } 447 448 /* 449 * Create multiboot info structure (mbi) base on the saved mbi. 450 * Recalculate values of the pointer type fields in the data 451 * structure based on the new starting physical address of the 452 * data structure. 453 */ 454 static int 455 fastboot_build_mbi(char *mdep, fastboot_info_t *nk) 456 { 457 mb_module_t *mbp; 458 multiboot_info_t *mbi; /* pointer to multiboot structure */ 459 uintptr_t start_addr_va; /* starting VA of mbi */ 460 uintptr_t start_addr_pa; /* starting PA of mbi */ 461 size_t offs = 0; /* offset from the starting address */ 462 size_t arglen; /* length of the command line arg */ 463 size_t size; /* size of the memory reserved for mbi */ 464 size_t mdnsz; /* length of the boot archive name */ 465 466 /* 467 * If mdep is not NULL or empty, use the length of mdep + 1 468 * (for NULL terminating) as the length of the new command 469 * line; else use the saved command line length as the 470 * length for the new command line. 471 */ 472 if (mdep != NULL && strlen(mdep) != 0) { 473 arglen = strlen(mdep) + 1; 474 } else { 475 arglen = saved_cmdline_len; 476 } 477 478 /* 479 * Allocate memory for the new multiboot info structure (mbi). 480 * If we have reserved memory for mbi but it's not enough, 481 * free it and reallocate. 482 */ 483 size = PAGESIZE + P2ROUNDUP(arglen, PAGESIZE); 484 if (nk->fi_mbi_size && nk->fi_mbi_size < size) { 485 contig_free((void *)nk->fi_new_mbi_va, nk->fi_mbi_size); 486 nk->fi_mbi_size = 0; 487 } 488 489 if (nk->fi_mbi_size == 0) { 490 if ((nk->fi_new_mbi_va = 491 (uintptr_t)contig_alloc(size, &fastboot_below_1G_dma_attr, 492 PAGESIZE, 0)) == 0) { 493 cmn_err(CE_NOTE, fastboot_enomem_msg, 494 (uint64_t)size, "1G"); 495 return (-1); 496 } 497 /* 498 * fi_mbi_size must be set after the allocation succeeds 499 * as it's used to determine how much memory to free. 500 */ 501 nk->fi_mbi_size = size; 502 } 503 504 /* 505 * Initalize memory 506 */ 507 bzero((void *)nk->fi_new_mbi_va, nk->fi_mbi_size); 508 509 /* 510 * Get PA for the new mbi 511 */ 512 start_addr_va = nk->fi_new_mbi_va; 513 start_addr_pa = mmu_ptob((uint64_t)hat_getpfnum(kas.a_hat, 514 (caddr_t)start_addr_va)); 515 nk->fi_new_mbi_pa = (paddr_t)start_addr_pa; 516 517 /* 518 * Populate the rest of the fields in the data structure 519 */ 520 521 /* 522 * Copy from the saved mbi to preserve all non-pointer type fields. 523 */ 524 mbi = (multiboot_info_t *)start_addr_va; 525 bcopy(&saved_mbi, mbi, sizeof (*mbi)); 526 527 /* 528 * Recalculate mods_addr. Set mod_start and mod_end based on 529 * the physical address of the new boot archive. Set mod_name 530 * to the name of the new boto archive. 531 */ 532 offs += sizeof (multiboot_info_t); 533 mbi->mods_addr = start_addr_pa + offs; 534 mbp = (mb_module_t *)(start_addr_va + offs); 535 mbp->mod_start = nk->fi_files[FASTBOOT_BOOTARCHIVE].fb_dest_pa; 536 mbp->mod_end = nk->fi_files[FASTBOOT_BOOTARCHIVE].fb_next_pa; 537 538 offs += sizeof (mb_module_t); 539 mdnsz = strlen(fastboot_filename[FASTBOOT_NAME_BOOTARCHIVE]) + 1; 540 bcopy(fastboot_filename[FASTBOOT_NAME_BOOTARCHIVE], 541 (void *)(start_addr_va + offs), mdnsz); 542 mbp->mod_name = start_addr_pa + offs; 543 mbp->reserved = 0; 544 545 /* 546 * Make sure the offset is 16-byte aligned to avoid unaligned access. 547 */ 548 offs += mdnsz; 549 offs = P2ROUNDUP_TYPED(offs, 16, size_t); 550 551 /* 552 * Recalculate mmap_addr 553 */ 554 mbi->mmap_addr = start_addr_pa + offs; 555 bcopy((void *)(uintptr_t)saved_mmap, (void *)(start_addr_va + offs), 556 saved_mbi.mmap_length); 557 offs += saved_mbi.mmap_length; 558 559 /* 560 * Recalculate drives_addr 561 */ 562 mbi->drives_addr = start_addr_pa + offs; 563 bcopy((void *)(uintptr_t)saved_drives, (void *)(start_addr_va + offs), 564 saved_mbi.drives_length); 565 offs += saved_mbi.drives_length; 566 567 /* 568 * Recalculate the address of cmdline. Set cmdline to contain the 569 * new boot argument. 570 */ 571 mbi->cmdline = start_addr_pa + offs; 572 573 if (mdep != NULL && strlen(mdep) != 0) { 574 bcopy(mdep, (void *)(start_addr_va + offs), arglen); 575 } else { 576 bcopy((void *)saved_cmdline, (void *)(start_addr_va + offs), 577 arglen); 578 } 579 580 /* clear fields and flags that are not copied */ 581 bzero(&mbi->config_table, 582 sizeof (*mbi) - offsetof(multiboot_info_t, config_table)); 583 mbi->flags &= ~(MB_INFO_CONFIG_TABLE | MB_INFO_BOOT_LOADER_NAME | 584 MB_INFO_APM_TABLE | MB_INFO_VIDEO_INFO); 585 586 return (0); 587 } 588 589 /* 590 * Initialize HAT related fields 591 */ 592 static void 593 fastboot_init_fields(fastboot_info_t *nk) 594 { 595 if (is_x86_feature(x86_featureset, X86FSET_PAE)) { 596 nk->fi_has_pae = 1; 597 nk->fi_shift_amt = fastboot_shift_amt_pae; 598 nk->fi_ptes_per_table = 512; 599 nk->fi_lpagesize = (2 << 20); /* 2M */ 600 nk->fi_top_level = 3; 601 } 602 } 603 604 /* 605 * Process boot argument 606 */ 607 static void 608 fastboot_parse_mdep(char *mdep, char *kern_bootpath, int *bootpath_len, 609 char *bootargs) 610 { 611 int i; 612 613 /* 614 * If mdep is not NULL, it comes in the format of 615 * mountpoint unix args 616 */ 617 if (mdep != NULL && strlen(mdep) != 0) { 618 if (mdep[0] != '-') { 619 /* First get the root argument */ 620 i = 0; 621 while (mdep[i] != '\0' && mdep[i] != ' ') { 622 i++; 623 } 624 625 if (i < 4 || strncmp(&mdep[i-4], "unix", 4) != 0) { 626 /* mount point */ 627 bcopy(mdep, kern_bootpath, i); 628 kern_bootpath[i] = '\0'; 629 *bootpath_len = i; 630 631 /* 632 * Get the next argument. It should be unix as 633 * we have validated in in halt.c. 634 */ 635 if (strlen(mdep) > i) { 636 mdep += (i + 1); 637 i = 0; 638 while (mdep[i] != '\0' && 639 mdep[i] != ' ') { 640 i++; 641 } 642 } 643 644 } 645 bcopy(mdep, kern_bootfile, i); 646 kern_bootfile[i] = '\0'; 647 bcopy(mdep, bootargs, strlen(mdep)); 648 } else { 649 int off = strlen(kern_bootfile); 650 bcopy(kern_bootfile, bootargs, off); 651 bcopy(" ", &bootargs[off++], 1); 652 bcopy(mdep, &bootargs[off], strlen(mdep)); 653 off += strlen(mdep); 654 bootargs[off] = '\0'; 655 } 656 } 657 } 658 659 /* 660 * Reserve memory under PA 1G for mapping the new kernel and boot archive. 661 * This function is only called if fastreboot_onpanic is *not* set. 662 */ 663 static void 664 fastboot_reserve_mem(fastboot_info_t *nk) 665 { 666 int i; 667 668 /* 669 * A valid kernel is in place. No need to reserve any memory. 670 */ 671 if (nk->fi_valid) 672 return; 673 674 /* 675 * Reserve memory under PA 1G for PTE lists. 676 */ 677 for (i = 0; i < FASTBOOT_MAX_FILES_MAP; i++) { 678 fastboot_file_t *fb = &nk->fi_files[i]; 679 size_t fsize_roundup, size; 680 681 fsize_roundup = P2ROUNDUP_TYPED(saved_file_size[i], 682 PAGESIZE, size_t); 683 size = FASTBOOT_PTE_LIST_SIZE(fsize_roundup); 684 if ((fb->fb_pte_list_va = contig_alloc(size, 685 &fastboot_below_1G_dma_attr, PAGESIZE, 0)) == NULL) { 686 return; 687 } 688 fb->fb_pte_list_size = size; 689 } 690 691 /* 692 * Reserve memory under PA 1G for page tables. 693 */ 694 if ((nk->fi_pagetable_va = 695 (uintptr_t)contig_alloc(fastboot_pagetable_size, 696 &fastboot_below_1G_dma_attr, PAGESIZE, 0)) == 0) { 697 return; 698 } 699 nk->fi_pagetable_size = fastboot_pagetable_size; 700 701 /* 702 * Reserve memory under PA 1G for multiboot structure. 703 */ 704 if ((nk->fi_new_mbi_va = (uintptr_t)contig_alloc(fastboot_mbi_size, 705 &fastboot_below_1G_dma_attr, PAGESIZE, 0)) == 0) { 706 return; 707 } 708 nk->fi_mbi_size = fastboot_mbi_size; 709 } 710 711 /* 712 * Calculate MD5 digest for the given fastboot_file. 713 * Assumes that the file is allready loaded properly. 714 */ 715 static void 716 fastboot_cksum_file(fastboot_file_t *fb, uchar_t *md5_hash) 717 { 718 MD5_CTX md5_ctx; 719 720 MD5Init(&md5_ctx); 721 MD5Update(&md5_ctx, (void *)fb->fb_va, fb->fb_size); 722 MD5Final(md5_hash, &md5_ctx); 723 } 724 725 /* 726 * Free up the memory we have allocated for a file 727 */ 728 static void 729 fastboot_free_file(fastboot_file_t *fb) 730 { 731 size_t fsize_roundup; 732 733 fsize_roundup = P2ROUNDUP_TYPED(fb->fb_size, PAGESIZE, size_t); 734 if (fsize_roundup) { 735 contig_free((void *)fb->fb_va, fsize_roundup); 736 fb->fb_va = 0; 737 fb->fb_size = 0; 738 } 739 } 740 741 /* 742 * Free up memory used by the PTEs for a file. 743 */ 744 static void 745 fastboot_free_file_pte(fastboot_file_t *fb, uint64_t endaddr) 746 { 747 if (fb->fb_pte_list_size && fb->fb_pte_list_pa < endaddr) { 748 contig_free((void *)fb->fb_pte_list_va, fb->fb_pte_list_size); 749 fb->fb_pte_list_va = 0; 750 fb->fb_pte_list_pa = 0; 751 fb->fb_pte_list_size = 0; 752 } 753 } 754 755 /* 756 * Free up all the memory used for representing a kernel with 757 * fastboot_info_t. 758 */ 759 static void 760 fastboot_free_mem(fastboot_info_t *nk, uint64_t endaddr) 761 { 762 int i; 763 764 for (i = 0; i < FASTBOOT_MAX_FILES_MAP; i++) { 765 fastboot_free_file(nk->fi_files + i); 766 fastboot_free_file_pte(nk->fi_files + i, endaddr); 767 } 768 769 if (nk->fi_pagetable_size && nk->fi_pagetable_pa < endaddr) { 770 contig_free((void *)nk->fi_pagetable_va, nk->fi_pagetable_size); 771 nk->fi_pagetable_va = 0; 772 nk->fi_pagetable_pa = 0; 773 nk->fi_pagetable_size = 0; 774 } 775 776 if (nk->fi_mbi_size && nk->fi_new_mbi_pa < endaddr) { 777 contig_free((void *)nk->fi_new_mbi_va, nk->fi_mbi_size); 778 nk->fi_new_mbi_va = 0; 779 nk->fi_new_mbi_pa = 0; 780 nk->fi_mbi_size = 0; 781 } 782 } 783 784 /* 785 * Only free up the memory allocated for the kernel and boot archive, 786 * but not for the page tables. 787 */ 788 void 789 fastboot_free_newkernel(fastboot_info_t *nk) 790 { 791 int i; 792 793 nk->fi_valid = 0; 794 /* 795 * Free the memory we have allocated 796 */ 797 for (i = 0; i < FASTBOOT_MAX_FILES_MAP; i++) { 798 fastboot_free_file(&(nk->fi_files[i])); 799 } 800 } 801 802 static void 803 fastboot_cksum_cdata(fastboot_info_t *nk, uchar_t *md5_hash) 804 { 805 int i; 806 MD5_CTX md5_ctx; 807 808 MD5Init(&md5_ctx); 809 for (i = 0; i < FASTBOOT_MAX_FILES_MAP; i++) { 810 MD5Update(&md5_ctx, nk->fi_files[i].fb_pte_list_va, 811 nk->fi_files[i].fb_pte_list_size); 812 } 813 MD5Update(&md5_ctx, (void *)nk->fi_pagetable_va, nk->fi_pagetable_size); 814 MD5Update(&md5_ctx, (void *)nk->fi_new_mbi_va, nk->fi_mbi_size); 815 816 MD5Final(md5_hash, &md5_ctx); 817 } 818 819 /* 820 * Generate MD5 checksum of the given kernel. 821 */ 822 static void 823 fastboot_cksum_generate(fastboot_info_t *nk) 824 { 825 int i; 826 827 for (i = 0; i < FASTBOOT_MAX_FILES_MAP; i++) { 828 fastboot_cksum_file(nk->fi_files + i, nk->fi_md5_hash[i]); 829 } 830 fastboot_cksum_cdata(nk, nk->fi_md5_hash[i]); 831 } 832 833 /* 834 * Calculate MD5 checksum of the given kernel and verify that 835 * it matches with what was calculated before. 836 */ 837 int 838 fastboot_cksum_verify(fastboot_info_t *nk) 839 { 840 int i; 841 uchar_t md5_hash[MD5_DIGEST_LENGTH]; 842 843 for (i = 0; i < FASTBOOT_MAX_FILES_MAP; i++) { 844 fastboot_cksum_file(nk->fi_files + i, md5_hash); 845 if (bcmp(nk->fi_md5_hash[i], md5_hash, 846 sizeof (nk->fi_md5_hash[i])) != 0) 847 return (i + 1); 848 } 849 850 fastboot_cksum_cdata(nk, md5_hash); 851 if (bcmp(nk->fi_md5_hash[i], md5_hash, 852 sizeof (nk->fi_md5_hash[i])) != 0) 853 return (i + 1); 854 855 return (0); 856 } 857 858 /* 859 * This function performs the following tasks: 860 * - Read the sizes of the new kernel and boot archive. 861 * - Allocate memory for the new kernel and boot archive. 862 * - Allocate memory for page tables necessary for mapping the memory 863 * allocated for the files. 864 * - Read the new kernel and boot archive into memory. 865 * - Map in the fast reboot switcher. 866 * - Load the fast reboot switcher to FASTBOOT_SWTCH_PA. 867 * - Build the new multiboot_info structure 868 * - Build page tables for the low 1G of physical memory. 869 * - Mark the data structure as valid if all steps have succeeded. 870 */ 871 void 872 fastboot_load_kernel(char *mdep) 873 { 874 void *buf = NULL; 875 int i; 876 fastboot_file_t *fb; 877 uint32_t dboot_start_offset; 878 char kern_bootpath[OBP_MAXPATHLEN]; 879 extern uintptr_t postbootkernelbase; 880 uintptr_t saved_kernelbase; 881 int bootpath_len = 0; 882 int is_failsafe = 0; 883 int is_retry = 0; 884 uint64_t end_addr; 885 886 if (!fastreboot_capable) 887 return; 888 889 if (newkernel.fi_valid) 890 fastboot_free_newkernel(&newkernel); 891 892 saved_kernelbase = postbootkernelbase; 893 894 postbootkernelbase = 0; 895 896 /* 897 * Initialize various HAT related fields in the data structure 898 */ 899 fastboot_init_fields(&newkernel); 900 901 bzero(kern_bootpath, OBP_MAXPATHLEN); 902 903 /* 904 * Process the boot argument 905 */ 906 bzero(fastboot_args, OBP_MAXPATHLEN); 907 fastboot_parse_mdep(mdep, kern_bootpath, &bootpath_len, fastboot_args); 908 909 /* 910 * Make sure we get the null character 911 */ 912 bcopy(kern_bootpath, fastboot_filename[FASTBOOT_NAME_UNIX], 913 bootpath_len); 914 bcopy(kern_bootfile, 915 &fastboot_filename[FASTBOOT_NAME_UNIX][bootpath_len], 916 strlen(kern_bootfile) + 1); 917 918 bcopy(kern_bootpath, fastboot_filename[FASTBOOT_NAME_BOOTARCHIVE], 919 bootpath_len); 920 921 if (bcmp(kern_bootfile, FAILSAFE_BOOTFILE32, 922 (sizeof (FAILSAFE_BOOTFILE32) - 1)) == 0 || 923 bcmp(kern_bootfile, FAILSAFE_BOOTFILE64, 924 (sizeof (FAILSAFE_BOOTFILE64) - 1)) == 0) { 925 is_failsafe = 1; 926 } 927 928 load_kernel_retry: 929 /* 930 * Read in unix and boot_archive 931 */ 932 end_addr = DBOOT_ENTRY_ADDRESS; 933 for (i = 0; i < FASTBOOT_MAX_FILES_MAP; i++) { 934 struct _buf *file; 935 uintptr_t va; 936 uint64_t fsize; 937 size_t fsize_roundup, pt_size; 938 int page_index; 939 uintptr_t offset; 940 ddi_dma_attr_t dma_attr = fastboot_dma_attr; 941 942 943 dprintf("fastboot_filename[%d] = %s\n", 944 i, fastboot_filename[i]); 945 946 if ((file = kobj_open_file(fastboot_filename[i])) == 947 (struct _buf *)-1) { 948 cmn_err(CE_NOTE, "!Fastboot: Couldn't open %s", 949 fastboot_filename[i]); 950 goto err_out; 951 } 952 953 if (kobj_get_filesize(file, &fsize) != 0) { 954 cmn_err(CE_NOTE, 955 "!Fastboot: Couldn't get filesize for %s", 956 fastboot_filename[i]); 957 goto err_out; 958 } 959 960 fsize_roundup = P2ROUNDUP_TYPED(fsize, PAGESIZE, size_t); 961 962 /* 963 * Where the files end in physical memory after being 964 * relocated by the fast boot switcher. 965 */ 966 end_addr += fsize_roundup; 967 if (end_addr > fastboot_below_1G_dma_attr.dma_attr_addr_hi) { 968 cmn_err(CE_NOTE, "!Fastboot: boot archive is too big"); 969 goto err_out; 970 } 971 972 /* 973 * Adjust dma_attr_addr_lo so that the new kernel and boot 974 * archive will not be overridden during relocation. 975 */ 976 if (end_addr > fastboot_dma_attr.dma_attr_addr_lo || 977 end_addr > fastboot_below_1G_dma_attr.dma_attr_addr_lo) { 978 979 if (is_retry) { 980 /* 981 * If we have already tried and didn't succeed, 982 * just give up. 983 */ 984 cmn_err(CE_NOTE, 985 "!Fastboot: boot archive is too big"); 986 goto err_out; 987 } else { 988 /* Set the flag so we don't keep retrying */ 989 is_retry++; 990 991 /* Adjust dma_attr_addr_lo */ 992 fastboot_dma_attr.dma_attr_addr_lo = end_addr; 993 fastboot_below_1G_dma_attr.dma_attr_addr_lo = 994 end_addr; 995 996 /* 997 * Free the memory we have already allocated 998 * whose physical addresses might not fit 999 * the new lo and hi constraints. 1000 */ 1001 fastboot_free_mem(&newkernel, end_addr); 1002 goto load_kernel_retry; 1003 } 1004 } 1005 1006 1007 if (!fastboot_contig) 1008 dma_attr.dma_attr_sgllen = (fsize / PAGESIZE) + 1009 (((fsize % PAGESIZE) == 0) ? 0 : 1); 1010 1011 if ((buf = contig_alloc(fsize, &dma_attr, PAGESIZE, 0)) 1012 == NULL) { 1013 cmn_err(CE_NOTE, fastboot_enomem_msg, fsize, "64G"); 1014 goto err_out; 1015 } 1016 1017 va = P2ROUNDUP_TYPED((uintptr_t)buf, PAGESIZE, uintptr_t); 1018 1019 if (kobj_read_file(file, (char *)va, fsize, 0) < 0) { 1020 cmn_err(CE_NOTE, "!Fastboot: Couldn't read %s", 1021 fastboot_filename[i]); 1022 goto err_out; 1023 } 1024 1025 fb = &newkernel.fi_files[i]; 1026 fb->fb_va = va; 1027 fb->fb_size = fsize; 1028 fb->fb_sectcnt = 0; 1029 1030 pt_size = FASTBOOT_PTE_LIST_SIZE(fsize_roundup); 1031 1032 /* 1033 * If we have reserved memory but it not enough, free it. 1034 */ 1035 if (fb->fb_pte_list_size && fb->fb_pte_list_size < pt_size) { 1036 contig_free((void *)fb->fb_pte_list_va, 1037 fb->fb_pte_list_size); 1038 fb->fb_pte_list_size = 0; 1039 } 1040 1041 if (fb->fb_pte_list_size == 0) { 1042 if ((fb->fb_pte_list_va = 1043 (x86pte_t *)contig_alloc(pt_size, 1044 &fastboot_below_1G_dma_attr, PAGESIZE, 0)) 1045 == NULL) { 1046 cmn_err(CE_NOTE, fastboot_enomem_msg, 1047 (uint64_t)pt_size, "1G"); 1048 goto err_out; 1049 } 1050 /* 1051 * fb_pte_list_size must be set after the allocation 1052 * succeeds as it's used to determine how much memory to 1053 * free. 1054 */ 1055 fb->fb_pte_list_size = pt_size; 1056 } 1057 1058 bzero((void *)(fb->fb_pte_list_va), fb->fb_pte_list_size); 1059 1060 fb->fb_pte_list_pa = mmu_ptob((uint64_t)hat_getpfnum(kas.a_hat, 1061 (caddr_t)fb->fb_pte_list_va)); 1062 1063 for (page_index = 0, offset = 0; offset < fb->fb_size; 1064 offset += PAGESIZE) { 1065 uint64_t paddr; 1066 1067 paddr = mmu_ptob((uint64_t)hat_getpfnum(kas.a_hat, 1068 (caddr_t)fb->fb_va + offset)); 1069 1070 ASSERT(paddr >= fastboot_dma_attr.dma_attr_addr_lo); 1071 1072 /* 1073 * Include the pte_bits so we don't have to make 1074 * it in assembly. 1075 */ 1076 fb->fb_pte_list_va[page_index++] = (x86pte_t) 1077 (paddr | pte_bits); 1078 } 1079 1080 fb->fb_pte_list_va[page_index] = FASTBOOT_TERMINATE; 1081 1082 if (i == FASTBOOT_UNIX) { 1083 Ehdr *ehdr = (Ehdr *)va; 1084 int j; 1085 1086 /* 1087 * Sanity checks: 1088 */ 1089 for (j = 0; j < SELFMAG; j++) { 1090 if (ehdr->e_ident[j] != ELFMAG[j]) { 1091 cmn_err(CE_NOTE, "!Fastboot: Bad ELF " 1092 "signature"); 1093 goto err_out; 1094 } 1095 } 1096 1097 if (ehdr->e_ident[EI_CLASS] == ELFCLASS32 && 1098 ehdr->e_ident[EI_DATA] == ELFDATA2LSB && 1099 ehdr->e_machine == EM_386) { 1100 1101 fb->fb_sectcnt = sizeof (fb->fb_sections) / 1102 sizeof (fb->fb_sections[0]); 1103 1104 if (fastboot_elf32_find_loadables((void *)va, 1105 fsize, &fb->fb_sections[0], 1106 &fb->fb_sectcnt, &dboot_start_offset) < 0) { 1107 cmn_err(CE_NOTE, "!Fastboot: ELF32 " 1108 "program section failure"); 1109 goto err_out; 1110 } 1111 1112 if (fb->fb_sectcnt == 0) { 1113 cmn_err(CE_NOTE, "!Fastboot: No ELF32 " 1114 "program sections found"); 1115 goto err_out; 1116 } 1117 1118 if (is_failsafe) { 1119 /* Failsafe boot_archive */ 1120 bcopy(BOOTARCHIVE32_FAILSAFE, 1121 &fastboot_filename 1122 [FASTBOOT_NAME_BOOTARCHIVE] 1123 [bootpath_len], 1124 sizeof (BOOTARCHIVE32_FAILSAFE)); 1125 } else { 1126 bcopy(BOOTARCHIVE32, 1127 &fastboot_filename 1128 [FASTBOOT_NAME_BOOTARCHIVE] 1129 [bootpath_len], 1130 sizeof (BOOTARCHIVE32)); 1131 } 1132 1133 } else if (ehdr->e_ident[EI_CLASS] == ELFCLASS64 && 1134 ehdr->e_ident[EI_DATA] == ELFDATA2LSB && 1135 ehdr->e_machine == EM_AMD64) { 1136 1137 if (fastboot_elf64_find_dboot_load_offset( 1138 (void *)va, fsize, &dboot_start_offset) 1139 != 0) { 1140 cmn_err(CE_NOTE, "!Fastboot: Couldn't " 1141 "find ELF64 dboot entry offset"); 1142 goto err_out; 1143 } 1144 1145 if (!is_x86_feature(x86_featureset, 1146 X86FSET_64) || 1147 !is_x86_feature(x86_featureset, 1148 X86FSET_PAE)) { 1149 cmn_err(CE_NOTE, "Fastboot: Cannot " 1150 "reboot to %s: " 1151 "not a 64-bit capable system", 1152 kern_bootfile); 1153 goto err_out; 1154 } 1155 1156 if (is_failsafe) { 1157 /* Failsafe boot_archive */ 1158 bcopy(BOOTARCHIVE64_FAILSAFE, 1159 &fastboot_filename 1160 [FASTBOOT_NAME_BOOTARCHIVE] 1161 [bootpath_len], 1162 sizeof (BOOTARCHIVE64_FAILSAFE)); 1163 } else { 1164 bcopy(BOOTARCHIVE64, 1165 &fastboot_filename 1166 [FASTBOOT_NAME_BOOTARCHIVE] 1167 [bootpath_len], 1168 sizeof (BOOTARCHIVE64)); 1169 } 1170 } else { 1171 cmn_err(CE_NOTE, "!Fastboot: Unknown ELF type"); 1172 goto err_out; 1173 } 1174 1175 fb->fb_dest_pa = DBOOT_ENTRY_ADDRESS - 1176 dboot_start_offset; 1177 1178 fb->fb_next_pa = DBOOT_ENTRY_ADDRESS + fsize_roundup; 1179 } else { 1180 fb->fb_dest_pa = newkernel.fi_files[i - 1].fb_next_pa; 1181 fb->fb_next_pa = fb->fb_dest_pa + fsize_roundup; 1182 } 1183 1184 kobj_close_file(file); 1185 1186 } 1187 1188 /* 1189 * Add the function that will switch us to 32-bit protected mode 1190 */ 1191 fb = &newkernel.fi_files[FASTBOOT_SWTCH]; 1192 fb->fb_va = fb->fb_dest_pa = FASTBOOT_SWTCH_PA; 1193 fb->fb_size = MMU_PAGESIZE; 1194 1195 hat_devload(kas.a_hat, (caddr_t)fb->fb_va, 1196 MMU_PAGESIZE, mmu_btop(fb->fb_dest_pa), 1197 PROT_READ | PROT_WRITE | PROT_EXEC, 1198 HAT_LOAD_NOCONSIST | HAT_LOAD_LOCK); 1199 1200 /* 1201 * Build the new multiboot_info structure 1202 */ 1203 if (fastboot_build_mbi(fastboot_args, &newkernel) != 0) { 1204 goto err_out; 1205 } 1206 1207 /* 1208 * Build page table for low 1G physical memory. Use big pages. 1209 * Allocate 4 (5 for amd64) pages for the page tables. 1210 * 1 page for PML4 (amd64) 1211 * 1 page for Page-Directory-Pointer Table 1212 * 2 pages for Page Directory 1213 * 1 page for Page Table. 1214 * The page table entry will be rewritten to map the physical 1215 * address as we do the copying. 1216 */ 1217 if (newkernel.fi_has_pae) { 1218 size_t size = MMU_PAGESIZE * 5; 1219 1220 if (newkernel.fi_pagetable_size && newkernel.fi_pagetable_size 1221 < size) { 1222 contig_free((void *)newkernel.fi_pagetable_va, 1223 newkernel.fi_pagetable_size); 1224 newkernel.fi_pagetable_size = 0; 1225 } 1226 1227 if (newkernel.fi_pagetable_size == 0) { 1228 if ((newkernel.fi_pagetable_va = (uintptr_t) 1229 contig_alloc(size, &fastboot_below_1G_dma_attr, 1230 MMU_PAGESIZE, 0)) == 0) { 1231 cmn_err(CE_NOTE, fastboot_enomem_msg, 1232 (uint64_t)size, "1G"); 1233 goto err_out; 1234 } 1235 /* 1236 * fi_pagetable_size must be set after the allocation 1237 * succeeds as it's used to determine how much memory to 1238 * free. 1239 */ 1240 newkernel.fi_pagetable_size = size; 1241 } 1242 1243 bzero((void *)(newkernel.fi_pagetable_va), size); 1244 1245 newkernel.fi_pagetable_pa = 1246 mmu_ptob((uint64_t)hat_getpfnum(kas.a_hat, 1247 (caddr_t)newkernel.fi_pagetable_va)); 1248 1249 newkernel.fi_last_table_pa = newkernel.fi_pagetable_pa + 1250 size - MMU_PAGESIZE; 1251 1252 newkernel.fi_next_table_va = newkernel.fi_pagetable_va + 1253 MMU_PAGESIZE; 1254 newkernel.fi_next_table_pa = newkernel.fi_pagetable_pa + 1255 MMU_PAGESIZE; 1256 1257 fastboot_build_pagetables(&newkernel); 1258 } 1259 1260 1261 /* Generate MD5 checksums */ 1262 fastboot_cksum_generate(&newkernel); 1263 1264 /* Mark it as valid */ 1265 newkernel.fi_valid = 1; 1266 newkernel.fi_magic = FASTBOOT_MAGIC; 1267 1268 postbootkernelbase = saved_kernelbase; 1269 return; 1270 1271 err_out: 1272 postbootkernelbase = saved_kernelbase; 1273 newkernel.fi_valid = 0; 1274 fastboot_free_newkernel(&newkernel); 1275 } 1276 1277 1278 /* ARGSUSED */ 1279 static int 1280 fastboot_xc_func(xc_arg_t arg1, xc_arg_t arg2 __unused, xc_arg_t arg3 __unused) 1281 { 1282 fastboot_info_t *nk = (fastboot_info_t *)arg1; 1283 void (*fastboot_func)(fastboot_info_t *); 1284 fastboot_file_t *fb = &nk->fi_files[FASTBOOT_SWTCH]; 1285 fastboot_func = (void (*)())(fb->fb_va); 1286 kthread_t *t_intr = curthread->t_intr; 1287 1288 if (&kas != curproc->p_as) { 1289 hat_devload(curproc->p_as->a_hat, (caddr_t)fb->fb_va, 1290 MMU_PAGESIZE, mmu_btop(fb->fb_dest_pa), 1291 PROT_READ | PROT_WRITE | PROT_EXEC, 1292 HAT_LOAD_NOCONSIST | HAT_LOAD_LOCK); 1293 } 1294 1295 /* 1296 * If we have pinned a thread, make sure the address is mapped 1297 * in the address space of the pinned thread. 1298 */ 1299 if (t_intr && t_intr->t_procp->p_as->a_hat != curproc->p_as->a_hat && 1300 t_intr->t_procp->p_as != &kas) 1301 hat_devload(t_intr->t_procp->p_as->a_hat, (caddr_t)fb->fb_va, 1302 MMU_PAGESIZE, mmu_btop(fb->fb_dest_pa), 1303 PROT_READ | PROT_WRITE | PROT_EXEC, 1304 HAT_LOAD_NOCONSIST | HAT_LOAD_LOCK); 1305 1306 (*psm_shutdownf)(A_SHUTDOWN, AD_FASTREBOOT); 1307 (*fastboot_func)(nk); 1308 1309 /*NOTREACHED*/ 1310 return (0); 1311 } 1312 1313 /* 1314 * Jump to the fast reboot switcher. This function never returns. 1315 */ 1316 void 1317 fast_reboot() 1318 { 1319 processorid_t bootcpuid = 0; 1320 extern uintptr_t postbootkernelbase; 1321 extern char fb_swtch_image[]; 1322 fastboot_file_t *fb; 1323 int i; 1324 1325 postbootkernelbase = 0; 1326 1327 fb = &newkernel.fi_files[FASTBOOT_SWTCH]; 1328 1329 /* 1330 * Map the address into both the current proc's address 1331 * space and the kernel's address space in case the panic 1332 * is forced by kmdb. 1333 */ 1334 if (&kas != curproc->p_as) { 1335 hat_devload(curproc->p_as->a_hat, (caddr_t)fb->fb_va, 1336 MMU_PAGESIZE, mmu_btop(fb->fb_dest_pa), 1337 PROT_READ | PROT_WRITE | PROT_EXEC, 1338 HAT_LOAD_NOCONSIST | HAT_LOAD_LOCK); 1339 } 1340 1341 bcopy((void *)fb_swtch_image, (void *)fb->fb_va, fb->fb_size); 1342 1343 1344 /* 1345 * Set fb_va to fake_va 1346 */ 1347 for (i = 0; i < FASTBOOT_MAX_FILES_MAP; i++) { 1348 newkernel.fi_files[i].fb_va = fake_va; 1349 1350 } 1351 1352 if (panicstr && CPU->cpu_id != bootcpuid && 1353 CPU_ACTIVE(cpu_get(bootcpuid))) { 1354 extern void panic_idle(void); 1355 cpuset_t cpuset; 1356 1357 CPUSET_ZERO(cpuset); 1358 CPUSET_ADD(cpuset, bootcpuid); 1359 xc_priority((xc_arg_t)&newkernel, 0, 0, CPUSET2BV(cpuset), 1360 fastboot_xc_func); 1361 1362 panic_idle(); 1363 } else 1364 (void) fastboot_xc_func((xc_arg_t)&newkernel, 0, 0); 1365 } 1366 1367 1368 /* 1369 * Get boot property value for fastreboot_onpanic. 1370 * 1371 * NOTE: If fastreboot_onpanic is set to non-zero in /etc/system, 1372 * new setting passed in via "-B fastreboot_onpanic" is ignored. 1373 * This order of precedence is to enable developers debugging panics 1374 * that occur early in boot to utilize Fast Reboot on panic. 1375 */ 1376 static void 1377 fastboot_get_bootprop(void) 1378 { 1379 int val = 0xaa, len, ret; 1380 dev_info_t *devi; 1381 char *propstr = NULL; 1382 1383 devi = ddi_root_node(); 1384 1385 ret = ddi_prop_lookup_string(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS, 1386 FASTREBOOT_ONPANIC, &propstr); 1387 1388 if (ret == DDI_PROP_SUCCESS) { 1389 if (FASTREBOOT_ONPANIC_NOTSET(propstr)) 1390 val = 0; 1391 else if (FASTREBOOT_ONPANIC_ISSET(propstr)) 1392 val = UA_FASTREBOOT_ONPANIC; 1393 1394 /* 1395 * Only set fastreboot_onpanic to the value passed in 1396 * if it's not already set to non-zero, and the value 1397 * has indeed been passed in via command line. 1398 */ 1399 if (!fastreboot_onpanic && val != 0xaa) 1400 fastreboot_onpanic = val; 1401 ddi_prop_free(propstr); 1402 } else if (ret != DDI_PROP_NOT_FOUND && ret != DDI_PROP_UNDEFINED) { 1403 cmn_err(CE_NOTE, "!%s value is invalid, will be ignored", 1404 FASTREBOOT_ONPANIC); 1405 } 1406 1407 len = sizeof (fastreboot_onpanic_cmdline); 1408 ret = ddi_getlongprop_buf(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS, 1409 FASTREBOOT_ONPANIC_CMDLINE, fastreboot_onpanic_cmdline, &len); 1410 1411 if (ret == DDI_PROP_BUF_TOO_SMALL) 1412 cmn_err(CE_NOTE, "!%s value is too long, will be ignored", 1413 FASTREBOOT_ONPANIC_CMDLINE); 1414 } 1415 1416 /* 1417 * This function is called by main() to either load the backup kernel for panic 1418 * fast reboot, or to reserve low physical memory for fast reboot. 1419 */ 1420 void 1421 fastboot_post_startup() 1422 { 1423 lbolt_at_boot = ddi_get_lbolt(); 1424 1425 /* Default to 10 minutes */ 1426 if (fastreboot_onpanic_uptime == LONG_MAX) 1427 fastreboot_onpanic_uptime = SEC_TO_TICK(10 * 60); 1428 1429 if (!fastreboot_capable) 1430 return; 1431 1432 mutex_enter(&fastreboot_config_mutex); 1433 1434 fastboot_get_bootprop(); 1435 1436 if (fastreboot_onpanic) 1437 fastboot_load_kernel(fastreboot_onpanic_cmdline); 1438 else if (reserve_mem_enabled) 1439 fastboot_reserve_mem(&newkernel); 1440 1441 mutex_exit(&fastreboot_config_mutex); 1442 } 1443 1444 /* 1445 * Update boot configuration settings. 1446 * If the new fastreboot_onpanic setting is false, and a kernel has 1447 * been preloaded, free the memory; 1448 * if the new fastreboot_onpanic setting is true and newkernel is 1449 * not valid, load the new kernel. 1450 */ 1451 void 1452 fastboot_update_config(const char *mdep) 1453 { 1454 uint8_t boot_config = (uint8_t)*mdep; 1455 int cur_fastreboot_onpanic; 1456 1457 if (!fastreboot_capable) 1458 return; 1459 1460 mutex_enter(&fastreboot_config_mutex); 1461 1462 cur_fastreboot_onpanic = fastreboot_onpanic; 1463 fastreboot_onpanic = boot_config & UA_FASTREBOOT_ONPANIC; 1464 1465 if (fastreboot_onpanic && (!cur_fastreboot_onpanic || 1466 !newkernel.fi_valid)) 1467 fastboot_load_kernel(fastreboot_onpanic_cmdline); 1468 if (cur_fastreboot_onpanic && !fastreboot_onpanic) 1469 fastboot_free_newkernel(&newkernel); 1470 1471 mutex_exit(&fastreboot_config_mutex); 1472 } 1473 1474 /* 1475 * This is an internal interface to disable Fast Reboot on Panic. 1476 * It frees up memory allocated for the backup kernel and sets 1477 * fastreboot_onpanic to zero. 1478 */ 1479 static void 1480 fastreboot_onpanic_disable(void) 1481 { 1482 uint8_t boot_config = (uint8_t)(~UA_FASTREBOOT_ONPANIC); 1483 fastboot_update_config((const char *)&boot_config); 1484 } 1485 1486 /* 1487 * This is the interface to be called by fm_panic() in case FMA has diagnosed 1488 * a terminal machine check exception. It does not free up memory allocated 1489 * for the backup kernel. General disabling fastreboot_onpanic in a 1490 * non-panicking situation must go through fastboot_onpanic_disable(). 1491 */ 1492 void 1493 fastreboot_disable_highpil(void) 1494 { 1495 fastreboot_onpanic = 0; 1496 } 1497 1498 /* 1499 * This is an internal interface to disable Fast Reboot by Default. 1500 * It does not free up memory allocated for the backup kernel. 1501 */ 1502 static void 1503 fastreboot_capable_disable(uint32_t msgid) 1504 { 1505 if (fastreboot_capable != 0) { 1506 fastreboot_capable = 0; 1507 if (msgid < sizeof (fastreboot_nosup_desc) / 1508 sizeof (fastreboot_nosup_desc[0])) 1509 fastreboot_nosup_id = msgid; 1510 else 1511 fastreboot_nosup_id = FBNS_DEFAULT; 1512 } 1513 } 1514 1515 /* 1516 * This is the kernel interface for disabling 1517 * Fast Reboot by Default and Fast Reboot on Panic. 1518 * Frees up memory allocated for the backup kernel. 1519 * General disabling of the Fast Reboot by Default feature should be done 1520 * via the userland interface scf_fastreboot_default_set_transient(). 1521 */ 1522 void 1523 fastreboot_disable(uint32_t msgid) 1524 { 1525 fastreboot_capable_disable(msgid); 1526 fastreboot_onpanic_disable(); 1527 } 1528 1529 /* 1530 * Returns Fast Reboot not support message for fastreboot_nosup_id. 1531 * If fastreboot_nosup_id contains invalid index, default 1532 * Fast Reboot not support message is returned. 1533 */ 1534 const char * 1535 fastreboot_nosup_message(void) 1536 { 1537 uint32_t msgid; 1538 1539 msgid = fastreboot_nosup_id; 1540 if (msgid >= sizeof (fastreboot_nosup_desc) / 1541 sizeof (fastreboot_nosup_desc[0])) 1542 msgid = FBNS_DEFAULT; 1543 1544 return (fastreboot_nosup_desc[msgid]); 1545 } 1546 1547 /* 1548 * A simplified interface for uadmin to call to update the configuration 1549 * setting and load a new kernel if necessary. 1550 */ 1551 void 1552 fastboot_update_and_load(int fcn, char *mdep) 1553 { 1554 if (fcn != AD_FASTREBOOT) { 1555 /* 1556 * If user has explicitly requested reboot to prom, 1557 * or uadmin(1M) was invoked with other functions, 1558 * don't try to fast reboot after dumping. 1559 */ 1560 fastreboot_onpanic_disable(); 1561 } 1562 1563 mutex_enter(&fastreboot_config_mutex); 1564 1565 if (fastreboot_onpanic) 1566 fastboot_load_kernel(mdep); 1567 1568 mutex_exit(&fastreboot_config_mutex); 1569 } 1570