1086 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2 3/* -----------------------------------------------------------------------4 *5 * Copyright 2011 Intel Corporation; author Matt Fleming6 *7 * ----------------------------------------------------------------------- */8 9#include <linux/efi.h>10#include <linux/pci.h>11#include <linux/stddef.h>12 13#include <asm/efi.h>14#include <asm/e820/types.h>15#include <asm/setup.h>16#include <asm/desc.h>17#include <asm/boot.h>18#include <asm/kaslr.h>19#include <asm/sev.h>20 21#include "efistub.h"22#include "x86-stub.h"23 24extern char _bss[], _ebss[];25 26const efi_system_table_t *efi_system_table;27const efi_dxe_services_table_t *efi_dxe_table;28static efi_loaded_image_t *image = NULL;29static efi_memory_attribute_protocol_t *memattr;30 31typedef union sev_memory_acceptance_protocol sev_memory_acceptance_protocol_t;32union sev_memory_acceptance_protocol {33 struct {34 efi_status_t (__efiapi * allow_unaccepted_memory)(35 sev_memory_acceptance_protocol_t *);36 };37 struct {38 u32 allow_unaccepted_memory;39 } mixed_mode;40};41 42static efi_status_t43preserve_pci_rom_image(efi_pci_io_protocol_t *pci, struct pci_setup_rom **__rom)44{45 struct pci_setup_rom *rom = NULL;46 efi_status_t status;47 unsigned long size;48 uint64_t romsize;49 void *romimage;50 51 /*52 * Some firmware images contain EFI function pointers at the place where53 * the romimage and romsize fields are supposed to be. Typically the EFI54 * code is mapped at high addresses, translating to an unrealistically55 * large romsize. The UEFI spec limits the size of option ROMs to 1656 * MiB so we reject any ROMs over 16 MiB in size to catch this.57 */58 romimage = efi_table_attr(pci, romimage);59 romsize = efi_table_attr(pci, romsize);60 if (!romimage || !romsize || romsize > SZ_16M)61 return EFI_INVALID_PARAMETER;62 63 size = romsize + sizeof(*rom);64 65 status = efi_bs_call(allocate_pool, EFI_LOADER_DATA, size,66 (void **)&rom);67 if (status != EFI_SUCCESS) {68 efi_err("Failed to allocate memory for 'rom'\n");69 return status;70 }71 72 memset(rom, 0, sizeof(*rom));73 74 rom->data.type = SETUP_PCI;75 rom->data.len = size - sizeof(struct setup_data);76 rom->data.next = 0;77 rom->pcilen = romsize;78 *__rom = rom;79 80 status = efi_call_proto(pci, pci.read, EfiPciIoWidthUint16,81 PCI_VENDOR_ID, 1, &rom->vendor);82 83 if (status != EFI_SUCCESS) {84 efi_err("Failed to read rom->vendor\n");85 goto free_struct;86 }87 88 status = efi_call_proto(pci, pci.read, EfiPciIoWidthUint16,89 PCI_DEVICE_ID, 1, &rom->devid);90 91 if (status != EFI_SUCCESS) {92 efi_err("Failed to read rom->devid\n");93 goto free_struct;94 }95 96 status = efi_call_proto(pci, get_location, &rom->segment, &rom->bus,97 &rom->device, &rom->function);98 99 if (status != EFI_SUCCESS)100 goto free_struct;101 102 memcpy(rom->romdata, romimage, romsize);103 return status;104 105free_struct:106 efi_bs_call(free_pool, rom);107 return status;108}109 110/*111 * There's no way to return an informative status from this function,112 * because any analysis (and printing of error messages) needs to be113 * done directly at the EFI function call-site.114 *115 * For example, EFI_INVALID_PARAMETER could indicate a bug or maybe we116 * just didn't find any PCI devices, but there's no way to tell outside117 * the context of the call.118 */119static void setup_efi_pci(struct boot_params *params)120{121 efi_status_t status;122 void **pci_handle = NULL;123 efi_guid_t pci_proto = EFI_PCI_IO_PROTOCOL_GUID;124 unsigned long size = 0;125 struct setup_data *data;126 efi_handle_t h;127 int i;128 129 status = efi_bs_call(locate_handle, EFI_LOCATE_BY_PROTOCOL,130 &pci_proto, NULL, &size, pci_handle);131 132 if (status == EFI_BUFFER_TOO_SMALL) {133 status = efi_bs_call(allocate_pool, EFI_LOADER_DATA, size,134 (void **)&pci_handle);135 136 if (status != EFI_SUCCESS) {137 efi_err("Failed to allocate memory for 'pci_handle'\n");138 return;139 }140 141 status = efi_bs_call(locate_handle, EFI_LOCATE_BY_PROTOCOL,142 &pci_proto, NULL, &size, pci_handle);143 }144 145 if (status != EFI_SUCCESS)146 goto free_handle;147 148 data = (struct setup_data *)(unsigned long)params->hdr.setup_data;149 150 while (data && data->next)151 data = (struct setup_data *)(unsigned long)data->next;152 153 for_each_efi_handle(h, pci_handle, size, i) {154 efi_pci_io_protocol_t *pci = NULL;155 struct pci_setup_rom *rom;156 157 status = efi_bs_call(handle_protocol, h, &pci_proto,158 (void **)&pci);159 if (status != EFI_SUCCESS || !pci)160 continue;161 162 status = preserve_pci_rom_image(pci, &rom);163 if (status != EFI_SUCCESS)164 continue;165 166 if (data)167 data->next = (unsigned long)rom;168 else169 params->hdr.setup_data = (unsigned long)rom;170 171 data = (struct setup_data *)rom;172 }173 174free_handle:175 efi_bs_call(free_pool, pci_handle);176}177 178static void retrieve_apple_device_properties(struct boot_params *boot_params)179{180 efi_guid_t guid = APPLE_PROPERTIES_PROTOCOL_GUID;181 struct setup_data *data, *new;182 efi_status_t status;183 u32 size = 0;184 apple_properties_protocol_t *p;185 186 status = efi_bs_call(locate_protocol, &guid, NULL, (void **)&p);187 if (status != EFI_SUCCESS)188 return;189 190 if (efi_table_attr(p, version) != 0x10000) {191 efi_err("Unsupported properties proto version\n");192 return;193 }194 195 efi_call_proto(p, get_all, NULL, &size);196 if (!size)197 return;198 199 do {200 status = efi_bs_call(allocate_pool, EFI_LOADER_DATA,201 size + sizeof(struct setup_data),202 (void **)&new);203 if (status != EFI_SUCCESS) {204 efi_err("Failed to allocate memory for 'properties'\n");205 return;206 }207 208 status = efi_call_proto(p, get_all, new->data, &size);209 210 if (status == EFI_BUFFER_TOO_SMALL)211 efi_bs_call(free_pool, new);212 } while (status == EFI_BUFFER_TOO_SMALL);213 214 new->type = SETUP_APPLE_PROPERTIES;215 new->len = size;216 new->next = 0;217 218 data = (struct setup_data *)(unsigned long)boot_params->hdr.setup_data;219 if (!data) {220 boot_params->hdr.setup_data = (unsigned long)new;221 } else {222 while (data->next)223 data = (struct setup_data *)(unsigned long)data->next;224 data->next = (unsigned long)new;225 }226}227 228static bool apple_match_product_name(void)229{230 static const char type1_product_matches[][15] = {231 "MacBookPro11,3",232 "MacBookPro11,5",233 "MacBookPro13,3",234 "MacBookPro14,3",235 "MacBookPro15,1",236 "MacBookPro15,3",237 "MacBookPro16,1",238 "MacBookPro16,4",239 };240 const struct efi_smbios_type1_record *record;241 const u8 *product;242 243 record = (struct efi_smbios_type1_record *)efi_get_smbios_record(1);244 if (!record)245 return false;246 247 product = efi_get_smbios_string(record, product_name);248 if (!product)249 return false;250 251 for (int i = 0; i < ARRAY_SIZE(type1_product_matches); i++) {252 if (!strcmp(product, type1_product_matches[i]))253 return true;254 }255 256 return false;257}258 259static void apple_set_os(void)260{261 struct {262 unsigned long version;263 efi_status_t (__efiapi *set_os_version)(const char *);264 efi_status_t (__efiapi *set_os_vendor)(const char *);265 } *set_os;266 efi_status_t status;267 268 if (!efi_is_64bit() || !apple_match_product_name())269 return;270 271 status = efi_bs_call(locate_protocol, &APPLE_SET_OS_PROTOCOL_GUID, NULL,272 (void **)&set_os);273 if (status != EFI_SUCCESS)274 return;275 276 if (set_os->version >= 2) {277 status = set_os->set_os_vendor("Apple Inc.");278 if (status != EFI_SUCCESS)279 efi_err("Failed to set OS vendor via apple_set_os\n");280 }281 282 if (set_os->version > 0) {283 /* The version being set doesn't seem to matter */284 status = set_os->set_os_version("Mac OS X 10.9");285 if (status != EFI_SUCCESS)286 efi_err("Failed to set OS version via apple_set_os\n");287 }288}289 290efi_status_t efi_adjust_memory_range_protection(unsigned long start,291 unsigned long size)292{293 efi_status_t status;294 efi_gcd_memory_space_desc_t desc;295 unsigned long end, next;296 unsigned long rounded_start, rounded_end;297 unsigned long unprotect_start, unprotect_size;298 299 rounded_start = rounddown(start, EFI_PAGE_SIZE);300 rounded_end = roundup(start + size, EFI_PAGE_SIZE);301 302 if (memattr != NULL) {303 status = efi_call_proto(memattr, set_memory_attributes,304 rounded_start,305 rounded_end - rounded_start,306 EFI_MEMORY_RO);307 if (status != EFI_SUCCESS) {308 efi_warn("Failed to set EFI_MEMORY_RO attribute\n");309 return status;310 }311 312 status = efi_call_proto(memattr, clear_memory_attributes,313 rounded_start,314 rounded_end - rounded_start,315 EFI_MEMORY_XP);316 if (status != EFI_SUCCESS)317 efi_warn("Failed to clear EFI_MEMORY_XP attribute\n");318 return status;319 }320 321 if (efi_dxe_table == NULL)322 return EFI_SUCCESS;323 324 /*325 * Don't modify memory region attributes, they are326 * already suitable, to lower the possibility to327 * encounter firmware bugs.328 */329 330 for (end = start + size; start < end; start = next) {331 332 status = efi_dxe_call(get_memory_space_descriptor, start, &desc);333 334 if (status != EFI_SUCCESS)335 break;336 337 next = desc.base_address + desc.length;338 339 /*340 * Only system memory is suitable for trampoline/kernel image placement,341 * so only this type of memory needs its attributes to be modified.342 */343 344 if (desc.gcd_memory_type != EfiGcdMemoryTypeSystemMemory ||345 (desc.attributes & (EFI_MEMORY_RO | EFI_MEMORY_XP)) == 0)346 continue;347 348 unprotect_start = max(rounded_start, (unsigned long)desc.base_address);349 unprotect_size = min(rounded_end, next) - unprotect_start;350 351 status = efi_dxe_call(set_memory_space_attributes,352 unprotect_start, unprotect_size,353 EFI_MEMORY_WB);354 355 if (status != EFI_SUCCESS) {356 efi_warn("Unable to unprotect memory range [%08lx,%08lx]: %lx\n",357 unprotect_start,358 unprotect_start + unprotect_size,359 status);360 break;361 }362 }363 return EFI_SUCCESS;364}365 366static void setup_unaccepted_memory(void)367{368 efi_guid_t mem_acceptance_proto = OVMF_SEV_MEMORY_ACCEPTANCE_PROTOCOL_GUID;369 sev_memory_acceptance_protocol_t *proto;370 efi_status_t status;371 372 if (!IS_ENABLED(CONFIG_UNACCEPTED_MEMORY))373 return;374 375 /*376 * Enable unaccepted memory before calling exit boot services in order377 * for the UEFI to not accept all memory on EBS.378 */379 status = efi_bs_call(locate_protocol, &mem_acceptance_proto, NULL,380 (void **)&proto);381 if (status != EFI_SUCCESS)382 return;383 384 status = efi_call_proto(proto, allow_unaccepted_memory);385 if (status != EFI_SUCCESS)386 efi_err("Memory acceptance protocol failed\n");387}388 389static efi_char16_t *efistub_fw_vendor(void)390{391 unsigned long vendor = efi_table_attr(efi_system_table, fw_vendor);392 393 return (efi_char16_t *)vendor;394}395 396static const efi_char16_t apple[] = L"Apple";397 398static void setup_quirks(struct boot_params *boot_params)399{400 if (!memcmp(efistub_fw_vendor(), apple, sizeof(apple))) {401 if (IS_ENABLED(CONFIG_APPLE_PROPERTIES))402 retrieve_apple_device_properties(boot_params);403 404 apple_set_os();405 }406}407 408/*409 * See if we have Universal Graphics Adapter (UGA) protocol410 */411static efi_status_t412setup_uga(struct screen_info *si, efi_guid_t *uga_proto, unsigned long size)413{414 efi_status_t status;415 u32 width, height;416 void **uga_handle = NULL;417 efi_uga_draw_protocol_t *uga = NULL, *first_uga;418 efi_handle_t handle;419 int i;420 421 status = efi_bs_call(allocate_pool, EFI_LOADER_DATA, size,422 (void **)&uga_handle);423 if (status != EFI_SUCCESS)424 return status;425 426 status = efi_bs_call(locate_handle, EFI_LOCATE_BY_PROTOCOL,427 uga_proto, NULL, &size, uga_handle);428 if (status != EFI_SUCCESS)429 goto free_handle;430 431 height = 0;432 width = 0;433 434 first_uga = NULL;435 for_each_efi_handle(handle, uga_handle, size, i) {436 efi_guid_t pciio_proto = EFI_PCI_IO_PROTOCOL_GUID;437 u32 w, h, depth, refresh;438 void *pciio;439 440 status = efi_bs_call(handle_protocol, handle, uga_proto,441 (void **)&uga);442 if (status != EFI_SUCCESS)443 continue;444 445 pciio = NULL;446 efi_bs_call(handle_protocol, handle, &pciio_proto, &pciio);447 448 status = efi_call_proto(uga, get_mode, &w, &h, &depth, &refresh);449 if (status == EFI_SUCCESS && (!first_uga || pciio)) {450 width = w;451 height = h;452 453 /*454 * Once we've found a UGA supporting PCIIO,455 * don't bother looking any further.456 */457 if (pciio)458 break;459 460 first_uga = uga;461 }462 }463 464 if (!width && !height)465 goto free_handle;466 467 /* EFI framebuffer */468 si->orig_video_isVGA = VIDEO_TYPE_EFI;469 470 si->lfb_depth = 32;471 si->lfb_width = width;472 si->lfb_height = height;473 474 si->red_size = 8;475 si->red_pos = 16;476 si->green_size = 8;477 si->green_pos = 8;478 si->blue_size = 8;479 si->blue_pos = 0;480 si->rsvd_size = 8;481 si->rsvd_pos = 24;482 483free_handle:484 efi_bs_call(free_pool, uga_handle);485 486 return status;487}488 489static void setup_graphics(struct boot_params *boot_params)490{491 efi_guid_t graphics_proto = EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID;492 struct screen_info *si;493 efi_guid_t uga_proto = EFI_UGA_PROTOCOL_GUID;494 efi_status_t status;495 unsigned long size;496 void **gop_handle = NULL;497 void **uga_handle = NULL;498 499 si = &boot_params->screen_info;500 memset(si, 0, sizeof(*si));501 502 size = 0;503 status = efi_bs_call(locate_handle, EFI_LOCATE_BY_PROTOCOL,504 &graphics_proto, NULL, &size, gop_handle);505 if (status == EFI_BUFFER_TOO_SMALL)506 status = efi_setup_gop(si, &graphics_proto, size);507 508 if (status != EFI_SUCCESS) {509 size = 0;510 status = efi_bs_call(locate_handle, EFI_LOCATE_BY_PROTOCOL,511 &uga_proto, NULL, &size, uga_handle);512 if (status == EFI_BUFFER_TOO_SMALL)513 setup_uga(si, &uga_proto, size);514 }515}516 517 518static void __noreturn efi_exit(efi_handle_t handle, efi_status_t status)519{520 efi_bs_call(exit, handle, status, 0, NULL);521 for(;;)522 asm("hlt");523}524 525void __noreturn efi_stub_entry(efi_handle_t handle,526 efi_system_table_t *sys_table_arg,527 struct boot_params *boot_params);528 529/*530 * Because the x86 boot code expects to be passed a boot_params we531 * need to create one ourselves (usually the bootloader would create532 * one for us).533 */534efi_status_t __efiapi efi_pe_entry(efi_handle_t handle,535 efi_system_table_t *sys_table_arg)536{537 efi_guid_t proto = LOADED_IMAGE_PROTOCOL_GUID;538 struct boot_params *boot_params;539 struct setup_header *hdr;540 int options_size = 0;541 efi_status_t status;542 unsigned long alloc;543 char *cmdline_ptr;544 545 efi_system_table = sys_table_arg;546 547 /* Check if we were booted by the EFI firmware */548 if (efi_system_table->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE)549 efi_exit(handle, EFI_INVALID_PARAMETER);550 551 status = efi_bs_call(handle_protocol, handle, &proto, (void **)&image);552 if (status != EFI_SUCCESS) {553 efi_err("Failed to get handle for LOADED_IMAGE_PROTOCOL\n");554 efi_exit(handle, status);555 }556 557 status = efi_allocate_pages(PARAM_SIZE, &alloc, ULONG_MAX);558 if (status != EFI_SUCCESS)559 efi_exit(handle, status);560 561 boot_params = memset((void *)alloc, 0x0, PARAM_SIZE);562 hdr = &boot_params->hdr;563 564 /* Assign the setup_header fields that the kernel actually cares about */565 hdr->root_flags = 1;566 hdr->vid_mode = 0xffff;567 568 hdr->type_of_loader = 0x21;569 hdr->initrd_addr_max = INT_MAX;570 571 /* Convert unicode cmdline to ascii */572 cmdline_ptr = efi_convert_cmdline(image, &options_size);573 if (!cmdline_ptr) {574 efi_free(PARAM_SIZE, alloc);575 efi_exit(handle, EFI_OUT_OF_RESOURCES);576 }577 578 efi_set_u64_split((unsigned long)cmdline_ptr, &hdr->cmd_line_ptr,579 &boot_params->ext_cmd_line_ptr);580 581 efi_stub_entry(handle, sys_table_arg, boot_params);582 /* not reached */583}584 585static void add_e820ext(struct boot_params *params,586 struct setup_data *e820ext, u32 nr_entries)587{588 struct setup_data *data;589 590 e820ext->type = SETUP_E820_EXT;591 e820ext->len = nr_entries * sizeof(struct boot_e820_entry);592 e820ext->next = 0;593 594 data = (struct setup_data *)(unsigned long)params->hdr.setup_data;595 596 while (data && data->next)597 data = (struct setup_data *)(unsigned long)data->next;598 599 if (data)600 data->next = (unsigned long)e820ext;601 else602 params->hdr.setup_data = (unsigned long)e820ext;603}604 605static efi_status_t606setup_e820(struct boot_params *params, struct setup_data *e820ext, u32 e820ext_size)607{608 struct boot_e820_entry *entry = params->e820_table;609 struct efi_info *efi = ¶ms->efi_info;610 struct boot_e820_entry *prev = NULL;611 u32 nr_entries;612 u32 nr_desc;613 int i;614 615 nr_entries = 0;616 nr_desc = efi->efi_memmap_size / efi->efi_memdesc_size;617 618 for (i = 0; i < nr_desc; i++) {619 efi_memory_desc_t *d;620 unsigned int e820_type = 0;621 unsigned long m = efi->efi_memmap;622 623#ifdef CONFIG_X86_64624 m |= (u64)efi->efi_memmap_hi << 32;625#endif626 627 d = efi_memdesc_ptr(m, efi->efi_memdesc_size, i);628 switch (d->type) {629 case EFI_RESERVED_TYPE:630 case EFI_RUNTIME_SERVICES_CODE:631 case EFI_RUNTIME_SERVICES_DATA:632 case EFI_MEMORY_MAPPED_IO:633 case EFI_MEMORY_MAPPED_IO_PORT_SPACE:634 case EFI_PAL_CODE:635 e820_type = E820_TYPE_RESERVED;636 break;637 638 case EFI_UNUSABLE_MEMORY:639 e820_type = E820_TYPE_UNUSABLE;640 break;641 642 case EFI_ACPI_RECLAIM_MEMORY:643 e820_type = E820_TYPE_ACPI;644 break;645 646 case EFI_LOADER_CODE:647 case EFI_LOADER_DATA:648 case EFI_BOOT_SERVICES_CODE:649 case EFI_BOOT_SERVICES_DATA:650 case EFI_CONVENTIONAL_MEMORY:651 if (efi_soft_reserve_enabled() &&652 (d->attribute & EFI_MEMORY_SP))653 e820_type = E820_TYPE_SOFT_RESERVED;654 else655 e820_type = E820_TYPE_RAM;656 break;657 658 case EFI_ACPI_MEMORY_NVS:659 e820_type = E820_TYPE_NVS;660 break;661 662 case EFI_PERSISTENT_MEMORY:663 e820_type = E820_TYPE_PMEM;664 break;665 666 case EFI_UNACCEPTED_MEMORY:667 if (!IS_ENABLED(CONFIG_UNACCEPTED_MEMORY))668 continue;669 e820_type = E820_TYPE_RAM;670 process_unaccepted_memory(d->phys_addr,671 d->phys_addr + PAGE_SIZE * d->num_pages);672 break;673 default:674 continue;675 }676 677 /* Merge adjacent mappings */678 if (prev && prev->type == e820_type &&679 (prev->addr + prev->size) == d->phys_addr) {680 prev->size += d->num_pages << 12;681 continue;682 }683 684 if (nr_entries == ARRAY_SIZE(params->e820_table)) {685 u32 need = (nr_desc - i) * sizeof(struct e820_entry) +686 sizeof(struct setup_data);687 688 if (!e820ext || e820ext_size < need)689 return EFI_BUFFER_TOO_SMALL;690 691 /* boot_params map full, switch to e820 extended */692 entry = (struct boot_e820_entry *)e820ext->data;693 }694 695 entry->addr = d->phys_addr;696 entry->size = d->num_pages << PAGE_SHIFT;697 entry->type = e820_type;698 prev = entry++;699 nr_entries++;700 }701 702 if (nr_entries > ARRAY_SIZE(params->e820_table)) {703 u32 nr_e820ext = nr_entries - ARRAY_SIZE(params->e820_table);704 705 add_e820ext(params, e820ext, nr_e820ext);706 nr_entries -= nr_e820ext;707 }708 709 params->e820_entries = (u8)nr_entries;710 711 return EFI_SUCCESS;712}713 714static efi_status_t alloc_e820ext(u32 nr_desc, struct setup_data **e820ext,715 u32 *e820ext_size)716{717 efi_status_t status;718 unsigned long size;719 720 size = sizeof(struct setup_data) +721 sizeof(struct e820_entry) * nr_desc;722 723 if (*e820ext) {724 efi_bs_call(free_pool, *e820ext);725 *e820ext = NULL;726 *e820ext_size = 0;727 }728 729 status = efi_bs_call(allocate_pool, EFI_LOADER_DATA, size,730 (void **)e820ext);731 if (status == EFI_SUCCESS)732 *e820ext_size = size;733 734 return status;735}736 737static efi_status_t allocate_e820(struct boot_params *params,738 struct setup_data **e820ext,739 u32 *e820ext_size)740{741 struct efi_boot_memmap *map;742 efi_status_t status;743 __u32 nr_desc;744 745 status = efi_get_memory_map(&map, false);746 if (status != EFI_SUCCESS)747 return status;748 749 nr_desc = map->map_size / map->desc_size;750 if (nr_desc > ARRAY_SIZE(params->e820_table) - EFI_MMAP_NR_SLACK_SLOTS) {751 u32 nr_e820ext = nr_desc - ARRAY_SIZE(params->e820_table) +752 EFI_MMAP_NR_SLACK_SLOTS;753 754 status = alloc_e820ext(nr_e820ext, e820ext, e820ext_size);755 }756 757 if (IS_ENABLED(CONFIG_UNACCEPTED_MEMORY) && status == EFI_SUCCESS)758 status = allocate_unaccepted_bitmap(nr_desc, map);759 760 efi_bs_call(free_pool, map);761 return status;762}763 764struct exit_boot_struct {765 struct boot_params *boot_params;766 struct efi_info *efi;767};768 769static efi_status_t exit_boot_func(struct efi_boot_memmap *map,770 void *priv)771{772 const char *signature;773 struct exit_boot_struct *p = priv;774 775 signature = efi_is_64bit() ? EFI64_LOADER_SIGNATURE776 : EFI32_LOADER_SIGNATURE;777 memcpy(&p->efi->efi_loader_signature, signature, sizeof(__u32));778 779 efi_set_u64_split((unsigned long)efi_system_table,780 &p->efi->efi_systab, &p->efi->efi_systab_hi);781 p->efi->efi_memdesc_size = map->desc_size;782 p->efi->efi_memdesc_version = map->desc_ver;783 efi_set_u64_split((unsigned long)map->map,784 &p->efi->efi_memmap, &p->efi->efi_memmap_hi);785 p->efi->efi_memmap_size = map->map_size;786 787 return EFI_SUCCESS;788}789 790static efi_status_t exit_boot(struct boot_params *boot_params, void *handle)791{792 struct setup_data *e820ext = NULL;793 __u32 e820ext_size = 0;794 efi_status_t status;795 struct exit_boot_struct priv;796 797 priv.boot_params = boot_params;798 priv.efi = &boot_params->efi_info;799 800 status = allocate_e820(boot_params, &e820ext, &e820ext_size);801 if (status != EFI_SUCCESS)802 return status;803 804 /* Might as well exit boot services now */805 status = efi_exit_boot_services(handle, &priv, exit_boot_func);806 if (status != EFI_SUCCESS)807 return status;808 809 /* Historic? */810 boot_params->alt_mem_k = 32 * 1024;811 812 status = setup_e820(boot_params, e820ext, e820ext_size);813 if (status != EFI_SUCCESS)814 return status;815 816 return EFI_SUCCESS;817}818 819static bool have_unsupported_snp_features(void)820{821 u64 unsupported;822 823 unsupported = snp_get_unsupported_features(sev_get_status());824 if (unsupported) {825 efi_err("Unsupported SEV-SNP features detected: 0x%llx\n",826 unsupported);827 return true;828 }829 return false;830}831 832static void efi_get_seed(void *seed, int size)833{834 efi_get_random_bytes(size, seed);835 836 /*837 * This only updates seed[0] when running on 32-bit, but in that case,838 * seed[1] is not used anyway, as there is no virtual KASLR on 32-bit.839 */840 *(unsigned long *)seed ^= kaslr_get_random_long("EFI");841}842 843static void error(char *str)844{845 efi_warn("Decompression failed: %s\n", str);846}847 848static const char *cmdline_memmap_override;849 850static efi_status_t parse_options(const char *cmdline)851{852 static const char opts[][14] = {853 "mem=", "memmap=", "hugepages="854 };855 856 for (int i = 0; i < ARRAY_SIZE(opts); i++) {857 const char *p = strstr(cmdline, opts[i]);858 859 if (p == cmdline || (p > cmdline && isspace(p[-1]))) {860 cmdline_memmap_override = opts[i];861 break;862 }863 }864 865 return efi_parse_options(cmdline);866}867 868static efi_status_t efi_decompress_kernel(unsigned long *kernel_entry)869{870 unsigned long virt_addr = LOAD_PHYSICAL_ADDR;871 unsigned long addr, alloc_size, entry;872 efi_status_t status;873 u32 seed[2] = {};874 875 /* determine the required size of the allocation */876 alloc_size = ALIGN(max_t(unsigned long, output_len, kernel_total_size),877 MIN_KERNEL_ALIGN);878 879 if (IS_ENABLED(CONFIG_RANDOMIZE_BASE) && !efi_nokaslr) {880 u64 range = KERNEL_IMAGE_SIZE - LOAD_PHYSICAL_ADDR - kernel_total_size;881 static const efi_char16_t ami[] = L"American Megatrends";882 883 efi_get_seed(seed, sizeof(seed));884 885 virt_addr += (range * seed[1]) >> 32;886 virt_addr &= ~(CONFIG_PHYSICAL_ALIGN - 1);887 888 /*889 * Older Dell systems with AMI UEFI firmware v2.0 may hang890 * while decompressing the kernel if physical address891 * randomization is enabled.892 *893 * https://bugzilla.kernel.org/show_bug.cgi?id=218173894 */895 if (efi_system_table->hdr.revision <= EFI_2_00_SYSTEM_TABLE_REVISION &&896 !memcmp(efistub_fw_vendor(), ami, sizeof(ami))) {897 efi_debug("AMI firmware v2.0 or older detected - disabling physical KASLR\n");898 seed[0] = 0;899 } else if (cmdline_memmap_override) {900 efi_info("%s detected on the kernel command line - disabling physical KASLR\n",901 cmdline_memmap_override);902 seed[0] = 0;903 }904 905 boot_params_ptr->hdr.loadflags |= KASLR_FLAG;906 }907 908 status = efi_random_alloc(alloc_size, CONFIG_PHYSICAL_ALIGN, &addr,909 seed[0], EFI_LOADER_CODE,910 LOAD_PHYSICAL_ADDR,911 EFI_X86_KERNEL_ALLOC_LIMIT);912 if (status != EFI_SUCCESS)913 return status;914 915 entry = decompress_kernel((void *)addr, virt_addr, error);916 if (entry == ULONG_MAX) {917 efi_free(alloc_size, addr);918 return EFI_LOAD_ERROR;919 }920 921 *kernel_entry = addr + entry;922 923 return efi_adjust_memory_range_protection(addr, kernel_text_size);924}925 926static void __noreturn enter_kernel(unsigned long kernel_addr,927 struct boot_params *boot_params)928{929 /* enter decompressed kernel with boot_params pointer in RSI/ESI */930 asm("jmp *%0"::"r"(kernel_addr), "S"(boot_params));931 932 unreachable();933}934 935/*936 * On success, this routine will jump to the relocated image directly and never937 * return. On failure, it will exit to the firmware via efi_exit() instead of938 * returning.939 */940void __noreturn efi_stub_entry(efi_handle_t handle,941 efi_system_table_t *sys_table_arg,942 struct boot_params *boot_params)943{944 efi_guid_t guid = EFI_MEMORY_ATTRIBUTE_PROTOCOL_GUID;945 struct setup_header *hdr = &boot_params->hdr;946 const struct linux_efi_initrd *initrd = NULL;947 unsigned long kernel_entry;948 efi_status_t status;949 950 boot_params_ptr = boot_params;951 952 efi_system_table = sys_table_arg;953 /* Check if we were booted by the EFI firmware */954 if (efi_system_table->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE)955 efi_exit(handle, EFI_INVALID_PARAMETER);956 957 if (have_unsupported_snp_features())958 efi_exit(handle, EFI_UNSUPPORTED);959 960 if (IS_ENABLED(CONFIG_EFI_DXE_MEM_ATTRIBUTES)) {961 efi_dxe_table = get_efi_config_table(EFI_DXE_SERVICES_TABLE_GUID);962 if (efi_dxe_table &&963 efi_dxe_table->hdr.signature != EFI_DXE_SERVICES_TABLE_SIGNATURE) {964 efi_warn("Ignoring DXE services table: invalid signature\n");965 efi_dxe_table = NULL;966 }967 }968 969 /* grab the memory attributes protocol if it exists */970 efi_bs_call(locate_protocol, &guid, NULL, (void **)&memattr);971 972 status = efi_setup_5level_paging();973 if (status != EFI_SUCCESS) {974 efi_err("efi_setup_5level_paging() failed!\n");975 goto fail;976 }977 978#ifdef CONFIG_CMDLINE_BOOL979 status = parse_options(CONFIG_CMDLINE);980 if (status != EFI_SUCCESS) {981 efi_err("Failed to parse options\n");982 goto fail;983 }984#endif985 if (!IS_ENABLED(CONFIG_CMDLINE_OVERRIDE)) {986 unsigned long cmdline_paddr = ((u64)hdr->cmd_line_ptr |987 ((u64)boot_params->ext_cmd_line_ptr << 32));988 status = parse_options((char *)cmdline_paddr);989 if (status != EFI_SUCCESS) {990 efi_err("Failed to parse options\n");991 goto fail;992 }993 }994 995 if (efi_mem_encrypt > 0)996 hdr->xloadflags |= XLF_MEM_ENCRYPTION;997 998 status = efi_decompress_kernel(&kernel_entry);999 if (status != EFI_SUCCESS) {1000 efi_err("Failed to decompress kernel\n");1001 goto fail;1002 }1003 1004 /*1005 * At this point, an initrd may already have been loaded by the1006 * bootloader and passed via bootparams. We permit an initrd loaded1007 * from the LINUX_EFI_INITRD_MEDIA_GUID device path to supersede it.1008 *1009 * If the device path is not present, any command-line initrd=1010 * arguments will be processed only if image is not NULL, which will be1011 * the case only if we were loaded via the PE entry point.1012 */1013 status = efi_load_initrd(image, hdr->initrd_addr_max, ULONG_MAX,1014 &initrd);1015 if (status != EFI_SUCCESS)1016 goto fail;1017 if (initrd && initrd->size > 0) {1018 efi_set_u64_split(initrd->base, &hdr->ramdisk_image,1019 &boot_params->ext_ramdisk_image);1020 efi_set_u64_split(initrd->size, &hdr->ramdisk_size,1021 &boot_params->ext_ramdisk_size);1022 }1023 1024 1025 /*1026 * If the boot loader gave us a value for secure_boot then we use that,1027 * otherwise we ask the BIOS.1028 */1029 if (boot_params->secure_boot == efi_secureboot_mode_unset)1030 boot_params->secure_boot = efi_get_secureboot();1031 1032 /* Ask the firmware to clear memory on unclean shutdown */1033 efi_enable_reset_attack_mitigation();1034 1035 efi_random_get_seed();1036 1037 efi_retrieve_eventlog();1038 1039 setup_graphics(boot_params);1040 1041 setup_efi_pci(boot_params);1042 1043 setup_quirks(boot_params);1044 1045 setup_unaccepted_memory();1046 1047 status = exit_boot(boot_params, handle);1048 if (status != EFI_SUCCESS) {1049 efi_err("exit_boot() failed!\n");1050 goto fail;1051 }1052 1053 /*1054 * Call the SEV init code while still running with the firmware's1055 * GDT/IDT, so #VC exceptions will be handled by EFI.1056 */1057 sev_enable(boot_params);1058 1059 efi_5level_switch();1060 1061 enter_kernel(kernel_entry, boot_params);1062fail:1063 efi_err("efi_stub_entry() failed!\n");1064 1065 efi_exit(handle, status);1066}1067 1068#ifdef CONFIG_EFI_HANDOVER_PROTOCOL1069void efi_handover_entry(efi_handle_t handle, efi_system_table_t *sys_table_arg,1070 struct boot_params *boot_params)1071{1072 memset(_bss, 0, _ebss - _bss);1073 efi_stub_entry(handle, sys_table_arg, boot_params);1074}1075 1076#ifndef CONFIG_EFI_MIXED1077extern __alias(efi_handover_entry)1078void efi32_stub_entry(efi_handle_t handle, efi_system_table_t *sys_table_arg,1079 struct boot_params *boot_params);1080 1081extern __alias(efi_handover_entry)1082void efi64_stub_entry(efi_handle_t handle, efi_system_table_t *sys_table_arg,1083 struct boot_params *boot_params);1084#endif1085#endif1086