119397407SSherry Moore /*
219397407SSherry Moore * CDDL HEADER START
319397407SSherry Moore *
419397407SSherry Moore * The contents of this file are subject to the terms of the
519397407SSherry Moore * Common Development and Distribution License (the "License").
619397407SSherry Moore * You may not use this file except in compliance with the License.
719397407SSherry Moore *
819397407SSherry Moore * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
919397407SSherry Moore * or http://www.opensolaris.org/os/licensing.
1019397407SSherry Moore * See the License for the specific language governing permissions
1119397407SSherry Moore * and limitations under the License.
1219397407SSherry Moore *
1319397407SSherry Moore * When distributing Covered Code, include this CDDL HEADER in each
1419397407SSherry Moore * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
1519397407SSherry Moore * If applicable, add the following below this CDDL HEADER, with the
1619397407SSherry Moore * fields enclosed by brackets "[]" replaced with your own identifying
1719397407SSherry Moore * information: Portions Copyright [yyyy] [name of copyright owner]
1819397407SSherry Moore *
1919397407SSherry Moore * CDDL HEADER END
2019397407SSherry Moore */
2119397407SSherry Moore
2219397407SSherry Moore /*
237417cfdeSKuriakose Kuruvilla * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
2419397407SSherry Moore */
2519397407SSherry Moore
266bc8bc6aSSherry Moore /*
276bc8bc6aSSherry Moore * This file contains the functions for performing Fast Reboot -- a
286bc8bc6aSSherry Moore * reboot which bypasses the firmware and bootloader, considerably
296bc8bc6aSSherry Moore * reducing downtime.
306bc8bc6aSSherry Moore *
31753a6d45SSherry Moore * fastboot_load_kernel(): This function is invoked by mdpreboot() in the
32753a6d45SSherry Moore * reboot path. It loads the new kernel and boot archive into memory, builds
336bc8bc6aSSherry Moore * the data structure containing sufficient information about the new
346bc8bc6aSSherry Moore * kernel and boot archive to be passed to the fast reboot switcher
35*5d9d9091SRichard Lowe * (see fb_swtch_src.S for details). When invoked the switcher relocates
366bc8bc6aSSherry Moore * the new kernel and boot archive to physically contiguous low memory,
376bc8bc6aSSherry Moore * similar to where the boot loader would have loaded them, and jumps to
386bc8bc6aSSherry Moore * the new kernel.
396bc8bc6aSSherry Moore *
40753a6d45SSherry Moore * If fastreboot_onpanic is enabled, fastboot_load_kernel() is called
41753a6d45SSherry Moore * by fastreboot_post_startup() to load the back up kernel in case of
42753a6d45SSherry Moore * panic.
43753a6d45SSherry Moore *
446bc8bc6aSSherry Moore * The physical addresses of the memory allocated for the new kernel, boot
456bc8bc6aSSherry Moore * archive and their page tables must be above where the boot archive ends
466bc8bc6aSSherry Moore * after it has been relocated by the switcher, otherwise the new files
476bc8bc6aSSherry Moore * and their page tables could be overridden during relocation.
486bc8bc6aSSherry Moore *
496bc8bc6aSSherry Moore * fast_reboot(): This function is invoked by mdboot() once it's determined
506bc8bc6aSSherry Moore * that the system is capable of fast reboot. It jumps to the fast reboot
51753a6d45SSherry Moore * switcher with the data structure built by fastboot_load_kernel() as the
52753a6d45SSherry Moore * argument.
536bc8bc6aSSherry Moore */
5419397407SSherry Moore
5519397407SSherry Moore #include <sys/types.h>
5619397407SSherry Moore #include <sys/param.h>
5719397407SSherry Moore #include <sys/segments.h>
5819397407SSherry Moore #include <sys/sysmacros.h>
5919397407SSherry Moore #include <sys/vm.h>
6019397407SSherry Moore
6119397407SSherry Moore #include <sys/proc.h>
6219397407SSherry Moore #include <sys/buf.h>
6319397407SSherry Moore #include <sys/kmem.h>
6419397407SSherry Moore
6519397407SSherry Moore #include <sys/reboot.h>
6619397407SSherry Moore #include <sys/uadmin.h>
6719397407SSherry Moore
6819397407SSherry Moore #include <sys/cred.h>
6919397407SSherry Moore #include <sys/vnode.h>
7019397407SSherry Moore #include <sys/file.h>
7119397407SSherry Moore
7219397407SSherry Moore #include <sys/cmn_err.h>
7319397407SSherry Moore #include <sys/dumphdr.h>
7419397407SSherry Moore #include <sys/bootconf.h>
7519397407SSherry Moore #include <sys/ddidmareq.h>
7619397407SSherry Moore #include <sys/varargs.h>
7719397407SSherry Moore #include <sys/promif.h>
7819397407SSherry Moore #include <sys/modctl.h>
7919397407SSherry Moore
8019397407SSherry Moore #include <vm/hat.h>
8119397407SSherry Moore #include <vm/as.h>
8219397407SSherry Moore #include <vm/page.h>
8319397407SSherry Moore #include <vm/seg.h>
8419397407SSherry Moore #include <vm/hat_i86.h>
8519397407SSherry Moore #include <sys/vm_machparam.h>
8619397407SSherry Moore #include <sys/archsystm.h>
8719397407SSherry Moore #include <sys/machsystm.h>
8819397407SSherry Moore #include <sys/mman.h>
8919397407SSherry Moore #include <sys/x86_archext.h>
90753a6d45SSherry Moore #include <sys/smp_impldefs.h>
91753a6d45SSherry Moore #include <sys/spl.h>
9219397407SSherry Moore
935ee8e422SKonstantin Ananyev #include <sys/fastboot_impl.h>
9419397407SSherry Moore #include <sys/machelf.h>
9519397407SSherry Moore #include <sys/kobj.h>
9619397407SSherry Moore #include <sys/multiboot.h>
97753a6d45SSherry Moore #include <sys/kobj_lex.h>
98753a6d45SSherry Moore
99753a6d45SSherry Moore /*
100753a6d45SSherry Moore * Macro to determine how many pages are needed for PTEs to map a particular
101753a6d45SSherry Moore * file. Allocate one extra page table entry for terminating the list.
102753a6d45SSherry Moore */
103753a6d45SSherry Moore #define FASTBOOT_PTE_LIST_SIZE(fsize) \
104753a6d45SSherry Moore P2ROUNDUP((((fsize) >> PAGESHIFT) + 1) * sizeof (x86pte_t), PAGESIZE)
10519397407SSherry Moore
1066bc8bc6aSSherry Moore /*
1076bc8bc6aSSherry Moore * Data structure containing necessary information for the fast reboot
1086bc8bc6aSSherry Moore * switcher to jump to the new kernel.
1096bc8bc6aSSherry Moore */
11019397407SSherry Moore fastboot_info_t newkernel = { 0 };
111753a6d45SSherry Moore char fastboot_args[OBP_MAXPATHLEN];
1126bc8bc6aSSherry Moore
11319397407SSherry Moore static char fastboot_filename[2][OBP_MAXPATHLEN] = { { 0 }, { 0 }};
11419397407SSherry Moore static x86pte_t ptp_bits = PT_VALID | PT_REF | PT_USER | PT_WRITABLE;
11519397407SSherry Moore static x86pte_t pte_bits =
11619397407SSherry Moore PT_VALID | PT_REF | PT_MOD | PT_NOCONSIST | PT_WRITABLE;
11719397407SSherry Moore static uint_t fastboot_shift_amt_pae[] = {12, 21, 30, 39};
11819397407SSherry Moore
1195ee8e422SKonstantin Ananyev /* Index into Fast Reboot not supported message array */
1205ee8e422SKonstantin Ananyev static uint32_t fastreboot_nosup_id = FBNS_DEFAULT;
1215ee8e422SKonstantin Ananyev
1225ee8e422SKonstantin Ananyev /* Fast Reboot not supported message array */
1235ee8e422SKonstantin Ananyev static const char * const fastreboot_nosup_desc[FBNS_END] = {
1245ee8e422SKonstantin Ananyev #define fastboot_nosup_msg(id, str) str,
1255ee8e422SKonstantin Ananyev #include <sys/fastboot_msg.h>
1265ee8e422SKonstantin Ananyev };
1275ee8e422SKonstantin Ananyev
12819397407SSherry Moore int fastboot_debug = 0;
12919397407SSherry Moore int fastboot_contig = 0;
13019397407SSherry Moore
13119397407SSherry Moore /*
13219397407SSherry Moore * Fake starting va for new kernel and boot archive.
13319397407SSherry Moore */
13419397407SSherry Moore static uintptr_t fake_va = FASTBOOT_FAKE_VA;
13519397407SSherry Moore
13619397407SSherry Moore /*
137753a6d45SSherry Moore * Reserve memory below PA 1G in preparation of fast reboot.
138753a6d45SSherry Moore *
139753a6d45SSherry Moore * This variable is only checked when fastreboot_capable is set, but
140753a6d45SSherry Moore * fastreboot_onpanic is not set. The amount of memory reserved
141753a6d45SSherry Moore * is negligible, but just in case we are really short of low memory,
142753a6d45SSherry Moore * this variable will give us a backdoor to not consume memory at all.
143753a6d45SSherry Moore */
144753a6d45SSherry Moore int reserve_mem_enabled = 1;
145753a6d45SSherry Moore
146c90a5fbeSSherry Moore /*
147c90a5fbeSSherry Moore * Mutex to protect fastreboot_onpanic.
148c90a5fbeSSherry Moore */
149c90a5fbeSSherry Moore kmutex_t fastreboot_config_mutex;
150c90a5fbeSSherry Moore
151753a6d45SSherry Moore /*
152753a6d45SSherry Moore * Amount of memory below PA 1G to reserve for constructing the multiboot
153753a6d45SSherry Moore * data structure and the page tables as we tend to run out of those
154753a6d45SSherry Moore * when more drivers are loaded.
155753a6d45SSherry Moore */
156753a6d45SSherry Moore static size_t fastboot_mbi_size = 0x2000; /* 8K */
157753a6d45SSherry Moore static size_t fastboot_pagetable_size = 0x5000; /* 20K */
158753a6d45SSherry Moore
159835b9930SSherry Moore /*
160835b9930SSherry Moore * Minimum system uptime in clock_t before Fast Reboot should be used
161835b9930SSherry Moore * on panic. Will be initialized in fastboot_post_startup().
162835b9930SSherry Moore */
163835b9930SSherry Moore clock_t fastreboot_onpanic_uptime = LONG_MAX;
164835b9930SSherry Moore
165835b9930SSherry Moore /*
166835b9930SSherry Moore * lbolt value when the system booted. This value will be used if the system
167835b9930SSherry Moore * panics to calculate how long the system has been up. If the uptime is less
168835b9930SSherry Moore * than fastreboot_onpanic_uptime, a reboot through BIOS will be performed to
169835b9930SSherry Moore * avoid a potential panic/reboot loop.
170835b9930SSherry Moore */
171835b9930SSherry Moore clock_t lbolt_at_boot = LONG_MAX;
172835b9930SSherry Moore
173753a6d45SSherry Moore /*
174753a6d45SSherry Moore * Use below 1G for page tables as
175753a6d45SSherry Moore * 1. we are only doing 1:1 mapping of the bottom 1G of physical memory.
176753a6d45SSherry Moore * 2. we are using 2G as the fake virtual address for the new kernel and
177753a6d45SSherry Moore * boot archive.
17819397407SSherry Moore */
17919397407SSherry Moore static ddi_dma_attr_t fastboot_below_1G_dma_attr = {
18019397407SSherry Moore DMA_ATTR_V0,
18119397407SSherry Moore 0x0000000008000000ULL, /* dma_attr_addr_lo: 128MB */
18219397407SSherry Moore 0x000000003FFFFFFFULL, /* dma_attr_addr_hi: 1G */
18319397407SSherry Moore 0x00000000FFFFFFFFULL, /* dma_attr_count_max */
18419397407SSherry Moore 0x0000000000001000ULL, /* dma_attr_align: 4KB */
18519397407SSherry Moore 1, /* dma_attr_burstsize */
18619397407SSherry Moore 1, /* dma_attr_minxfer */
18719397407SSherry Moore 0x00000000FFFFFFFFULL, /* dma_attr_maxxfer */
18819397407SSherry Moore 0x00000000FFFFFFFFULL, /* dma_attr_seg */
18919397407SSherry Moore 1, /* dma_attr_sgllen */
19019397407SSherry Moore 0x1000ULL, /* dma_attr_granular */
19119397407SSherry Moore 0, /* dma_attr_flags */
19219397407SSherry Moore };
19319397407SSherry Moore
19419397407SSherry Moore static ddi_dma_attr_t fastboot_dma_attr = {
19519397407SSherry Moore DMA_ATTR_V0,
19619397407SSherry Moore 0x0000000008000000ULL, /* dma_attr_addr_lo: 128MB */
197877400d3SKonstantin Ananyev 0xFFFFFFFFFFFFFFFFULL, /* dma_attr_addr_hi: 2^64B */
19819397407SSherry Moore 0x00000000FFFFFFFFULL, /* dma_attr_count_max */
19919397407SSherry Moore 0x0000000000001000ULL, /* dma_attr_align: 4KB */
20019397407SSherry Moore 1, /* dma_attr_burstsize */
20119397407SSherry Moore 1, /* dma_attr_minxfer */
20219397407SSherry Moore 0x00000000FFFFFFFFULL, /* dma_attr_maxxfer */
20319397407SSherry Moore 0x00000000FFFFFFFFULL, /* dma_attr_seg */
20419397407SSherry Moore 1, /* dma_attr_sgllen */
20519397407SSherry Moore 0x1000ULL, /* dma_attr_granular */
20619397407SSherry Moore 0, /* dma_attr_flags */
20719397407SSherry Moore };
20819397407SSherry Moore
20919397407SSherry Moore /*
21019397407SSherry Moore * Various information saved from the previous boot to reconstruct
21119397407SSherry Moore * multiboot_info.
21219397407SSherry Moore */
21319397407SSherry Moore extern multiboot_info_t saved_mbi;
21419397407SSherry Moore extern mb_memory_map_t saved_mmap[FASTBOOT_SAVED_MMAP_COUNT];
2156915124bSKonstantin Ananyev extern uint8_t saved_drives[FASTBOOT_SAVED_DRIVES_SIZE];
21619397407SSherry Moore extern char saved_cmdline[FASTBOOT_SAVED_CMDLINE_LEN];
21719397407SSherry Moore extern int saved_cmdline_len;
218753a6d45SSherry Moore extern size_t saved_file_size[];
21919397407SSherry Moore
22019397407SSherry Moore extern void* contig_alloc(size_t size, ddi_dma_attr_t *attr,
22119397407SSherry Moore uintptr_t align, int cansleep);
2226bc8bc6aSSherry Moore extern void contig_free(void *addr, size_t size);
2236bc8bc6aSSherry Moore
22419397407SSherry Moore
22519397407SSherry Moore /* PRINTLIKE */
22619397407SSherry Moore extern void vprintf(const char *, va_list);
22719397407SSherry Moore
22819397407SSherry Moore
22919397407SSherry Moore /*
23019397407SSherry Moore * Need to be able to get boot_archives from other places
23119397407SSherry Moore */
23219397407SSherry Moore #define BOOTARCHIVE64 "/platform/i86pc/amd64/boot_archive"
23319397407SSherry Moore #define BOOTARCHIVE32 "/platform/i86pc/boot_archive"
234753a6d45SSherry Moore #define BOOTARCHIVE32_FAILSAFE "/boot/x86.miniroot-safe"
235753a6d45SSherry Moore #define BOOTARCHIVE64_FAILSAFE "/boot/amd64/x86.miniroot-safe"
236753a6d45SSherry Moore #define FAILSAFE_BOOTFILE32 "/boot/platform/i86pc/kernel/unix"
237753a6d45SSherry Moore #define FAILSAFE_BOOTFILE64 "/boot/platform/i86pc/kernel/amd64/unix"
23819397407SSherry Moore
23919397407SSherry Moore static uint_t fastboot_vatoindex(fastboot_info_t *, uintptr_t, int);
24019397407SSherry Moore static void fastboot_map_with_size(fastboot_info_t *, uintptr_t,
24119397407SSherry Moore paddr_t, size_t, int);
24219397407SSherry Moore static void fastboot_build_pagetables(fastboot_info_t *);
24319397407SSherry Moore static int fastboot_build_mbi(char *, fastboot_info_t *);
244753a6d45SSherry Moore static void fastboot_free_file(fastboot_file_t *);
24519397407SSherry Moore
246a2491ff4SSherry Moore static const char fastboot_enomem_msg[] = "!Fastboot: Couldn't allocate 0x%"
24719397407SSherry Moore PRIx64" bytes below %s to do fast reboot";
24819397407SSherry Moore
24919397407SSherry Moore static void
dprintf(char * fmt,...)25019397407SSherry Moore dprintf(char *fmt, ...)
25119397407SSherry Moore {
25219397407SSherry Moore va_list adx;
25319397407SSherry Moore
25419397407SSherry Moore if (!fastboot_debug)
25519397407SSherry Moore return;
25619397407SSherry Moore
25719397407SSherry Moore va_start(adx, fmt);
25819397407SSherry Moore vprintf(fmt, adx);
25919397407SSherry Moore va_end(adx);
26019397407SSherry Moore }
26119397407SSherry Moore
26219397407SSherry Moore
26319397407SSherry Moore /*
26419397407SSherry Moore * Return the index corresponding to a virt address at a given page table level.
26519397407SSherry Moore */
26619397407SSherry Moore static uint_t
fastboot_vatoindex(fastboot_info_t * nk,uintptr_t va,int level)26719397407SSherry Moore fastboot_vatoindex(fastboot_info_t *nk, uintptr_t va, int level)
26819397407SSherry Moore {
26919397407SSherry Moore return ((va >> nk->fi_shift_amt[level]) & (nk->fi_ptes_per_table - 1));
27019397407SSherry Moore }
27119397407SSherry Moore
27219397407SSherry Moore
27319397407SSherry Moore /*
27419397407SSherry Moore * Add mapping from vstart to pstart for the specified size.
275877400d3SKonstantin Ananyev * vstart, pstart and size should all have been aligned at 2M boundaries.
27619397407SSherry Moore */
27719397407SSherry Moore static void
fastboot_map_with_size(fastboot_info_t * nk,uintptr_t vstart,paddr_t pstart,size_t size,int level)27819397407SSherry Moore fastboot_map_with_size(fastboot_info_t *nk, uintptr_t vstart, paddr_t pstart,
27919397407SSherry Moore size_t size, int level)
28019397407SSherry Moore {
28119397407SSherry Moore x86pte_t pteval, *table;
28219397407SSherry Moore uintptr_t vaddr;
28319397407SSherry Moore paddr_t paddr;
28419397407SSherry Moore int index, l;
28519397407SSherry Moore
28619397407SSherry Moore table = (x86pte_t *)(nk->fi_pagetable_va);
28719397407SSherry Moore
28819397407SSherry Moore for (l = nk->fi_top_level; l >= level; l--) {
28919397407SSherry Moore
29019397407SSherry Moore index = fastboot_vatoindex(nk, vstart, l);
29119397407SSherry Moore
29219397407SSherry Moore if (l == level) {
29319397407SSherry Moore /*
29419397407SSherry Moore * Last level. Program the page table entries.
29519397407SSherry Moore */
29619397407SSherry Moore for (vaddr = vstart, paddr = pstart;
29719397407SSherry Moore vaddr < vstart + size;
29819397407SSherry Moore vaddr += (1ULL << nk->fi_shift_amt[l]),
29919397407SSherry Moore paddr += (1ULL << nk->fi_shift_amt[l])) {
30019397407SSherry Moore
30119397407SSherry Moore uint_t index = fastboot_vatoindex(nk, vaddr, l);
30219397407SSherry Moore
30319397407SSherry Moore if (l > 0)
30419397407SSherry Moore pteval = paddr | pte_bits | PT_PAGESIZE;
30519397407SSherry Moore else
30619397407SSherry Moore pteval = paddr | pte_bits;
30719397407SSherry Moore
30819397407SSherry Moore table[index] = pteval;
30919397407SSherry Moore }
31019397407SSherry Moore } else if (table[index] & PT_VALID) {
31119397407SSherry Moore
31219397407SSherry Moore table = (x86pte_t *)
31319397407SSherry Moore ((uintptr_t)(((paddr_t)table[index] & MMU_PAGEMASK)
31419397407SSherry Moore - nk->fi_pagetable_pa) + nk->fi_pagetable_va);
31519397407SSherry Moore } else {
31619397407SSherry Moore /*
317877400d3SKonstantin Ananyev * Intermediate levels.
318877400d3SKonstantin Ananyev * Program with either valid bit or PTP bits.
31919397407SSherry Moore */
32019397407SSherry Moore if (l == nk->fi_top_level) {
321877400d3SKonstantin Ananyev ASSERT(nk->fi_top_level == 3);
322877400d3SKonstantin Ananyev table[index] = nk->fi_next_table_pa | ptp_bits;
32319397407SSherry Moore } else {
32419397407SSherry Moore table[index] = nk->fi_next_table_pa | ptp_bits;
32519397407SSherry Moore }
32619397407SSherry Moore table = (x86pte_t *)(nk->fi_next_table_va);
32719397407SSherry Moore nk->fi_next_table_va += MMU_PAGESIZE;
32819397407SSherry Moore nk->fi_next_table_pa += MMU_PAGESIZE;
32919397407SSherry Moore }
33019397407SSherry Moore }
33119397407SSherry Moore }
33219397407SSherry Moore
33319397407SSherry Moore /*
33419397407SSherry Moore * Build page tables for the lower 1G of physical memory using 2M
33519397407SSherry Moore * pages, and prepare page tables for mapping new kernel and boot
33619397407SSherry Moore * archive pages using 4K pages.
33719397407SSherry Moore */
33819397407SSherry Moore static void
fastboot_build_pagetables(fastboot_info_t * nk)33919397407SSherry Moore fastboot_build_pagetables(fastboot_info_t *nk)
34019397407SSherry Moore {
34119397407SSherry Moore /*
34219397407SSherry Moore * Map lower 1G physical memory. Use large pages.
34319397407SSherry Moore */
34419397407SSherry Moore fastboot_map_with_size(nk, 0, 0, ONE_GIG, 1);
34519397407SSherry Moore
34619397407SSherry Moore /*
34719397407SSherry Moore * Map one 4K page to get the middle page tables set up.
34819397407SSherry Moore */
34919397407SSherry Moore fake_va = P2ALIGN_TYPED(fake_va, nk->fi_lpagesize, uintptr_t);
35019397407SSherry Moore fastboot_map_with_size(nk, fake_va,
35119397407SSherry Moore nk->fi_files[0].fb_pte_list_va[0] & MMU_PAGEMASK, PAGESIZE, 0);
35219397407SSherry Moore }
35319397407SSherry Moore
35419397407SSherry Moore
35519397407SSherry Moore /*
35619397407SSherry Moore * Sanity check. Look for dboot offset.
35719397407SSherry Moore */
35819397407SSherry Moore static int
fastboot_elf64_find_dboot_load_offset(void * img,off_t imgsz,uint32_t * offp)35919397407SSherry Moore fastboot_elf64_find_dboot_load_offset(void *img, off_t imgsz, uint32_t *offp)
36019397407SSherry Moore {
36119397407SSherry Moore Elf64_Ehdr *ehdr = (Elf64_Ehdr *)img;
36219397407SSherry Moore Elf64_Phdr *phdr;
36319397407SSherry Moore uint8_t *phdrbase;
36419397407SSherry Moore int i;
36519397407SSherry Moore
36619397407SSherry Moore if ((ehdr->e_phoff + ehdr->e_phnum * ehdr->e_phentsize) >= imgsz)
36719397407SSherry Moore return (-1);
36819397407SSherry Moore
36919397407SSherry Moore phdrbase = (uint8_t *)img + ehdr->e_phoff;
37019397407SSherry Moore
37119397407SSherry Moore for (i = 0; i < ehdr->e_phnum; i++) {
37219397407SSherry Moore phdr = (Elf64_Phdr *)(phdrbase + ehdr->e_phentsize * i);
37319397407SSherry Moore
37419397407SSherry Moore if (phdr->p_type == PT_LOAD) {
37519397407SSherry Moore if (phdr->p_vaddr == phdr->p_paddr &&
37619397407SSherry Moore phdr->p_vaddr == DBOOT_ENTRY_ADDRESS) {
37719397407SSherry Moore ASSERT(phdr->p_offset <= UINT32_MAX);
37819397407SSherry Moore *offp = (uint32_t)phdr->p_offset;
37919397407SSherry Moore return (0);
38019397407SSherry Moore }
38119397407SSherry Moore }
38219397407SSherry Moore }
38319397407SSherry Moore
38419397407SSherry Moore return (-1);
38519397407SSherry Moore }
38619397407SSherry Moore
38719397407SSherry Moore
38819397407SSherry Moore /*
38919397407SSherry Moore * Initialize text and data section information for 32-bit kernel.
390877400d3SKonstantin Ananyev * sectcntp - is both input/output parameter.
391877400d3SKonstantin Ananyev * On entry, *sectcntp contains maximum allowable number of sections;
392877400d3SKonstantin Ananyev * on return, it contains the actual number of sections filled.
39319397407SSherry Moore */
39419397407SSherry Moore static int
fastboot_elf32_find_loadables(void * img,off_t imgsz,fastboot_section_t * sectp,int * sectcntp,uint32_t * offp)39519397407SSherry Moore fastboot_elf32_find_loadables(void *img, off_t imgsz, fastboot_section_t *sectp,
39619397407SSherry Moore int *sectcntp, uint32_t *offp)
39719397407SSherry Moore {
39819397407SSherry Moore Elf32_Ehdr *ehdr = (Elf32_Ehdr *)img;
39919397407SSherry Moore Elf32_Phdr *phdr;
40019397407SSherry Moore uint8_t *phdrbase;
40119397407SSherry Moore int i;
40219397407SSherry Moore int used_sections = 0;
403877400d3SKonstantin Ananyev const int max_sectcnt = *sectcntp;
40419397407SSherry Moore
40519397407SSherry Moore if ((ehdr->e_phoff + ehdr->e_phnum * ehdr->e_phentsize) >= imgsz)
40619397407SSherry Moore return (-1);
40719397407SSherry Moore
40819397407SSherry Moore phdrbase = (uint8_t *)img + ehdr->e_phoff;
40919397407SSherry Moore
41019397407SSherry Moore for (i = 0; i < ehdr->e_phnum; i++) {
41119397407SSherry Moore phdr = (Elf32_Phdr *)(phdrbase + ehdr->e_phentsize * i);
41219397407SSherry Moore
41319397407SSherry Moore if (phdr->p_type == PT_INTERP)
41419397407SSherry Moore return (-1);
41519397407SSherry Moore
41619397407SSherry Moore if (phdr->p_type != PT_LOAD)
41719397407SSherry Moore continue;
41819397407SSherry Moore
41919397407SSherry Moore if (phdr->p_vaddr == phdr->p_paddr &&
42019397407SSherry Moore phdr->p_paddr == DBOOT_ENTRY_ADDRESS) {
42119397407SSherry Moore *offp = (uint32_t)phdr->p_offset;
42219397407SSherry Moore } else {
423877400d3SKonstantin Ananyev if (max_sectcnt <= used_sections)
424877400d3SKonstantin Ananyev return (-1);
425877400d3SKonstantin Ananyev
42619397407SSherry Moore sectp[used_sections].fb_sec_offset = phdr->p_offset;
42719397407SSherry Moore sectp[used_sections].fb_sec_paddr = phdr->p_paddr;
42819397407SSherry Moore sectp[used_sections].fb_sec_size = phdr->p_filesz;
42919397407SSherry Moore sectp[used_sections].fb_sec_bss_size =
43019397407SSherry Moore (phdr->p_filesz < phdr->p_memsz) ?
43119397407SSherry Moore (phdr->p_memsz - phdr->p_filesz) : 0;
43219397407SSherry Moore
433877400d3SKonstantin Ananyev /* Extra sanity check for the input object file */
434877400d3SKonstantin Ananyev if (sectp[used_sections].fb_sec_paddr +
435877400d3SKonstantin Ananyev sectp[used_sections].fb_sec_size +
436877400d3SKonstantin Ananyev sectp[used_sections].fb_sec_bss_size >=
437877400d3SKonstantin Ananyev DBOOT_ENTRY_ADDRESS)
438877400d3SKonstantin Ananyev return (-1);
439877400d3SKonstantin Ananyev
44019397407SSherry Moore used_sections++;
44119397407SSherry Moore }
44219397407SSherry Moore }
44319397407SSherry Moore
44419397407SSherry Moore *sectcntp = used_sections;
44519397407SSherry Moore return (0);
44619397407SSherry Moore }
44719397407SSherry Moore
44819397407SSherry Moore /*
4491a6f4459SKonstantin Ananyev * Create multiboot info structure (mbi) base on the saved mbi.
4501a6f4459SKonstantin Ananyev * Recalculate values of the pointer type fields in the data
4511a6f4459SKonstantin Ananyev * structure based on the new starting physical address of the
4521a6f4459SKonstantin Ananyev * data structure.
45319397407SSherry Moore */
45419397407SSherry Moore static int
fastboot_build_mbi(char * mdep,fastboot_info_t * nk)45519397407SSherry Moore fastboot_build_mbi(char *mdep, fastboot_info_t *nk)
45619397407SSherry Moore {
45719397407SSherry Moore mb_module_t *mbp;
4581a6f4459SKonstantin Ananyev multiboot_info_t *mbi; /* pointer to multiboot structure */
4591a6f4459SKonstantin Ananyev uintptr_t start_addr_va; /* starting VA of mbi */
4601a6f4459SKonstantin Ananyev uintptr_t start_addr_pa; /* starting PA of mbi */
4611a6f4459SKonstantin Ananyev size_t offs = 0; /* offset from the starting address */
4621a6f4459SKonstantin Ananyev size_t arglen; /* length of the command line arg */
4631a6f4459SKonstantin Ananyev size_t size; /* size of the memory reserved for mbi */
4641a6f4459SKonstantin Ananyev size_t mdnsz; /* length of the boot archive name */
46519397407SSherry Moore
4661a6f4459SKonstantin Ananyev /*
4671a6f4459SKonstantin Ananyev * If mdep is not NULL or empty, use the length of mdep + 1
4681a6f4459SKonstantin Ananyev * (for NULL terminating) as the length of the new command
4691a6f4459SKonstantin Ananyev * line; else use the saved command line length as the
4701a6f4459SKonstantin Ananyev * length for the new command line.
4711a6f4459SKonstantin Ananyev */
4726bc8bc6aSSherry Moore if (mdep != NULL && strlen(mdep) != 0) {
47319397407SSherry Moore arglen = strlen(mdep) + 1;
47419397407SSherry Moore } else {
47519397407SSherry Moore arglen = saved_cmdline_len;
47619397407SSherry Moore }
47719397407SSherry Moore
4781a6f4459SKonstantin Ananyev /*
4791a6f4459SKonstantin Ananyev * Allocate memory for the new multiboot info structure (mbi).
4801a6f4459SKonstantin Ananyev * If we have reserved memory for mbi but it's not enough,
4811a6f4459SKonstantin Ananyev * free it and reallocate.
4821a6f4459SKonstantin Ananyev */
48319397407SSherry Moore size = PAGESIZE + P2ROUNDUP(arglen, PAGESIZE);
484753a6d45SSherry Moore if (nk->fi_mbi_size && nk->fi_mbi_size < size) {
485753a6d45SSherry Moore contig_free((void *)nk->fi_new_mbi_va, nk->fi_mbi_size);
486753a6d45SSherry Moore nk->fi_mbi_size = 0;
48719397407SSherry Moore }
48819397407SSherry Moore
489753a6d45SSherry Moore if (nk->fi_mbi_size == 0) {
490753a6d45SSherry Moore if ((nk->fi_new_mbi_va =
491753a6d45SSherry Moore (uintptr_t)contig_alloc(size, &fastboot_below_1G_dma_attr,
4924da99751SToomas Soome PAGESIZE, 0)) == 0) {
493a2491ff4SSherry Moore cmn_err(CE_NOTE, fastboot_enomem_msg,
494753a6d45SSherry Moore (uint64_t)size, "1G");
495753a6d45SSherry Moore return (-1);
496753a6d45SSherry Moore }
497753a6d45SSherry Moore /*
498753a6d45SSherry Moore * fi_mbi_size must be set after the allocation succeeds
499753a6d45SSherry Moore * as it's used to determine how much memory to free.
500753a6d45SSherry Moore */
501753a6d45SSherry Moore nk->fi_mbi_size = size;
502753a6d45SSherry Moore }
50319397407SSherry Moore
5041a6f4459SKonstantin Ananyev /*
5051a6f4459SKonstantin Ananyev * Initalize memory
5061a6f4459SKonstantin Ananyev */
507753a6d45SSherry Moore bzero((void *)nk->fi_new_mbi_va, nk->fi_mbi_size);
50819397407SSherry Moore
509753a6d45SSherry Moore /*
5101a6f4459SKonstantin Ananyev * Get PA for the new mbi
511753a6d45SSherry Moore */
5121a6f4459SKonstantin Ananyev start_addr_va = nk->fi_new_mbi_va;
5131a6f4459SKonstantin Ananyev start_addr_pa = mmu_ptob((uint64_t)hat_getpfnum(kas.a_hat,
5141a6f4459SKonstantin Ananyev (caddr_t)start_addr_va));
5151a6f4459SKonstantin Ananyev nk->fi_new_mbi_pa = (paddr_t)start_addr_pa;
51619397407SSherry Moore
5171a6f4459SKonstantin Ananyev /*
5181a6f4459SKonstantin Ananyev * Populate the rest of the fields in the data structure
5191a6f4459SKonstantin Ananyev */
52019397407SSherry Moore
5211a6f4459SKonstantin Ananyev /*
5221a6f4459SKonstantin Ananyev * Copy from the saved mbi to preserve all non-pointer type fields.
5231a6f4459SKonstantin Ananyev */
5241a6f4459SKonstantin Ananyev mbi = (multiboot_info_t *)start_addr_va;
5251a6f4459SKonstantin Ananyev bcopy(&saved_mbi, mbi, sizeof (*mbi));
52619397407SSherry Moore
5271a6f4459SKonstantin Ananyev /*
5281a6f4459SKonstantin Ananyev * Recalculate mods_addr. Set mod_start and mod_end based on
5291a6f4459SKonstantin Ananyev * the physical address of the new boot archive. Set mod_name
5301a6f4459SKonstantin Ananyev * to the name of the new boto archive.
5311a6f4459SKonstantin Ananyev */
5321a6f4459SKonstantin Ananyev offs += sizeof (multiboot_info_t);
5331a6f4459SKonstantin Ananyev mbi->mods_addr = start_addr_pa + offs;
5341a6f4459SKonstantin Ananyev mbp = (mb_module_t *)(start_addr_va + offs);
535753a6d45SSherry Moore mbp->mod_start = nk->fi_files[FASTBOOT_BOOTARCHIVE].fb_dest_pa;
536753a6d45SSherry Moore mbp->mod_end = nk->fi_files[FASTBOOT_BOOTARCHIVE].fb_next_pa;
53719397407SSherry Moore
5381a6f4459SKonstantin Ananyev offs += sizeof (mb_module_t);
5391a6f4459SKonstantin Ananyev mdnsz = strlen(fastboot_filename[FASTBOOT_NAME_BOOTARCHIVE]) + 1;
5401a6f4459SKonstantin Ananyev bcopy(fastboot_filename[FASTBOOT_NAME_BOOTARCHIVE],
5411a6f4459SKonstantin Ananyev (void *)(start_addr_va + offs), mdnsz);
5421a6f4459SKonstantin Ananyev mbp->mod_name = start_addr_pa + offs;
54319397407SSherry Moore mbp->reserved = 0;
54419397407SSherry Moore
5451a6f4459SKonstantin Ananyev /*
5461a6f4459SKonstantin Ananyev * Make sure the offset is 16-byte aligned to avoid unaligned access.
5471a6f4459SKonstantin Ananyev */
5481a6f4459SKonstantin Ananyev offs += mdnsz;
5491a6f4459SKonstantin Ananyev offs = P2ROUNDUP_TYPED(offs, 16, size_t);
5501a6f4459SKonstantin Ananyev
5511a6f4459SKonstantin Ananyev /*
5521a6f4459SKonstantin Ananyev * Recalculate mmap_addr
5531a6f4459SKonstantin Ananyev */
5541a6f4459SKonstantin Ananyev mbi->mmap_addr = start_addr_pa + offs;
5551a6f4459SKonstantin Ananyev bcopy((void *)(uintptr_t)saved_mmap, (void *)(start_addr_va + offs),
55619397407SSherry Moore saved_mbi.mmap_length);
5571a6f4459SKonstantin Ananyev offs += saved_mbi.mmap_length;
55819397407SSherry Moore
5591a6f4459SKonstantin Ananyev /*
5601a6f4459SKonstantin Ananyev * Recalculate drives_addr
5611a6f4459SKonstantin Ananyev */
5621a6f4459SKonstantin Ananyev mbi->drives_addr = start_addr_pa + offs;
5631a6f4459SKonstantin Ananyev bcopy((void *)(uintptr_t)saved_drives, (void *)(start_addr_va + offs),
56419397407SSherry Moore saved_mbi.drives_length);
5651a6f4459SKonstantin Ananyev offs += saved_mbi.drives_length;
56619397407SSherry Moore
5671a6f4459SKonstantin Ananyev /*
5681a6f4459SKonstantin Ananyev * Recalculate the address of cmdline. Set cmdline to contain the
5691a6f4459SKonstantin Ananyev * new boot argument.
5701a6f4459SKonstantin Ananyev */
5711a6f4459SKonstantin Ananyev mbi->cmdline = start_addr_pa + offs;
57219397407SSherry Moore
5736bc8bc6aSSherry Moore if (mdep != NULL && strlen(mdep) != 0) {
5741a6f4459SKonstantin Ananyev bcopy(mdep, (void *)(start_addr_va + offs), arglen);
57519397407SSherry Moore } else {
5761a6f4459SKonstantin Ananyev bcopy((void *)saved_cmdline, (void *)(start_addr_va + offs),
5771a6f4459SKonstantin Ananyev arglen);
57819397407SSherry Moore }
57919397407SSherry Moore
5806915124bSKonstantin Ananyev /* clear fields and flags that are not copied */
5816915124bSKonstantin Ananyev bzero(&mbi->config_table,
5826915124bSKonstantin Ananyev sizeof (*mbi) - offsetof(multiboot_info_t, config_table));
5836915124bSKonstantin Ananyev mbi->flags &= ~(MB_INFO_CONFIG_TABLE | MB_INFO_BOOT_LOADER_NAME |
5846915124bSKonstantin Ananyev MB_INFO_APM_TABLE | MB_INFO_VIDEO_INFO);
5856915124bSKonstantin Ananyev
58619397407SSherry Moore return (0);
58719397407SSherry Moore }
58819397407SSherry Moore
5896bc8bc6aSSherry Moore /*
5906bc8bc6aSSherry Moore * Initialize HAT related fields
5916bc8bc6aSSherry Moore */
5926bc8bc6aSSherry Moore static void
fastboot_init_fields(fastboot_info_t * nk)5936bc8bc6aSSherry Moore fastboot_init_fields(fastboot_info_t *nk)
59419397407SSherry Moore {
5957417cfdeSKuriakose Kuruvilla if (is_x86_feature(x86_featureset, X86FSET_PAE)) {
5966bc8bc6aSSherry Moore nk->fi_has_pae = 1;
5976bc8bc6aSSherry Moore nk->fi_shift_amt = fastboot_shift_amt_pae;
5986bc8bc6aSSherry Moore nk->fi_ptes_per_table = 512;
5996bc8bc6aSSherry Moore nk->fi_lpagesize = (2 << 20); /* 2M */
600877400d3SKonstantin Ananyev nk->fi_top_level = 3;
60119397407SSherry Moore }
6026bc8bc6aSSherry Moore }
60319397407SSherry Moore
6046bc8bc6aSSherry Moore /*
6056bc8bc6aSSherry Moore * Process boot argument
6066bc8bc6aSSherry Moore */
6076bc8bc6aSSherry Moore static void
fastboot_parse_mdep(char * mdep,char * kern_bootpath,int * bootpath_len,char * bootargs)6086bc8bc6aSSherry Moore fastboot_parse_mdep(char *mdep, char *kern_bootpath, int *bootpath_len,
6096bc8bc6aSSherry Moore char *bootargs)
6106bc8bc6aSSherry Moore {
6116bc8bc6aSSherry Moore int i;
61219397407SSherry Moore
61319397407SSherry Moore /*
61419397407SSherry Moore * If mdep is not NULL, it comes in the format of
61519397407SSherry Moore * mountpoint unix args
61619397407SSherry Moore */
6176bc8bc6aSSherry Moore if (mdep != NULL && strlen(mdep) != 0) {
61819397407SSherry Moore if (mdep[0] != '-') {
61919397407SSherry Moore /* First get the root argument */
62019397407SSherry Moore i = 0;
62119397407SSherry Moore while (mdep[i] != '\0' && mdep[i] != ' ') {
62219397407SSherry Moore i++;
62319397407SSherry Moore }
62419397407SSherry Moore
62519397407SSherry Moore if (i < 4 || strncmp(&mdep[i-4], "unix", 4) != 0) {
62619397407SSherry Moore /* mount point */
62719397407SSherry Moore bcopy(mdep, kern_bootpath, i);
62819397407SSherry Moore kern_bootpath[i] = '\0';
6296bc8bc6aSSherry Moore *bootpath_len = i;
63019397407SSherry Moore
63119397407SSherry Moore /*
63219397407SSherry Moore * Get the next argument. It should be unix as
63319397407SSherry Moore * we have validated in in halt.c.
63419397407SSherry Moore */
63519397407SSherry Moore if (strlen(mdep) > i) {
63619397407SSherry Moore mdep += (i + 1);
63719397407SSherry Moore i = 0;
63819397407SSherry Moore while (mdep[i] != '\0' &&
63919397407SSherry Moore mdep[i] != ' ') {
64019397407SSherry Moore i++;
64119397407SSherry Moore }
64219397407SSherry Moore }
64319397407SSherry Moore
64419397407SSherry Moore }
64519397407SSherry Moore bcopy(mdep, kern_bootfile, i);
64619397407SSherry Moore kern_bootfile[i] = '\0';
6476bc8bc6aSSherry Moore bcopy(mdep, bootargs, strlen(mdep));
64819397407SSherry Moore } else {
64919397407SSherry Moore int off = strlen(kern_bootfile);
65019397407SSherry Moore bcopy(kern_bootfile, bootargs, off);
65119397407SSherry Moore bcopy(" ", &bootargs[off++], 1);
65219397407SSherry Moore bcopy(mdep, &bootargs[off], strlen(mdep));
65319397407SSherry Moore off += strlen(mdep);
65419397407SSherry Moore bootargs[off] = '\0';
65519397407SSherry Moore }
65619397407SSherry Moore }
6576bc8bc6aSSherry Moore }
6586bc8bc6aSSherry Moore
6596bc8bc6aSSherry Moore /*
660753a6d45SSherry Moore * Reserve memory under PA 1G for mapping the new kernel and boot archive.
661753a6d45SSherry Moore * This function is only called if fastreboot_onpanic is *not* set.
662753a6d45SSherry Moore */
663753a6d45SSherry Moore static void
fastboot_reserve_mem(fastboot_info_t * nk)664753a6d45SSherry Moore fastboot_reserve_mem(fastboot_info_t *nk)
665753a6d45SSherry Moore {
666753a6d45SSherry Moore int i;
667753a6d45SSherry Moore
668753a6d45SSherry Moore /*
669753a6d45SSherry Moore * A valid kernel is in place. No need to reserve any memory.
670753a6d45SSherry Moore */
671753a6d45SSherry Moore if (nk->fi_valid)
672753a6d45SSherry Moore return;
673753a6d45SSherry Moore
674753a6d45SSherry Moore /*
675753a6d45SSherry Moore * Reserve memory under PA 1G for PTE lists.
676753a6d45SSherry Moore */
677753a6d45SSherry Moore for (i = 0; i < FASTBOOT_MAX_FILES_MAP; i++) {
678753a6d45SSherry Moore fastboot_file_t *fb = &nk->fi_files[i];
679753a6d45SSherry Moore size_t fsize_roundup, size;
680753a6d45SSherry Moore
681753a6d45SSherry Moore fsize_roundup = P2ROUNDUP_TYPED(saved_file_size[i],
682753a6d45SSherry Moore PAGESIZE, size_t);
683753a6d45SSherry Moore size = FASTBOOT_PTE_LIST_SIZE(fsize_roundup);
684753a6d45SSherry Moore if ((fb->fb_pte_list_va = contig_alloc(size,
685753a6d45SSherry Moore &fastboot_below_1G_dma_attr, PAGESIZE, 0)) == NULL) {
686753a6d45SSherry Moore return;
687753a6d45SSherry Moore }
688753a6d45SSherry Moore fb->fb_pte_list_size = size;
689753a6d45SSherry Moore }
690753a6d45SSherry Moore
691753a6d45SSherry Moore /*
692753a6d45SSherry Moore * Reserve memory under PA 1G for page tables.
693753a6d45SSherry Moore */
694753a6d45SSherry Moore if ((nk->fi_pagetable_va =
695753a6d45SSherry Moore (uintptr_t)contig_alloc(fastboot_pagetable_size,
6964da99751SToomas Soome &fastboot_below_1G_dma_attr, PAGESIZE, 0)) == 0) {
697753a6d45SSherry Moore return;
698753a6d45SSherry Moore }
699753a6d45SSherry Moore nk->fi_pagetable_size = fastboot_pagetable_size;
700753a6d45SSherry Moore
701753a6d45SSherry Moore /*
702753a6d45SSherry Moore * Reserve memory under PA 1G for multiboot structure.
703753a6d45SSherry Moore */
704753a6d45SSherry Moore if ((nk->fi_new_mbi_va = (uintptr_t)contig_alloc(fastboot_mbi_size,
7054da99751SToomas Soome &fastboot_below_1G_dma_attr, PAGESIZE, 0)) == 0) {
706753a6d45SSherry Moore return;
707753a6d45SSherry Moore }
708753a6d45SSherry Moore nk->fi_mbi_size = fastboot_mbi_size;
709753a6d45SSherry Moore }
710753a6d45SSherry Moore
711753a6d45SSherry Moore /*
712753a6d45SSherry Moore * Calculate MD5 digest for the given fastboot_file.
713753a6d45SSherry Moore * Assumes that the file is allready loaded properly.
714753a6d45SSherry Moore */
715753a6d45SSherry Moore static void
fastboot_cksum_file(fastboot_file_t * fb,uchar_t * md5_hash)716753a6d45SSherry Moore fastboot_cksum_file(fastboot_file_t *fb, uchar_t *md5_hash)
717753a6d45SSherry Moore {
718753a6d45SSherry Moore MD5_CTX md5_ctx;
719753a6d45SSherry Moore
720753a6d45SSherry Moore MD5Init(&md5_ctx);
721753a6d45SSherry Moore MD5Update(&md5_ctx, (void *)fb->fb_va, fb->fb_size);
722753a6d45SSherry Moore MD5Final(md5_hash, &md5_ctx);
723753a6d45SSherry Moore }
724753a6d45SSherry Moore
725753a6d45SSherry Moore /*
726753a6d45SSherry Moore * Free up the memory we have allocated for a file
7276bc8bc6aSSherry Moore */
7286bc8bc6aSSherry Moore static void
fastboot_free_file(fastboot_file_t * fb)7296bc8bc6aSSherry Moore fastboot_free_file(fastboot_file_t *fb)
7306bc8bc6aSSherry Moore {
731753a6d45SSherry Moore size_t fsize_roundup;
7326bc8bc6aSSherry Moore
7336bc8bc6aSSherry Moore fsize_roundup = P2ROUNDUP_TYPED(fb->fb_size, PAGESIZE, size_t);
734753a6d45SSherry Moore if (fsize_roundup) {
735753a6d45SSherry Moore contig_free((void *)fb->fb_va, fsize_roundup);
7364da99751SToomas Soome fb->fb_va = 0;
737753a6d45SSherry Moore fb->fb_size = 0;
738753a6d45SSherry Moore }
739753a6d45SSherry Moore }
740753a6d45SSherry Moore
741753a6d45SSherry Moore /*
742753a6d45SSherry Moore * Free up memory used by the PTEs for a file.
743753a6d45SSherry Moore */
744753a6d45SSherry Moore static void
fastboot_free_file_pte(fastboot_file_t * fb,uint64_t endaddr)745753a6d45SSherry Moore fastboot_free_file_pte(fastboot_file_t *fb, uint64_t endaddr)
746753a6d45SSherry Moore {
747753a6d45SSherry Moore if (fb->fb_pte_list_size && fb->fb_pte_list_pa < endaddr) {
748753a6d45SSherry Moore contig_free((void *)fb->fb_pte_list_va, fb->fb_pte_list_size);
749753a6d45SSherry Moore fb->fb_pte_list_va = 0;
750753a6d45SSherry Moore fb->fb_pte_list_pa = 0;
751753a6d45SSherry Moore fb->fb_pte_list_size = 0;
752753a6d45SSherry Moore }
753753a6d45SSherry Moore }
754753a6d45SSherry Moore
755753a6d45SSherry Moore /*
756753a6d45SSherry Moore * Free up all the memory used for representing a kernel with
757753a6d45SSherry Moore * fastboot_info_t.
758753a6d45SSherry Moore */
759753a6d45SSherry Moore static void
fastboot_free_mem(fastboot_info_t * nk,uint64_t endaddr)760753a6d45SSherry Moore fastboot_free_mem(fastboot_info_t *nk, uint64_t endaddr)
761753a6d45SSherry Moore {
762753a6d45SSherry Moore int i;
763753a6d45SSherry Moore
764753a6d45SSherry Moore for (i = 0; i < FASTBOOT_MAX_FILES_MAP; i++) {
765753a6d45SSherry Moore fastboot_free_file(nk->fi_files + i);
766753a6d45SSherry Moore fastboot_free_file_pte(nk->fi_files + i, endaddr);
767753a6d45SSherry Moore }
768753a6d45SSherry Moore
769753a6d45SSherry Moore if (nk->fi_pagetable_size && nk->fi_pagetable_pa < endaddr) {
770753a6d45SSherry Moore contig_free((void *)nk->fi_pagetable_va, nk->fi_pagetable_size);
771753a6d45SSherry Moore nk->fi_pagetable_va = 0;
772753a6d45SSherry Moore nk->fi_pagetable_pa = 0;
773753a6d45SSherry Moore nk->fi_pagetable_size = 0;
774753a6d45SSherry Moore }
775753a6d45SSherry Moore
776753a6d45SSherry Moore if (nk->fi_mbi_size && nk->fi_new_mbi_pa < endaddr) {
777753a6d45SSherry Moore contig_free((void *)nk->fi_new_mbi_va, nk->fi_mbi_size);
778753a6d45SSherry Moore nk->fi_new_mbi_va = 0;
779753a6d45SSherry Moore nk->fi_new_mbi_pa = 0;
780753a6d45SSherry Moore nk->fi_mbi_size = 0;
781753a6d45SSherry Moore }
782753a6d45SSherry Moore }
783753a6d45SSherry Moore
784753a6d45SSherry Moore /*
785753a6d45SSherry Moore * Only free up the memory allocated for the kernel and boot archive,
786753a6d45SSherry Moore * but not for the page tables.
787753a6d45SSherry Moore */
788753a6d45SSherry Moore void
fastboot_free_newkernel(fastboot_info_t * nk)789753a6d45SSherry Moore fastboot_free_newkernel(fastboot_info_t *nk)
790753a6d45SSherry Moore {
791753a6d45SSherry Moore int i;
792753a6d45SSherry Moore
793753a6d45SSherry Moore nk->fi_valid = 0;
794753a6d45SSherry Moore /*
795753a6d45SSherry Moore * Free the memory we have allocated
796753a6d45SSherry Moore */
797753a6d45SSherry Moore for (i = 0; i < FASTBOOT_MAX_FILES_MAP; i++) {
798753a6d45SSherry Moore fastboot_free_file(&(nk->fi_files[i]));
799753a6d45SSherry Moore }
800753a6d45SSherry Moore }
801753a6d45SSherry Moore
802753a6d45SSherry Moore static void
fastboot_cksum_cdata(fastboot_info_t * nk,uchar_t * md5_hash)803753a6d45SSherry Moore fastboot_cksum_cdata(fastboot_info_t *nk, uchar_t *md5_hash)
804753a6d45SSherry Moore {
805753a6d45SSherry Moore int i;
806753a6d45SSherry Moore MD5_CTX md5_ctx;
807753a6d45SSherry Moore
808753a6d45SSherry Moore MD5Init(&md5_ctx);
809753a6d45SSherry Moore for (i = 0; i < FASTBOOT_MAX_FILES_MAP; i++) {
810753a6d45SSherry Moore MD5Update(&md5_ctx, nk->fi_files[i].fb_pte_list_va,
811753a6d45SSherry Moore nk->fi_files[i].fb_pte_list_size);
812753a6d45SSherry Moore }
813753a6d45SSherry Moore MD5Update(&md5_ctx, (void *)nk->fi_pagetable_va, nk->fi_pagetable_size);
814753a6d45SSherry Moore MD5Update(&md5_ctx, (void *)nk->fi_new_mbi_va, nk->fi_mbi_size);
815753a6d45SSherry Moore
816753a6d45SSherry Moore MD5Final(md5_hash, &md5_ctx);
817753a6d45SSherry Moore }
818753a6d45SSherry Moore
819753a6d45SSherry Moore /*
820753a6d45SSherry Moore * Generate MD5 checksum of the given kernel.
821753a6d45SSherry Moore */
822753a6d45SSherry Moore static void
fastboot_cksum_generate(fastboot_info_t * nk)823753a6d45SSherry Moore fastboot_cksum_generate(fastboot_info_t *nk)
824753a6d45SSherry Moore {
825753a6d45SSherry Moore int i;
826753a6d45SSherry Moore
827753a6d45SSherry Moore for (i = 0; i < FASTBOOT_MAX_FILES_MAP; i++) {
828753a6d45SSherry Moore fastboot_cksum_file(nk->fi_files + i, nk->fi_md5_hash[i]);
829753a6d45SSherry Moore }
830753a6d45SSherry Moore fastboot_cksum_cdata(nk, nk->fi_md5_hash[i]);
831753a6d45SSherry Moore }
832753a6d45SSherry Moore
833753a6d45SSherry Moore /*
834753a6d45SSherry Moore * Calculate MD5 checksum of the given kernel and verify that
835753a6d45SSherry Moore * it matches with what was calculated before.
836753a6d45SSherry Moore */
837753a6d45SSherry Moore int
fastboot_cksum_verify(fastboot_info_t * nk)838753a6d45SSherry Moore fastboot_cksum_verify(fastboot_info_t *nk)
839753a6d45SSherry Moore {
840753a6d45SSherry Moore int i;
841753a6d45SSherry Moore uchar_t md5_hash[MD5_DIGEST_LENGTH];
842753a6d45SSherry Moore
843753a6d45SSherry Moore for (i = 0; i < FASTBOOT_MAX_FILES_MAP; i++) {
844753a6d45SSherry Moore fastboot_cksum_file(nk->fi_files + i, md5_hash);
845753a6d45SSherry Moore if (bcmp(nk->fi_md5_hash[i], md5_hash,
846753a6d45SSherry Moore sizeof (nk->fi_md5_hash[i])) != 0)
847753a6d45SSherry Moore return (i + 1);
848753a6d45SSherry Moore }
849753a6d45SSherry Moore
850753a6d45SSherry Moore fastboot_cksum_cdata(nk, md5_hash);
851753a6d45SSherry Moore if (bcmp(nk->fi_md5_hash[i], md5_hash,
852753a6d45SSherry Moore sizeof (nk->fi_md5_hash[i])) != 0)
853753a6d45SSherry Moore return (i + 1);
8546bc8bc6aSSherry Moore
855753a6d45SSherry Moore return (0);
8566bc8bc6aSSherry Moore }
8576bc8bc6aSSherry Moore
8586bc8bc6aSSherry Moore /*
8596bc8bc6aSSherry Moore * This function performs the following tasks:
8606bc8bc6aSSherry Moore * - Read the sizes of the new kernel and boot archive.
8616bc8bc6aSSherry Moore * - Allocate memory for the new kernel and boot archive.
8626bc8bc6aSSherry Moore * - Allocate memory for page tables necessary for mapping the memory
8636bc8bc6aSSherry Moore * allocated for the files.
8646bc8bc6aSSherry Moore * - Read the new kernel and boot archive into memory.
8656bc8bc6aSSherry Moore * - Map in the fast reboot switcher.
8666bc8bc6aSSherry Moore * - Load the fast reboot switcher to FASTBOOT_SWTCH_PA.
8676bc8bc6aSSherry Moore * - Build the new multiboot_info structure
8686bc8bc6aSSherry Moore * - Build page tables for the low 1G of physical memory.
8696bc8bc6aSSherry Moore * - Mark the data structure as valid if all steps have succeeded.
8706bc8bc6aSSherry Moore */
8716bc8bc6aSSherry Moore void
fastboot_load_kernel(char * mdep)872753a6d45SSherry Moore fastboot_load_kernel(char *mdep)
8736bc8bc6aSSherry Moore {
8746bc8bc6aSSherry Moore void *buf = NULL;
8756bc8bc6aSSherry Moore int i;
8766bc8bc6aSSherry Moore fastboot_file_t *fb;
8776bc8bc6aSSherry Moore uint32_t dboot_start_offset;
8786bc8bc6aSSherry Moore char kern_bootpath[OBP_MAXPATHLEN];
8796bc8bc6aSSherry Moore extern uintptr_t postbootkernelbase;
880753a6d45SSherry Moore uintptr_t saved_kernelbase;
8816bc8bc6aSSherry Moore int bootpath_len = 0;
8826bc8bc6aSSherry Moore int is_failsafe = 0;
8836bc8bc6aSSherry Moore int is_retry = 0;
8846bc8bc6aSSherry Moore uint64_t end_addr;
8856bc8bc6aSSherry Moore
886c90a5fbeSSherry Moore if (!fastreboot_capable)
887c90a5fbeSSherry Moore return;
8886bc8bc6aSSherry Moore
889753a6d45SSherry Moore if (newkernel.fi_valid)
890753a6d45SSherry Moore fastboot_free_newkernel(&newkernel);
891753a6d45SSherry Moore
892753a6d45SSherry Moore saved_kernelbase = postbootkernelbase;
893753a6d45SSherry Moore
8946bc8bc6aSSherry Moore postbootkernelbase = 0;
8956bc8bc6aSSherry Moore
8966bc8bc6aSSherry Moore /*
8976bc8bc6aSSherry Moore * Initialize various HAT related fields in the data structure
8986bc8bc6aSSherry Moore */
8996bc8bc6aSSherry Moore fastboot_init_fields(&newkernel);
9006bc8bc6aSSherry Moore
9016bc8bc6aSSherry Moore bzero(kern_bootpath, OBP_MAXPATHLEN);
9026bc8bc6aSSherry Moore
9036bc8bc6aSSherry Moore /*
9046bc8bc6aSSherry Moore * Process the boot argument
9056bc8bc6aSSherry Moore */
906753a6d45SSherry Moore bzero(fastboot_args, OBP_MAXPATHLEN);
907753a6d45SSherry Moore fastboot_parse_mdep(mdep, kern_bootpath, &bootpath_len, fastboot_args);
90819397407SSherry Moore
90919397407SSherry Moore /*
91019397407SSherry Moore * Make sure we get the null character
91119397407SSherry Moore */
91219397407SSherry Moore bcopy(kern_bootpath, fastboot_filename[FASTBOOT_NAME_UNIX],
91319397407SSherry Moore bootpath_len);
91419397407SSherry Moore bcopy(kern_bootfile,
91519397407SSherry Moore &fastboot_filename[FASTBOOT_NAME_UNIX][bootpath_len],
91619397407SSherry Moore strlen(kern_bootfile) + 1);
91719397407SSherry Moore
91819397407SSherry Moore bcopy(kern_bootpath, fastboot_filename[FASTBOOT_NAME_BOOTARCHIVE],
91919397407SSherry Moore bootpath_len);
92019397407SSherry Moore
921753a6d45SSherry Moore if (bcmp(kern_bootfile, FAILSAFE_BOOTFILE32,
922753a6d45SSherry Moore (sizeof (FAILSAFE_BOOTFILE32) - 1)) == 0 ||
923753a6d45SSherry Moore bcmp(kern_bootfile, FAILSAFE_BOOTFILE64,
924753a6d45SSherry Moore (sizeof (FAILSAFE_BOOTFILE64) - 1)) == 0) {
92519397407SSherry Moore is_failsafe = 1;
92619397407SSherry Moore }
92719397407SSherry Moore
9286bc8bc6aSSherry Moore load_kernel_retry:
92919397407SSherry Moore /*
93019397407SSherry Moore * Read in unix and boot_archive
93119397407SSherry Moore */
9326bc8bc6aSSherry Moore end_addr = DBOOT_ENTRY_ADDRESS;
93319397407SSherry Moore for (i = 0; i < FASTBOOT_MAX_FILES_MAP; i++) {
9346bc8bc6aSSherry Moore struct _buf *file;
9356bc8bc6aSSherry Moore uintptr_t va;
9366bc8bc6aSSherry Moore uint64_t fsize;
9376bc8bc6aSSherry Moore size_t fsize_roundup, pt_size;
9386bc8bc6aSSherry Moore int page_index;
9396bc8bc6aSSherry Moore uintptr_t offset;
94019397407SSherry Moore ddi_dma_attr_t dma_attr = fastboot_dma_attr;
94119397407SSherry Moore
9426bc8bc6aSSherry Moore
94319397407SSherry Moore dprintf("fastboot_filename[%d] = %s\n",
94419397407SSherry Moore i, fastboot_filename[i]);
94519397407SSherry Moore
94619397407SSherry Moore if ((file = kobj_open_file(fastboot_filename[i])) ==
94719397407SSherry Moore (struct _buf *)-1) {
948a2491ff4SSherry Moore cmn_err(CE_NOTE, "!Fastboot: Couldn't open %s",
94919397407SSherry Moore fastboot_filename[i]);
95019397407SSherry Moore goto err_out;
95119397407SSherry Moore }
95219397407SSherry Moore
95319397407SSherry Moore if (kobj_get_filesize(file, &fsize) != 0) {
954a2491ff4SSherry Moore cmn_err(CE_NOTE,
955a2491ff4SSherry Moore "!Fastboot: Couldn't get filesize for %s",
95619397407SSherry Moore fastboot_filename[i]);
95719397407SSherry Moore goto err_out;
95819397407SSherry Moore }
95919397407SSherry Moore
9606bc8bc6aSSherry Moore fsize_roundup = P2ROUNDUP_TYPED(fsize, PAGESIZE, size_t);
9616bc8bc6aSSherry Moore
9626bc8bc6aSSherry Moore /*
9636bc8bc6aSSherry Moore * Where the files end in physical memory after being
9646bc8bc6aSSherry Moore * relocated by the fast boot switcher.
9656bc8bc6aSSherry Moore */
9666bc8bc6aSSherry Moore end_addr += fsize_roundup;
9676bc8bc6aSSherry Moore if (end_addr > fastboot_below_1G_dma_attr.dma_attr_addr_hi) {
968a2491ff4SSherry Moore cmn_err(CE_NOTE, "!Fastboot: boot archive is too big");
9696bc8bc6aSSherry Moore goto err_out;
9706bc8bc6aSSherry Moore }
9716bc8bc6aSSherry Moore
9726bc8bc6aSSherry Moore /*
9736bc8bc6aSSherry Moore * Adjust dma_attr_addr_lo so that the new kernel and boot
9746bc8bc6aSSherry Moore * archive will not be overridden during relocation.
9756bc8bc6aSSherry Moore */
9766bc8bc6aSSherry Moore if (end_addr > fastboot_dma_attr.dma_attr_addr_lo ||
9776bc8bc6aSSherry Moore end_addr > fastboot_below_1G_dma_attr.dma_attr_addr_lo) {
9786bc8bc6aSSherry Moore
9796bc8bc6aSSherry Moore if (is_retry) {
9806bc8bc6aSSherry Moore /*
9816bc8bc6aSSherry Moore * If we have already tried and didn't succeed,
9826bc8bc6aSSherry Moore * just give up.
9836bc8bc6aSSherry Moore */
984a2491ff4SSherry Moore cmn_err(CE_NOTE,
985a2491ff4SSherry Moore "!Fastboot: boot archive is too big");
9866bc8bc6aSSherry Moore goto err_out;
9876bc8bc6aSSherry Moore } else {
9886bc8bc6aSSherry Moore /* Set the flag so we don't keep retrying */
9896bc8bc6aSSherry Moore is_retry++;
9906bc8bc6aSSherry Moore
9916bc8bc6aSSherry Moore /* Adjust dma_attr_addr_lo */
9926bc8bc6aSSherry Moore fastboot_dma_attr.dma_attr_addr_lo = end_addr;
9936bc8bc6aSSherry Moore fastboot_below_1G_dma_attr.dma_attr_addr_lo =
9946bc8bc6aSSherry Moore end_addr;
9956bc8bc6aSSherry Moore
9966bc8bc6aSSherry Moore /*
9976bc8bc6aSSherry Moore * Free the memory we have already allocated
9986bc8bc6aSSherry Moore * whose physical addresses might not fit
9996bc8bc6aSSherry Moore * the new lo and hi constraints.
10006bc8bc6aSSherry Moore */
1001753a6d45SSherry Moore fastboot_free_mem(&newkernel, end_addr);
10026bc8bc6aSSherry Moore goto load_kernel_retry;
10036bc8bc6aSSherry Moore }
100419397407SSherry Moore }
100519397407SSherry Moore
10066bc8bc6aSSherry Moore
100719397407SSherry Moore if (!fastboot_contig)
100819397407SSherry Moore dma_attr.dma_attr_sgllen = (fsize / PAGESIZE) +
100919397407SSherry Moore (((fsize % PAGESIZE) == 0) ? 0 : 1);
101019397407SSherry Moore
101119397407SSherry Moore if ((buf = contig_alloc(fsize, &dma_attr, PAGESIZE, 0))
101219397407SSherry Moore == NULL) {
1013a2491ff4SSherry Moore cmn_err(CE_NOTE, fastboot_enomem_msg, fsize, "64G");
101419397407SSherry Moore goto err_out;
101519397407SSherry Moore }
101619397407SSherry Moore
101719397407SSherry Moore va = P2ROUNDUP_TYPED((uintptr_t)buf, PAGESIZE, uintptr_t);
101819397407SSherry Moore
101919397407SSherry Moore if (kobj_read_file(file, (char *)va, fsize, 0) < 0) {
1020a2491ff4SSherry Moore cmn_err(CE_NOTE, "!Fastboot: Couldn't read %s",
102119397407SSherry Moore fastboot_filename[i]);
102219397407SSherry Moore goto err_out;
102319397407SSherry Moore }
102419397407SSherry Moore
102519397407SSherry Moore fb = &newkernel.fi_files[i];
102619397407SSherry Moore fb->fb_va = va;
102719397407SSherry Moore fb->fb_size = fsize;
102819397407SSherry Moore fb->fb_sectcnt = 0;
102919397407SSherry Moore
1030753a6d45SSherry Moore pt_size = FASTBOOT_PTE_LIST_SIZE(fsize_roundup);
1031753a6d45SSherry Moore
103219397407SSherry Moore /*
1033753a6d45SSherry Moore * If we have reserved memory but it not enough, free it.
103419397407SSherry Moore */
1035753a6d45SSherry Moore if (fb->fb_pte_list_size && fb->fb_pte_list_size < pt_size) {
1036753a6d45SSherry Moore contig_free((void *)fb->fb_pte_list_va,
1037753a6d45SSherry Moore fb->fb_pte_list_size);
1038753a6d45SSherry Moore fb->fb_pte_list_size = 0;
1039753a6d45SSherry Moore }
104019397407SSherry Moore
1041753a6d45SSherry Moore if (fb->fb_pte_list_size == 0) {
1042753a6d45SSherry Moore if ((fb->fb_pte_list_va =
1043753a6d45SSherry Moore (x86pte_t *)contig_alloc(pt_size,
1044753a6d45SSherry Moore &fastboot_below_1G_dma_attr, PAGESIZE, 0))
1045753a6d45SSherry Moore == NULL) {
1046a2491ff4SSherry Moore cmn_err(CE_NOTE, fastboot_enomem_msg,
1047753a6d45SSherry Moore (uint64_t)pt_size, "1G");
1048753a6d45SSherry Moore goto err_out;
1049753a6d45SSherry Moore }
1050753a6d45SSherry Moore /*
1051753a6d45SSherry Moore * fb_pte_list_size must be set after the allocation
1052753a6d45SSherry Moore * succeeds as it's used to determine how much memory to
1053753a6d45SSherry Moore * free.
1054753a6d45SSherry Moore */
1055753a6d45SSherry Moore fb->fb_pte_list_size = pt_size;
105619397407SSherry Moore }
105719397407SSherry Moore
1058753a6d45SSherry Moore bzero((void *)(fb->fb_pte_list_va), fb->fb_pte_list_size);
105919397407SSherry Moore
106019397407SSherry Moore fb->fb_pte_list_pa = mmu_ptob((uint64_t)hat_getpfnum(kas.a_hat,
106119397407SSherry Moore (caddr_t)fb->fb_pte_list_va));
106219397407SSherry Moore
106319397407SSherry Moore for (page_index = 0, offset = 0; offset < fb->fb_size;
106419397407SSherry Moore offset += PAGESIZE) {
106519397407SSherry Moore uint64_t paddr;
106619397407SSherry Moore
106719397407SSherry Moore paddr = mmu_ptob((uint64_t)hat_getpfnum(kas.a_hat,
106819397407SSherry Moore (caddr_t)fb->fb_va + offset));
106919397407SSherry Moore
107019397407SSherry Moore ASSERT(paddr >= fastboot_dma_attr.dma_attr_addr_lo);
107119397407SSherry Moore
107219397407SSherry Moore /*
107319397407SSherry Moore * Include the pte_bits so we don't have to make
107419397407SSherry Moore * it in assembly.
107519397407SSherry Moore */
107619397407SSherry Moore fb->fb_pte_list_va[page_index++] = (x86pte_t)
107719397407SSherry Moore (paddr | pte_bits);
107819397407SSherry Moore }
107919397407SSherry Moore
108019397407SSherry Moore fb->fb_pte_list_va[page_index] = FASTBOOT_TERMINATE;
108119397407SSherry Moore
108219397407SSherry Moore if (i == FASTBOOT_UNIX) {
10836bc8bc6aSSherry Moore Ehdr *ehdr = (Ehdr *)va;
10846bc8bc6aSSherry Moore int j;
108519397407SSherry Moore
108619397407SSherry Moore /*
108719397407SSherry Moore * Sanity checks:
108819397407SSherry Moore */
108919397407SSherry Moore for (j = 0; j < SELFMAG; j++) {
109019397407SSherry Moore if (ehdr->e_ident[j] != ELFMAG[j]) {
1091a2491ff4SSherry Moore cmn_err(CE_NOTE, "!Fastboot: Bad ELF "
109219397407SSherry Moore "signature");
109319397407SSherry Moore goto err_out;
109419397407SSherry Moore }
109519397407SSherry Moore }
109619397407SSherry Moore
109719397407SSherry Moore if (ehdr->e_ident[EI_CLASS] == ELFCLASS32 &&
109819397407SSherry Moore ehdr->e_ident[EI_DATA] == ELFDATA2LSB &&
109919397407SSherry Moore ehdr->e_machine == EM_386) {
110019397407SSherry Moore
1101877400d3SKonstantin Ananyev fb->fb_sectcnt = sizeof (fb->fb_sections) /
1102877400d3SKonstantin Ananyev sizeof (fb->fb_sections[0]);
1103877400d3SKonstantin Ananyev
110419397407SSherry Moore if (fastboot_elf32_find_loadables((void *)va,
110519397407SSherry Moore fsize, &fb->fb_sections[0],
110619397407SSherry Moore &fb->fb_sectcnt, &dboot_start_offset) < 0) {
1107a2491ff4SSherry Moore cmn_err(CE_NOTE, "!Fastboot: ELF32 "
110819397407SSherry Moore "program section failure");
110919397407SSherry Moore goto err_out;
111019397407SSherry Moore }
111119397407SSherry Moore
111219397407SSherry Moore if (fb->fb_sectcnt == 0) {
1113a2491ff4SSherry Moore cmn_err(CE_NOTE, "!Fastboot: No ELF32 "
111419397407SSherry Moore "program sections found");
111519397407SSherry Moore goto err_out;
111619397407SSherry Moore }
111719397407SSherry Moore
111819397407SSherry Moore if (is_failsafe) {
111919397407SSherry Moore /* Failsafe boot_archive */
1120753a6d45SSherry Moore bcopy(BOOTARCHIVE32_FAILSAFE,
112119397407SSherry Moore &fastboot_filename
112219397407SSherry Moore [FASTBOOT_NAME_BOOTARCHIVE]
112319397407SSherry Moore [bootpath_len],
1124753a6d45SSherry Moore sizeof (BOOTARCHIVE32_FAILSAFE));
112519397407SSherry Moore } else {
112619397407SSherry Moore bcopy(BOOTARCHIVE32,
112719397407SSherry Moore &fastboot_filename
112819397407SSherry Moore [FASTBOOT_NAME_BOOTARCHIVE]
112919397407SSherry Moore [bootpath_len],
113019397407SSherry Moore sizeof (BOOTARCHIVE32));
113119397407SSherry Moore }
113219397407SSherry Moore
113319397407SSherry Moore } else if (ehdr->e_ident[EI_CLASS] == ELFCLASS64 &&
113419397407SSherry Moore ehdr->e_ident[EI_DATA] == ELFDATA2LSB &&
113519397407SSherry Moore ehdr->e_machine == EM_AMD64) {
113619397407SSherry Moore
113719397407SSherry Moore if (fastboot_elf64_find_dboot_load_offset(
113819397407SSherry Moore (void *)va, fsize, &dboot_start_offset)
113919397407SSherry Moore != 0) {
1140a2491ff4SSherry Moore cmn_err(CE_NOTE, "!Fastboot: Couldn't "
114119397407SSherry Moore "find ELF64 dboot entry offset");
114219397407SSherry Moore goto err_out;
114319397407SSherry Moore }
114419397407SSherry Moore
11457417cfdeSKuriakose Kuruvilla if (!is_x86_feature(x86_featureset,
11467417cfdeSKuriakose Kuruvilla X86FSET_64) ||
11477417cfdeSKuriakose Kuruvilla !is_x86_feature(x86_featureset,
11487417cfdeSKuriakose Kuruvilla X86FSET_PAE)) {
11497417cfdeSKuriakose Kuruvilla cmn_err(CE_NOTE, "Fastboot: Cannot "
115019397407SSherry Moore "reboot to %s: "
115119397407SSherry Moore "not a 64-bit capable system",
115219397407SSherry Moore kern_bootfile);
115319397407SSherry Moore goto err_out;
115419397407SSherry Moore }
115519397407SSherry Moore
1156753a6d45SSherry Moore if (is_failsafe) {
1157753a6d45SSherry Moore /* Failsafe boot_archive */
1158753a6d45SSherry Moore bcopy(BOOTARCHIVE64_FAILSAFE,
1159753a6d45SSherry Moore &fastboot_filename
1160753a6d45SSherry Moore [FASTBOOT_NAME_BOOTARCHIVE]
1161753a6d45SSherry Moore [bootpath_len],
1162753a6d45SSherry Moore sizeof (BOOTARCHIVE64_FAILSAFE));
1163753a6d45SSherry Moore } else {
1164753a6d45SSherry Moore bcopy(BOOTARCHIVE64,
1165753a6d45SSherry Moore &fastboot_filename
1166753a6d45SSherry Moore [FASTBOOT_NAME_BOOTARCHIVE]
1167753a6d45SSherry Moore [bootpath_len],
1168753a6d45SSherry Moore sizeof (BOOTARCHIVE64));
1169753a6d45SSherry Moore }
117019397407SSherry Moore } else {
1171a2491ff4SSherry Moore cmn_err(CE_NOTE, "!Fastboot: Unknown ELF type");
117219397407SSherry Moore goto err_out;
117319397407SSherry Moore }
117419397407SSherry Moore
117519397407SSherry Moore fb->fb_dest_pa = DBOOT_ENTRY_ADDRESS -
117619397407SSherry Moore dboot_start_offset;
117719397407SSherry Moore
117819397407SSherry Moore fb->fb_next_pa = DBOOT_ENTRY_ADDRESS + fsize_roundup;
117919397407SSherry Moore } else {
118019397407SSherry Moore fb->fb_dest_pa = newkernel.fi_files[i - 1].fb_next_pa;
118119397407SSherry Moore fb->fb_next_pa = fb->fb_dest_pa + fsize_roundup;
118219397407SSherry Moore }
118319397407SSherry Moore
118419397407SSherry Moore kobj_close_file(file);
118519397407SSherry Moore
118619397407SSherry Moore }
118719397407SSherry Moore
118819397407SSherry Moore /*
118919397407SSherry Moore * Add the function that will switch us to 32-bit protected mode
119019397407SSherry Moore */
119119397407SSherry Moore fb = &newkernel.fi_files[FASTBOOT_SWTCH];
119219397407SSherry Moore fb->fb_va = fb->fb_dest_pa = FASTBOOT_SWTCH_PA;
1193877400d3SKonstantin Ananyev fb->fb_size = MMU_PAGESIZE;
119419397407SSherry Moore
1195753a6d45SSherry Moore hat_devload(kas.a_hat, (caddr_t)fb->fb_va,
1196753a6d45SSherry Moore MMU_PAGESIZE, mmu_btop(fb->fb_dest_pa),
1197753a6d45SSherry Moore PROT_READ | PROT_WRITE | PROT_EXEC,
1198753a6d45SSherry Moore HAT_LOAD_NOCONSIST | HAT_LOAD_LOCK);
119919397407SSherry Moore
120019397407SSherry Moore /*
120119397407SSherry Moore * Build the new multiboot_info structure
120219397407SSherry Moore */
1203753a6d45SSherry Moore if (fastboot_build_mbi(fastboot_args, &newkernel) != 0) {
120419397407SSherry Moore goto err_out;
120519397407SSherry Moore }
120619397407SSherry Moore
120719397407SSherry Moore /*
120819397407SSherry Moore * Build page table for low 1G physical memory. Use big pages.
1209877400d3SKonstantin Ananyev * Allocate 4 (5 for amd64) pages for the page tables.
1210877400d3SKonstantin Ananyev * 1 page for PML4 (amd64)
121119397407SSherry Moore * 1 page for Page-Directory-Pointer Table
1212877400d3SKonstantin Ananyev * 2 pages for Page Directory
121319397407SSherry Moore * 1 page for Page Table.
121419397407SSherry Moore * The page table entry will be rewritten to map the physical
121519397407SSherry Moore * address as we do the copying.
121619397407SSherry Moore */
121719397407SSherry Moore if (newkernel.fi_has_pae) {
1218877400d3SKonstantin Ananyev size_t size = MMU_PAGESIZE * 5;
121919397407SSherry Moore
1220753a6d45SSherry Moore if (newkernel.fi_pagetable_size && newkernel.fi_pagetable_size
1221753a6d45SSherry Moore < size) {
1222753a6d45SSherry Moore contig_free((void *)newkernel.fi_pagetable_va,
1223753a6d45SSherry Moore newkernel.fi_pagetable_size);
1224753a6d45SSherry Moore newkernel.fi_pagetable_size = 0;
1225753a6d45SSherry Moore }
1226753a6d45SSherry Moore
1227753a6d45SSherry Moore if (newkernel.fi_pagetable_size == 0) {
1228753a6d45SSherry Moore if ((newkernel.fi_pagetable_va = (uintptr_t)
1229753a6d45SSherry Moore contig_alloc(size, &fastboot_below_1G_dma_attr,
12304da99751SToomas Soome MMU_PAGESIZE, 0)) == 0) {
1231a2491ff4SSherry Moore cmn_err(CE_NOTE, fastboot_enomem_msg,
1232753a6d45SSherry Moore (uint64_t)size, "1G");
1233753a6d45SSherry Moore goto err_out;
1234753a6d45SSherry Moore }
1235753a6d45SSherry Moore /*
1236753a6d45SSherry Moore * fi_pagetable_size must be set after the allocation
1237753a6d45SSherry Moore * succeeds as it's used to determine how much memory to
1238753a6d45SSherry Moore * free.
1239753a6d45SSherry Moore */
1240753a6d45SSherry Moore newkernel.fi_pagetable_size = size;
124119397407SSherry Moore }
124219397407SSherry Moore
124319397407SSherry Moore bzero((void *)(newkernel.fi_pagetable_va), size);
124419397407SSherry Moore
124519397407SSherry Moore newkernel.fi_pagetable_pa =
124619397407SSherry Moore mmu_ptob((uint64_t)hat_getpfnum(kas.a_hat,
124719397407SSherry Moore (caddr_t)newkernel.fi_pagetable_va));
124819397407SSherry Moore
124919397407SSherry Moore newkernel.fi_last_table_pa = newkernel.fi_pagetable_pa +
1250877400d3SKonstantin Ananyev size - MMU_PAGESIZE;
125119397407SSherry Moore
125219397407SSherry Moore newkernel.fi_next_table_va = newkernel.fi_pagetable_va +
125319397407SSherry Moore MMU_PAGESIZE;
125419397407SSherry Moore newkernel.fi_next_table_pa = newkernel.fi_pagetable_pa +
125519397407SSherry Moore MMU_PAGESIZE;
125619397407SSherry Moore
125719397407SSherry Moore fastboot_build_pagetables(&newkernel);
125819397407SSherry Moore }
125919397407SSherry Moore
126019397407SSherry Moore
1261753a6d45SSherry Moore /* Generate MD5 checksums */
1262753a6d45SSherry Moore fastboot_cksum_generate(&newkernel);
1263753a6d45SSherry Moore
126419397407SSherry Moore /* Mark it as valid */
126519397407SSherry Moore newkernel.fi_valid = 1;
126619397407SSherry Moore newkernel.fi_magic = FASTBOOT_MAGIC;
126719397407SSherry Moore
1268753a6d45SSherry Moore postbootkernelbase = saved_kernelbase;
126919397407SSherry Moore return;
127019397407SSherry Moore
127119397407SSherry Moore err_out:
1272753a6d45SSherry Moore postbootkernelbase = saved_kernelbase;
127319397407SSherry Moore newkernel.fi_valid = 0;
1274753a6d45SSherry Moore fastboot_free_newkernel(&newkernel);
1275753a6d45SSherry Moore }
1276753a6d45SSherry Moore
1277753a6d45SSherry Moore
1278753a6d45SSherry Moore /* ARGSUSED */
1279753a6d45SSherry Moore static int
fastboot_xc_func(xc_arg_t arg1,xc_arg_t arg2 __unused,xc_arg_t arg3 __unused)1280027bcc9fSToomas Soome fastboot_xc_func(xc_arg_t arg1, xc_arg_t arg2 __unused, xc_arg_t arg3 __unused)
1281753a6d45SSherry Moore {
1282027bcc9fSToomas Soome fastboot_info_t *nk = (fastboot_info_t *)arg1;
1283753a6d45SSherry Moore void (*fastboot_func)(fastboot_info_t *);
1284753a6d45SSherry Moore fastboot_file_t *fb = &nk->fi_files[FASTBOOT_SWTCH];
1285753a6d45SSherry Moore fastboot_func = (void (*)())(fb->fb_va);
1286753a6d45SSherry Moore kthread_t *t_intr = curthread->t_intr;
1287753a6d45SSherry Moore
1288753a6d45SSherry Moore if (&kas != curproc->p_as) {
1289753a6d45SSherry Moore hat_devload(curproc->p_as->a_hat, (caddr_t)fb->fb_va,
1290753a6d45SSherry Moore MMU_PAGESIZE, mmu_btop(fb->fb_dest_pa),
1291753a6d45SSherry Moore PROT_READ | PROT_WRITE | PROT_EXEC,
1292753a6d45SSherry Moore HAT_LOAD_NOCONSIST | HAT_LOAD_LOCK);
1293753a6d45SSherry Moore }
1294753a6d45SSherry Moore
1295753a6d45SSherry Moore /*
1296753a6d45SSherry Moore * If we have pinned a thread, make sure the address is mapped
1297753a6d45SSherry Moore * in the address space of the pinned thread.
1298753a6d45SSherry Moore */
1299753a6d45SSherry Moore if (t_intr && t_intr->t_procp->p_as->a_hat != curproc->p_as->a_hat &&
1300753a6d45SSherry Moore t_intr->t_procp->p_as != &kas)
1301753a6d45SSherry Moore hat_devload(t_intr->t_procp->p_as->a_hat, (caddr_t)fb->fb_va,
1302753a6d45SSherry Moore MMU_PAGESIZE, mmu_btop(fb->fb_dest_pa),
1303753a6d45SSherry Moore PROT_READ | PROT_WRITE | PROT_EXEC,
1304753a6d45SSherry Moore HAT_LOAD_NOCONSIST | HAT_LOAD_LOCK);
1305753a6d45SSherry Moore
1306753a6d45SSherry Moore (*psm_shutdownf)(A_SHUTDOWN, AD_FASTREBOOT);
1307753a6d45SSherry Moore (*fastboot_func)(nk);
1308753a6d45SSherry Moore
1309753a6d45SSherry Moore /*NOTREACHED*/
1310753a6d45SSherry Moore return (0);
131119397407SSherry Moore }
131219397407SSherry Moore
13136bc8bc6aSSherry Moore /*
13146bc8bc6aSSherry Moore * Jump to the fast reboot switcher. This function never returns.
13156bc8bc6aSSherry Moore */
131619397407SSherry Moore void
fast_reboot()131719397407SSherry Moore fast_reboot()
131819397407SSherry Moore {
1319753a6d45SSherry Moore processorid_t bootcpuid = 0;
1320753a6d45SSherry Moore extern uintptr_t postbootkernelbase;
1321753a6d45SSherry Moore extern char fb_swtch_image[];
1322753a6d45SSherry Moore fastboot_file_t *fb;
1323753a6d45SSherry Moore int i;
1324753a6d45SSherry Moore
1325753a6d45SSherry Moore postbootkernelbase = 0;
1326753a6d45SSherry Moore
1327753a6d45SSherry Moore fb = &newkernel.fi_files[FASTBOOT_SWTCH];
1328753a6d45SSherry Moore
1329753a6d45SSherry Moore /*
1330753a6d45SSherry Moore * Map the address into both the current proc's address
1331753a6d45SSherry Moore * space and the kernel's address space in case the panic
1332753a6d45SSherry Moore * is forced by kmdb.
1333753a6d45SSherry Moore */
1334753a6d45SSherry Moore if (&kas != curproc->p_as) {
1335753a6d45SSherry Moore hat_devload(curproc->p_as->a_hat, (caddr_t)fb->fb_va,
1336753a6d45SSherry Moore MMU_PAGESIZE, mmu_btop(fb->fb_dest_pa),
1337753a6d45SSherry Moore PROT_READ | PROT_WRITE | PROT_EXEC,
1338753a6d45SSherry Moore HAT_LOAD_NOCONSIST | HAT_LOAD_LOCK);
1339753a6d45SSherry Moore }
1340753a6d45SSherry Moore
1341753a6d45SSherry Moore bcopy((void *)fb_swtch_image, (void *)fb->fb_va, fb->fb_size);
1342753a6d45SSherry Moore
1343753a6d45SSherry Moore
1344753a6d45SSherry Moore /*
1345753a6d45SSherry Moore * Set fb_va to fake_va
1346753a6d45SSherry Moore */
1347753a6d45SSherry Moore for (i = 0; i < FASTBOOT_MAX_FILES_MAP; i++) {
1348753a6d45SSherry Moore newkernel.fi_files[i].fb_va = fake_va;
1349753a6d45SSherry Moore
1350753a6d45SSherry Moore }
1351753a6d45SSherry Moore
1352753a6d45SSherry Moore if (panicstr && CPU->cpu_id != bootcpuid &&
1353753a6d45SSherry Moore CPU_ACTIVE(cpu_get(bootcpuid))) {
1354f34a7178SJoe Bonasera extern void panic_idle(void);
1355753a6d45SSherry Moore cpuset_t cpuset;
1356753a6d45SSherry Moore
1357753a6d45SSherry Moore CPUSET_ZERO(cpuset);
1358753a6d45SSherry Moore CPUSET_ADD(cpuset, bootcpuid);
1359f34a7178SJoe Bonasera xc_priority((xc_arg_t)&newkernel, 0, 0, CPUSET2BV(cpuset),
1360027bcc9fSToomas Soome fastboot_xc_func);
1361753a6d45SSherry Moore
1362f34a7178SJoe Bonasera panic_idle();
1363753a6d45SSherry Moore } else
1364027bcc9fSToomas Soome (void) fastboot_xc_func((xc_arg_t)&newkernel, 0, 0);
1365753a6d45SSherry Moore }
1366753a6d45SSherry Moore
1367753a6d45SSherry Moore
1368753a6d45SSherry Moore /*
1369753a6d45SSherry Moore * Get boot property value for fastreboot_onpanic.
1370753a6d45SSherry Moore *
1371753a6d45SSherry Moore * NOTE: If fastreboot_onpanic is set to non-zero in /etc/system,
1372753a6d45SSherry Moore * new setting passed in via "-B fastreboot_onpanic" is ignored.
1373753a6d45SSherry Moore * This order of precedence is to enable developers debugging panics
1374753a6d45SSherry Moore * that occur early in boot to utilize Fast Reboot on panic.
1375753a6d45SSherry Moore */
1376753a6d45SSherry Moore static void
fastboot_get_bootprop(void)1377753a6d45SSherry Moore fastboot_get_bootprop(void)
1378753a6d45SSherry Moore {
1379753a6d45SSherry Moore int val = 0xaa, len, ret;
1380753a6d45SSherry Moore dev_info_t *devi;
1381753a6d45SSherry Moore char *propstr = NULL;
1382753a6d45SSherry Moore
1383753a6d45SSherry Moore devi = ddi_root_node();
1384753a6d45SSherry Moore
1385753a6d45SSherry Moore ret = ddi_prop_lookup_string(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
1386753a6d45SSherry Moore FASTREBOOT_ONPANIC, &propstr);
1387753a6d45SSherry Moore
1388753a6d45SSherry Moore if (ret == DDI_PROP_SUCCESS) {
1389753a6d45SSherry Moore if (FASTREBOOT_ONPANIC_NOTSET(propstr))
1390753a6d45SSherry Moore val = 0;
1391753a6d45SSherry Moore else if (FASTREBOOT_ONPANIC_ISSET(propstr))
1392753a6d45SSherry Moore val = UA_FASTREBOOT_ONPANIC;
1393753a6d45SSherry Moore
1394753a6d45SSherry Moore /*
1395753a6d45SSherry Moore * Only set fastreboot_onpanic to the value passed in
1396753a6d45SSherry Moore * if it's not already set to non-zero, and the value
1397753a6d45SSherry Moore * has indeed been passed in via command line.
1398753a6d45SSherry Moore */
1399753a6d45SSherry Moore if (!fastreboot_onpanic && val != 0xaa)
1400753a6d45SSherry Moore fastreboot_onpanic = val;
1401753a6d45SSherry Moore ddi_prop_free(propstr);
1402753a6d45SSherry Moore } else if (ret != DDI_PROP_NOT_FOUND && ret != DDI_PROP_UNDEFINED) {
1403a2491ff4SSherry Moore cmn_err(CE_NOTE, "!%s value is invalid, will be ignored",
1404753a6d45SSherry Moore FASTREBOOT_ONPANIC);
1405753a6d45SSherry Moore }
1406753a6d45SSherry Moore
1407753a6d45SSherry Moore len = sizeof (fastreboot_onpanic_cmdline);
1408753a6d45SSherry Moore ret = ddi_getlongprop_buf(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
1409753a6d45SSherry Moore FASTREBOOT_ONPANIC_CMDLINE, fastreboot_onpanic_cmdline, &len);
1410753a6d45SSherry Moore
1411753a6d45SSherry Moore if (ret == DDI_PROP_BUF_TOO_SMALL)
1412a2491ff4SSherry Moore cmn_err(CE_NOTE, "!%s value is too long, will be ignored",
1413753a6d45SSherry Moore FASTREBOOT_ONPANIC_CMDLINE);
1414753a6d45SSherry Moore }
1415753a6d45SSherry Moore
1416753a6d45SSherry Moore /*
1417753a6d45SSherry Moore * This function is called by main() to either load the backup kernel for panic
1418753a6d45SSherry Moore * fast reboot, or to reserve low physical memory for fast reboot.
1419753a6d45SSherry Moore */
1420753a6d45SSherry Moore void
fastboot_post_startup()1421753a6d45SSherry Moore fastboot_post_startup()
1422753a6d45SSherry Moore {
1423835b9930SSherry Moore lbolt_at_boot = ddi_get_lbolt();
1424835b9930SSherry Moore
1425835b9930SSherry Moore /* Default to 10 minutes */
1426835b9930SSherry Moore if (fastreboot_onpanic_uptime == LONG_MAX)
1427835b9930SSherry Moore fastreboot_onpanic_uptime = SEC_TO_TICK(10 * 60);
1428835b9930SSherry Moore
1429753a6d45SSherry Moore if (!fastreboot_capable)
1430753a6d45SSherry Moore return;
1431753a6d45SSherry Moore
1432c90a5fbeSSherry Moore mutex_enter(&fastreboot_config_mutex);
1433c90a5fbeSSherry Moore
1434753a6d45SSherry Moore fastboot_get_bootprop();
1435753a6d45SSherry Moore
1436753a6d45SSherry Moore if (fastreboot_onpanic)
1437753a6d45SSherry Moore fastboot_load_kernel(fastreboot_onpanic_cmdline);
1438753a6d45SSherry Moore else if (reserve_mem_enabled)
1439753a6d45SSherry Moore fastboot_reserve_mem(&newkernel);
1440c90a5fbeSSherry Moore
1441c90a5fbeSSherry Moore mutex_exit(&fastreboot_config_mutex);
1442753a6d45SSherry Moore }
1443753a6d45SSherry Moore
1444753a6d45SSherry Moore /*
1445753a6d45SSherry Moore * Update boot configuration settings.
1446753a6d45SSherry Moore * If the new fastreboot_onpanic setting is false, and a kernel has
1447753a6d45SSherry Moore * been preloaded, free the memory;
1448753a6d45SSherry Moore * if the new fastreboot_onpanic setting is true and newkernel is
1449753a6d45SSherry Moore * not valid, load the new kernel.
1450753a6d45SSherry Moore */
1451753a6d45SSherry Moore void
fastboot_update_config(const char * mdep)1452753a6d45SSherry Moore fastboot_update_config(const char *mdep)
1453753a6d45SSherry Moore {
1454753a6d45SSherry Moore uint8_t boot_config = (uint8_t)*mdep;
1455c90a5fbeSSherry Moore int cur_fastreboot_onpanic;
1456753a6d45SSherry Moore
1457753a6d45SSherry Moore if (!fastreboot_capable)
1458753a6d45SSherry Moore return;
145919397407SSherry Moore
1460c90a5fbeSSherry Moore mutex_enter(&fastreboot_config_mutex);
1461c90a5fbeSSherry Moore
1462c90a5fbeSSherry Moore cur_fastreboot_onpanic = fastreboot_onpanic;
1463753a6d45SSherry Moore fastreboot_onpanic = boot_config & UA_FASTREBOOT_ONPANIC;
1464c90a5fbeSSherry Moore
1465753a6d45SSherry Moore if (fastreboot_onpanic && (!cur_fastreboot_onpanic ||
1466753a6d45SSherry Moore !newkernel.fi_valid))
1467753a6d45SSherry Moore fastboot_load_kernel(fastreboot_onpanic_cmdline);
1468753a6d45SSherry Moore if (cur_fastreboot_onpanic && !fastreboot_onpanic)
1469753a6d45SSherry Moore fastboot_free_newkernel(&newkernel);
1470c90a5fbeSSherry Moore
1471c90a5fbeSSherry Moore mutex_exit(&fastreboot_config_mutex);
1472c90a5fbeSSherry Moore }
1473c90a5fbeSSherry Moore
1474c90a5fbeSSherry Moore /*
14755ee8e422SKonstantin Ananyev * This is an internal interface to disable Fast Reboot on Panic.
14765ee8e422SKonstantin Ananyev * It frees up memory allocated for the backup kernel and sets
14775ee8e422SKonstantin Ananyev * fastreboot_onpanic to zero.
1478c90a5fbeSSherry Moore */
14795ee8e422SKonstantin Ananyev static void
fastreboot_onpanic_disable(void)14805ee8e422SKonstantin Ananyev fastreboot_onpanic_disable(void)
1481c90a5fbeSSherry Moore {
1482c90a5fbeSSherry Moore uint8_t boot_config = (uint8_t)(~UA_FASTREBOOT_ONPANIC);
1483c90a5fbeSSherry Moore fastboot_update_config((const char *)&boot_config);
1484c90a5fbeSSherry Moore }
1485c90a5fbeSSherry Moore
1486c90a5fbeSSherry Moore /*
1487c90a5fbeSSherry Moore * This is the interface to be called by fm_panic() in case FMA has diagnosed
1488c90a5fbeSSherry Moore * a terminal machine check exception. It does not free up memory allocated
1489c90a5fbeSSherry Moore * for the backup kernel. General disabling fastreboot_onpanic in a
14905ee8e422SKonstantin Ananyev * non-panicking situation must go through fastboot_onpanic_disable().
1491c90a5fbeSSherry Moore */
1492c90a5fbeSSherry Moore void
fastreboot_disable_highpil(void)14935ee8e422SKonstantin Ananyev fastreboot_disable_highpil(void)
1494c90a5fbeSSherry Moore {
1495c90a5fbeSSherry Moore fastreboot_onpanic = 0;
1496c90a5fbeSSherry Moore }
1497c90a5fbeSSherry Moore
14985ee8e422SKonstantin Ananyev /*
14995ee8e422SKonstantin Ananyev * This is an internal interface to disable Fast Reboot by Default.
15005ee8e422SKonstantin Ananyev * It does not free up memory allocated for the backup kernel.
15015ee8e422SKonstantin Ananyev */
15025ee8e422SKonstantin Ananyev static void
fastreboot_capable_disable(uint32_t msgid)15035ee8e422SKonstantin Ananyev fastreboot_capable_disable(uint32_t msgid)
15045ee8e422SKonstantin Ananyev {
15055ee8e422SKonstantin Ananyev if (fastreboot_capable != 0) {
15065ee8e422SKonstantin Ananyev fastreboot_capable = 0;
15075ee8e422SKonstantin Ananyev if (msgid < sizeof (fastreboot_nosup_desc) /
15085ee8e422SKonstantin Ananyev sizeof (fastreboot_nosup_desc[0]))
15095ee8e422SKonstantin Ananyev fastreboot_nosup_id = msgid;
15105ee8e422SKonstantin Ananyev else
15115ee8e422SKonstantin Ananyev fastreboot_nosup_id = FBNS_DEFAULT;
15125ee8e422SKonstantin Ananyev }
15135ee8e422SKonstantin Ananyev }
15145ee8e422SKonstantin Ananyev
15155ee8e422SKonstantin Ananyev /*
15165ee8e422SKonstantin Ananyev * This is the kernel interface for disabling
15175ee8e422SKonstantin Ananyev * Fast Reboot by Default and Fast Reboot on Panic.
15185ee8e422SKonstantin Ananyev * Frees up memory allocated for the backup kernel.
15195ee8e422SKonstantin Ananyev * General disabling of the Fast Reboot by Default feature should be done
15205ee8e422SKonstantin Ananyev * via the userland interface scf_fastreboot_default_set_transient().
15215ee8e422SKonstantin Ananyev */
15225ee8e422SKonstantin Ananyev void
fastreboot_disable(uint32_t msgid)15235ee8e422SKonstantin Ananyev fastreboot_disable(uint32_t msgid)
15245ee8e422SKonstantin Ananyev {
15255ee8e422SKonstantin Ananyev fastreboot_capable_disable(msgid);
15265ee8e422SKonstantin Ananyev fastreboot_onpanic_disable();
15275ee8e422SKonstantin Ananyev }
15285ee8e422SKonstantin Ananyev
15295ee8e422SKonstantin Ananyev /*
15305ee8e422SKonstantin Ananyev * Returns Fast Reboot not support message for fastreboot_nosup_id.
15315ee8e422SKonstantin Ananyev * If fastreboot_nosup_id contains invalid index, default
15325ee8e422SKonstantin Ananyev * Fast Reboot not support message is returned.
15335ee8e422SKonstantin Ananyev */
15345ee8e422SKonstantin Ananyev const char *
fastreboot_nosup_message(void)15355ee8e422SKonstantin Ananyev fastreboot_nosup_message(void)
15365ee8e422SKonstantin Ananyev {
15375ee8e422SKonstantin Ananyev uint32_t msgid;
15385ee8e422SKonstantin Ananyev
15395ee8e422SKonstantin Ananyev msgid = fastreboot_nosup_id;
15405ee8e422SKonstantin Ananyev if (msgid >= sizeof (fastreboot_nosup_desc) /
15415ee8e422SKonstantin Ananyev sizeof (fastreboot_nosup_desc[0]))
15425ee8e422SKonstantin Ananyev msgid = FBNS_DEFAULT;
15435ee8e422SKonstantin Ananyev
15445ee8e422SKonstantin Ananyev return (fastreboot_nosup_desc[msgid]);
15455ee8e422SKonstantin Ananyev }
1546c90a5fbeSSherry Moore
1547c90a5fbeSSherry Moore /*
1548c90a5fbeSSherry Moore * A simplified interface for uadmin to call to update the configuration
1549c90a5fbeSSherry Moore * setting and load a new kernel if necessary.
1550c90a5fbeSSherry Moore */
1551c90a5fbeSSherry Moore void
fastboot_update_and_load(int fcn,char * mdep)1552c90a5fbeSSherry Moore fastboot_update_and_load(int fcn, char *mdep)
1553c90a5fbeSSherry Moore {
1554c90a5fbeSSherry Moore if (fcn != AD_FASTREBOOT) {
1555c90a5fbeSSherry Moore /*
1556c90a5fbeSSherry Moore * If user has explicitly requested reboot to prom,
1557bbf21555SRichard Lowe * or uadmin(8) was invoked with other functions,
1558c90a5fbeSSherry Moore * don't try to fast reboot after dumping.
1559c90a5fbeSSherry Moore */
15605ee8e422SKonstantin Ananyev fastreboot_onpanic_disable();
1561c90a5fbeSSherry Moore }
1562c90a5fbeSSherry Moore
1563c90a5fbeSSherry Moore mutex_enter(&fastreboot_config_mutex);
1564c90a5fbeSSherry Moore
1565c90a5fbeSSherry Moore if (fastreboot_onpanic)
1566c90a5fbeSSherry Moore fastboot_load_kernel(mdep);
1567c90a5fbeSSherry Moore
1568c90a5fbeSSherry Moore mutex_exit(&fastreboot_config_mutex);
156919397407SSherry Moore }
1570