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