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 #ifdef CONFIG_EFI_RCI2_TABLE 469 {DELLEMC_EFI_RCI2_TABLE_GUID, NULL, &rci2_table_phys}, 470 #endif 471 {NULL_GUID, NULL, NULL}, 472 }; 473 474 static __init int match_config_table(efi_guid_t *guid, 475 unsigned long table, 476 efi_config_table_type_t *table_types) 477 { 478 int i; 479 480 if (table_types) { 481 for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) { 482 if (!efi_guidcmp(*guid, table_types[i].guid)) { 483 *(table_types[i].ptr) = table; 484 if (table_types[i].name) 485 pr_cont(" %s=0x%lx ", 486 table_types[i].name, table); 487 return 1; 488 } 489 } 490 } 491 492 return 0; 493 } 494 495 int __init efi_config_parse_tables(void *config_tables, int count, int sz, 496 efi_config_table_type_t *arch_tables) 497 { 498 void *tablep; 499 int i; 500 501 tablep = config_tables; 502 pr_info(""); 503 for (i = 0; i < count; i++) { 504 efi_guid_t guid; 505 unsigned long table; 506 507 if (efi_enabled(EFI_64BIT)) { 508 u64 table64; 509 guid = ((efi_config_table_64_t *)tablep)->guid; 510 table64 = ((efi_config_table_64_t *)tablep)->table; 511 table = table64; 512 #ifndef CONFIG_64BIT 513 if (table64 >> 32) { 514 pr_cont("\n"); 515 pr_err("Table located above 4GB, disabling EFI.\n"); 516 return -EINVAL; 517 } 518 #endif 519 } else { 520 guid = ((efi_config_table_32_t *)tablep)->guid; 521 table = ((efi_config_table_32_t *)tablep)->table; 522 } 523 524 if (!match_config_table(&guid, table, common_tables)) 525 match_config_table(&guid, table, arch_tables); 526 527 tablep += sz; 528 } 529 pr_cont("\n"); 530 set_bit(EFI_CONFIG_TABLES, &efi.flags); 531 532 if (efi.rng_seed != EFI_INVALID_TABLE_ADDR) { 533 struct linux_efi_random_seed *seed; 534 u32 size = 0; 535 536 seed = early_memremap(efi.rng_seed, sizeof(*seed)); 537 if (seed != NULL) { 538 size = seed->size; 539 early_memunmap(seed, sizeof(*seed)); 540 } else { 541 pr_err("Could not map UEFI random seed!\n"); 542 } 543 if (size > 0) { 544 seed = early_memremap(efi.rng_seed, 545 sizeof(*seed) + size); 546 if (seed != NULL) { 547 pr_notice("seeding entropy pool\n"); 548 add_device_randomness(seed->bits, seed->size); 549 early_memunmap(seed, sizeof(*seed) + size); 550 } else { 551 pr_err("Could not map UEFI random seed!\n"); 552 } 553 } 554 } 555 556 if (efi_enabled(EFI_MEMMAP)) 557 efi_memattr_init(); 558 559 efi_tpm_eventlog_init(); 560 561 /* Parse the EFI Properties table if it exists */ 562 if (efi.properties_table != EFI_INVALID_TABLE_ADDR) { 563 efi_properties_table_t *tbl; 564 565 tbl = early_memremap(efi.properties_table, sizeof(*tbl)); 566 if (tbl == NULL) { 567 pr_err("Could not map Properties table!\n"); 568 return -ENOMEM; 569 } 570 571 if (tbl->memory_protection_attribute & 572 EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA) 573 set_bit(EFI_NX_PE_DATA, &efi.flags); 574 575 early_memunmap(tbl, sizeof(*tbl)); 576 } 577 578 if (efi.mem_reserve != EFI_INVALID_TABLE_ADDR) { 579 unsigned long prsv = efi.mem_reserve; 580 581 while (prsv) { 582 struct linux_efi_memreserve *rsv; 583 u8 *p; 584 int i; 585 586 /* 587 * Just map a full page: that is what we will get 588 * anyway, and it permits us to map the entire entry 589 * before knowing its size. 590 */ 591 p = early_memremap(ALIGN_DOWN(prsv, PAGE_SIZE), 592 PAGE_SIZE); 593 if (p == NULL) { 594 pr_err("Could not map UEFI memreserve entry!\n"); 595 return -ENOMEM; 596 } 597 598 rsv = (void *)(p + prsv % PAGE_SIZE); 599 600 /* reserve the entry itself */ 601 memblock_reserve(prsv, EFI_MEMRESERVE_SIZE(rsv->size)); 602 603 for (i = 0; i < atomic_read(&rsv->count); i++) { 604 memblock_reserve(rsv->entry[i].base, 605 rsv->entry[i].size); 606 } 607 608 prsv = rsv->next; 609 early_memunmap(p, PAGE_SIZE); 610 } 611 } 612 613 return 0; 614 } 615 616 int __init efi_config_init(efi_config_table_type_t *arch_tables) 617 { 618 void *config_tables; 619 int sz, ret; 620 621 if (efi.systab->nr_tables == 0) 622 return 0; 623 624 if (efi_enabled(EFI_64BIT)) 625 sz = sizeof(efi_config_table_64_t); 626 else 627 sz = sizeof(efi_config_table_32_t); 628 629 /* 630 * Let's see what config tables the firmware passed to us. 631 */ 632 config_tables = early_memremap(efi.systab->tables, 633 efi.systab->nr_tables * sz); 634 if (config_tables == NULL) { 635 pr_err("Could not map Configuration table!\n"); 636 return -ENOMEM; 637 } 638 639 ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz, 640 arch_tables); 641 642 early_memunmap(config_tables, efi.systab->nr_tables * sz); 643 return ret; 644 } 645 646 #ifdef CONFIG_EFI_VARS_MODULE 647 static int __init efi_load_efivars(void) 648 { 649 struct platform_device *pdev; 650 651 if (!efi_enabled(EFI_RUNTIME_SERVICES)) 652 return 0; 653 654 pdev = platform_device_register_simple("efivars", 0, NULL, 0); 655 return PTR_ERR_OR_ZERO(pdev); 656 } 657 device_initcall(efi_load_efivars); 658 #endif 659 660 #ifdef CONFIG_EFI_PARAMS_FROM_FDT 661 662 #define UEFI_PARAM(name, prop, field) \ 663 { \ 664 { name }, \ 665 { prop }, \ 666 offsetof(struct efi_fdt_params, field), \ 667 FIELD_SIZEOF(struct efi_fdt_params, field) \ 668 } 669 670 struct params { 671 const char name[32]; 672 const char propname[32]; 673 int offset; 674 int size; 675 }; 676 677 static __initdata struct params fdt_params[] = { 678 UEFI_PARAM("System Table", "linux,uefi-system-table", system_table), 679 UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap), 680 UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size), 681 UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size), 682 UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver) 683 }; 684 685 static __initdata struct params xen_fdt_params[] = { 686 UEFI_PARAM("System Table", "xen,uefi-system-table", system_table), 687 UEFI_PARAM("MemMap Address", "xen,uefi-mmap-start", mmap), 688 UEFI_PARAM("MemMap Size", "xen,uefi-mmap-size", mmap_size), 689 UEFI_PARAM("MemMap Desc. Size", "xen,uefi-mmap-desc-size", desc_size), 690 UEFI_PARAM("MemMap Desc. Version", "xen,uefi-mmap-desc-ver", desc_ver) 691 }; 692 693 #define EFI_FDT_PARAMS_SIZE ARRAY_SIZE(fdt_params) 694 695 static __initdata struct { 696 const char *uname; 697 const char *subnode; 698 struct params *params; 699 } dt_params[] = { 700 { "hypervisor", "uefi", xen_fdt_params }, 701 { "chosen", NULL, fdt_params }, 702 }; 703 704 struct param_info { 705 int found; 706 void *params; 707 const char *missing; 708 }; 709 710 static int __init __find_uefi_params(unsigned long node, 711 struct param_info *info, 712 struct params *params) 713 { 714 const void *prop; 715 void *dest; 716 u64 val; 717 int i, len; 718 719 for (i = 0; i < EFI_FDT_PARAMS_SIZE; i++) { 720 prop = of_get_flat_dt_prop(node, params[i].propname, &len); 721 if (!prop) { 722 info->missing = params[i].name; 723 return 0; 724 } 725 726 dest = info->params + params[i].offset; 727 info->found++; 728 729 val = of_read_number(prop, len / sizeof(u32)); 730 731 if (params[i].size == sizeof(u32)) 732 *(u32 *)dest = val; 733 else 734 *(u64 *)dest = val; 735 736 if (efi_enabled(EFI_DBG)) 737 pr_info(" %s: 0x%0*llx\n", params[i].name, 738 params[i].size * 2, val); 739 } 740 741 return 1; 742 } 743 744 static int __init fdt_find_uefi_params(unsigned long node, const char *uname, 745 int depth, void *data) 746 { 747 struct param_info *info = data; 748 int i; 749 750 for (i = 0; i < ARRAY_SIZE(dt_params); i++) { 751 const char *subnode = dt_params[i].subnode; 752 753 if (depth != 1 || strcmp(uname, dt_params[i].uname) != 0) { 754 info->missing = dt_params[i].params[0].name; 755 continue; 756 } 757 758 if (subnode) { 759 int err = of_get_flat_dt_subnode_by_name(node, subnode); 760 761 if (err < 0) 762 return 0; 763 764 node = err; 765 } 766 767 return __find_uefi_params(node, info, dt_params[i].params); 768 } 769 770 return 0; 771 } 772 773 int __init efi_get_fdt_params(struct efi_fdt_params *params) 774 { 775 struct param_info info; 776 int ret; 777 778 pr_info("Getting EFI parameters from FDT:\n"); 779 780 info.found = 0; 781 info.params = params; 782 783 ret = of_scan_flat_dt(fdt_find_uefi_params, &info); 784 if (!info.found) 785 pr_info("UEFI not found.\n"); 786 else if (!ret) 787 pr_err("Can't find '%s' in device tree!\n", 788 info.missing); 789 790 return ret; 791 } 792 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */ 793 794 static __initdata char memory_type_name[][20] = { 795 "Reserved", 796 "Loader Code", 797 "Loader Data", 798 "Boot Code", 799 "Boot Data", 800 "Runtime Code", 801 "Runtime Data", 802 "Conventional Memory", 803 "Unusable Memory", 804 "ACPI Reclaim Memory", 805 "ACPI Memory NVS", 806 "Memory Mapped I/O", 807 "MMIO Port Space", 808 "PAL Code", 809 "Persistent Memory", 810 }; 811 812 char * __init efi_md_typeattr_format(char *buf, size_t size, 813 const efi_memory_desc_t *md) 814 { 815 char *pos; 816 int type_len; 817 u64 attr; 818 819 pos = buf; 820 if (md->type >= ARRAY_SIZE(memory_type_name)) 821 type_len = snprintf(pos, size, "[type=%u", md->type); 822 else 823 type_len = snprintf(pos, size, "[%-*s", 824 (int)(sizeof(memory_type_name[0]) - 1), 825 memory_type_name[md->type]); 826 if (type_len >= size) 827 return buf; 828 829 pos += type_len; 830 size -= type_len; 831 832 attr = md->attribute; 833 if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT | 834 EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO | 835 EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP | 836 EFI_MEMORY_NV | 837 EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE)) 838 snprintf(pos, size, "|attr=0x%016llx]", 839 (unsigned long long)attr); 840 else 841 snprintf(pos, size, 842 "|%3s|%2s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]", 843 attr & EFI_MEMORY_RUNTIME ? "RUN" : "", 844 attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "", 845 attr & EFI_MEMORY_NV ? "NV" : "", 846 attr & EFI_MEMORY_XP ? "XP" : "", 847 attr & EFI_MEMORY_RP ? "RP" : "", 848 attr & EFI_MEMORY_WP ? "WP" : "", 849 attr & EFI_MEMORY_RO ? "RO" : "", 850 attr & EFI_MEMORY_UCE ? "UCE" : "", 851 attr & EFI_MEMORY_WB ? "WB" : "", 852 attr & EFI_MEMORY_WT ? "WT" : "", 853 attr & EFI_MEMORY_WC ? "WC" : "", 854 attr & EFI_MEMORY_UC ? "UC" : ""); 855 return buf; 856 } 857 858 /* 859 * IA64 has a funky EFI memory map that doesn't work the same way as 860 * other architectures. 861 */ 862 #ifndef CONFIG_IA64 863 /* 864 * efi_mem_attributes - lookup memmap attributes for physical address 865 * @phys_addr: the physical address to lookup 866 * 867 * Search in the EFI memory map for the region covering 868 * @phys_addr. Returns the EFI memory attributes if the region 869 * was found in the memory map, 0 otherwise. 870 */ 871 u64 efi_mem_attributes(unsigned long phys_addr) 872 { 873 efi_memory_desc_t *md; 874 875 if (!efi_enabled(EFI_MEMMAP)) 876 return 0; 877 878 for_each_efi_memory_desc(md) { 879 if ((md->phys_addr <= phys_addr) && 880 (phys_addr < (md->phys_addr + 881 (md->num_pages << EFI_PAGE_SHIFT)))) 882 return md->attribute; 883 } 884 return 0; 885 } 886 887 /* 888 * efi_mem_type - lookup memmap type for physical address 889 * @phys_addr: the physical address to lookup 890 * 891 * Search in the EFI memory map for the region covering @phys_addr. 892 * Returns the EFI memory type if the region was found in the memory 893 * map, EFI_RESERVED_TYPE (zero) otherwise. 894 */ 895 int efi_mem_type(unsigned long phys_addr) 896 { 897 const efi_memory_desc_t *md; 898 899 if (!efi_enabled(EFI_MEMMAP)) 900 return -ENOTSUPP; 901 902 for_each_efi_memory_desc(md) { 903 if ((md->phys_addr <= phys_addr) && 904 (phys_addr < (md->phys_addr + 905 (md->num_pages << EFI_PAGE_SHIFT)))) 906 return md->type; 907 } 908 return -EINVAL; 909 } 910 #endif 911 912 int efi_status_to_err(efi_status_t status) 913 { 914 int err; 915 916 switch (status) { 917 case EFI_SUCCESS: 918 err = 0; 919 break; 920 case EFI_INVALID_PARAMETER: 921 err = -EINVAL; 922 break; 923 case EFI_OUT_OF_RESOURCES: 924 err = -ENOSPC; 925 break; 926 case EFI_DEVICE_ERROR: 927 err = -EIO; 928 break; 929 case EFI_WRITE_PROTECTED: 930 err = -EROFS; 931 break; 932 case EFI_SECURITY_VIOLATION: 933 err = -EACCES; 934 break; 935 case EFI_NOT_FOUND: 936 err = -ENOENT; 937 break; 938 case EFI_ABORTED: 939 err = -EINTR; 940 break; 941 default: 942 err = -EINVAL; 943 } 944 945 return err; 946 } 947 948 static DEFINE_SPINLOCK(efi_mem_reserve_persistent_lock); 949 static struct linux_efi_memreserve *efi_memreserve_root __ro_after_init; 950 951 static int __init efi_memreserve_map_root(void) 952 { 953 if (efi.mem_reserve == EFI_INVALID_TABLE_ADDR) 954 return -ENODEV; 955 956 efi_memreserve_root = memremap(efi.mem_reserve, 957 sizeof(*efi_memreserve_root), 958 MEMREMAP_WB); 959 if (WARN_ON_ONCE(!efi_memreserve_root)) 960 return -ENOMEM; 961 return 0; 962 } 963 964 int __ref efi_mem_reserve_persistent(phys_addr_t addr, u64 size) 965 { 966 struct linux_efi_memreserve *rsv; 967 unsigned long prsv; 968 int rc, index; 969 970 if (efi_memreserve_root == (void *)ULONG_MAX) 971 return -ENODEV; 972 973 if (!efi_memreserve_root) { 974 rc = efi_memreserve_map_root(); 975 if (rc) 976 return rc; 977 } 978 979 /* first try to find a slot in an existing linked list entry */ 980 for (prsv = efi_memreserve_root->next; prsv; prsv = rsv->next) { 981 rsv = memremap(prsv, sizeof(*rsv), MEMREMAP_WB); 982 index = atomic_fetch_add_unless(&rsv->count, 1, rsv->size); 983 if (index < rsv->size) { 984 rsv->entry[index].base = addr; 985 rsv->entry[index].size = size; 986 987 memunmap(rsv); 988 return 0; 989 } 990 memunmap(rsv); 991 } 992 993 /* no slot found - allocate a new linked list entry */ 994 rsv = (struct linux_efi_memreserve *)__get_free_page(GFP_ATOMIC); 995 if (!rsv) 996 return -ENOMEM; 997 998 /* 999 * The memremap() call above assumes that a linux_efi_memreserve entry 1000 * never crosses a page boundary, so let's ensure that this remains true 1001 * even when kexec'ing a 4k pages kernel from a >4k pages kernel, by 1002 * using SZ_4K explicitly in the size calculation below. 1003 */ 1004 rsv->size = EFI_MEMRESERVE_COUNT(SZ_4K); 1005 atomic_set(&rsv->count, 1); 1006 rsv->entry[0].base = addr; 1007 rsv->entry[0].size = size; 1008 1009 spin_lock(&efi_mem_reserve_persistent_lock); 1010 rsv->next = efi_memreserve_root->next; 1011 efi_memreserve_root->next = __pa(rsv); 1012 spin_unlock(&efi_mem_reserve_persistent_lock); 1013 1014 return 0; 1015 } 1016 1017 static int __init efi_memreserve_root_init(void) 1018 { 1019 if (efi_memreserve_root) 1020 return 0; 1021 if (efi_memreserve_map_root()) 1022 efi_memreserve_root = (void *)ULONG_MAX; 1023 return 0; 1024 } 1025 early_initcall(efi_memreserve_root_init); 1026 1027 #ifdef CONFIG_KEXEC 1028 static int update_efi_random_seed(struct notifier_block *nb, 1029 unsigned long code, void *unused) 1030 { 1031 struct linux_efi_random_seed *seed; 1032 u32 size = 0; 1033 1034 if (!kexec_in_progress) 1035 return NOTIFY_DONE; 1036 1037 seed = memremap(efi.rng_seed, sizeof(*seed), MEMREMAP_WB); 1038 if (seed != NULL) { 1039 size = min(seed->size, EFI_RANDOM_SEED_SIZE); 1040 memunmap(seed); 1041 } else { 1042 pr_err("Could not map UEFI random seed!\n"); 1043 } 1044 if (size > 0) { 1045 seed = memremap(efi.rng_seed, sizeof(*seed) + size, 1046 MEMREMAP_WB); 1047 if (seed != NULL) { 1048 seed->size = size; 1049 get_random_bytes(seed->bits, seed->size); 1050 memunmap(seed); 1051 } else { 1052 pr_err("Could not map UEFI random seed!\n"); 1053 } 1054 } 1055 return NOTIFY_DONE; 1056 } 1057 1058 static struct notifier_block efi_random_seed_nb = { 1059 .notifier_call = update_efi_random_seed, 1060 }; 1061 1062 static int register_update_efi_random_seed(void) 1063 { 1064 if (efi.rng_seed == EFI_INVALID_TABLE_ADDR) 1065 return 0; 1066 return register_reboot_notifier(&efi_random_seed_nb); 1067 } 1068 late_initcall(register_update_efi_random_seed); 1069 #endif 1070