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/device.h> 21 #include <linux/efi.h> 22 #include <linux/of.h> 23 #include <linux/of_fdt.h> 24 #include <linux/io.h> 25 #include <linux/kexec.h> 26 #include <linux/platform_device.h> 27 #include <linux/random.h> 28 #include <linux/reboot.h> 29 #include <linux/slab.h> 30 #include <linux/acpi.h> 31 #include <linux/ucs2_string.h> 32 #include <linux/memblock.h> 33 #include <linux/security.h> 34 35 #include <asm/early_ioremap.h> 36 37 struct efi __read_mostly efi = { 38 .mps = EFI_INVALID_TABLE_ADDR, 39 .acpi = EFI_INVALID_TABLE_ADDR, 40 .acpi20 = EFI_INVALID_TABLE_ADDR, 41 .smbios = EFI_INVALID_TABLE_ADDR, 42 .smbios3 = EFI_INVALID_TABLE_ADDR, 43 .boot_info = EFI_INVALID_TABLE_ADDR, 44 .hcdp = EFI_INVALID_TABLE_ADDR, 45 .uga = EFI_INVALID_TABLE_ADDR, 46 .fw_vendor = EFI_INVALID_TABLE_ADDR, 47 .runtime = EFI_INVALID_TABLE_ADDR, 48 .config_table = EFI_INVALID_TABLE_ADDR, 49 .esrt = EFI_INVALID_TABLE_ADDR, 50 .properties_table = EFI_INVALID_TABLE_ADDR, 51 .mem_attr_table = EFI_INVALID_TABLE_ADDR, 52 .rng_seed = EFI_INVALID_TABLE_ADDR, 53 .tpm_log = EFI_INVALID_TABLE_ADDR, 54 .tpm_final_log = EFI_INVALID_TABLE_ADDR, 55 .mem_reserve = EFI_INVALID_TABLE_ADDR, 56 }; 57 EXPORT_SYMBOL(efi); 58 59 struct mm_struct efi_mm = { 60 .mm_rb = RB_ROOT, 61 .mm_users = ATOMIC_INIT(2), 62 .mm_count = ATOMIC_INIT(1), 63 .mmap_sem = __RWSEM_INITIALIZER(efi_mm.mmap_sem), 64 .page_table_lock = __SPIN_LOCK_UNLOCKED(efi_mm.page_table_lock), 65 .mmlist = LIST_HEAD_INIT(efi_mm.mmlist), 66 .cpu_bitmap = { [BITS_TO_LONGS(NR_CPUS)] = 0}, 67 }; 68 69 struct workqueue_struct *efi_rts_wq; 70 71 static bool disable_runtime; 72 static int __init setup_noefi(char *arg) 73 { 74 disable_runtime = true; 75 return 0; 76 } 77 early_param("noefi", setup_noefi); 78 79 bool efi_runtime_disabled(void) 80 { 81 return disable_runtime; 82 } 83 84 static int __init parse_efi_cmdline(char *str) 85 { 86 if (!str) { 87 pr_warn("need at least one option\n"); 88 return -EINVAL; 89 } 90 91 if (parse_option_str(str, "debug")) 92 set_bit(EFI_DBG, &efi.flags); 93 94 if (parse_option_str(str, "noruntime")) 95 disable_runtime = true; 96 97 return 0; 98 } 99 early_param("efi", parse_efi_cmdline); 100 101 struct kobject *efi_kobj; 102 103 /* 104 * Let's not leave out systab information that snuck into 105 * the efivars driver 106 * Note, do not add more fields in systab sysfs file as it breaks sysfs 107 * one value per file rule! 108 */ 109 static ssize_t systab_show(struct kobject *kobj, 110 struct kobj_attribute *attr, char *buf) 111 { 112 char *str = buf; 113 114 if (!kobj || !buf) 115 return -EINVAL; 116 117 if (efi.mps != EFI_INVALID_TABLE_ADDR) 118 str += sprintf(str, "MPS=0x%lx\n", efi.mps); 119 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR) 120 str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20); 121 if (efi.acpi != EFI_INVALID_TABLE_ADDR) 122 str += sprintf(str, "ACPI=0x%lx\n", efi.acpi); 123 /* 124 * If both SMBIOS and SMBIOS3 entry points are implemented, the 125 * SMBIOS3 entry point shall be preferred, so we list it first to 126 * let applications stop parsing after the first match. 127 */ 128 if (efi.smbios3 != EFI_INVALID_TABLE_ADDR) 129 str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3); 130 if (efi.smbios != EFI_INVALID_TABLE_ADDR) 131 str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios); 132 if (efi.hcdp != EFI_INVALID_TABLE_ADDR) 133 str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp); 134 if (efi.boot_info != EFI_INVALID_TABLE_ADDR) 135 str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info); 136 if (efi.uga != EFI_INVALID_TABLE_ADDR) 137 str += sprintf(str, "UGA=0x%lx\n", efi.uga); 138 139 return str - buf; 140 } 141 142 static struct kobj_attribute efi_attr_systab = __ATTR_RO_MODE(systab, 0400); 143 144 #define EFI_FIELD(var) efi.var 145 146 #define EFI_ATTR_SHOW(name) \ 147 static ssize_t name##_show(struct kobject *kobj, \ 148 struct kobj_attribute *attr, char *buf) \ 149 { \ 150 return sprintf(buf, "0x%lx\n", EFI_FIELD(name)); \ 151 } 152 153 EFI_ATTR_SHOW(fw_vendor); 154 EFI_ATTR_SHOW(runtime); 155 EFI_ATTR_SHOW(config_table); 156 157 static ssize_t fw_platform_size_show(struct kobject *kobj, 158 struct kobj_attribute *attr, char *buf) 159 { 160 return sprintf(buf, "%d\n", efi_enabled(EFI_64BIT) ? 64 : 32); 161 } 162 163 static struct kobj_attribute efi_attr_fw_vendor = __ATTR_RO(fw_vendor); 164 static struct kobj_attribute efi_attr_runtime = __ATTR_RO(runtime); 165 static struct kobj_attribute efi_attr_config_table = __ATTR_RO(config_table); 166 static struct kobj_attribute efi_attr_fw_platform_size = 167 __ATTR_RO(fw_platform_size); 168 169 static struct attribute *efi_subsys_attrs[] = { 170 &efi_attr_systab.attr, 171 &efi_attr_fw_vendor.attr, 172 &efi_attr_runtime.attr, 173 &efi_attr_config_table.attr, 174 &efi_attr_fw_platform_size.attr, 175 NULL, 176 }; 177 178 static umode_t efi_attr_is_visible(struct kobject *kobj, 179 struct attribute *attr, int n) 180 { 181 if (attr == &efi_attr_fw_vendor.attr) { 182 if (efi_enabled(EFI_PARAVIRT) || 183 efi.fw_vendor == EFI_INVALID_TABLE_ADDR) 184 return 0; 185 } else if (attr == &efi_attr_runtime.attr) { 186 if (efi.runtime == EFI_INVALID_TABLE_ADDR) 187 return 0; 188 } else if (attr == &efi_attr_config_table.attr) { 189 if (efi.config_table == EFI_INVALID_TABLE_ADDR) 190 return 0; 191 } 192 193 return attr->mode; 194 } 195 196 static const struct attribute_group efi_subsys_attr_group = { 197 .attrs = efi_subsys_attrs, 198 .is_visible = efi_attr_is_visible, 199 }; 200 201 static struct efivars generic_efivars; 202 static struct efivar_operations generic_ops; 203 204 static int generic_ops_register(void) 205 { 206 generic_ops.get_variable = efi.get_variable; 207 generic_ops.set_variable = efi.set_variable; 208 generic_ops.set_variable_nonblocking = efi.set_variable_nonblocking; 209 generic_ops.get_next_variable = efi.get_next_variable; 210 generic_ops.query_variable_store = efi_query_variable_store; 211 212 return efivars_register(&generic_efivars, &generic_ops, efi_kobj); 213 } 214 215 static void generic_ops_unregister(void) 216 { 217 efivars_unregister(&generic_efivars); 218 } 219 220 #if IS_ENABLED(CONFIG_ACPI) 221 #define EFIVAR_SSDT_NAME_MAX 16 222 static char efivar_ssdt[EFIVAR_SSDT_NAME_MAX] __initdata; 223 static int __init efivar_ssdt_setup(char *str) 224 { 225 int ret = security_locked_down(LOCKDOWN_ACPI_TABLES); 226 227 if (ret) 228 return ret; 229 230 if (strlen(str) < sizeof(efivar_ssdt)) 231 memcpy(efivar_ssdt, str, strlen(str)); 232 else 233 pr_warn("efivar_ssdt: name too long: %s\n", str); 234 return 0; 235 } 236 __setup("efivar_ssdt=", efivar_ssdt_setup); 237 238 static __init int efivar_ssdt_iter(efi_char16_t *name, efi_guid_t vendor, 239 unsigned long name_size, void *data) 240 { 241 struct efivar_entry *entry; 242 struct list_head *list = data; 243 char utf8_name[EFIVAR_SSDT_NAME_MAX]; 244 int limit = min_t(unsigned long, EFIVAR_SSDT_NAME_MAX, name_size); 245 246 ucs2_as_utf8(utf8_name, name, limit - 1); 247 if (strncmp(utf8_name, efivar_ssdt, limit) != 0) 248 return 0; 249 250 entry = kmalloc(sizeof(*entry), GFP_KERNEL); 251 if (!entry) 252 return 0; 253 254 memcpy(entry->var.VariableName, name, name_size); 255 memcpy(&entry->var.VendorGuid, &vendor, sizeof(efi_guid_t)); 256 257 efivar_entry_add(entry, list); 258 259 return 0; 260 } 261 262 static __init int efivar_ssdt_load(void) 263 { 264 LIST_HEAD(entries); 265 struct efivar_entry *entry, *aux; 266 unsigned long size; 267 void *data; 268 int ret; 269 270 ret = efivar_init(efivar_ssdt_iter, &entries, true, &entries); 271 272 list_for_each_entry_safe(entry, aux, &entries, list) { 273 pr_info("loading SSDT from variable %s-%pUl\n", efivar_ssdt, 274 &entry->var.VendorGuid); 275 276 list_del(&entry->list); 277 278 ret = efivar_entry_size(entry, &size); 279 if (ret) { 280 pr_err("failed to get var size\n"); 281 goto free_entry; 282 } 283 284 data = kmalloc(size, GFP_KERNEL); 285 if (!data) { 286 ret = -ENOMEM; 287 goto free_entry; 288 } 289 290 ret = efivar_entry_get(entry, NULL, &size, data); 291 if (ret) { 292 pr_err("failed to get var data\n"); 293 goto free_data; 294 } 295 296 ret = acpi_load_table(data); 297 if (ret) { 298 pr_err("failed to load table: %d\n", ret); 299 goto free_data; 300 } 301 302 goto free_entry; 303 304 free_data: 305 kfree(data); 306 307 free_entry: 308 kfree(entry); 309 } 310 311 return ret; 312 } 313 #else 314 static inline int efivar_ssdt_load(void) { return 0; } 315 #endif 316 317 /* 318 * We register the efi subsystem with the firmware subsystem and the 319 * efivars subsystem with the efi subsystem, if the system was booted with 320 * EFI. 321 */ 322 static int __init efisubsys_init(void) 323 { 324 int error; 325 326 if (!efi_enabled(EFI_BOOT)) 327 return 0; 328 329 /* 330 * Since we process only one efi_runtime_service() at a time, an 331 * ordered workqueue (which creates only one execution context) 332 * should suffice all our needs. 333 */ 334 efi_rts_wq = alloc_ordered_workqueue("efi_rts_wq", 0); 335 if (!efi_rts_wq) { 336 pr_err("Creating efi_rts_wq failed, EFI runtime services disabled.\n"); 337 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags); 338 return 0; 339 } 340 341 /* We register the efi directory at /sys/firmware/efi */ 342 efi_kobj = kobject_create_and_add("efi", firmware_kobj); 343 if (!efi_kobj) { 344 pr_err("efi: Firmware registration failed.\n"); 345 return -ENOMEM; 346 } 347 348 error = generic_ops_register(); 349 if (error) 350 goto err_put; 351 352 if (efi_enabled(EFI_RUNTIME_SERVICES)) 353 efivar_ssdt_load(); 354 355 error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group); 356 if (error) { 357 pr_err("efi: Sysfs attribute export failed with error %d.\n", 358 error); 359 goto err_unregister; 360 } 361 362 error = efi_runtime_map_init(efi_kobj); 363 if (error) 364 goto err_remove_group; 365 366 /* and the standard mountpoint for efivarfs */ 367 error = sysfs_create_mount_point(efi_kobj, "efivars"); 368 if (error) { 369 pr_err("efivars: Subsystem registration failed.\n"); 370 goto err_remove_group; 371 } 372 373 return 0; 374 375 err_remove_group: 376 sysfs_remove_group(efi_kobj, &efi_subsys_attr_group); 377 err_unregister: 378 generic_ops_unregister(); 379 err_put: 380 kobject_put(efi_kobj); 381 return error; 382 } 383 384 subsys_initcall(efisubsys_init); 385 386 /* 387 * Find the efi memory descriptor for a given physical address. Given a 388 * physical address, determine if it exists within an EFI Memory Map entry, 389 * and if so, populate the supplied memory descriptor with the appropriate 390 * data. 391 */ 392 int efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md) 393 { 394 efi_memory_desc_t *md; 395 396 if (!efi_enabled(EFI_MEMMAP)) { 397 pr_err_once("EFI_MEMMAP is not enabled.\n"); 398 return -EINVAL; 399 } 400 401 if (!out_md) { 402 pr_err_once("out_md is null.\n"); 403 return -EINVAL; 404 } 405 406 for_each_efi_memory_desc(md) { 407 u64 size; 408 u64 end; 409 410 size = md->num_pages << EFI_PAGE_SHIFT; 411 end = md->phys_addr + size; 412 if (phys_addr >= md->phys_addr && phys_addr < end) { 413 memcpy(out_md, md, sizeof(*out_md)); 414 return 0; 415 } 416 } 417 return -ENOENT; 418 } 419 420 /* 421 * Calculate the highest address of an efi memory descriptor. 422 */ 423 u64 __init efi_mem_desc_end(efi_memory_desc_t *md) 424 { 425 u64 size = md->num_pages << EFI_PAGE_SHIFT; 426 u64 end = md->phys_addr + size; 427 return end; 428 } 429 430 void __init __weak efi_arch_mem_reserve(phys_addr_t addr, u64 size) {} 431 432 /** 433 * efi_mem_reserve - Reserve an EFI memory region 434 * @addr: Physical address to reserve 435 * @size: Size of reservation 436 * 437 * Mark a region as reserved from general kernel allocation and 438 * prevent it being released by efi_free_boot_services(). 439 * 440 * This function should be called drivers once they've parsed EFI 441 * configuration tables to figure out where their data lives, e.g. 442 * efi_esrt_init(). 443 */ 444 void __init efi_mem_reserve(phys_addr_t addr, u64 size) 445 { 446 if (!memblock_is_region_reserved(addr, size)) 447 memblock_reserve(addr, size); 448 449 /* 450 * Some architectures (x86) reserve all boot services ranges 451 * until efi_free_boot_services() because of buggy firmware 452 * implementations. This means the above memblock_reserve() is 453 * superfluous on x86 and instead what it needs to do is 454 * ensure the @start, @size is not freed. 455 */ 456 efi_arch_mem_reserve(addr, size); 457 } 458 459 static __initdata efi_config_table_type_t common_tables[] = { 460 {ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20}, 461 {ACPI_TABLE_GUID, "ACPI", &efi.acpi}, 462 {HCDP_TABLE_GUID, "HCDP", &efi.hcdp}, 463 {MPS_TABLE_GUID, "MPS", &efi.mps}, 464 {SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios}, 465 {SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3}, 466 {UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga}, 467 {EFI_SYSTEM_RESOURCE_TABLE_GUID, "ESRT", &efi.esrt}, 468 {EFI_PROPERTIES_TABLE_GUID, "PROP", &efi.properties_table}, 469 {EFI_MEMORY_ATTRIBUTES_TABLE_GUID, "MEMATTR", &efi.mem_attr_table}, 470 {LINUX_EFI_RANDOM_SEED_TABLE_GUID, "RNG", &efi.rng_seed}, 471 {LINUX_EFI_TPM_EVENT_LOG_GUID, "TPMEventLog", &efi.tpm_log}, 472 {LINUX_EFI_TPM_FINAL_LOG_GUID, "TPMFinalLog", &efi.tpm_final_log}, 473 {LINUX_EFI_MEMRESERVE_TABLE_GUID, "MEMRESERVE", &efi.mem_reserve}, 474 #ifdef CONFIG_EFI_RCI2_TABLE 475 {DELLEMC_EFI_RCI2_TABLE_GUID, NULL, &rci2_table_phys}, 476 #endif 477 {NULL_GUID, NULL, NULL}, 478 }; 479 480 static __init int match_config_table(efi_guid_t *guid, 481 unsigned long table, 482 efi_config_table_type_t *table_types) 483 { 484 int i; 485 486 if (table_types) { 487 for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) { 488 if (!efi_guidcmp(*guid, table_types[i].guid)) { 489 *(table_types[i].ptr) = table; 490 if (table_types[i].name) 491 pr_cont(" %s=0x%lx ", 492 table_types[i].name, table); 493 return 1; 494 } 495 } 496 } 497 498 return 0; 499 } 500 501 int __init efi_config_parse_tables(void *config_tables, int count, int sz, 502 efi_config_table_type_t *arch_tables) 503 { 504 void *tablep; 505 int i; 506 507 tablep = config_tables; 508 pr_info(""); 509 for (i = 0; i < count; i++) { 510 efi_guid_t guid; 511 unsigned long table; 512 513 if (efi_enabled(EFI_64BIT)) { 514 u64 table64; 515 guid = ((efi_config_table_64_t *)tablep)->guid; 516 table64 = ((efi_config_table_64_t *)tablep)->table; 517 table = table64; 518 #ifndef CONFIG_64BIT 519 if (table64 >> 32) { 520 pr_cont("\n"); 521 pr_err("Table located above 4GB, disabling EFI.\n"); 522 return -EINVAL; 523 } 524 #endif 525 } else { 526 guid = ((efi_config_table_32_t *)tablep)->guid; 527 table = ((efi_config_table_32_t *)tablep)->table; 528 } 529 530 if (!match_config_table(&guid, table, common_tables)) 531 match_config_table(&guid, table, arch_tables); 532 533 tablep += sz; 534 } 535 pr_cont("\n"); 536 set_bit(EFI_CONFIG_TABLES, &efi.flags); 537 538 if (efi.rng_seed != EFI_INVALID_TABLE_ADDR) { 539 struct linux_efi_random_seed *seed; 540 u32 size = 0; 541 542 seed = early_memremap(efi.rng_seed, sizeof(*seed)); 543 if (seed != NULL) { 544 size = seed->size; 545 early_memunmap(seed, sizeof(*seed)); 546 } else { 547 pr_err("Could not map UEFI random seed!\n"); 548 } 549 if (size > 0) { 550 seed = early_memremap(efi.rng_seed, 551 sizeof(*seed) + size); 552 if (seed != NULL) { 553 pr_notice("seeding entropy pool\n"); 554 add_device_randomness(seed->bits, seed->size); 555 early_memunmap(seed, sizeof(*seed) + size); 556 } else { 557 pr_err("Could not map UEFI random seed!\n"); 558 } 559 } 560 } 561 562 if (efi_enabled(EFI_MEMMAP)) 563 efi_memattr_init(); 564 565 efi_tpm_eventlog_init(); 566 567 /* Parse the EFI Properties table if it exists */ 568 if (efi.properties_table != EFI_INVALID_TABLE_ADDR) { 569 efi_properties_table_t *tbl; 570 571 tbl = early_memremap(efi.properties_table, sizeof(*tbl)); 572 if (tbl == NULL) { 573 pr_err("Could not map Properties table!\n"); 574 return -ENOMEM; 575 } 576 577 if (tbl->memory_protection_attribute & 578 EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA) 579 set_bit(EFI_NX_PE_DATA, &efi.flags); 580 581 early_memunmap(tbl, sizeof(*tbl)); 582 } 583 584 if (efi.mem_reserve != EFI_INVALID_TABLE_ADDR) { 585 unsigned long prsv = efi.mem_reserve; 586 587 while (prsv) { 588 struct linux_efi_memreserve *rsv; 589 u8 *p; 590 int i; 591 592 /* 593 * Just map a full page: that is what we will get 594 * anyway, and it permits us to map the entire entry 595 * before knowing its size. 596 */ 597 p = early_memremap(ALIGN_DOWN(prsv, PAGE_SIZE), 598 PAGE_SIZE); 599 if (p == NULL) { 600 pr_err("Could not map UEFI memreserve entry!\n"); 601 return -ENOMEM; 602 } 603 604 rsv = (void *)(p + prsv % PAGE_SIZE); 605 606 /* reserve the entry itself */ 607 memblock_reserve(prsv, EFI_MEMRESERVE_SIZE(rsv->size)); 608 609 for (i = 0; i < atomic_read(&rsv->count); i++) { 610 memblock_reserve(rsv->entry[i].base, 611 rsv->entry[i].size); 612 } 613 614 prsv = rsv->next; 615 early_memunmap(p, PAGE_SIZE); 616 } 617 } 618 619 return 0; 620 } 621 622 int __init efi_config_init(efi_config_table_type_t *arch_tables) 623 { 624 void *config_tables; 625 int sz, ret; 626 627 if (efi.systab->nr_tables == 0) 628 return 0; 629 630 if (efi_enabled(EFI_64BIT)) 631 sz = sizeof(efi_config_table_64_t); 632 else 633 sz = sizeof(efi_config_table_32_t); 634 635 /* 636 * Let's see what config tables the firmware passed to us. 637 */ 638 config_tables = early_memremap(efi.systab->tables, 639 efi.systab->nr_tables * sz); 640 if (config_tables == NULL) { 641 pr_err("Could not map Configuration table!\n"); 642 return -ENOMEM; 643 } 644 645 ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz, 646 arch_tables); 647 648 early_memunmap(config_tables, efi.systab->nr_tables * sz); 649 return ret; 650 } 651 652 #ifdef CONFIG_EFI_VARS_MODULE 653 static int __init efi_load_efivars(void) 654 { 655 struct platform_device *pdev; 656 657 if (!efi_enabled(EFI_RUNTIME_SERVICES)) 658 return 0; 659 660 pdev = platform_device_register_simple("efivars", 0, NULL, 0); 661 return PTR_ERR_OR_ZERO(pdev); 662 } 663 device_initcall(efi_load_efivars); 664 #endif 665 666 #ifdef CONFIG_EFI_PARAMS_FROM_FDT 667 668 #define UEFI_PARAM(name, prop, field) \ 669 { \ 670 { name }, \ 671 { prop }, \ 672 offsetof(struct efi_fdt_params, field), \ 673 FIELD_SIZEOF(struct efi_fdt_params, field) \ 674 } 675 676 struct params { 677 const char name[32]; 678 const char propname[32]; 679 int offset; 680 int size; 681 }; 682 683 static __initdata struct params fdt_params[] = { 684 UEFI_PARAM("System Table", "linux,uefi-system-table", system_table), 685 UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap), 686 UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size), 687 UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size), 688 UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver) 689 }; 690 691 static __initdata struct params xen_fdt_params[] = { 692 UEFI_PARAM("System Table", "xen,uefi-system-table", system_table), 693 UEFI_PARAM("MemMap Address", "xen,uefi-mmap-start", mmap), 694 UEFI_PARAM("MemMap Size", "xen,uefi-mmap-size", mmap_size), 695 UEFI_PARAM("MemMap Desc. Size", "xen,uefi-mmap-desc-size", desc_size), 696 UEFI_PARAM("MemMap Desc. Version", "xen,uefi-mmap-desc-ver", desc_ver) 697 }; 698 699 #define EFI_FDT_PARAMS_SIZE ARRAY_SIZE(fdt_params) 700 701 static __initdata struct { 702 const char *uname; 703 const char *subnode; 704 struct params *params; 705 } dt_params[] = { 706 { "hypervisor", "uefi", xen_fdt_params }, 707 { "chosen", NULL, fdt_params }, 708 }; 709 710 struct param_info { 711 int found; 712 void *params; 713 const char *missing; 714 }; 715 716 static int __init __find_uefi_params(unsigned long node, 717 struct param_info *info, 718 struct params *params) 719 { 720 const void *prop; 721 void *dest; 722 u64 val; 723 int i, len; 724 725 for (i = 0; i < EFI_FDT_PARAMS_SIZE; i++) { 726 prop = of_get_flat_dt_prop(node, params[i].propname, &len); 727 if (!prop) { 728 info->missing = params[i].name; 729 return 0; 730 } 731 732 dest = info->params + params[i].offset; 733 info->found++; 734 735 val = of_read_number(prop, len / sizeof(u32)); 736 737 if (params[i].size == sizeof(u32)) 738 *(u32 *)dest = val; 739 else 740 *(u64 *)dest = val; 741 742 if (efi_enabled(EFI_DBG)) 743 pr_info(" %s: 0x%0*llx\n", params[i].name, 744 params[i].size * 2, val); 745 } 746 747 return 1; 748 } 749 750 static int __init fdt_find_uefi_params(unsigned long node, const char *uname, 751 int depth, void *data) 752 { 753 struct param_info *info = data; 754 int i; 755 756 for (i = 0; i < ARRAY_SIZE(dt_params); i++) { 757 const char *subnode = dt_params[i].subnode; 758 759 if (depth != 1 || strcmp(uname, dt_params[i].uname) != 0) { 760 info->missing = dt_params[i].params[0].name; 761 continue; 762 } 763 764 if (subnode) { 765 int err = of_get_flat_dt_subnode_by_name(node, subnode); 766 767 if (err < 0) 768 return 0; 769 770 node = err; 771 } 772 773 return __find_uefi_params(node, info, dt_params[i].params); 774 } 775 776 return 0; 777 } 778 779 int __init efi_get_fdt_params(struct efi_fdt_params *params) 780 { 781 struct param_info info; 782 int ret; 783 784 pr_info("Getting EFI parameters from FDT:\n"); 785 786 info.found = 0; 787 info.params = params; 788 789 ret = of_scan_flat_dt(fdt_find_uefi_params, &info); 790 if (!info.found) 791 pr_info("UEFI not found.\n"); 792 else if (!ret) 793 pr_err("Can't find '%s' in device tree!\n", 794 info.missing); 795 796 return ret; 797 } 798 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */ 799 800 static __initdata char memory_type_name[][20] = { 801 "Reserved", 802 "Loader Code", 803 "Loader Data", 804 "Boot Code", 805 "Boot Data", 806 "Runtime Code", 807 "Runtime Data", 808 "Conventional Memory", 809 "Unusable Memory", 810 "ACPI Reclaim Memory", 811 "ACPI Memory NVS", 812 "Memory Mapped I/O", 813 "MMIO Port Space", 814 "PAL Code", 815 "Persistent Memory", 816 }; 817 818 char * __init efi_md_typeattr_format(char *buf, size_t size, 819 const efi_memory_desc_t *md) 820 { 821 char *pos; 822 int type_len; 823 u64 attr; 824 825 pos = buf; 826 if (md->type >= ARRAY_SIZE(memory_type_name)) 827 type_len = snprintf(pos, size, "[type=%u", md->type); 828 else 829 type_len = snprintf(pos, size, "[%-*s", 830 (int)(sizeof(memory_type_name[0]) - 1), 831 memory_type_name[md->type]); 832 if (type_len >= size) 833 return buf; 834 835 pos += type_len; 836 size -= type_len; 837 838 attr = md->attribute; 839 if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT | 840 EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO | 841 EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP | 842 EFI_MEMORY_NV | 843 EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE)) 844 snprintf(pos, size, "|attr=0x%016llx]", 845 (unsigned long long)attr); 846 else 847 snprintf(pos, size, 848 "|%3s|%2s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]", 849 attr & EFI_MEMORY_RUNTIME ? "RUN" : "", 850 attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "", 851 attr & EFI_MEMORY_NV ? "NV" : "", 852 attr & EFI_MEMORY_XP ? "XP" : "", 853 attr & EFI_MEMORY_RP ? "RP" : "", 854 attr & EFI_MEMORY_WP ? "WP" : "", 855 attr & EFI_MEMORY_RO ? "RO" : "", 856 attr & EFI_MEMORY_UCE ? "UCE" : "", 857 attr & EFI_MEMORY_WB ? "WB" : "", 858 attr & EFI_MEMORY_WT ? "WT" : "", 859 attr & EFI_MEMORY_WC ? "WC" : "", 860 attr & EFI_MEMORY_UC ? "UC" : ""); 861 return buf; 862 } 863 864 /* 865 * IA64 has a funky EFI memory map that doesn't work the same way as 866 * other architectures. 867 */ 868 #ifndef CONFIG_IA64 869 /* 870 * efi_mem_attributes - lookup memmap attributes for physical address 871 * @phys_addr: the physical address to lookup 872 * 873 * Search in the EFI memory map for the region covering 874 * @phys_addr. Returns the EFI memory attributes if the region 875 * was found in the memory map, 0 otherwise. 876 */ 877 u64 efi_mem_attributes(unsigned long phys_addr) 878 { 879 efi_memory_desc_t *md; 880 881 if (!efi_enabled(EFI_MEMMAP)) 882 return 0; 883 884 for_each_efi_memory_desc(md) { 885 if ((md->phys_addr <= phys_addr) && 886 (phys_addr < (md->phys_addr + 887 (md->num_pages << EFI_PAGE_SHIFT)))) 888 return md->attribute; 889 } 890 return 0; 891 } 892 893 /* 894 * efi_mem_type - lookup memmap type for physical address 895 * @phys_addr: the physical address to lookup 896 * 897 * Search in the EFI memory map for the region covering @phys_addr. 898 * Returns the EFI memory type if the region was found in the memory 899 * map, EFI_RESERVED_TYPE (zero) otherwise. 900 */ 901 int efi_mem_type(unsigned long phys_addr) 902 { 903 const efi_memory_desc_t *md; 904 905 if (!efi_enabled(EFI_MEMMAP)) 906 return -ENOTSUPP; 907 908 for_each_efi_memory_desc(md) { 909 if ((md->phys_addr <= phys_addr) && 910 (phys_addr < (md->phys_addr + 911 (md->num_pages << EFI_PAGE_SHIFT)))) 912 return md->type; 913 } 914 return -EINVAL; 915 } 916 #endif 917 918 int efi_status_to_err(efi_status_t status) 919 { 920 int err; 921 922 switch (status) { 923 case EFI_SUCCESS: 924 err = 0; 925 break; 926 case EFI_INVALID_PARAMETER: 927 err = -EINVAL; 928 break; 929 case EFI_OUT_OF_RESOURCES: 930 err = -ENOSPC; 931 break; 932 case EFI_DEVICE_ERROR: 933 err = -EIO; 934 break; 935 case EFI_WRITE_PROTECTED: 936 err = -EROFS; 937 break; 938 case EFI_SECURITY_VIOLATION: 939 err = -EACCES; 940 break; 941 case EFI_NOT_FOUND: 942 err = -ENOENT; 943 break; 944 case EFI_ABORTED: 945 err = -EINTR; 946 break; 947 default: 948 err = -EINVAL; 949 } 950 951 return err; 952 } 953 954 static DEFINE_SPINLOCK(efi_mem_reserve_persistent_lock); 955 static struct linux_efi_memreserve *efi_memreserve_root __ro_after_init; 956 957 static int __init efi_memreserve_map_root(void) 958 { 959 if (efi.mem_reserve == EFI_INVALID_TABLE_ADDR) 960 return -ENODEV; 961 962 efi_memreserve_root = memremap(efi.mem_reserve, 963 sizeof(*efi_memreserve_root), 964 MEMREMAP_WB); 965 if (WARN_ON_ONCE(!efi_memreserve_root)) 966 return -ENOMEM; 967 return 0; 968 } 969 970 int __ref efi_mem_reserve_persistent(phys_addr_t addr, u64 size) 971 { 972 struct linux_efi_memreserve *rsv; 973 unsigned long prsv; 974 int rc, index; 975 976 if (efi_memreserve_root == (void *)ULONG_MAX) 977 return -ENODEV; 978 979 if (!efi_memreserve_root) { 980 rc = efi_memreserve_map_root(); 981 if (rc) 982 return rc; 983 } 984 985 /* first try to find a slot in an existing linked list entry */ 986 for (prsv = efi_memreserve_root->next; prsv; prsv = rsv->next) { 987 rsv = memremap(prsv, sizeof(*rsv), MEMREMAP_WB); 988 index = atomic_fetch_add_unless(&rsv->count, 1, rsv->size); 989 if (index < rsv->size) { 990 rsv->entry[index].base = addr; 991 rsv->entry[index].size = size; 992 993 memunmap(rsv); 994 return 0; 995 } 996 memunmap(rsv); 997 } 998 999 /* no slot found - allocate a new linked list entry */ 1000 rsv = (struct linux_efi_memreserve *)__get_free_page(GFP_ATOMIC); 1001 if (!rsv) 1002 return -ENOMEM; 1003 1004 /* 1005 * The memremap() call above assumes that a linux_efi_memreserve entry 1006 * never crosses a page boundary, so let's ensure that this remains true 1007 * even when kexec'ing a 4k pages kernel from a >4k pages kernel, by 1008 * using SZ_4K explicitly in the size calculation below. 1009 */ 1010 rsv->size = EFI_MEMRESERVE_COUNT(SZ_4K); 1011 atomic_set(&rsv->count, 1); 1012 rsv->entry[0].base = addr; 1013 rsv->entry[0].size = size; 1014 1015 spin_lock(&efi_mem_reserve_persistent_lock); 1016 rsv->next = efi_memreserve_root->next; 1017 efi_memreserve_root->next = __pa(rsv); 1018 spin_unlock(&efi_mem_reserve_persistent_lock); 1019 1020 return 0; 1021 } 1022 1023 static int __init efi_memreserve_root_init(void) 1024 { 1025 if (efi_memreserve_root) 1026 return 0; 1027 if (efi_memreserve_map_root()) 1028 efi_memreserve_root = (void *)ULONG_MAX; 1029 return 0; 1030 } 1031 early_initcall(efi_memreserve_root_init); 1032 1033 #ifdef CONFIG_KEXEC 1034 static int update_efi_random_seed(struct notifier_block *nb, 1035 unsigned long code, void *unused) 1036 { 1037 struct linux_efi_random_seed *seed; 1038 u32 size = 0; 1039 1040 if (!kexec_in_progress) 1041 return NOTIFY_DONE; 1042 1043 seed = memremap(efi.rng_seed, sizeof(*seed), MEMREMAP_WB); 1044 if (seed != NULL) { 1045 size = min(seed->size, EFI_RANDOM_SEED_SIZE); 1046 memunmap(seed); 1047 } else { 1048 pr_err("Could not map UEFI random seed!\n"); 1049 } 1050 if (size > 0) { 1051 seed = memremap(efi.rng_seed, sizeof(*seed) + size, 1052 MEMREMAP_WB); 1053 if (seed != NULL) { 1054 seed->size = size; 1055 get_random_bytes(seed->bits, seed->size); 1056 memunmap(seed); 1057 } else { 1058 pr_err("Could not map UEFI random seed!\n"); 1059 } 1060 } 1061 return NOTIFY_DONE; 1062 } 1063 1064 static struct notifier_block efi_random_seed_nb = { 1065 .notifier_call = update_efi_random_seed, 1066 }; 1067 1068 static int register_update_efi_random_seed(void) 1069 { 1070 if (efi.rng_seed == EFI_INVALID_TABLE_ADDR) 1071 return 0; 1072 return register_reboot_notifier(&efi_random_seed_nb); 1073 } 1074 late_initcall(register_update_efi_random_seed); 1075 #endif 1076