diff --git a/stand/kboot/arch/aarch64/exec.c b/stand/kboot/arch/aarch64/exec.c index 521e28beb562..22fb48471dc2 100644 --- a/stand/kboot/arch/aarch64/exec.c +++ b/stand/kboot/arch/aarch64/exec.c @@ -1,296 +1,294 @@ /*- * Copyright (c) 2006 Marcel Moolenaar * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #ifdef EFI #include #include #include "loader_efi.h" #else #include "host_syscall.h" #endif #include #include "bootstrap.h" #include "kboot.h" #include "bootstrap.h" #include "platform/acfreebsd.h" #include "acconfig.h" #define ACPI_SYSTEM_XFACE #include "actypes.h" #include "actbl.h" #include "cache.h" #ifndef EFI #define LOADER_PAGE_SIZE PAGE_SIZE #endif #ifdef EFI static EFI_GUID acpi_guid = ACPI_TABLE_GUID; static EFI_GUID acpi20_guid = ACPI_20_TABLE_GUID; #endif static int elf64_exec(struct preloaded_file *amp); static int elf64_obj_exec(struct preloaded_file *amp); bool do_mem_map = false; extern uint32_t efi_map_size; extern vm_paddr_t efi_map_phys_src; /* From DTB */ extern vm_paddr_t efi_map_phys_dst; /* From our memory map metadata module */ int bi_load(char *args, vm_offset_t *modulep, vm_offset_t *kernendp, bool exit_bs); static struct file_format arm64_elf = { elf64_loadfile, elf64_exec }; struct file_format *file_formats[] = { &arm64_elf, NULL }; #ifndef EFI extern uintptr_t tramp; extern uint32_t tramp_size; extern uint32_t tramp_data_offset; struct trampoline_data { uint64_t entry; // 0 (PA where kernel loaded) uint64_t modulep; // 8 module metadata uint64_t memmap_src; // 16 Linux-provided memory map PA uint64_t memmap_dst; // 24 Module data copy PA uint64_t memmap_len; // 32 Length to copy }; #endif -extern vm_offset_t kboot_get_phys_load_segment(void); - static int elf64_exec(struct preloaded_file *fp) { vm_offset_t modulep, kernendp; #ifdef EFI vm_offset_t clean_addr; size_t clean_size; void (*entry)(vm_offset_t); #else vm_offset_t trampolinebase; vm_offset_t staging; void *trampcode; uint64_t *trampoline; struct trampoline_data *trampoline_data; int nseg; void *kseg; #endif struct file_metadata *md; Elf_Ehdr *ehdr; int error; #ifdef EFI ACPI_TABLE_RSDP *rsdp; char buf[24]; int revision; /* * Report the RSDP to the kernel. The old code used the 'hints' method * to communite this to the kernel. However, while convenient, the * 'hints' method is fragile and does not work when static hints are * compiled into the kernel. Instead, move to setting different tunables * that start with acpi. The old 'hints' can be removed before we branch * for FreeBSD 15. */ rsdp = efi_get_table(&acpi20_guid); if (rsdp == NULL) { rsdp = efi_get_table(&acpi_guid); } if (rsdp != NULL) { sprintf(buf, "0x%016llx", (unsigned long long)rsdp); setenv("hint.acpi.0.rsdp", buf, 1); setenv("acpi.rsdp", buf, 1); revision = rsdp->Revision; if (revision == 0) revision = 1; sprintf(buf, "%d", revision); setenv("hint.acpi.0.revision", buf, 1); setenv("acpi.revision", buf, 1); strncpy(buf, rsdp->OemId, sizeof(rsdp->OemId)); buf[sizeof(rsdp->OemId)] = '\0'; setenv("hint.acpi.0.oem", buf, 1); setenv("acpi.oem", buf, 1); sprintf(buf, "0x%016x", rsdp->RsdtPhysicalAddress); setenv("hint.acpi.0.rsdt", buf, 1); setenv("acpi.rsdt", buf, 1); if (revision >= 2) { /* XXX extended checksum? */ sprintf(buf, "0x%016llx", (unsigned long long)rsdp->XsdtPhysicalAddress); setenv("hint.acpi.0.xsdt", buf, 1); setenv("acpi.xsdt", buf, 1); sprintf(buf, "%d", rsdp->Length); setenv("hint.acpi.0.xsdt_length", buf, 1); setenv("acpi.xsdt_length", buf, 1); } } #else vm_offset_t rsdp; rsdp = acpi_rsdp(); if (rsdp != 0) { char buf[24]; printf("Found ACPI 2.0 at %#016lx\n", rsdp); sprintf(buf, "0x%016llx", (unsigned long long)rsdp); setenv("hint.acpi.0.rsdp", buf, 1); /* For 13.1R bootability */ setenv("acpi.rsdp", buf, 1); /* Nobody uses the rest of that stuff */ } // XXX Question: why not just use malloc? trampcode = host_getmem(LOADER_PAGE_SIZE); if (trampcode == NULL) { printf("Unable to allocate trampoline\n"); return (ENOMEM); } bzero((void *)trampcode, LOADER_PAGE_SIZE); bcopy((void *)&tramp, (void *)trampcode, tramp_size); trampoline = (void *)trampcode; /* * Figure out where to put it. * * Linux does not allow us to kexec_load into any part of memory. Ask * arch_loadaddr to resolve the first available chunk of physical memory * where loading is possible (load_addr). * * The kernel is loaded at the 'base' address in continguous physical * memory. We use the 2MB in front of the kernel as a place to put our * trampoline, but that's really overkill since we only need ~100 bytes. * The arm64 kernel's entry requirements are only 'load the kernel at a * 2MB alignment' and it figures out the rest, creates the right page * tables, etc. */ staging = kboot_get_phys_load_segment(); printf("Load address at %#jx\n", (uintmax_t)staging); printf("Relocation offset is %#jx\n", (uintmax_t)elf64_relocation_offset); #endif if ((md = file_findmetadata(fp, MODINFOMD_ELFHDR)) == NULL) return(EFTYPE); ehdr = (Elf_Ehdr *)&(md->md_data); #ifdef EFI entry = efi_translate(ehdr->e_entry); efi_time_fini(); #endif error = bi_load(fp->f_args, &modulep, &kernendp, true); if (error != 0) { #ifdef EFI efi_time_init(); #endif return (error); } dev_cleanup(); #ifdef EFI /* Clean D-cache under kernel area and invalidate whole I-cache */ clean_addr = (vm_offset_t)efi_translate(fp->f_addr); clean_size = (vm_offset_t)efi_translate(kernendp) - clean_addr; cpu_flush_dcache((void *)clean_addr, clean_size); cpu_inval_icache(); (*entry)(modulep); #else /* Linux will flush the caches, just pass this data into our trampoline and go */ trampoline_data = (void *)trampoline + tramp_data_offset; memset(trampoline_data, 0, sizeof(*trampoline_data)); trampoline_data->entry = ehdr->e_entry - fp->f_addr + staging; trampoline_data->modulep = modulep; printf("Modulep = %jx\n", (uintmax_t)modulep); if (efi_map_phys_src != 0) { md = file_findmetadata(fp, MODINFOMD_EFI_MAP); if (md == NULL || md->md_addr == 0) { printf("Need to copy EFI MAP, but EFI MAP not found. %p\n", md); } else { printf("Metadata EFI map loaded at VA %lx\n", md->md_addr); efi_map_phys_dst = md->md_addr + staging + roundup2(sizeof(struct efi_map_header), 16) - fp->f_addr; trampoline_data->memmap_src = efi_map_phys_src; trampoline_data->memmap_dst = efi_map_phys_dst; trampoline_data->memmap_len = efi_map_size - roundup2(sizeof(struct efi_map_header), 16); printf("Copying UEFI Memory Map data from %#lx to %#lx %ld bytes\n", efi_map_phys_src, trampoline_data->memmap_dst, trampoline_data->memmap_len); } } /* * Copy the trampoline to the ksegs. Since we're just bouncing off of * this into the kernel, no need to preserve the pages. On arm64, the * kernel sets up the initial page table, so we don't have to preserve * the memory used for the trampoline past when it calls the kernel. */ printf("kernendp = %#llx\n", (long long)kernendp); trampolinebase = staging + (kernendp - fp->f_addr); printf("trampolinebase = %#llx\n", (long long)trampolinebase); archsw.arch_copyin((void *)trampcode, kernendp, tramp_size); printf("Trampoline bouncing to %#llx\n", (long long)trampoline_data->entry); kboot_kseg_get(&nseg, &kseg); error = host_kexec_load(trampolinebase, nseg, kseg, HOST_KEXEC_ARCH_AARCH64); if (error != 0) panic("kexec_load returned error: %d", error); host_reboot(HOST_REBOOT_MAGIC1, HOST_REBOOT_MAGIC2, HOST_REBOOT_CMD_KEXEC, 0); #endif panic("exec returned"); } static int elf64_obj_exec(struct preloaded_file *fp) { printf("%s called for preloaded file %p (=%s):\n", __func__, fp, fp->f_name); return (ENOSYS); } diff --git a/stand/kboot/arch/amd64/elf64_freebsd.c b/stand/kboot/arch/amd64/elf64_freebsd.c index 0d950fb61eb6..c3ed842a2abd 100644 --- a/stand/kboot/arch/amd64/elf64_freebsd.c +++ b/stand/kboot/arch/amd64/elf64_freebsd.c @@ -1,464 +1,462 @@ /*- * Copyright (c) 1998 Michael Smith * Copyright (c) 2014 The FreeBSD Foundation * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #define __ELF_WORD_SIZE 64 #include #include #include #include #include #include #include #include #ifdef EFI #include #include #else #include "host_syscall.h" #endif #include "bootstrap.h" #include "kboot.h" #include "platform/acfreebsd.h" #include "acconfig.h" #define ACPI_SYSTEM_XFACE #include "actypes.h" #include "actbl.h" #ifdef EFI #include "loader_efi.h" static EFI_GUID acpi_guid = ACPI_TABLE_GUID; static EFI_GUID acpi20_guid = ACPI_20_TABLE_GUID; #endif #ifdef EFI #define LOADER_PAGE_SIZE EFI_PAGE_SIZE #else #define LOADER_PAGE_SIZE PAGE_SIZE #endif -extern vm_offset_t kboot_get_phys_load_segment(void); - extern int bi_load(char *args, vm_offset_t *modulep, vm_offset_t *kernendp, bool exit_bs); static int elf64_exec(struct preloaded_file *amp); static int elf64_obj_exec(struct preloaded_file *amp); static struct file_format amd64_elf = { .l_load = elf64_loadfile, .l_exec = elf64_exec, }; static struct file_format amd64_elf_obj = { .l_load = elf64_obj_loadfile, .l_exec = elf64_obj_exec, }; #ifdef EFI extern struct file_format multiboot2; extern struct file_format multiboot2_obj; #endif struct file_format *file_formats[] = { #ifdef EFI &multiboot2, &multiboot2_obj, #endif &amd64_elf, &amd64_elf_obj, NULL }; #ifndef EFI /* * We create the stack that we want. We have the address of the page tables * we make on top (so we pop that off and set %cr3). We have the entry point * to the kernel (which retq pops off) This leaves the stack that the btext * wants: offset 4 is modulep and offset8 is kernend, with the filler bytes * to keep this aligned. This makes the trampoline very simple. */ struct trampoline_data { uint64_t pt4; // Page table address to pop uint64_t entry; // return address to jump to kernel uint32_t fill1; // 0 uint32_t modulep; // 4 module metadata uint32_t kernend; // 8 kernel end uint32_t fill2; // 12 }; _Static_assert(sizeof(struct trampoline_data) == 32, "Bad size for trampoline data"); #endif static pml4_entry_t *PT4; static pdp_entry_t *PT3_l, *PT3_u; static pd_entry_t *PT2_l0, *PT2_l1, *PT2_l2, *PT2_l3, *PT2_u0, *PT2_u1; #ifdef EFI static pdp_entry_t *PT3; static pd_entry_t *PT2; extern EFI_PHYSICAL_ADDRESS staging; static void (*trampoline)(uint64_t stack, void *copy_finish, uint64_t kernend, uint64_t modulep, pml4_entry_t *pagetable, uint64_t entry); #endif extern uintptr_t tramp; extern uint32_t tramp_size; #ifndef EFI extern uint32_t tramp_data_offset; #endif /* * There is an ELF kernel and one or more ELF modules loaded. * We wish to start executing the kernel image, so make such * preparations as are required, and do so. */ static int elf64_exec(struct preloaded_file *fp) { struct file_metadata *md; Elf_Ehdr *ehdr; vm_offset_t modulep, kernend; int err, i; char buf[24]; #ifdef EFI ACPI_TABLE_RSDP *rsdp = NULL; int revision; int copy_auto; vm_offset_t trampstack, trampcode; #else vm_offset_t rsdp = 0; void *trampcode; int nseg; void *kseg; vm_offset_t trampolinebase; uint64_t *trampoline; struct trampoline_data *trampoline_data; vm_offset_t staging; int error; #endif #ifdef EFI copy_auto = copy_staging == COPY_STAGING_AUTO; if (copy_auto) copy_staging = fp->f_kernphys_relocatable ? COPY_STAGING_DISABLE : COPY_STAGING_ENABLE; #else /* * Figure out where to put it. * * Linux does not allow to do kexec_load into any part of memory. Ask * arch_loadaddr to resolve the first available chunk of physical memory * where loading is possible (load_addr). * * The kernel is loaded at the 'base' address in continguous physical * pages (using 2MB super pages). The first such page is unused by the * kernel and serves as a good place to put not only the trampoline, but * the page table pages that the trampoline needs to setup the proper * kernel starting environment. */ staging = trampolinebase = kboot_get_phys_load_segment(); trampolinebase += 1ULL << 20; /* Copy trampoline to base + 1MB, kernel will wind up at 2MB */ printf("Load address at %#jx\n", (uintmax_t)trampolinebase); printf("Relocation offset is %#jx\n", (uintmax_t)elf64_relocation_offset); #endif /* * Report the RSDP to the kernel. While this can be found with * a BIOS boot, the RSDP may be elsewhere when booted from UEFI. */ #ifdef EFI rsdp = efi_get_table(&acpi20_guid); if (rsdp == NULL) { rsdp = efi_get_table(&acpi_guid); } #else rsdp = acpi_rsdp(); #endif if (rsdp != 0) { sprintf(buf, "0x%016llx", (unsigned long long)rsdp); setenv("acpi.rsdp", buf, 1); } if ((md = file_findmetadata(fp, MODINFOMD_ELFHDR)) == NULL) return (EFTYPE); ehdr = (Elf_Ehdr *)&(md->md_data); #ifdef EFI trampcode = copy_staging == COPY_STAGING_ENABLE ? (vm_offset_t)0x0000000040000000 /* 1G */ : (vm_offset_t)0x0000000100000000; /* 4G */; err = BS->AllocatePages(AllocateMaxAddress, EfiLoaderData, 1, (EFI_PHYSICAL_ADDRESS *)&trampcode); if (EFI_ERROR(err)) { printf("Unable to allocate trampoline\n"); if (copy_auto) copy_staging = COPY_STAGING_AUTO; return (ENOMEM); } trampstack = trampcode + LOADER_PAGE_SIZE - 8; #else // XXX Question: why not just use malloc? trampcode = host_getmem(LOADER_PAGE_SIZE); if (trampcode == NULL) { printf("Unable to allocate trampoline\n"); return (ENOMEM); } #endif bzero((void *)trampcode, LOADER_PAGE_SIZE); bcopy((void *)&tramp, (void *)trampcode, tramp_size); trampoline = (void *)trampcode; #ifdef EFI if (copy_staging == COPY_STAGING_ENABLE) { PT4 = (pml4_entry_t *)0x0000000040000000; err = BS->AllocatePages(AllocateMaxAddress, EfiLoaderData, 3, (EFI_PHYSICAL_ADDRESS *)&PT4); if (EFI_ERROR(err)) { printf("Unable to allocate trampoline page table\n"); BS->FreePages(trampcode, 1); if (copy_auto) copy_staging = COPY_STAGING_AUTO; return (ENOMEM); } bzero(PT4, 3 * LOADER_PAGE_SIZE); PT3 = &PT4[512]; PT2 = &PT3[512]; /* * This is kinda brutal, but every single 1GB VM * memory segment points to the same first 1GB of * physical memory. But it is more than adequate. */ for (i = 0; i < NPTEPG; i++) { /* * Each slot of the L4 pages points to the * same L3 page. */ PT4[i] = (pml4_entry_t)PT3; PT4[i] |= PG_V | PG_RW; /* * Each slot of the L3 pages points to the * same L2 page. */ PT3[i] = (pdp_entry_t)PT2; PT3[i] |= PG_V | PG_RW; /* * The L2 page slots are mapped with 2MB pages for 1GB. */ PT2[i] = (pd_entry_t)i * (2 * 1024 * 1024); PT2[i] |= PG_V | PG_RW | PG_PS; } } else { PT4 = (pml4_entry_t *)0x0000000100000000; /* 4G */ err = BS->AllocatePages(AllocateMaxAddress, EfiLoaderData, 9, (EFI_PHYSICAL_ADDRESS *)&PT4); if (EFI_ERROR(err)) { printf("Unable to allocate trampoline page table\n"); BS->FreePages(trampcode, 9); if (copy_auto) copy_staging = COPY_STAGING_AUTO; return (ENOMEM); } bzero(PT4, 9 * LOADER_PAGE_SIZE); PT3_l = &PT4[NPML4EPG * 1]; PT3_u = &PT4[NPML4EPG * 2]; PT2_l0 = &PT4[NPML4EPG * 3]; PT2_l1 = &PT4[NPML4EPG * 4]; PT2_l2 = &PT4[NPML4EPG * 5]; PT2_l3 = &PT4[NPML4EPG * 6]; PT2_u0 = &PT4[NPML4EPG * 7]; PT2_u1 = &PT4[NPML4EPG * 8]; /* 1:1 mapping of lower 4G */ PT4[0] = (pml4_entry_t)PT3_l | PG_V | PG_RW; PT3_l[0] = (pdp_entry_t)PT2_l0 | PG_V | PG_RW; PT3_l[1] = (pdp_entry_t)PT2_l1 | PG_V | PG_RW; PT3_l[2] = (pdp_entry_t)PT2_l2 | PG_V | PG_RW; PT3_l[3] = (pdp_entry_t)PT2_l3 | PG_V | PG_RW; for (i = 0; i < 4 * NPDEPG; i++) { PT2_l0[i] = ((pd_entry_t)i << PDRSHIFT) | PG_V | PG_RW | PG_PS; } /* mapping of kernel 2G below top */ PT4[NPML4EPG - 1] = (pml4_entry_t)PT3_u | PG_V | PG_RW; PT3_u[NPDPEPG - 2] = (pdp_entry_t)PT2_u0 | PG_V | PG_RW; PT3_u[NPDPEPG - 1] = (pdp_entry_t)PT2_u1 | PG_V | PG_RW; /* compat mapping of phys @0 */ PT2_u0[0] = PG_PS | PG_V | PG_RW; /* this maps past staging area */ for (i = 1; i < 2 * NPDEPG; i++) { PT2_u0[i] = ((pd_entry_t)staging + ((pd_entry_t)i - 1) * NBPDR) | PG_V | PG_RW | PG_PS; } } #else { vm_offset_t pabase, pa_pt3_l, pa_pt3_u, pa_pt2_l0, pa_pt2_l1, pa_pt2_l2, pa_pt2_l3, pa_pt2_u0, pa_pt2_u1; /* We'll find a place for these later */ PT4 = (pml4_entry_t *)host_getmem(9 * LOADER_PAGE_SIZE); bzero(PT4, 9 * LOADER_PAGE_SIZE); PT3_l = &PT4[NPML4EPG * 1]; PT3_u = &PT4[NPML4EPG * 2]; PT2_l0 = &PT4[NPML4EPG * 3]; PT2_l1 = &PT4[NPML4EPG * 4]; PT2_l2 = &PT4[NPML4EPG * 5]; PT2_l3 = &PT4[NPML4EPG * 6]; PT2_u0 = &PT4[NPML4EPG * 7]; PT2_u1 = &PT4[NPML4EPG * 8]; pabase = trampolinebase + LOADER_PAGE_SIZE; pa_pt3_l = pabase + LOADER_PAGE_SIZE * 1; pa_pt3_u = pabase + LOADER_PAGE_SIZE * 2; pa_pt2_l0 = pabase + LOADER_PAGE_SIZE * 3; pa_pt2_l1 = pabase + LOADER_PAGE_SIZE * 4; pa_pt2_l2 = pabase + LOADER_PAGE_SIZE * 5; pa_pt2_l3 = pabase + LOADER_PAGE_SIZE * 6; pa_pt2_u0 = pabase + LOADER_PAGE_SIZE * 7; pa_pt2_u1 = pabase + LOADER_PAGE_SIZE * 8; /* 1:1 mapping of lower 4G */ PT4[0] = (pml4_entry_t)pa_pt3_l | PG_V | PG_RW; PT3_l[0] = (pdp_entry_t)pa_pt2_l0 | PG_V | PG_RW; PT3_l[1] = (pdp_entry_t)pa_pt2_l1 | PG_V | PG_RW; PT3_l[2] = (pdp_entry_t)pa_pt2_l2 | PG_V | PG_RW; PT3_l[3] = (pdp_entry_t)pa_pt2_l3 | PG_V | PG_RW; for (i = 0; i < 4 * NPDEPG; i++) { /* we overflow PT2_l0 into _l1, etc */ PT2_l0[i] = ((pd_entry_t)i << PDRSHIFT) | PG_V | PG_RW | PG_PS; } /* mapping of kernel 2G below top */ PT4[NPML4EPG - 1] = (pml4_entry_t)pa_pt3_u | PG_V | PG_RW; PT3_u[NPDPEPG - 2] = (pdp_entry_t)pa_pt2_u0 | PG_V | PG_RW; PT3_u[NPDPEPG - 1] = (pdp_entry_t)pa_pt2_u1 | PG_V | PG_RW; /* compat mapping of phys @0 */ PT2_u0[0] = PG_PS | PG_V | PG_RW; /* this maps past staging area */ /* * Kernel uses the KERNSTART (== KERNBASE + 2MB) entry to figure * out where we loaded the kernel. This is PT2_u0[1] (since * these map 2MB pages. So the PA that this maps has to be * kboot's staging + 2MB. For UEFI we do 'i - 1' since we load * the kernel right at staging (and assume the first address we * load is 2MB in efi_copyin). However for kboot, staging + 1 * * NBPDR == staging + 2MB which is where the kernel starts. Our * trampoline need not be mapped into the kernel space since we * execute PA==VA for that, and the trampoline can just go away * once the kernel is called. * * Staging should likely be as low as possible, though, because * all the 'early' allocations are at kernend (which the kernel * calls physfree). */ for (i = 1; i < 2 * NPDEPG; i++) { /* we overflow PT2_u0 into _u1 */ PT2_u0[i] = ((pd_entry_t)staging + ((pd_entry_t)i) * NBPDR) | PG_V | PG_RW | PG_PS; if (i < 10) printf("Mapping %d to %#lx staging %#lx\n", i, PT2_u0[i], staging); } } #endif #ifdef EFI printf("staging %#lx (%scopying) tramp %p PT4 %p\n", staging, copy_staging == COPY_STAGING_ENABLE ? "" : "not ", trampoline, PT4); #else printf("staging %#lx tramp %p PT4 %p\n", staging, (void *)trampolinebase, (void *)trampolinebase + LOADER_PAGE_SIZE); #endif printf("Start @ 0x%lx ...\n", ehdr->e_entry); #ifdef EFI efi_time_fini(); #endif err = bi_load(fp->f_args, &modulep, &kernend, true); if (err != 0) { #ifdef EFI efi_time_init(); if (copy_auto) copy_staging = COPY_STAGING_AUTO; #endif return (err); } dev_cleanup(); #ifdef EFI trampoline(trampstack, copy_staging == COPY_STAGING_ENABLE ? efi_copy_finish : efi_copy_finish_nop, kernend, modulep, PT4, ehdr->e_entry); #else trampoline_data = (void *)trampoline + tramp_data_offset; trampoline_data->entry = ehdr->e_entry; trampoline_data->pt4 = trampolinebase + LOADER_PAGE_SIZE; /* * So we compute the VA of the module data by modulep + KERNBASE.... * need to make sure that that address is mapped right. We calculate * the start of available memory to allocate via kernend (which is * calculated with a phyaddr of "kernend + PA(PT_u0[1])"), so we better * make sure we're not overwriting the last 2MB of the kernel :). */ trampoline_data->modulep = modulep; /* Offset from KERNBASE */ trampoline_data->kernend = kernend; /* Offset from the load address */ trampoline_data->fill1 = trampoline_data->fill2 = 0; printf("Modulep = %lx kernend %lx\n", modulep, kernend); /* NOTE: when copyting in, it's relative to the start of our 'area' not an abs addr */ /* Copy the trampoline to the ksegs */ archsw.arch_copyin((void *)trampcode, trampolinebase - staging, tramp_size); /* Copy the page table to the ksegs */ archsw.arch_copyin(PT4, trampoline_data->pt4 - staging, 9 * LOADER_PAGE_SIZE); kboot_kseg_get(&nseg, &kseg); error = host_kexec_load(trampolinebase, nseg, kseg, HOST_KEXEC_ARCH_X86_64); if (error != 0) panic("kexec_load returned error: %d", error); host_reboot(HOST_REBOOT_MAGIC1, HOST_REBOOT_MAGIC2, HOST_REBOOT_CMD_KEXEC, 0); #endif panic("exec returned"); } static int elf64_obj_exec(struct preloaded_file *fp) { return (EFTYPE); }