1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Helper functions used by the EFI stub on multiple 4 * architectures. This should be #included by the EFI stub 5 * implementation files. 6 * 7 * Copyright 2011 Intel Corporation; author Matt Fleming 8 */ 9 10#include <linux/stdarg.h> 11 12#include <linux/efi.h> 13#include <linux/kernel.h> 14#include <linux/overflow.h> 15#include <asm/efi.h> 16#include <asm/setup.h> 17 18#include "efistub.h" 19 20bool efi_nochunk; 21bool efi_nokaslr = !IS_ENABLED(CONFIG_RANDOMIZE_BASE); 22bool efi_novamap; 23 24static bool efi_noinitrd; 25static bool efi_nosoftreserve; 26static bool efi_disable_pci_dma = IS_ENABLED(CONFIG_EFI_DISABLE_PCI_DMA); 27 28int efi_mem_encrypt; 29 30bool __pure __efi_soft_reserve_enabled(void) 31{ 32 return !efi_nosoftreserve; 33} 34 35/** 36 * efi_parse_options() - Parse EFI command line options 37 * @cmdline: kernel command line 38 * 39 * Parse the ASCII string @cmdline for EFI options, denoted by the efi= 40 * option, e.g. efi=nochunk. 41 * 42 * It should be noted that efi= is parsed in two very different 43 * environments, first in the early boot environment of the EFI boot 44 * stub, and subsequently during the kernel boot. 45 * 46 * Return: status code 47 */ 48efi_status_t efi_parse_options(char const *cmdline) 49{ 50 size_t len; 51 efi_status_t status; 52 char *str, *buf; 53 54 if (!cmdline) 55 return EFI_SUCCESS; 56 57 len = strnlen(cmdline, COMMAND_LINE_SIZE - 1) + 1; 58 status = efi_bs_call(allocate_pool, EFI_LOADER_DATA, len, (void **)&buf); 59 if (status != EFI_SUCCESS) 60 return status; 61 62 memcpy(buf, cmdline, len - 1); 63 buf[len - 1] = '\0'; 64 str = skip_spaces(buf); 65 66 while (*str) { 67 char *param, *val; 68 69 str = next_arg(str, ¶m, &val); 70 if (!val && !strcmp(param, "--")) 71 break; 72 73 if (!strcmp(param, "nokaslr")) { 74 efi_nokaslr = true; 75 } else if (!strcmp(param, "quiet")) { 76 efi_loglevel = CONSOLE_LOGLEVEL_QUIET; 77 } else if (!strcmp(param, "noinitrd")) { 78 efi_noinitrd = true; 79 } else if (IS_ENABLED(CONFIG_X86_64) && !strcmp(param, "no5lvl")) { 80 efi_no5lvl = true; 81 } else if (IS_ENABLED(CONFIG_ARCH_HAS_MEM_ENCRYPT) && 82 !strcmp(param, "mem_encrypt") && val) { 83 if (parse_option_str(val, "on")) 84 efi_mem_encrypt = 1; 85 else if (parse_option_str(val, "off")) 86 efi_mem_encrypt = -1; 87 } else if (!strcmp(param, "efi") && val) { 88 efi_nochunk = parse_option_str(val, "nochunk"); 89 efi_novamap |= parse_option_str(val, "novamap"); 90 91 efi_nosoftreserve = IS_ENABLED(CONFIG_EFI_SOFT_RESERVE) && 92 parse_option_str(val, "nosoftreserve"); 93 94 if (parse_option_str(val, "disable_early_pci_dma")) 95 efi_disable_pci_dma = true; 96 if (parse_option_str(val, "no_disable_early_pci_dma")) 97 efi_disable_pci_dma = false; 98 if (parse_option_str(val, "debug")) 99 efi_loglevel = CONSOLE_LOGLEVEL_DEBUG; 100 } else if (!strcmp(param, "video") && 101 val && strstarts(val, "efifb:")) { 102 efi_parse_option_graphics(val + strlen("efifb:")); 103 } 104 } 105 efi_bs_call(free_pool, buf); 106 return EFI_SUCCESS; 107} 108 109/* 110 * The EFI_LOAD_OPTION descriptor has the following layout: 111 * u32 Attributes; 112 * u16 FilePathListLength; 113 * u16 Description[]; 114 * efi_device_path_protocol_t FilePathList[]; 115 * u8 OptionalData[]; 116 * 117 * This function validates and unpacks the variable-size data fields. 118 */ 119static 120bool efi_load_option_unpack(efi_load_option_unpacked_t *dest, 121 const efi_load_option_t *src, size_t size) 122{ 123 const void *pos; 124 u16 c; 125 efi_device_path_protocol_t header; 126 const efi_char16_t *description; 127 const efi_device_path_protocol_t *file_path_list; 128 129 if (size < offsetof(efi_load_option_t, variable_data)) 130 return false; 131 pos = src->variable_data; 132 size -= offsetof(efi_load_option_t, variable_data); 133 134 if ((src->attributes & ~EFI_LOAD_OPTION_MASK) != 0) 135 return false; 136 137 /* Scan description. */ 138 description = pos; 139 do { 140 if (size < sizeof(c)) 141 return false; 142 c = *(const u16 *)pos; 143 pos += sizeof(c); 144 size -= sizeof(c); 145 } while (c != L'\0'); 146 147 /* Scan file_path_list. */ 148 file_path_list = pos; 149 do { 150 if (size < sizeof(header)) 151 return false; 152 header = *(const efi_device_path_protocol_t *)pos; 153 if (header.length < sizeof(header)) 154 return false; 155 if (size < header.length) 156 return false; 157 pos += header.length; 158 size -= header.length; 159 } while ((header.type != EFI_DEV_END_PATH && header.type != EFI_DEV_END_PATH2) || 160 (header.sub_type != EFI_DEV_END_ENTIRE)); 161 if (pos != (const void *)file_path_list + src->file_path_list_length) 162 return false; 163 164 dest->attributes = src->attributes; 165 dest->file_path_list_length = src->file_path_list_length; 166 dest->description = description; 167 dest->file_path_list = file_path_list; 168 dest->optional_data_size = size; 169 dest->optional_data = size ? pos : NULL; 170 171 return true; 172} 173 174/* 175 * At least some versions of Dell firmware pass the entire contents of the 176 * Boot#### variable, i.e. the EFI_LOAD_OPTION descriptor, rather than just the 177 * OptionalData field. 178 * 179 * Detect this case and extract OptionalData. 180 */ 181void efi_apply_loadoptions_quirk(const void **load_options, u32 *load_options_size) 182{ 183 const efi_load_option_t *load_option = *load_options; 184 efi_load_option_unpacked_t load_option_unpacked; 185 186 if (!IS_ENABLED(CONFIG_X86)) 187 return; 188 if (!load_option) 189 return; 190 if (*load_options_size < sizeof(*load_option)) 191 return; 192 if ((load_option->attributes & ~EFI_LOAD_OPTION_BOOT_MASK) != 0) 193 return; 194 195 if (!efi_load_option_unpack(&load_option_unpacked, load_option, *load_options_size)) 196 return; 197 198 efi_warn_once(FW_BUG "LoadOptions is an EFI_LOAD_OPTION descriptor\n"); 199 efi_warn_once(FW_BUG "Using OptionalData as a workaround\n"); 200 201 *load_options = load_option_unpacked.optional_data; 202 *load_options_size = load_option_unpacked.optional_data_size; 203} 204 205enum efistub_event_type { 206 EFISTUB_EVT_INITRD, 207 EFISTUB_EVT_LOAD_OPTIONS, 208 EFISTUB_EVT_COUNT, 209}; 210 211#define STR_WITH_SIZE(s) sizeof(s), s 212 213static const struct { 214 u32 pcr_index; 215 u32 event_id; 216 u32 event_data_len; 217 u8 event_data[52]; 218} events[] = { 219 [EFISTUB_EVT_INITRD] = { 220 9, 221 INITRD_EVENT_TAG_ID, 222 STR_WITH_SIZE("Linux initrd") 223 }, 224 [EFISTUB_EVT_LOAD_OPTIONS] = { 225 9, 226 LOAD_OPTIONS_EVENT_TAG_ID, 227 STR_WITH_SIZE("LOADED_IMAGE::LoadOptions") 228 }, 229}; 230 231static_assert(sizeof(efi_tcg2_event_t) == sizeof(efi_cc_event_t)); 232 233union efistub_event { 234 efi_tcg2_event_t tcg2_data; 235 efi_cc_event_t cc_data; 236}; 237 238struct efistub_measured_event { 239 union efistub_event event_data; 240 TCG_PCClientTaggedEvent tagged_event __packed; 241}; 242 243static efi_status_t efi_measure_tagged_event(unsigned long load_addr, 244 unsigned long load_size, 245 enum efistub_event_type event) 246{ 247 union { 248 efi_status_t 249 (__efiapi *hash_log_extend_event)(void *, u64, efi_physical_addr_t, 250 u64, const union efistub_event *); 251 struct { u32 hash_log_extend_event; } mixed_mode; 252 } method; 253 struct efistub_measured_event *evt; 254 int size = struct_size(evt, tagged_event.tagged_event_data, 255 events[event].event_data_len); 256 efi_guid_t tcg2_guid = EFI_TCG2_PROTOCOL_GUID; 257 efi_tcg2_protocol_t *tcg2 = NULL; 258 union efistub_event ev; 259 efi_status_t status; 260 void *protocol; 261 262 efi_bs_call(locate_protocol, &tcg2_guid, NULL, (void **)&tcg2); 263 if (tcg2) { 264 ev.tcg2_data = (struct efi_tcg2_event){ 265 .event_size = size, 266 .event_header.header_size = sizeof(ev.tcg2_data.event_header), 267 .event_header.header_version = EFI_TCG2_EVENT_HEADER_VERSION, 268 .event_header.pcr_index = events[event].pcr_index, 269 .event_header.event_type = EV_EVENT_TAG, 270 }; 271 protocol = tcg2; 272 method.hash_log_extend_event = 273 (void *)efi_table_attr(tcg2, hash_log_extend_event); 274 } else { 275 efi_guid_t cc_guid = EFI_CC_MEASUREMENT_PROTOCOL_GUID; 276 efi_cc_protocol_t *cc = NULL; 277 278 efi_bs_call(locate_protocol, &cc_guid, NULL, (void **)&cc); 279 if (!cc) 280 return EFI_UNSUPPORTED; 281 282 ev.cc_data = (struct efi_cc_event){ 283 .event_size = size, 284 .event_header.header_size = sizeof(ev.cc_data.event_header), 285 .event_header.header_version = EFI_CC_EVENT_HEADER_VERSION, 286 .event_header.event_type = EV_EVENT_TAG, 287 }; 288 289 status = efi_call_proto(cc, map_pcr_to_mr_index, 290 events[event].pcr_index, 291 &ev.cc_data.event_header.mr_index); 292 if (status != EFI_SUCCESS) 293 goto fail; 294 295 protocol = cc; 296 method.hash_log_extend_event = 297 (void *)efi_table_attr(cc, hash_log_extend_event); 298 } 299 300 status = efi_bs_call(allocate_pool, EFI_LOADER_DATA, size, (void **)&evt); 301 if (status != EFI_SUCCESS) 302 goto fail; 303 304 *evt = (struct efistub_measured_event) { 305 .event_data = ev, 306 .tagged_event.tagged_event_id = events[event].event_id, 307 .tagged_event.tagged_event_data_size = events[event].event_data_len, 308 }; 309 310 memcpy(evt->tagged_event.tagged_event_data, events[event].event_data, 311 events[event].event_data_len); 312 313 status = efi_fn_call(&method, hash_log_extend_event, protocol, 0, 314 load_addr, load_size, &evt->event_data); 315 efi_bs_call(free_pool, evt); 316 317 if (status == EFI_SUCCESS) 318 return EFI_SUCCESS; 319 320fail: 321 efi_warn("Failed to measure data for event %d: 0x%lx\n", event, status); 322 return status; 323} 324 325/* 326 * Convert the unicode UEFI command line to ASCII to pass to kernel. 327 * Size of memory allocated return in *cmd_line_len. 328 * Returns NULL on error. 329 */ 330char *efi_convert_cmdline(efi_loaded_image_t *image, int *cmd_line_len) 331{ 332 const efi_char16_t *options = efi_table_attr(image, load_options); 333 u32 options_size = efi_table_attr(image, load_options_size); 334 int options_bytes = 0, safe_options_bytes = 0; /* UTF-8 bytes */ 335 unsigned long cmdline_addr = 0; 336 const efi_char16_t *s2; 337 bool in_quote = false; 338 efi_status_t status; 339 u32 options_chars; 340 341 if (options_size > 0) 342 efi_measure_tagged_event((unsigned long)options, options_size, 343 EFISTUB_EVT_LOAD_OPTIONS); 344 345 efi_apply_loadoptions_quirk((const void **)&options, &options_size); 346 options_chars = options_size / sizeof(efi_char16_t); 347 348 if (options) { 349 s2 = options; 350 while (options_bytes < COMMAND_LINE_SIZE && options_chars--) { 351 efi_char16_t c = *s2++; 352 353 if (c < 0x80) { 354 if (c == L'\0' || c == L'\n') 355 break; 356 if (c == L'"') 357 in_quote = !in_quote; 358 else if (!in_quote && isspace((char)c)) 359 safe_options_bytes = options_bytes; 360 361 options_bytes++; 362 continue; 363 } 364 365 /* 366 * Get the number of UTF-8 bytes corresponding to a 367 * UTF-16 character. 368 * The first part handles everything in the BMP. 369 */ 370 options_bytes += 2 + (c >= 0x800); 371 /* 372 * Add one more byte for valid surrogate pairs. Invalid 373 * surrogates will be replaced with 0xfffd and take up 374 * only 3 bytes. 375 */ 376 if ((c & 0xfc00) == 0xd800) { 377 /* 378 * If the very last word is a high surrogate, 379 * we must ignore it since we can't access the 380 * low surrogate. 381 */ 382 if (!options_chars) { 383 options_bytes -= 3; 384 } else if ((*s2 & 0xfc00) == 0xdc00) { 385 options_bytes++; 386 options_chars--; 387 s2++; 388 } 389 } 390 } 391 if (options_bytes >= COMMAND_LINE_SIZE) { 392 options_bytes = safe_options_bytes; 393 efi_err("Command line is too long: truncated to %d bytes\n", 394 options_bytes); 395 } 396 } 397 398 options_bytes++; /* NUL termination */ 399 400 status = efi_bs_call(allocate_pool, EFI_LOADER_DATA, options_bytes, 401 (void **)&cmdline_addr); 402 if (status != EFI_SUCCESS) 403 return NULL; 404 405 snprintf((char *)cmdline_addr, options_bytes, "%.*ls", 406 options_bytes - 1, options); 407 408 *cmd_line_len = options_bytes; 409 return (char *)cmdline_addr; 410} 411 412/** 413 * efi_exit_boot_services() - Exit boot services 414 * @handle: handle of the exiting image 415 * @priv: argument to be passed to @priv_func 416 * @priv_func: function to process the memory map before exiting boot services 417 * 418 * Handle calling ExitBootServices according to the requirements set out by the 419 * spec. Obtains the current memory map, and returns that info after calling 420 * ExitBootServices. The client must specify a function to perform any 421 * processing of the memory map data prior to ExitBootServices. A client 422 * specific structure may be passed to the function via priv. The client 423 * function may be called multiple times. 424 * 425 * Return: status code 426 */ 427efi_status_t efi_exit_boot_services(void *handle, void *priv, 428 efi_exit_boot_map_processing priv_func) 429{ 430 struct efi_boot_memmap *map; 431 efi_status_t status; 432 433 if (efi_disable_pci_dma) 434 efi_pci_disable_bridge_busmaster(); 435 436 status = efi_get_memory_map(&map, true); 437 if (status != EFI_SUCCESS) 438 return status; 439 440 status = priv_func(map, priv); 441 if (status != EFI_SUCCESS) { 442 efi_bs_call(free_pool, map); 443 return status; 444 } 445 446 status = efi_bs_call(exit_boot_services, handle, map->map_key); 447 448 if (status == EFI_INVALID_PARAMETER) { 449 /* 450 * The memory map changed between efi_get_memory_map() and 451 * exit_boot_services(). Per the UEFI Spec v2.6, Section 6.4: 452 * EFI_BOOT_SERVICES.ExitBootServices we need to get the 453 * updated map, and try again. The spec implies one retry 454 * should be sufficent, which is confirmed against the EDK2 455 * implementation. Per the spec, we can only invoke 456 * get_memory_map() and exit_boot_services() - we cannot alloc 457 * so efi_get_memory_map() cannot be used, and we must reuse 458 * the buffer. For all practical purposes, the headroom in the 459 * buffer should account for any changes in the map so the call 460 * to get_memory_map() is expected to succeed here. 461 */ 462 map->map_size = map->buff_size; 463 status = efi_bs_call(get_memory_map, 464 &map->map_size, 465 &map->map, 466 &map->map_key, 467 &map->desc_size, 468 &map->desc_ver); 469 470 /* exit_boot_services() was called, thus cannot free */ 471 if (status != EFI_SUCCESS) 472 return status; 473 474 status = priv_func(map, priv); 475 /* exit_boot_services() was called, thus cannot free */ 476 if (status != EFI_SUCCESS) 477 return status; 478 479 status = efi_bs_call(exit_boot_services, handle, map->map_key); 480 } 481 482 return status; 483} 484 485/** 486 * get_efi_config_table() - retrieve UEFI configuration table 487 * @guid: GUID of the configuration table to be retrieved 488 * Return: pointer to the configuration table or NULL 489 */ 490void *get_efi_config_table(efi_guid_t guid) 491{ 492 unsigned long tables = efi_table_attr(efi_system_table, tables); 493 int nr_tables = efi_table_attr(efi_system_table, nr_tables); 494 int i; 495 496 for (i = 0; i < nr_tables; i++) { 497 efi_config_table_t *t = (void *)tables; 498 499 if (efi_guidcmp(t->guid, guid) == 0) 500 return efi_table_attr(t, table); 501 502 tables += efi_is_native() ? sizeof(efi_config_table_t) 503 : sizeof(efi_config_table_32_t); 504 } 505 return NULL; 506} 507 508/* 509 * The LINUX_EFI_INITRD_MEDIA_GUID vendor media device path below provides a way 510 * for the firmware or bootloader to expose the initrd data directly to the stub 511 * via the trivial LoadFile2 protocol, which is defined in the UEFI spec, and is 512 * very easy to implement. It is a simple Linux initrd specific conduit between 513 * kernel and firmware, allowing us to put the EFI stub (being part of the 514 * kernel) in charge of where and when to load the initrd, while leaving it up 515 * to the firmware to decide whether it needs to expose its filesystem hierarchy 516 * via EFI protocols. 517 */ 518static const struct { 519 struct efi_vendor_dev_path vendor; 520 struct efi_generic_dev_path end; 521} __packed initrd_dev_path = { 522 { 523 { 524 EFI_DEV_MEDIA, 525 EFI_DEV_MEDIA_VENDOR, 526 sizeof(struct efi_vendor_dev_path), 527 }, 528 LINUX_EFI_INITRD_MEDIA_GUID 529 }, { 530 EFI_DEV_END_PATH, 531 EFI_DEV_END_ENTIRE, 532 sizeof(struct efi_generic_dev_path) 533 } 534}; 535 536/** 537 * efi_load_initrd_dev_path() - load the initrd from the Linux initrd device path 538 * @initrd: pointer of struct to store the address where the initrd was loaded 539 * and the size of the loaded initrd 540 * @max: upper limit for the initrd memory allocation 541 * 542 * Return: 543 * * %EFI_SUCCESS if the initrd was loaded successfully, in which 544 * case @load_addr and @load_size are assigned accordingly 545 * * %EFI_NOT_FOUND if no LoadFile2 protocol exists on the initrd device path 546 * * %EFI_OUT_OF_RESOURCES if memory allocation failed 547 * * %EFI_LOAD_ERROR in all other cases 548 */ 549static 550efi_status_t efi_load_initrd_dev_path(struct linux_efi_initrd *initrd, 551 unsigned long max) 552{ 553 efi_guid_t lf2_proto_guid = EFI_LOAD_FILE2_PROTOCOL_GUID; 554 efi_device_path_protocol_t *dp; 555 efi_load_file2_protocol_t *lf2; 556 efi_handle_t handle; 557 efi_status_t status; 558 559 dp = (efi_device_path_protocol_t *)&initrd_dev_path; 560 status = efi_bs_call(locate_device_path, &lf2_proto_guid, &dp, &handle); 561 if (status != EFI_SUCCESS) 562 return status; 563 564 status = efi_bs_call(handle_protocol, handle, &lf2_proto_guid, 565 (void **)&lf2); 566 if (status != EFI_SUCCESS) 567 return status; 568 569 initrd->size = 0; 570 status = efi_call_proto(lf2, load_file, dp, false, &initrd->size, NULL); 571 if (status != EFI_BUFFER_TOO_SMALL) 572 return EFI_LOAD_ERROR; 573 574 status = efi_allocate_pages(initrd->size, &initrd->base, max); 575 if (status != EFI_SUCCESS) 576 return status; 577 578 status = efi_call_proto(lf2, load_file, dp, false, &initrd->size, 579 (void *)initrd->base); 580 if (status != EFI_SUCCESS) { 581 efi_free(initrd->size, initrd->base); 582 return EFI_LOAD_ERROR; 583 } 584 return EFI_SUCCESS; 585} 586 587static 588efi_status_t efi_load_initrd_cmdline(efi_loaded_image_t *image, 589 struct linux_efi_initrd *initrd, 590 unsigned long soft_limit, 591 unsigned long hard_limit) 592{ 593 if (image == NULL) 594 return EFI_UNSUPPORTED; 595 596 return handle_cmdline_files(image, L"initrd=", sizeof(L"initrd=") - 2, 597 soft_limit, hard_limit, 598 &initrd->base, &initrd->size); 599} 600 601/** 602 * efi_load_initrd() - Load initial RAM disk 603 * @image: EFI loaded image protocol 604 * @soft_limit: preferred address for loading the initrd 605 * @hard_limit: upper limit address for loading the initrd 606 * 607 * Return: status code 608 */ 609efi_status_t efi_load_initrd(efi_loaded_image_t *image, 610 unsigned long soft_limit, 611 unsigned long hard_limit, 612 const struct linux_efi_initrd **out) 613{ 614 efi_guid_t tbl_guid = LINUX_EFI_INITRD_MEDIA_GUID; 615 efi_status_t status = EFI_SUCCESS; 616 struct linux_efi_initrd initrd, *tbl; 617 618 if (!IS_ENABLED(CONFIG_BLK_DEV_INITRD) || efi_noinitrd) 619 return EFI_SUCCESS; 620 621 status = efi_load_initrd_dev_path(&initrd, hard_limit); 622 if (status == EFI_SUCCESS) { 623 efi_info("Loaded initrd from LINUX_EFI_INITRD_MEDIA_GUID device path\n"); 624 if (initrd.size > 0 && 625 efi_measure_tagged_event(initrd.base, initrd.size, 626 EFISTUB_EVT_INITRD) == EFI_SUCCESS) 627 efi_info("Measured initrd data into PCR 9\n"); 628 } else if (status == EFI_NOT_FOUND) { 629 status = efi_load_initrd_cmdline(image, &initrd, soft_limit, 630 hard_limit); 631 /* command line loader disabled or no initrd= passed? */ 632 if (status == EFI_UNSUPPORTED || status == EFI_NOT_READY) 633 return EFI_SUCCESS; 634 if (status == EFI_SUCCESS) 635 efi_info("Loaded initrd from command line option\n"); 636 } 637 if (status != EFI_SUCCESS) 638 goto failed; 639 640 status = efi_bs_call(allocate_pool, EFI_LOADER_DATA, sizeof(initrd), 641 (void **)&tbl); 642 if (status != EFI_SUCCESS) 643 goto free_initrd; 644 645 *tbl = initrd; 646 status = efi_bs_call(install_configuration_table, &tbl_guid, tbl); 647 if (status != EFI_SUCCESS) 648 goto free_tbl; 649 650 if (out) 651 *out = tbl; 652 return EFI_SUCCESS; 653 654free_tbl: 655 efi_bs_call(free_pool, tbl); 656free_initrd: 657 efi_free(initrd.size, initrd.base); 658failed: 659 efi_err("Failed to load initrd: 0x%lx\n", status); 660 return status; 661} 662 663/** 664 * efi_wait_for_key() - Wait for key stroke 665 * @usec: number of microseconds to wait for key stroke 666 * @key: key entered 667 * 668 * Wait for up to @usec microseconds for a key stroke. 669 * 670 * Return: status code, EFI_SUCCESS if key received 671 */ 672efi_status_t efi_wait_for_key(unsigned long usec, efi_input_key_t *key) 673{ 674 efi_event_t events[2], timer; 675 unsigned long index; 676 efi_simple_text_input_protocol_t *con_in; 677 efi_status_t status; 678 679 con_in = efi_table_attr(efi_system_table, con_in); 680 if (!con_in) 681 return EFI_UNSUPPORTED; 682 efi_set_event_at(events, 0, efi_table_attr(con_in, wait_for_key)); 683 684 status = efi_bs_call(create_event, EFI_EVT_TIMER, 0, NULL, NULL, &timer); 685 if (status != EFI_SUCCESS) 686 return status; 687 688 status = efi_bs_call(set_timer, timer, EfiTimerRelative, 689 EFI_100NSEC_PER_USEC * usec); 690 if (status != EFI_SUCCESS) 691 return status; 692 efi_set_event_at(events, 1, timer); 693 694 status = efi_bs_call(wait_for_event, 2, events, &index); 695 if (status == EFI_SUCCESS) { 696 if (index == 0) 697 status = efi_call_proto(con_in, read_keystroke, key); 698 else 699 status = EFI_TIMEOUT; 700 } 701 702 efi_bs_call(close_event, timer); 703 704 return status; 705} 706 707/** 708 * efi_remap_image - Remap a loaded image with the appropriate permissions 709 * for code and data 710 * 711 * @image_base: the base of the image in memory 712 * @alloc_size: the size of the area in memory occupied by the image 713 * @code_size: the size of the leading part of the image containing code 714 * and read-only data 715 * 716 * efi_remap_image() uses the EFI memory attribute protocol to remap the code 717 * region of the loaded image read-only/executable, and the remainder 718 * read-write/non-executable. The code region is assumed to start at the base 719 * of the image, and will therefore cover the PE/COFF header as well. 720 */ 721void efi_remap_image(unsigned long image_base, unsigned alloc_size, 722 unsigned long code_size) 723{ 724 efi_guid_t guid = EFI_MEMORY_ATTRIBUTE_PROTOCOL_GUID; 725 efi_memory_attribute_protocol_t *memattr; 726 efi_status_t status; 727 u64 attr; 728 729 /* 730 * If the firmware implements the EFI_MEMORY_ATTRIBUTE_PROTOCOL, let's 731 * invoke it to remap the text/rodata region of the decompressed image 732 * as read-only and the data/bss region as non-executable. 733 */ 734 status = efi_bs_call(locate_protocol, &guid, NULL, (void **)&memattr); 735 if (status != EFI_SUCCESS) 736 return; 737 738 // Get the current attributes for the entire region 739 status = memattr->get_memory_attributes(memattr, image_base, 740 alloc_size, &attr); 741 if (status != EFI_SUCCESS) { 742 efi_warn("Failed to retrieve memory attributes for image region: 0x%lx\n", 743 status); 744 return; 745 } 746 747 // Mark the code region as read-only 748 status = memattr->set_memory_attributes(memattr, image_base, code_size, 749 EFI_MEMORY_RO); 750 if (status != EFI_SUCCESS) { 751 efi_warn("Failed to remap code region read-only\n"); 752 return; 753 } 754 755 // If the entire region was already mapped as non-exec, clear the 756 // attribute from the code region. Otherwise, set it on the data 757 // region. 758 if (attr & EFI_MEMORY_XP) { 759 status = memattr->clear_memory_attributes(memattr, image_base, 760 code_size, 761 EFI_MEMORY_XP); 762 if (status != EFI_SUCCESS) 763 efi_warn("Failed to remap code region executable\n"); 764 } else { 765 status = memattr->set_memory_attributes(memattr, 766 image_base + code_size, 767 alloc_size - code_size, 768 EFI_MEMORY_XP); 769 if (status != EFI_SUCCESS) 770 efi_warn("Failed to remap data region non-executable\n"); 771 } 772} 773