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