elf64_freebsd.c revision 293297
1/*- 2 * Copyright (c) 1998 Michael Smith <msmith@freebsd.org> 3 * Copyright (c) 2014 The FreeBSD Foundation 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28#include <sys/cdefs.h> 29__FBSDID("$FreeBSD: stable/10/sys/boot/efi/loader/arch/amd64/elf64_freebsd.c 293297 2016-01-07 02:22:45Z emaste $"); 30 31#define __ELF_WORD_SIZE 64 32#include <sys/param.h> 33#include <sys/exec.h> 34#include <sys/linker.h> 35#include <string.h> 36#include <machine/elf.h> 37#include <stand.h> 38 39#include <efi.h> 40#include <efilib.h> 41 42#include "bootstrap.h" 43 44#include "platform/acfreebsd.h" 45#include "acconfig.h" 46#define ACPI_SYSTEM_XFACE 47#include "actypes.h" 48#include "actbl.h" 49 50#include "loader_efi.h" 51 52static EFI_GUID acpi_guid = ACPI_TABLE_GUID; 53static EFI_GUID acpi20_guid = ACPI_20_TABLE_GUID; 54 55extern int bi_load(char *args, vm_offset_t *modulep, vm_offset_t *kernendp); 56 57static int elf64_exec(struct preloaded_file *amp); 58static int elf64_obj_exec(struct preloaded_file *amp); 59 60static struct file_format amd64_elf = { elf64_loadfile, elf64_exec }; 61static struct file_format amd64_elf_obj = { elf64_obj_loadfile, elf64_obj_exec }; 62 63struct file_format *file_formats[] = { 64 &amd64_elf, 65 &amd64_elf_obj, 66 NULL 67}; 68 69#define PG_V 0x001 70#define PG_RW 0x002 71#define PG_U 0x004 72#define PG_PS 0x080 73 74typedef u_int64_t p4_entry_t; 75typedef u_int64_t p3_entry_t; 76typedef u_int64_t p2_entry_t; 77static p4_entry_t *PT4; 78static p3_entry_t *PT3; 79static p2_entry_t *PT2; 80 81static void (*trampoline)(uint64_t stack, void *copy_finish, uint64_t kernend, 82 uint64_t modulep, p4_entry_t *pagetable, 83 uint64_t entry); 84 85extern uintptr_t amd64_tramp; 86extern uint32_t amd64_tramp_size; 87 88/* 89 * There is an ELF kernel and one or more ELF modules loaded. 90 * We wish to start executing the kernel image, so make such 91 * preparations as are required, and do so. 92 */ 93static int 94elf64_exec(struct preloaded_file *fp) 95{ 96 struct file_metadata *md; 97 Elf_Ehdr *ehdr; 98 vm_offset_t modulep, kernend, trampcode, trampstack; 99 int err, i; 100 ACPI_TABLE_RSDP *rsdp; 101 char buf[24]; 102 int revision; 103 EFI_STATUS status; 104 105 rsdp = efi_get_table(&acpi20_guid); 106 if (rsdp == NULL) { 107 rsdp = efi_get_table(&acpi_guid); 108 } 109 if (rsdp != NULL) { 110 sprintf(buf, "0x%016llx", (unsigned long long)rsdp); 111 setenv("hint.acpi.0.rsdp", buf, 1); 112 revision = rsdp->Revision; 113 if (revision == 0) 114 revision = 1; 115 sprintf(buf, "%d", revision); 116 setenv("hint.acpi.0.revision", buf, 1); 117 strncpy(buf, rsdp->OemId, sizeof(rsdp->OemId)); 118 buf[sizeof(rsdp->OemId)] = '\0'; 119 setenv("hint.acpi.0.oem", buf, 1); 120 sprintf(buf, "0x%016x", rsdp->RsdtPhysicalAddress); 121 setenv("hint.acpi.0.rsdt", buf, 1); 122 if (revision >= 2) { 123 /* XXX extended checksum? */ 124 sprintf(buf, "0x%016llx", 125 (unsigned long long)rsdp->XsdtPhysicalAddress); 126 setenv("hint.acpi.0.xsdt", buf, 1); 127 sprintf(buf, "%d", rsdp->Length); 128 setenv("hint.acpi.0.xsdt_length", buf, 1); 129 } 130 } 131 132 if ((md = file_findmetadata(fp, MODINFOMD_ELFHDR)) == NULL) 133 return(EFTYPE); 134 ehdr = (Elf_Ehdr *)&(md->md_data); 135 136 trampcode = (vm_offset_t)0x0000000040000000; 137 err = BS->AllocatePages(AllocateMaxAddress, EfiLoaderData, 1, 138 (EFI_PHYSICAL_ADDRESS *)&trampcode); 139 bzero((void *)trampcode, EFI_PAGE_SIZE); 140 trampstack = trampcode + EFI_PAGE_SIZE - 8; 141 bcopy((void *)&amd64_tramp, (void *)trampcode, amd64_tramp_size); 142 trampoline = (void *)trampcode; 143 144 PT4 = (p4_entry_t *)0x0000000040000000; 145 err = BS->AllocatePages(AllocateMaxAddress, EfiLoaderData, 3, 146 (EFI_PHYSICAL_ADDRESS *)&PT4); 147 bzero(PT4, 3 * EFI_PAGE_SIZE); 148 149 PT3 = &PT4[512]; 150 PT2 = &PT3[512]; 151 152 /* 153 * This is kinda brutal, but every single 1GB VM memory segment points 154 * to the same first 1GB of physical memory. But it is more than 155 * adequate. 156 */ 157 for (i = 0; i < 512; i++) { 158 /* Each slot of the L4 pages points to the same L3 page. */ 159 PT4[i] = (p4_entry_t)PT3; 160 PT4[i] |= PG_V | PG_RW | PG_U; 161 162 /* Each slot of the L3 pages points to the same L2 page. */ 163 PT3[i] = (p3_entry_t)PT2; 164 PT3[i] |= PG_V | PG_RW | PG_U; 165 166 /* The L2 page slots are mapped with 2MB pages for 1GB. */ 167 PT2[i] = i * (2 * 1024 * 1024); 168 PT2[i] |= PG_V | PG_RW | PG_PS | PG_U; 169 } 170 171 printf("Start @ 0x%lx ...\n", ehdr->e_entry); 172 173 err = bi_load(fp->f_args, &modulep, &kernend); 174 if (err != 0) 175 return(err); 176 177 status = BS->ExitBootServices(IH, efi_mapkey); 178 if (EFI_ERROR(status)) { 179 printf("%s: ExitBootServices() returned 0x%lx\n", __func__, 180 (long)status); 181 return (EINVAL); 182 } 183 184 dev_cleanup(); 185 186 trampoline(trampstack, efi_copy_finish, kernend, modulep, PT4, 187 ehdr->e_entry); 188 189 panic("exec returned"); 190} 191 192static int 193elf64_obj_exec(struct preloaded_file *fp) 194{ 195 return (EFTYPE); 196} 197