1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * efi.c - EFI subsystem 4 * 5 * Copyright (C) 2001,2003,2004 Dell <Matt_Domsch@dell.com> 6 * Copyright (C) 2004 Intel Corporation <matthew.e.tolentino@intel.com> 7 * Copyright (C) 2013 Tom Gundersen <teg@jklm.no> 8 * 9 * This code registers /sys/firmware/efi{,/efivars} when EFI is supported, 10 * allowing the efivarfs to be mounted or the efivars module to be loaded. 11 * The existance of /sys/firmware/efi may also be used by userspace to 12 * determine that the system supports EFI. 13 */ 14 15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 16 17 #include <linux/kobject.h> 18 #include <linux/module.h> 19 #include <linux/init.h> 20 #include <linux/debugfs.h> 21 #include <linux/device.h> 22 #include <linux/efi.h> 23 #include <linux/of.h> 24 #include <linux/initrd.h> 25 #include <linux/io.h> 26 #include <linux/kexec.h> 27 #include <linux/platform_device.h> 28 #include <linux/random.h> 29 #include <linux/reboot.h> 30 #include <linux/slab.h> 31 #include <linux/acpi.h> 32 #include <linux/ucs2_string.h> 33 #include <linux/memblock.h> 34 #include <linux/security.h> 35 36 #include <asm/early_ioremap.h> 37 38 struct efi __read_mostly efi = { 39 .runtime_supported_mask = EFI_RT_SUPPORTED_ALL, 40 .acpi = EFI_INVALID_TABLE_ADDR, 41 .acpi20 = EFI_INVALID_TABLE_ADDR, 42 .smbios = EFI_INVALID_TABLE_ADDR, 43 .smbios3 = EFI_INVALID_TABLE_ADDR, 44 .esrt = EFI_INVALID_TABLE_ADDR, 45 .tpm_log = EFI_INVALID_TABLE_ADDR, 46 .tpm_final_log = EFI_INVALID_TABLE_ADDR, 47 #ifdef CONFIG_LOAD_UEFI_KEYS 48 .mokvar_table = EFI_INVALID_TABLE_ADDR, 49 #endif 50 #ifdef CONFIG_EFI_COCO_SECRET 51 .coco_secret = EFI_INVALID_TABLE_ADDR, 52 #endif 53 #ifdef CONFIG_UNACCEPTED_MEMORY 54 .unaccepted = EFI_INVALID_TABLE_ADDR, 55 #endif 56 }; 57 EXPORT_SYMBOL(efi); 58 59 unsigned long __ro_after_init efi_rng_seed = EFI_INVALID_TABLE_ADDR; 60 static unsigned long __initdata mem_reserve = EFI_INVALID_TABLE_ADDR; 61 static unsigned long __initdata rt_prop = EFI_INVALID_TABLE_ADDR; 62 static unsigned long __initdata initrd = EFI_INVALID_TABLE_ADDR; 63 64 extern unsigned long screen_info_table; 65 66 struct mm_struct efi_mm = { 67 .mm_mt = MTREE_INIT_EXT(mm_mt, MM_MT_FLAGS, efi_mm.mmap_lock), 68 .mm_users = ATOMIC_INIT(2), 69 .mm_count = ATOMIC_INIT(1), 70 .write_protect_seq = SEQCNT_ZERO(efi_mm.write_protect_seq), 71 MMAP_LOCK_INITIALIZER(efi_mm) 72 .page_table_lock = __SPIN_LOCK_UNLOCKED(efi_mm.page_table_lock), 73 .mmlist = LIST_HEAD_INIT(efi_mm.mmlist), 74 .cpu_bitmap = { [BITS_TO_LONGS(NR_CPUS)] = 0}, 75 }; 76 77 struct workqueue_struct *efi_rts_wq; 78 79 static bool disable_runtime = IS_ENABLED(CONFIG_EFI_DISABLE_RUNTIME); 80 static int __init setup_noefi(char *arg) 81 { 82 disable_runtime = true; 83 return 0; 84 } 85 early_param("noefi", setup_noefi); 86 87 bool efi_runtime_disabled(void) 88 { 89 return disable_runtime; 90 } 91 92 bool __pure __efi_soft_reserve_enabled(void) 93 { 94 return !efi_enabled(EFI_MEM_NO_SOFT_RESERVE); 95 } 96 97 static int __init parse_efi_cmdline(char *str) 98 { 99 if (!str) { 100 pr_warn("need at least one option\n"); 101 return -EINVAL; 102 } 103 104 if (parse_option_str(str, "debug")) 105 set_bit(EFI_DBG, &efi.flags); 106 107 if (parse_option_str(str, "noruntime")) 108 disable_runtime = true; 109 110 if (parse_option_str(str, "runtime")) 111 disable_runtime = false; 112 113 if (parse_option_str(str, "nosoftreserve")) 114 set_bit(EFI_MEM_NO_SOFT_RESERVE, &efi.flags); 115 116 return 0; 117 } 118 early_param("efi", parse_efi_cmdline); 119 120 struct kobject *efi_kobj; 121 122 /* 123 * Let's not leave out systab information that snuck into 124 * the efivars driver 125 * Note, do not add more fields in systab sysfs file as it breaks sysfs 126 * one value per file rule! 127 */ 128 static ssize_t systab_show(struct kobject *kobj, 129 struct kobj_attribute *attr, char *buf) 130 { 131 char *str = buf; 132 133 if (!kobj || !buf) 134 return -EINVAL; 135 136 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR) 137 str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20); 138 if (efi.acpi != EFI_INVALID_TABLE_ADDR) 139 str += sprintf(str, "ACPI=0x%lx\n", efi.acpi); 140 /* 141 * If both SMBIOS and SMBIOS3 entry points are implemented, the 142 * SMBIOS3 entry point shall be preferred, so we list it first to 143 * let applications stop parsing after the first match. 144 */ 145 if (efi.smbios3 != EFI_INVALID_TABLE_ADDR) 146 str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3); 147 if (efi.smbios != EFI_INVALID_TABLE_ADDR) 148 str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios); 149 150 if (IS_ENABLED(CONFIG_IA64) || IS_ENABLED(CONFIG_X86)) 151 str = efi_systab_show_arch(str); 152 153 return str - buf; 154 } 155 156 static struct kobj_attribute efi_attr_systab = __ATTR_RO_MODE(systab, 0400); 157 158 static ssize_t fw_platform_size_show(struct kobject *kobj, 159 struct kobj_attribute *attr, char *buf) 160 { 161 return sprintf(buf, "%d\n", efi_enabled(EFI_64BIT) ? 64 : 32); 162 } 163 164 extern __weak struct kobj_attribute efi_attr_fw_vendor; 165 extern __weak struct kobj_attribute efi_attr_runtime; 166 extern __weak struct kobj_attribute efi_attr_config_table; 167 static struct kobj_attribute efi_attr_fw_platform_size = 168 __ATTR_RO(fw_platform_size); 169 170 static struct attribute *efi_subsys_attrs[] = { 171 &efi_attr_systab.attr, 172 &efi_attr_fw_platform_size.attr, 173 &efi_attr_fw_vendor.attr, 174 &efi_attr_runtime.attr, 175 &efi_attr_config_table.attr, 176 NULL, 177 }; 178 179 umode_t __weak efi_attr_is_visible(struct kobject *kobj, struct attribute *attr, 180 int n) 181 { 182 return attr->mode; 183 } 184 185 static const struct attribute_group efi_subsys_attr_group = { 186 .attrs = efi_subsys_attrs, 187 .is_visible = efi_attr_is_visible, 188 }; 189 190 static struct efivars generic_efivars; 191 static struct efivar_operations generic_ops; 192 193 static bool generic_ops_supported(void) 194 { 195 unsigned long name_size; 196 efi_status_t status; 197 efi_char16_t name; 198 efi_guid_t guid; 199 200 name_size = sizeof(name); 201 202 status = efi.get_next_variable(&name_size, &name, &guid); 203 if (status == EFI_UNSUPPORTED) 204 return false; 205 206 return true; 207 } 208 209 static int generic_ops_register(void) 210 { 211 if (!generic_ops_supported()) 212 return 0; 213 214 generic_ops.get_variable = efi.get_variable; 215 generic_ops.get_next_variable = efi.get_next_variable; 216 generic_ops.query_variable_store = efi_query_variable_store; 217 generic_ops.query_variable_info = efi.query_variable_info; 218 219 if (efi_rt_services_supported(EFI_RT_SUPPORTED_SET_VARIABLE)) { 220 generic_ops.set_variable = efi.set_variable; 221 generic_ops.set_variable_nonblocking = efi.set_variable_nonblocking; 222 } 223 return efivars_register(&generic_efivars, &generic_ops); 224 } 225 226 static void generic_ops_unregister(void) 227 { 228 if (!generic_ops.get_variable) 229 return; 230 231 efivars_unregister(&generic_efivars); 232 } 233 234 #ifdef CONFIG_EFI_CUSTOM_SSDT_OVERLAYS 235 #define EFIVAR_SSDT_NAME_MAX 16UL 236 static char efivar_ssdt[EFIVAR_SSDT_NAME_MAX] __initdata; 237 static int __init efivar_ssdt_setup(char *str) 238 { 239 int ret = security_locked_down(LOCKDOWN_ACPI_TABLES); 240 241 if (ret) 242 return ret; 243 244 if (strlen(str) < sizeof(efivar_ssdt)) 245 memcpy(efivar_ssdt, str, strlen(str)); 246 else 247 pr_warn("efivar_ssdt: name too long: %s\n", str); 248 return 1; 249 } 250 __setup("efivar_ssdt=", efivar_ssdt_setup); 251 252 static __init int efivar_ssdt_load(void) 253 { 254 unsigned long name_size = 256; 255 efi_char16_t *name = NULL; 256 efi_status_t status; 257 efi_guid_t guid; 258 259 if (!efivar_ssdt[0]) 260 return 0; 261 262 name = kzalloc(name_size, GFP_KERNEL); 263 if (!name) 264 return -ENOMEM; 265 266 for (;;) { 267 char utf8_name[EFIVAR_SSDT_NAME_MAX]; 268 unsigned long data_size = 0; 269 void *data; 270 int limit; 271 272 status = efi.get_next_variable(&name_size, name, &guid); 273 if (status == EFI_NOT_FOUND) { 274 break; 275 } else if (status == EFI_BUFFER_TOO_SMALL) { 276 name = krealloc(name, name_size, GFP_KERNEL); 277 if (!name) 278 return -ENOMEM; 279 continue; 280 } 281 282 limit = min(EFIVAR_SSDT_NAME_MAX, name_size); 283 ucs2_as_utf8(utf8_name, name, limit - 1); 284 if (strncmp(utf8_name, efivar_ssdt, limit) != 0) 285 continue; 286 287 pr_info("loading SSDT from variable %s-%pUl\n", efivar_ssdt, &guid); 288 289 status = efi.get_variable(name, &guid, NULL, &data_size, NULL); 290 if (status != EFI_BUFFER_TOO_SMALL || !data_size) 291 return -EIO; 292 293 data = kmalloc(data_size, GFP_KERNEL); 294 if (!data) 295 return -ENOMEM; 296 297 status = efi.get_variable(name, &guid, NULL, &data_size, data); 298 if (status == EFI_SUCCESS) { 299 acpi_status ret = acpi_load_table(data, NULL); 300 if (ret) 301 pr_err("failed to load table: %u\n", ret); 302 else 303 continue; 304 } else { 305 pr_err("failed to get var data: 0x%lx\n", status); 306 } 307 kfree(data); 308 } 309 return 0; 310 } 311 #else 312 static inline int efivar_ssdt_load(void) { return 0; } 313 #endif 314 315 #ifdef CONFIG_DEBUG_FS 316 317 #define EFI_DEBUGFS_MAX_BLOBS 32 318 319 static struct debugfs_blob_wrapper debugfs_blob[EFI_DEBUGFS_MAX_BLOBS]; 320 321 static void __init efi_debugfs_init(void) 322 { 323 struct dentry *efi_debugfs; 324 efi_memory_desc_t *md; 325 char name[32]; 326 int type_count[EFI_BOOT_SERVICES_DATA + 1] = {}; 327 int i = 0; 328 329 efi_debugfs = debugfs_create_dir("efi", NULL); 330 if (IS_ERR_OR_NULL(efi_debugfs)) 331 return; 332 333 for_each_efi_memory_desc(md) { 334 switch (md->type) { 335 case EFI_BOOT_SERVICES_CODE: 336 snprintf(name, sizeof(name), "boot_services_code%d", 337 type_count[md->type]++); 338 break; 339 case EFI_BOOT_SERVICES_DATA: 340 snprintf(name, sizeof(name), "boot_services_data%d", 341 type_count[md->type]++); 342 break; 343 default: 344 continue; 345 } 346 347 if (i >= EFI_DEBUGFS_MAX_BLOBS) { 348 pr_warn("More then %d EFI boot service segments, only showing first %d in debugfs\n", 349 EFI_DEBUGFS_MAX_BLOBS, EFI_DEBUGFS_MAX_BLOBS); 350 break; 351 } 352 353 debugfs_blob[i].size = md->num_pages << EFI_PAGE_SHIFT; 354 debugfs_blob[i].data = memremap(md->phys_addr, 355 debugfs_blob[i].size, 356 MEMREMAP_WB); 357 if (!debugfs_blob[i].data) 358 continue; 359 360 debugfs_create_blob(name, 0400, efi_debugfs, &debugfs_blob[i]); 361 i++; 362 } 363 } 364 #else 365 static inline void efi_debugfs_init(void) {} 366 #endif 367 368 /* 369 * We register the efi subsystem with the firmware subsystem and the 370 * efivars subsystem with the efi subsystem, if the system was booted with 371 * EFI. 372 */ 373 static int __init efisubsys_init(void) 374 { 375 int error; 376 377 if (!efi_enabled(EFI_RUNTIME_SERVICES)) 378 efi.runtime_supported_mask = 0; 379 380 if (!efi_enabled(EFI_BOOT)) 381 return 0; 382 383 if (efi.runtime_supported_mask) { 384 /* 385 * Since we process only one efi_runtime_service() at a time, an 386 * ordered workqueue (which creates only one execution context) 387 * should suffice for all our needs. 388 */ 389 efi_rts_wq = alloc_ordered_workqueue("efi_rts_wq", 0); 390 if (!efi_rts_wq) { 391 pr_err("Creating efi_rts_wq failed, EFI runtime services disabled.\n"); 392 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags); 393 efi.runtime_supported_mask = 0; 394 return 0; 395 } 396 } 397 398 if (efi_rt_services_supported(EFI_RT_SUPPORTED_TIME_SERVICES)) 399 platform_device_register_simple("rtc-efi", 0, NULL, 0); 400 401 /* We register the efi directory at /sys/firmware/efi */ 402 efi_kobj = kobject_create_and_add("efi", firmware_kobj); 403 if (!efi_kobj) { 404 pr_err("efi: Firmware registration failed.\n"); 405 error = -ENOMEM; 406 goto err_destroy_wq; 407 } 408 409 if (efi_rt_services_supported(EFI_RT_SUPPORTED_GET_VARIABLE | 410 EFI_RT_SUPPORTED_GET_NEXT_VARIABLE_NAME)) { 411 error = generic_ops_register(); 412 if (error) 413 goto err_put; 414 efivar_ssdt_load(); 415 platform_device_register_simple("efivars", 0, NULL, 0); 416 } 417 418 error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group); 419 if (error) { 420 pr_err("efi: Sysfs attribute export failed with error %d.\n", 421 error); 422 goto err_unregister; 423 } 424 425 /* and the standard mountpoint for efivarfs */ 426 error = sysfs_create_mount_point(efi_kobj, "efivars"); 427 if (error) { 428 pr_err("efivars: Subsystem registration failed.\n"); 429 goto err_remove_group; 430 } 431 432 if (efi_enabled(EFI_DBG) && efi_enabled(EFI_PRESERVE_BS_REGIONS)) 433 efi_debugfs_init(); 434 435 #ifdef CONFIG_EFI_COCO_SECRET 436 if (efi.coco_secret != EFI_INVALID_TABLE_ADDR) 437 platform_device_register_simple("efi_secret", 0, NULL, 0); 438 #endif 439 440 return 0; 441 442 err_remove_group: 443 sysfs_remove_group(efi_kobj, &efi_subsys_attr_group); 444 err_unregister: 445 if (efi_rt_services_supported(EFI_RT_SUPPORTED_GET_VARIABLE | 446 EFI_RT_SUPPORTED_GET_NEXT_VARIABLE_NAME)) 447 generic_ops_unregister(); 448 err_put: 449 kobject_put(efi_kobj); 450 efi_kobj = NULL; 451 err_destroy_wq: 452 if (efi_rts_wq) 453 destroy_workqueue(efi_rts_wq); 454 455 return error; 456 } 457 458 subsys_initcall(efisubsys_init); 459 460 void __init efi_find_mirror(void) 461 { 462 efi_memory_desc_t *md; 463 u64 mirror_size = 0, total_size = 0; 464 465 if (!efi_enabled(EFI_MEMMAP)) 466 return; 467 468 for_each_efi_memory_desc(md) { 469 unsigned long long start = md->phys_addr; 470 unsigned long long size = md->num_pages << EFI_PAGE_SHIFT; 471 472 total_size += size; 473 if (md->attribute & EFI_MEMORY_MORE_RELIABLE) { 474 memblock_mark_mirror(start, size); 475 mirror_size += size; 476 } 477 } 478 if (mirror_size) 479 pr_info("Memory: %lldM/%lldM mirrored memory\n", 480 mirror_size>>20, total_size>>20); 481 } 482 483 /* 484 * Find the efi memory descriptor for a given physical address. Given a 485 * physical address, determine if it exists within an EFI Memory Map entry, 486 * and if so, populate the supplied memory descriptor with the appropriate 487 * data. 488 */ 489 int __efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md) 490 { 491 efi_memory_desc_t *md; 492 493 if (!efi_enabled(EFI_MEMMAP)) { 494 pr_err_once("EFI_MEMMAP is not enabled.\n"); 495 return -EINVAL; 496 } 497 498 if (!out_md) { 499 pr_err_once("out_md is null.\n"); 500 return -EINVAL; 501 } 502 503 for_each_efi_memory_desc(md) { 504 u64 size; 505 u64 end; 506 507 /* skip bogus entries (including empty ones) */ 508 if ((md->phys_addr & (EFI_PAGE_SIZE - 1)) || 509 (md->num_pages <= 0) || 510 (md->num_pages > (U64_MAX - md->phys_addr) >> EFI_PAGE_SHIFT)) 511 continue; 512 513 size = md->num_pages << EFI_PAGE_SHIFT; 514 end = md->phys_addr + size; 515 if (phys_addr >= md->phys_addr && phys_addr < end) { 516 memcpy(out_md, md, sizeof(*out_md)); 517 return 0; 518 } 519 } 520 return -ENOENT; 521 } 522 523 extern int efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md) 524 __weak __alias(__efi_mem_desc_lookup); 525 526 /* 527 * Calculate the highest address of an efi memory descriptor. 528 */ 529 u64 __init efi_mem_desc_end(efi_memory_desc_t *md) 530 { 531 u64 size = md->num_pages << EFI_PAGE_SHIFT; 532 u64 end = md->phys_addr + size; 533 return end; 534 } 535 536 void __init __weak efi_arch_mem_reserve(phys_addr_t addr, u64 size) {} 537 538 /** 539 * efi_mem_reserve - Reserve an EFI memory region 540 * @addr: Physical address to reserve 541 * @size: Size of reservation 542 * 543 * Mark a region as reserved from general kernel allocation and 544 * prevent it being released by efi_free_boot_services(). 545 * 546 * This function should be called drivers once they've parsed EFI 547 * configuration tables to figure out where their data lives, e.g. 548 * efi_esrt_init(). 549 */ 550 void __init efi_mem_reserve(phys_addr_t addr, u64 size) 551 { 552 /* efi_mem_reserve() does not work under Xen */ 553 if (WARN_ON_ONCE(efi_enabled(EFI_PARAVIRT))) 554 return; 555 556 if (!memblock_is_region_reserved(addr, size)) 557 memblock_reserve(addr, size); 558 559 /* 560 * Some architectures (x86) reserve all boot services ranges 561 * until efi_free_boot_services() because of buggy firmware 562 * implementations. This means the above memblock_reserve() is 563 * superfluous on x86 and instead what it needs to do is 564 * ensure the @start, @size is not freed. 565 */ 566 efi_arch_mem_reserve(addr, size); 567 } 568 569 static const efi_config_table_type_t common_tables[] __initconst = { 570 {ACPI_20_TABLE_GUID, &efi.acpi20, "ACPI 2.0" }, 571 {ACPI_TABLE_GUID, &efi.acpi, "ACPI" }, 572 {SMBIOS_TABLE_GUID, &efi.smbios, "SMBIOS" }, 573 {SMBIOS3_TABLE_GUID, &efi.smbios3, "SMBIOS 3.0" }, 574 {EFI_SYSTEM_RESOURCE_TABLE_GUID, &efi.esrt, "ESRT" }, 575 {EFI_MEMORY_ATTRIBUTES_TABLE_GUID, &efi_mem_attr_table, "MEMATTR" }, 576 {LINUX_EFI_RANDOM_SEED_TABLE_GUID, &efi_rng_seed, "RNG" }, 577 {LINUX_EFI_TPM_EVENT_LOG_GUID, &efi.tpm_log, "TPMEventLog" }, 578 {LINUX_EFI_TPM_FINAL_LOG_GUID, &efi.tpm_final_log, "TPMFinalLog" }, 579 {LINUX_EFI_MEMRESERVE_TABLE_GUID, &mem_reserve, "MEMRESERVE" }, 580 {LINUX_EFI_INITRD_MEDIA_GUID, &initrd, "INITRD" }, 581 {EFI_RT_PROPERTIES_TABLE_GUID, &rt_prop, "RTPROP" }, 582 #ifdef CONFIG_EFI_RCI2_TABLE 583 {DELLEMC_EFI_RCI2_TABLE_GUID, &rci2_table_phys }, 584 #endif 585 #ifdef CONFIG_LOAD_UEFI_KEYS 586 {LINUX_EFI_MOK_VARIABLE_TABLE_GUID, &efi.mokvar_table, "MOKvar" }, 587 #endif 588 #ifdef CONFIG_EFI_COCO_SECRET 589 {LINUX_EFI_COCO_SECRET_AREA_GUID, &efi.coco_secret, "CocoSecret" }, 590 #endif 591 #ifdef CONFIG_UNACCEPTED_MEMORY 592 {LINUX_EFI_UNACCEPTED_MEM_TABLE_GUID, &efi.unaccepted, "Unaccepted" }, 593 #endif 594 #ifdef CONFIG_EFI_GENERIC_STUB 595 {LINUX_EFI_SCREEN_INFO_TABLE_GUID, &screen_info_table }, 596 #endif 597 {}, 598 }; 599 600 static __init int match_config_table(const efi_guid_t *guid, 601 unsigned long table, 602 const efi_config_table_type_t *table_types) 603 { 604 int i; 605 606 for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) { 607 if (efi_guidcmp(*guid, table_types[i].guid)) 608 continue; 609 610 if (!efi_config_table_is_usable(guid, table)) { 611 if (table_types[i].name[0]) 612 pr_cont("(%s=0x%lx unusable) ", 613 table_types[i].name, table); 614 return 1; 615 } 616 617 *(table_types[i].ptr) = table; 618 if (table_types[i].name[0]) 619 pr_cont("%s=0x%lx ", table_types[i].name, table); 620 return 1; 621 } 622 623 return 0; 624 } 625 626 int __init efi_config_parse_tables(const efi_config_table_t *config_tables, 627 int count, 628 const efi_config_table_type_t *arch_tables) 629 { 630 const efi_config_table_64_t *tbl64 = (void *)config_tables; 631 const efi_config_table_32_t *tbl32 = (void *)config_tables; 632 const efi_guid_t *guid; 633 unsigned long table; 634 int i; 635 636 pr_info(""); 637 for (i = 0; i < count; i++) { 638 if (!IS_ENABLED(CONFIG_X86)) { 639 guid = &config_tables[i].guid; 640 table = (unsigned long)config_tables[i].table; 641 } else if (efi_enabled(EFI_64BIT)) { 642 guid = &tbl64[i].guid; 643 table = tbl64[i].table; 644 645 if (IS_ENABLED(CONFIG_X86_32) && 646 tbl64[i].table > U32_MAX) { 647 pr_cont("\n"); 648 pr_err("Table located above 4GB, disabling EFI.\n"); 649 return -EINVAL; 650 } 651 } else { 652 guid = &tbl32[i].guid; 653 table = tbl32[i].table; 654 } 655 656 if (!match_config_table(guid, table, common_tables) && arch_tables) 657 match_config_table(guid, table, arch_tables); 658 } 659 pr_cont("\n"); 660 set_bit(EFI_CONFIG_TABLES, &efi.flags); 661 662 if (efi_rng_seed != EFI_INVALID_TABLE_ADDR) { 663 struct linux_efi_random_seed *seed; 664 u32 size = 0; 665 666 seed = early_memremap(efi_rng_seed, sizeof(*seed)); 667 if (seed != NULL) { 668 size = min_t(u32, seed->size, SZ_1K); // sanity check 669 early_memunmap(seed, sizeof(*seed)); 670 } else { 671 pr_err("Could not map UEFI random seed!\n"); 672 } 673 if (size > 0) { 674 seed = early_memremap(efi_rng_seed, 675 sizeof(*seed) + size); 676 if (seed != NULL) { 677 add_bootloader_randomness(seed->bits, size); 678 memzero_explicit(seed->bits, size); 679 early_memunmap(seed, sizeof(*seed) + size); 680 } else { 681 pr_err("Could not map UEFI random seed!\n"); 682 } 683 } 684 } 685 686 if (!IS_ENABLED(CONFIG_X86_32) && efi_enabled(EFI_MEMMAP)) 687 efi_memattr_init(); 688 689 efi_tpm_eventlog_init(); 690 691 if (mem_reserve != EFI_INVALID_TABLE_ADDR) { 692 unsigned long prsv = mem_reserve; 693 694 while (prsv) { 695 struct linux_efi_memreserve *rsv; 696 u8 *p; 697 698 /* 699 * Just map a full page: that is what we will get 700 * anyway, and it permits us to map the entire entry 701 * before knowing its size. 702 */ 703 p = early_memremap(ALIGN_DOWN(prsv, PAGE_SIZE), 704 PAGE_SIZE); 705 if (p == NULL) { 706 pr_err("Could not map UEFI memreserve entry!\n"); 707 return -ENOMEM; 708 } 709 710 rsv = (void *)(p + prsv % PAGE_SIZE); 711 712 /* reserve the entry itself */ 713 memblock_reserve(prsv, 714 struct_size(rsv, entry, rsv->size)); 715 716 for (i = 0; i < atomic_read(&rsv->count); i++) { 717 memblock_reserve(rsv->entry[i].base, 718 rsv->entry[i].size); 719 } 720 721 prsv = rsv->next; 722 early_memunmap(p, PAGE_SIZE); 723 } 724 } 725 726 if (rt_prop != EFI_INVALID_TABLE_ADDR) { 727 efi_rt_properties_table_t *tbl; 728 729 tbl = early_memremap(rt_prop, sizeof(*tbl)); 730 if (tbl) { 731 efi.runtime_supported_mask &= tbl->runtime_services_supported; 732 early_memunmap(tbl, sizeof(*tbl)); 733 } 734 } 735 736 if (IS_ENABLED(CONFIG_BLK_DEV_INITRD) && 737 initrd != EFI_INVALID_TABLE_ADDR && phys_initrd_size == 0) { 738 struct linux_efi_initrd *tbl; 739 740 tbl = early_memremap(initrd, sizeof(*tbl)); 741 if (tbl) { 742 phys_initrd_start = tbl->base; 743 phys_initrd_size = tbl->size; 744 early_memunmap(tbl, sizeof(*tbl)); 745 } 746 } 747 748 if (IS_ENABLED(CONFIG_UNACCEPTED_MEMORY) && 749 efi.unaccepted != EFI_INVALID_TABLE_ADDR) { 750 struct efi_unaccepted_memory *unaccepted; 751 752 unaccepted = early_memremap(efi.unaccepted, sizeof(*unaccepted)); 753 if (unaccepted) { 754 unsigned long size; 755 756 if (unaccepted->version == 1) { 757 size = sizeof(*unaccepted) + unaccepted->size; 758 memblock_reserve(efi.unaccepted, size); 759 } else { 760 efi.unaccepted = EFI_INVALID_TABLE_ADDR; 761 } 762 763 early_memunmap(unaccepted, sizeof(*unaccepted)); 764 } 765 } 766 767 return 0; 768 } 769 770 int __init efi_systab_check_header(const efi_table_hdr_t *systab_hdr) 771 { 772 if (systab_hdr->signature != EFI_SYSTEM_TABLE_SIGNATURE) { 773 pr_err("System table signature incorrect!\n"); 774 return -EINVAL; 775 } 776 777 return 0; 778 } 779 780 #ifndef CONFIG_IA64 781 static const efi_char16_t *__init map_fw_vendor(unsigned long fw_vendor, 782 size_t size) 783 { 784 const efi_char16_t *ret; 785 786 ret = early_memremap_ro(fw_vendor, size); 787 if (!ret) 788 pr_err("Could not map the firmware vendor!\n"); 789 return ret; 790 } 791 792 static void __init unmap_fw_vendor(const void *fw_vendor, size_t size) 793 { 794 early_memunmap((void *)fw_vendor, size); 795 } 796 #else 797 #define map_fw_vendor(p, s) __va(p) 798 #define unmap_fw_vendor(v, s) 799 #endif 800 801 void __init efi_systab_report_header(const efi_table_hdr_t *systab_hdr, 802 unsigned long fw_vendor) 803 { 804 char vendor[100] = "unknown"; 805 const efi_char16_t *c16; 806 size_t i; 807 u16 rev; 808 809 c16 = map_fw_vendor(fw_vendor, sizeof(vendor) * sizeof(efi_char16_t)); 810 if (c16) { 811 for (i = 0; i < sizeof(vendor) - 1 && c16[i]; ++i) 812 vendor[i] = c16[i]; 813 vendor[i] = '\0'; 814 815 unmap_fw_vendor(c16, sizeof(vendor) * sizeof(efi_char16_t)); 816 } 817 818 rev = (u16)systab_hdr->revision; 819 pr_info("EFI v%u.%u", systab_hdr->revision >> 16, rev / 10); 820 821 rev %= 10; 822 if (rev) 823 pr_cont(".%u", rev); 824 825 pr_cont(" by %s\n", vendor); 826 827 if (IS_ENABLED(CONFIG_X86_64) && 828 systab_hdr->revision > EFI_1_10_SYSTEM_TABLE_REVISION && 829 !strcmp(vendor, "Apple")) { 830 pr_info("Apple Mac detected, using EFI v1.10 runtime services only\n"); 831 efi.runtime_version = EFI_1_10_SYSTEM_TABLE_REVISION; 832 } 833 } 834 835 static __initdata char memory_type_name[][13] = { 836 "Reserved", 837 "Loader Code", 838 "Loader Data", 839 "Boot Code", 840 "Boot Data", 841 "Runtime Code", 842 "Runtime Data", 843 "Conventional", 844 "Unusable", 845 "ACPI Reclaim", 846 "ACPI Mem NVS", 847 "MMIO", 848 "MMIO Port", 849 "PAL Code", 850 "Persistent", 851 "Unaccepted", 852 }; 853 854 char * __init efi_md_typeattr_format(char *buf, size_t size, 855 const efi_memory_desc_t *md) 856 { 857 char *pos; 858 int type_len; 859 u64 attr; 860 861 pos = buf; 862 if (md->type >= ARRAY_SIZE(memory_type_name)) 863 type_len = snprintf(pos, size, "[type=%u", md->type); 864 else 865 type_len = snprintf(pos, size, "[%-*s", 866 (int)(sizeof(memory_type_name[0]) - 1), 867 memory_type_name[md->type]); 868 if (type_len >= size) 869 return buf; 870 871 pos += type_len; 872 size -= type_len; 873 874 attr = md->attribute; 875 if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT | 876 EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO | 877 EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP | 878 EFI_MEMORY_NV | EFI_MEMORY_SP | EFI_MEMORY_CPU_CRYPTO | 879 EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE)) 880 snprintf(pos, size, "|attr=0x%016llx]", 881 (unsigned long long)attr); 882 else 883 snprintf(pos, size, 884 "|%3s|%2s|%2s|%2s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]", 885 attr & EFI_MEMORY_RUNTIME ? "RUN" : "", 886 attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "", 887 attr & EFI_MEMORY_CPU_CRYPTO ? "CC" : "", 888 attr & EFI_MEMORY_SP ? "SP" : "", 889 attr & EFI_MEMORY_NV ? "NV" : "", 890 attr & EFI_MEMORY_XP ? "XP" : "", 891 attr & EFI_MEMORY_RP ? "RP" : "", 892 attr & EFI_MEMORY_WP ? "WP" : "", 893 attr & EFI_MEMORY_RO ? "RO" : "", 894 attr & EFI_MEMORY_UCE ? "UCE" : "", 895 attr & EFI_MEMORY_WB ? "WB" : "", 896 attr & EFI_MEMORY_WT ? "WT" : "", 897 attr & EFI_MEMORY_WC ? "WC" : "", 898 attr & EFI_MEMORY_UC ? "UC" : ""); 899 return buf; 900 } 901 902 /* 903 * IA64 has a funky EFI memory map that doesn't work the same way as 904 * other architectures. 905 */ 906 #ifndef CONFIG_IA64 907 /* 908 * efi_mem_attributes - lookup memmap attributes for physical address 909 * @phys_addr: the physical address to lookup 910 * 911 * Search in the EFI memory map for the region covering 912 * @phys_addr. Returns the EFI memory attributes if the region 913 * was found in the memory map, 0 otherwise. 914 */ 915 u64 efi_mem_attributes(unsigned long phys_addr) 916 { 917 efi_memory_desc_t *md; 918 919 if (!efi_enabled(EFI_MEMMAP)) 920 return 0; 921 922 for_each_efi_memory_desc(md) { 923 if ((md->phys_addr <= phys_addr) && 924 (phys_addr < (md->phys_addr + 925 (md->num_pages << EFI_PAGE_SHIFT)))) 926 return md->attribute; 927 } 928 return 0; 929 } 930 931 /* 932 * efi_mem_type - lookup memmap type for physical address 933 * @phys_addr: the physical address to lookup 934 * 935 * Search in the EFI memory map for the region covering @phys_addr. 936 * Returns the EFI memory type if the region was found in the memory 937 * map, -EINVAL otherwise. 938 */ 939 int efi_mem_type(unsigned long phys_addr) 940 { 941 const efi_memory_desc_t *md; 942 943 if (!efi_enabled(EFI_MEMMAP)) 944 return -ENOTSUPP; 945 946 for_each_efi_memory_desc(md) { 947 if ((md->phys_addr <= phys_addr) && 948 (phys_addr < (md->phys_addr + 949 (md->num_pages << EFI_PAGE_SHIFT)))) 950 return md->type; 951 } 952 return -EINVAL; 953 } 954 #endif 955 956 int efi_status_to_err(efi_status_t status) 957 { 958 int err; 959 960 switch (status) { 961 case EFI_SUCCESS: 962 err = 0; 963 break; 964 case EFI_INVALID_PARAMETER: 965 err = -EINVAL; 966 break; 967 case EFI_OUT_OF_RESOURCES: 968 err = -ENOSPC; 969 break; 970 case EFI_DEVICE_ERROR: 971 err = -EIO; 972 break; 973 case EFI_WRITE_PROTECTED: 974 err = -EROFS; 975 break; 976 case EFI_SECURITY_VIOLATION: 977 err = -EACCES; 978 break; 979 case EFI_NOT_FOUND: 980 err = -ENOENT; 981 break; 982 case EFI_ABORTED: 983 err = -EINTR; 984 break; 985 default: 986 err = -EINVAL; 987 } 988 989 return err; 990 } 991 EXPORT_SYMBOL_GPL(efi_status_to_err); 992 993 static DEFINE_SPINLOCK(efi_mem_reserve_persistent_lock); 994 static struct linux_efi_memreserve *efi_memreserve_root __ro_after_init; 995 996 static int __init efi_memreserve_map_root(void) 997 { 998 if (mem_reserve == EFI_INVALID_TABLE_ADDR) 999 return -ENODEV; 1000 1001 efi_memreserve_root = memremap(mem_reserve, 1002 sizeof(*efi_memreserve_root), 1003 MEMREMAP_WB); 1004 if (WARN_ON_ONCE(!efi_memreserve_root)) 1005 return -ENOMEM; 1006 return 0; 1007 } 1008 1009 static int efi_mem_reserve_iomem(phys_addr_t addr, u64 size) 1010 { 1011 struct resource *res, *parent; 1012 int ret; 1013 1014 res = kzalloc(sizeof(struct resource), GFP_ATOMIC); 1015 if (!res) 1016 return -ENOMEM; 1017 1018 res->name = "reserved"; 1019 res->flags = IORESOURCE_MEM; 1020 res->start = addr; 1021 res->end = addr + size - 1; 1022 1023 /* we expect a conflict with a 'System RAM' region */ 1024 parent = request_resource_conflict(&iomem_resource, res); 1025 ret = parent ? request_resource(parent, res) : 0; 1026 1027 /* 1028 * Given that efi_mem_reserve_iomem() can be called at any 1029 * time, only call memblock_reserve() if the architecture 1030 * keeps the infrastructure around. 1031 */ 1032 if (IS_ENABLED(CONFIG_ARCH_KEEP_MEMBLOCK) && !ret) 1033 memblock_reserve(addr, size); 1034 1035 return ret; 1036 } 1037 1038 int __ref efi_mem_reserve_persistent(phys_addr_t addr, u64 size) 1039 { 1040 struct linux_efi_memreserve *rsv; 1041 unsigned long prsv; 1042 int rc, index; 1043 1044 if (efi_memreserve_root == (void *)ULONG_MAX) 1045 return -ENODEV; 1046 1047 if (!efi_memreserve_root) { 1048 rc = efi_memreserve_map_root(); 1049 if (rc) 1050 return rc; 1051 } 1052 1053 /* first try to find a slot in an existing linked list entry */ 1054 for (prsv = efi_memreserve_root->next; prsv; ) { 1055 rsv = memremap(prsv, sizeof(*rsv), MEMREMAP_WB); 1056 if (!rsv) 1057 return -ENOMEM; 1058 index = atomic_fetch_add_unless(&rsv->count, 1, rsv->size); 1059 if (index < rsv->size) { 1060 rsv->entry[index].base = addr; 1061 rsv->entry[index].size = size; 1062 1063 memunmap(rsv); 1064 return efi_mem_reserve_iomem(addr, size); 1065 } 1066 prsv = rsv->next; 1067 memunmap(rsv); 1068 } 1069 1070 /* no slot found - allocate a new linked list entry */ 1071 rsv = (struct linux_efi_memreserve *)__get_free_page(GFP_ATOMIC); 1072 if (!rsv) 1073 return -ENOMEM; 1074 1075 rc = efi_mem_reserve_iomem(__pa(rsv), SZ_4K); 1076 if (rc) { 1077 free_page((unsigned long)rsv); 1078 return rc; 1079 } 1080 1081 /* 1082 * The memremap() call above assumes that a linux_efi_memreserve entry 1083 * never crosses a page boundary, so let's ensure that this remains true 1084 * even when kexec'ing a 4k pages kernel from a >4k pages kernel, by 1085 * using SZ_4K explicitly in the size calculation below. 1086 */ 1087 rsv->size = EFI_MEMRESERVE_COUNT(SZ_4K); 1088 atomic_set(&rsv->count, 1); 1089 rsv->entry[0].base = addr; 1090 rsv->entry[0].size = size; 1091 1092 spin_lock(&efi_mem_reserve_persistent_lock); 1093 rsv->next = efi_memreserve_root->next; 1094 efi_memreserve_root->next = __pa(rsv); 1095 spin_unlock(&efi_mem_reserve_persistent_lock); 1096 1097 return efi_mem_reserve_iomem(addr, size); 1098 } 1099 1100 static int __init efi_memreserve_root_init(void) 1101 { 1102 if (efi_memreserve_root) 1103 return 0; 1104 if (efi_memreserve_map_root()) 1105 efi_memreserve_root = (void *)ULONG_MAX; 1106 return 0; 1107 } 1108 early_initcall(efi_memreserve_root_init); 1109 1110 #ifdef CONFIG_KEXEC 1111 static int update_efi_random_seed(struct notifier_block *nb, 1112 unsigned long code, void *unused) 1113 { 1114 struct linux_efi_random_seed *seed; 1115 u32 size = 0; 1116 1117 if (!kexec_in_progress) 1118 return NOTIFY_DONE; 1119 1120 seed = memremap(efi_rng_seed, sizeof(*seed), MEMREMAP_WB); 1121 if (seed != NULL) { 1122 size = min(seed->size, EFI_RANDOM_SEED_SIZE); 1123 memunmap(seed); 1124 } else { 1125 pr_err("Could not map UEFI random seed!\n"); 1126 } 1127 if (size > 0) { 1128 seed = memremap(efi_rng_seed, sizeof(*seed) + size, 1129 MEMREMAP_WB); 1130 if (seed != NULL) { 1131 seed->size = size; 1132 get_random_bytes(seed->bits, seed->size); 1133 memunmap(seed); 1134 } else { 1135 pr_err("Could not map UEFI random seed!\n"); 1136 } 1137 } 1138 return NOTIFY_DONE; 1139 } 1140 1141 static struct notifier_block efi_random_seed_nb = { 1142 .notifier_call = update_efi_random_seed, 1143 }; 1144 1145 static int __init register_update_efi_random_seed(void) 1146 { 1147 if (efi_rng_seed == EFI_INVALID_TABLE_ADDR) 1148 return 0; 1149 return register_reboot_notifier(&efi_random_seed_nb); 1150 } 1151 late_initcall(register_update_efi_random_seed); 1152 #endif 1153