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 bool __pure __efi_soft_reserve_enabled(void) 85 { 86 return !efi_enabled(EFI_MEM_NO_SOFT_RESERVE); 87 } 88 89 static int __init parse_efi_cmdline(char *str) 90 { 91 if (!str) { 92 pr_warn("need at least one option\n"); 93 return -EINVAL; 94 } 95 96 if (parse_option_str(str, "debug")) 97 set_bit(EFI_DBG, &efi.flags); 98 99 if (parse_option_str(str, "noruntime")) 100 disable_runtime = true; 101 102 if (parse_option_str(str, "nosoftreserve")) 103 set_bit(EFI_MEM_NO_SOFT_RESERVE, &efi.flags); 104 105 return 0; 106 } 107 early_param("efi", parse_efi_cmdline); 108 109 struct kobject *efi_kobj; 110 111 /* 112 * Let's not leave out systab information that snuck into 113 * the efivars driver 114 * Note, do not add more fields in systab sysfs file as it breaks sysfs 115 * one value per file rule! 116 */ 117 static ssize_t systab_show(struct kobject *kobj, 118 struct kobj_attribute *attr, char *buf) 119 { 120 char *str = buf; 121 122 if (!kobj || !buf) 123 return -EINVAL; 124 125 if (efi.mps != EFI_INVALID_TABLE_ADDR) 126 str += sprintf(str, "MPS=0x%lx\n", efi.mps); 127 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR) 128 str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20); 129 if (efi.acpi != EFI_INVALID_TABLE_ADDR) 130 str += sprintf(str, "ACPI=0x%lx\n", efi.acpi); 131 /* 132 * If both SMBIOS and SMBIOS3 entry points are implemented, the 133 * SMBIOS3 entry point shall be preferred, so we list it first to 134 * let applications stop parsing after the first match. 135 */ 136 if (efi.smbios3 != EFI_INVALID_TABLE_ADDR) 137 str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3); 138 if (efi.smbios != EFI_INVALID_TABLE_ADDR) 139 str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios); 140 if (efi.hcdp != EFI_INVALID_TABLE_ADDR) 141 str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp); 142 if (efi.boot_info != EFI_INVALID_TABLE_ADDR) 143 str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info); 144 if (efi.uga != EFI_INVALID_TABLE_ADDR) 145 str += sprintf(str, "UGA=0x%lx\n", efi.uga); 146 147 return str - buf; 148 } 149 150 static struct kobj_attribute efi_attr_systab = __ATTR_RO_MODE(systab, 0400); 151 152 #define EFI_FIELD(var) efi.var 153 154 #define EFI_ATTR_SHOW(name) \ 155 static ssize_t name##_show(struct kobject *kobj, \ 156 struct kobj_attribute *attr, char *buf) \ 157 { \ 158 return sprintf(buf, "0x%lx\n", EFI_FIELD(name)); \ 159 } 160 161 EFI_ATTR_SHOW(fw_vendor); 162 EFI_ATTR_SHOW(runtime); 163 EFI_ATTR_SHOW(config_table); 164 165 static ssize_t fw_platform_size_show(struct kobject *kobj, 166 struct kobj_attribute *attr, char *buf) 167 { 168 return sprintf(buf, "%d\n", efi_enabled(EFI_64BIT) ? 64 : 32); 169 } 170 171 static struct kobj_attribute efi_attr_fw_vendor = __ATTR_RO(fw_vendor); 172 static struct kobj_attribute efi_attr_runtime = __ATTR_RO(runtime); 173 static struct kobj_attribute efi_attr_config_table = __ATTR_RO(config_table); 174 static struct kobj_attribute efi_attr_fw_platform_size = 175 __ATTR_RO(fw_platform_size); 176 177 static struct attribute *efi_subsys_attrs[] = { 178 &efi_attr_systab.attr, 179 &efi_attr_fw_vendor.attr, 180 &efi_attr_runtime.attr, 181 &efi_attr_config_table.attr, 182 &efi_attr_fw_platform_size.attr, 183 NULL, 184 }; 185 186 static umode_t efi_attr_is_visible(struct kobject *kobj, 187 struct attribute *attr, int n) 188 { 189 if (attr == &efi_attr_fw_vendor.attr) { 190 if (efi_enabled(EFI_PARAVIRT) || 191 efi.fw_vendor == EFI_INVALID_TABLE_ADDR) 192 return 0; 193 } else if (attr == &efi_attr_runtime.attr) { 194 if (efi.runtime == EFI_INVALID_TABLE_ADDR) 195 return 0; 196 } else if (attr == &efi_attr_config_table.attr) { 197 if (efi.config_table == EFI_INVALID_TABLE_ADDR) 198 return 0; 199 } 200 201 return attr->mode; 202 } 203 204 static const struct attribute_group efi_subsys_attr_group = { 205 .attrs = efi_subsys_attrs, 206 .is_visible = efi_attr_is_visible, 207 }; 208 209 static struct efivars generic_efivars; 210 static struct efivar_operations generic_ops; 211 212 static int generic_ops_register(void) 213 { 214 generic_ops.get_variable = efi.get_variable; 215 generic_ops.set_variable = efi.set_variable; 216 generic_ops.set_variable_nonblocking = efi.set_variable_nonblocking; 217 generic_ops.get_next_variable = efi.get_next_variable; 218 generic_ops.query_variable_store = efi_query_variable_store; 219 220 return efivars_register(&generic_efivars, &generic_ops, efi_kobj); 221 } 222 223 static void generic_ops_unregister(void) 224 { 225 efivars_unregister(&generic_efivars); 226 } 227 228 #if IS_ENABLED(CONFIG_ACPI) 229 #define EFIVAR_SSDT_NAME_MAX 16 230 static char efivar_ssdt[EFIVAR_SSDT_NAME_MAX] __initdata; 231 static int __init efivar_ssdt_setup(char *str) 232 { 233 int ret = security_locked_down(LOCKDOWN_ACPI_TABLES); 234 235 if (ret) 236 return ret; 237 238 if (strlen(str) < sizeof(efivar_ssdt)) 239 memcpy(efivar_ssdt, str, strlen(str)); 240 else 241 pr_warn("efivar_ssdt: name too long: %s\n", str); 242 return 0; 243 } 244 __setup("efivar_ssdt=", efivar_ssdt_setup); 245 246 static __init int efivar_ssdt_iter(efi_char16_t *name, efi_guid_t vendor, 247 unsigned long name_size, void *data) 248 { 249 struct efivar_entry *entry; 250 struct list_head *list = data; 251 char utf8_name[EFIVAR_SSDT_NAME_MAX]; 252 int limit = min_t(unsigned long, EFIVAR_SSDT_NAME_MAX, name_size); 253 254 ucs2_as_utf8(utf8_name, name, limit - 1); 255 if (strncmp(utf8_name, efivar_ssdt, limit) != 0) 256 return 0; 257 258 entry = kmalloc(sizeof(*entry), GFP_KERNEL); 259 if (!entry) 260 return 0; 261 262 memcpy(entry->var.VariableName, name, name_size); 263 memcpy(&entry->var.VendorGuid, &vendor, sizeof(efi_guid_t)); 264 265 efivar_entry_add(entry, list); 266 267 return 0; 268 } 269 270 static __init int efivar_ssdt_load(void) 271 { 272 LIST_HEAD(entries); 273 struct efivar_entry *entry, *aux; 274 unsigned long size; 275 void *data; 276 int ret; 277 278 if (!efivar_ssdt[0]) 279 return 0; 280 281 ret = efivar_init(efivar_ssdt_iter, &entries, true, &entries); 282 283 list_for_each_entry_safe(entry, aux, &entries, list) { 284 pr_info("loading SSDT from variable %s-%pUl\n", efivar_ssdt, 285 &entry->var.VendorGuid); 286 287 list_del(&entry->list); 288 289 ret = efivar_entry_size(entry, &size); 290 if (ret) { 291 pr_err("failed to get var size\n"); 292 goto free_entry; 293 } 294 295 data = kmalloc(size, GFP_KERNEL); 296 if (!data) { 297 ret = -ENOMEM; 298 goto free_entry; 299 } 300 301 ret = efivar_entry_get(entry, NULL, &size, data); 302 if (ret) { 303 pr_err("failed to get var data\n"); 304 goto free_data; 305 } 306 307 ret = acpi_load_table(data, NULL); 308 if (ret) { 309 pr_err("failed to load table: %d\n", ret); 310 goto free_data; 311 } 312 313 goto free_entry; 314 315 free_data: 316 kfree(data); 317 318 free_entry: 319 kfree(entry); 320 } 321 322 return ret; 323 } 324 #else 325 static inline int efivar_ssdt_load(void) { return 0; } 326 #endif 327 328 /* 329 * We register the efi subsystem with the firmware subsystem and the 330 * efivars subsystem with the efi subsystem, if the system was booted with 331 * EFI. 332 */ 333 static int __init efisubsys_init(void) 334 { 335 int error; 336 337 if (!efi_enabled(EFI_BOOT)) 338 return 0; 339 340 /* 341 * Since we process only one efi_runtime_service() at a time, an 342 * ordered workqueue (which creates only one execution context) 343 * should suffice all our needs. 344 */ 345 efi_rts_wq = alloc_ordered_workqueue("efi_rts_wq", 0); 346 if (!efi_rts_wq) { 347 pr_err("Creating efi_rts_wq failed, EFI runtime services disabled.\n"); 348 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags); 349 return 0; 350 } 351 352 /* We register the efi directory at /sys/firmware/efi */ 353 efi_kobj = kobject_create_and_add("efi", firmware_kobj); 354 if (!efi_kobj) { 355 pr_err("efi: Firmware registration failed.\n"); 356 return -ENOMEM; 357 } 358 359 error = generic_ops_register(); 360 if (error) 361 goto err_put; 362 363 if (efi_enabled(EFI_RUNTIME_SERVICES)) 364 efivar_ssdt_load(); 365 366 error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group); 367 if (error) { 368 pr_err("efi: Sysfs attribute export failed with error %d.\n", 369 error); 370 goto err_unregister; 371 } 372 373 error = efi_runtime_map_init(efi_kobj); 374 if (error) 375 goto err_remove_group; 376 377 /* and the standard mountpoint for efivarfs */ 378 error = sysfs_create_mount_point(efi_kobj, "efivars"); 379 if (error) { 380 pr_err("efivars: Subsystem registration failed.\n"); 381 goto err_remove_group; 382 } 383 384 return 0; 385 386 err_remove_group: 387 sysfs_remove_group(efi_kobj, &efi_subsys_attr_group); 388 err_unregister: 389 generic_ops_unregister(); 390 err_put: 391 kobject_put(efi_kobj); 392 return error; 393 } 394 395 subsys_initcall(efisubsys_init); 396 397 /* 398 * Find the efi memory descriptor for a given physical address. Given a 399 * physical address, determine if it exists within an EFI Memory Map entry, 400 * and if so, populate the supplied memory descriptor with the appropriate 401 * data. 402 */ 403 int efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md) 404 { 405 efi_memory_desc_t *md; 406 407 if (!efi_enabled(EFI_MEMMAP)) { 408 pr_err_once("EFI_MEMMAP is not enabled.\n"); 409 return -EINVAL; 410 } 411 412 if (!out_md) { 413 pr_err_once("out_md is null.\n"); 414 return -EINVAL; 415 } 416 417 for_each_efi_memory_desc(md) { 418 u64 size; 419 u64 end; 420 421 size = md->num_pages << EFI_PAGE_SHIFT; 422 end = md->phys_addr + size; 423 if (phys_addr >= md->phys_addr && phys_addr < end) { 424 memcpy(out_md, md, sizeof(*out_md)); 425 return 0; 426 } 427 } 428 return -ENOENT; 429 } 430 431 /* 432 * Calculate the highest address of an efi memory descriptor. 433 */ 434 u64 __init efi_mem_desc_end(efi_memory_desc_t *md) 435 { 436 u64 size = md->num_pages << EFI_PAGE_SHIFT; 437 u64 end = md->phys_addr + size; 438 return end; 439 } 440 441 void __init __weak efi_arch_mem_reserve(phys_addr_t addr, u64 size) {} 442 443 /** 444 * efi_mem_reserve - Reserve an EFI memory region 445 * @addr: Physical address to reserve 446 * @size: Size of reservation 447 * 448 * Mark a region as reserved from general kernel allocation and 449 * prevent it being released by efi_free_boot_services(). 450 * 451 * This function should be called drivers once they've parsed EFI 452 * configuration tables to figure out where their data lives, e.g. 453 * efi_esrt_init(). 454 */ 455 void __init efi_mem_reserve(phys_addr_t addr, u64 size) 456 { 457 if (!memblock_is_region_reserved(addr, size)) 458 memblock_reserve(addr, size); 459 460 /* 461 * Some architectures (x86) reserve all boot services ranges 462 * until efi_free_boot_services() because of buggy firmware 463 * implementations. This means the above memblock_reserve() is 464 * superfluous on x86 and instead what it needs to do is 465 * ensure the @start, @size is not freed. 466 */ 467 efi_arch_mem_reserve(addr, size); 468 } 469 470 static __initdata efi_config_table_type_t common_tables[] = { 471 {ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20}, 472 {ACPI_TABLE_GUID, "ACPI", &efi.acpi}, 473 {HCDP_TABLE_GUID, "HCDP", &efi.hcdp}, 474 {MPS_TABLE_GUID, "MPS", &efi.mps}, 475 {SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios}, 476 {SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3}, 477 {UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga}, 478 {EFI_SYSTEM_RESOURCE_TABLE_GUID, "ESRT", &efi.esrt}, 479 {EFI_PROPERTIES_TABLE_GUID, "PROP", &efi.properties_table}, 480 {EFI_MEMORY_ATTRIBUTES_TABLE_GUID, "MEMATTR", &efi.mem_attr_table}, 481 {LINUX_EFI_RANDOM_SEED_TABLE_GUID, "RNG", &efi.rng_seed}, 482 {LINUX_EFI_TPM_EVENT_LOG_GUID, "TPMEventLog", &efi.tpm_log}, 483 {LINUX_EFI_TPM_FINAL_LOG_GUID, "TPMFinalLog", &efi.tpm_final_log}, 484 {LINUX_EFI_MEMRESERVE_TABLE_GUID, "MEMRESERVE", &efi.mem_reserve}, 485 #ifdef CONFIG_EFI_RCI2_TABLE 486 {DELLEMC_EFI_RCI2_TABLE_GUID, NULL, &rci2_table_phys}, 487 #endif 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_bootloader_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 sizeof_field(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 | EFI_MEMORY_SP | 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|%2s|%3s|%2s|%2s|%2s|%2s]", 860 attr & EFI_MEMORY_RUNTIME ? "RUN" : "", 861 attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "", 862 attr & EFI_MEMORY_SP ? "SP" : "", 863 attr & EFI_MEMORY_NV ? "NV" : "", 864 attr & EFI_MEMORY_XP ? "XP" : "", 865 attr & EFI_MEMORY_RP ? "RP" : "", 866 attr & EFI_MEMORY_WP ? "WP" : "", 867 attr & EFI_MEMORY_RO ? "RO" : "", 868 attr & EFI_MEMORY_UCE ? "UCE" : "", 869 attr & EFI_MEMORY_WB ? "WB" : "", 870 attr & EFI_MEMORY_WT ? "WT" : "", 871 attr & EFI_MEMORY_WC ? "WC" : "", 872 attr & EFI_MEMORY_UC ? "UC" : ""); 873 return buf; 874 } 875 876 /* 877 * IA64 has a funky EFI memory map that doesn't work the same way as 878 * other architectures. 879 */ 880 #ifndef CONFIG_IA64 881 /* 882 * efi_mem_attributes - lookup memmap attributes for physical address 883 * @phys_addr: the physical address to lookup 884 * 885 * Search in the EFI memory map for the region covering 886 * @phys_addr. Returns the EFI memory attributes if the region 887 * was found in the memory map, 0 otherwise. 888 */ 889 u64 efi_mem_attributes(unsigned long phys_addr) 890 { 891 efi_memory_desc_t *md; 892 893 if (!efi_enabled(EFI_MEMMAP)) 894 return 0; 895 896 for_each_efi_memory_desc(md) { 897 if ((md->phys_addr <= phys_addr) && 898 (phys_addr < (md->phys_addr + 899 (md->num_pages << EFI_PAGE_SHIFT)))) 900 return md->attribute; 901 } 902 return 0; 903 } 904 905 /* 906 * efi_mem_type - lookup memmap type for physical address 907 * @phys_addr: the physical address to lookup 908 * 909 * Search in the EFI memory map for the region covering @phys_addr. 910 * Returns the EFI memory type if the region was found in the memory 911 * map, -EINVAL otherwise. 912 */ 913 int efi_mem_type(unsigned long phys_addr) 914 { 915 const efi_memory_desc_t *md; 916 917 if (!efi_enabled(EFI_MEMMAP)) 918 return -ENOTSUPP; 919 920 for_each_efi_memory_desc(md) { 921 if ((md->phys_addr <= phys_addr) && 922 (phys_addr < (md->phys_addr + 923 (md->num_pages << EFI_PAGE_SHIFT)))) 924 return md->type; 925 } 926 return -EINVAL; 927 } 928 #endif 929 930 int efi_status_to_err(efi_status_t status) 931 { 932 int err; 933 934 switch (status) { 935 case EFI_SUCCESS: 936 err = 0; 937 break; 938 case EFI_INVALID_PARAMETER: 939 err = -EINVAL; 940 break; 941 case EFI_OUT_OF_RESOURCES: 942 err = -ENOSPC; 943 break; 944 case EFI_DEVICE_ERROR: 945 err = -EIO; 946 break; 947 case EFI_WRITE_PROTECTED: 948 err = -EROFS; 949 break; 950 case EFI_SECURITY_VIOLATION: 951 err = -EACCES; 952 break; 953 case EFI_NOT_FOUND: 954 err = -ENOENT; 955 break; 956 case EFI_ABORTED: 957 err = -EINTR; 958 break; 959 default: 960 err = -EINVAL; 961 } 962 963 return err; 964 } 965 966 static DEFINE_SPINLOCK(efi_mem_reserve_persistent_lock); 967 static struct linux_efi_memreserve *efi_memreserve_root __ro_after_init; 968 969 static int __init efi_memreserve_map_root(void) 970 { 971 if (efi.mem_reserve == EFI_INVALID_TABLE_ADDR) 972 return -ENODEV; 973 974 efi_memreserve_root = memremap(efi.mem_reserve, 975 sizeof(*efi_memreserve_root), 976 MEMREMAP_WB); 977 if (WARN_ON_ONCE(!efi_memreserve_root)) 978 return -ENOMEM; 979 return 0; 980 } 981 982 static int efi_mem_reserve_iomem(phys_addr_t addr, u64 size) 983 { 984 struct resource *res, *parent; 985 986 res = kzalloc(sizeof(struct resource), GFP_ATOMIC); 987 if (!res) 988 return -ENOMEM; 989 990 res->name = "reserved"; 991 res->flags = IORESOURCE_MEM; 992 res->start = addr; 993 res->end = addr + size - 1; 994 995 /* we expect a conflict with a 'System RAM' region */ 996 parent = request_resource_conflict(&iomem_resource, res); 997 return parent ? request_resource(parent, res) : 0; 998 } 999 1000 int __ref efi_mem_reserve_persistent(phys_addr_t addr, u64 size) 1001 { 1002 struct linux_efi_memreserve *rsv; 1003 unsigned long prsv; 1004 int rc, index; 1005 1006 if (efi_memreserve_root == (void *)ULONG_MAX) 1007 return -ENODEV; 1008 1009 if (!efi_memreserve_root) { 1010 rc = efi_memreserve_map_root(); 1011 if (rc) 1012 return rc; 1013 } 1014 1015 /* first try to find a slot in an existing linked list entry */ 1016 for (prsv = efi_memreserve_root->next; prsv; prsv = rsv->next) { 1017 rsv = memremap(prsv, sizeof(*rsv), MEMREMAP_WB); 1018 index = atomic_fetch_add_unless(&rsv->count, 1, rsv->size); 1019 if (index < rsv->size) { 1020 rsv->entry[index].base = addr; 1021 rsv->entry[index].size = size; 1022 1023 memunmap(rsv); 1024 return efi_mem_reserve_iomem(addr, size); 1025 } 1026 memunmap(rsv); 1027 } 1028 1029 /* no slot found - allocate a new linked list entry */ 1030 rsv = (struct linux_efi_memreserve *)__get_free_page(GFP_ATOMIC); 1031 if (!rsv) 1032 return -ENOMEM; 1033 1034 rc = efi_mem_reserve_iomem(__pa(rsv), SZ_4K); 1035 if (rc) { 1036 free_page((unsigned long)rsv); 1037 return rc; 1038 } 1039 1040 /* 1041 * The memremap() call above assumes that a linux_efi_memreserve entry 1042 * never crosses a page boundary, so let's ensure that this remains true 1043 * even when kexec'ing a 4k pages kernel from a >4k pages kernel, by 1044 * using SZ_4K explicitly in the size calculation below. 1045 */ 1046 rsv->size = EFI_MEMRESERVE_COUNT(SZ_4K); 1047 atomic_set(&rsv->count, 1); 1048 rsv->entry[0].base = addr; 1049 rsv->entry[0].size = size; 1050 1051 spin_lock(&efi_mem_reserve_persistent_lock); 1052 rsv->next = efi_memreserve_root->next; 1053 efi_memreserve_root->next = __pa(rsv); 1054 spin_unlock(&efi_mem_reserve_persistent_lock); 1055 1056 return efi_mem_reserve_iomem(addr, size); 1057 } 1058 1059 static int __init efi_memreserve_root_init(void) 1060 { 1061 if (efi_memreserve_root) 1062 return 0; 1063 if (efi_memreserve_map_root()) 1064 efi_memreserve_root = (void *)ULONG_MAX; 1065 return 0; 1066 } 1067 early_initcall(efi_memreserve_root_init); 1068 1069 #ifdef CONFIG_KEXEC 1070 static int update_efi_random_seed(struct notifier_block *nb, 1071 unsigned long code, void *unused) 1072 { 1073 struct linux_efi_random_seed *seed; 1074 u32 size = 0; 1075 1076 if (!kexec_in_progress) 1077 return NOTIFY_DONE; 1078 1079 seed = memremap(efi.rng_seed, sizeof(*seed), MEMREMAP_WB); 1080 if (seed != NULL) { 1081 size = min(seed->size, EFI_RANDOM_SEED_SIZE); 1082 memunmap(seed); 1083 } else { 1084 pr_err("Could not map UEFI random seed!\n"); 1085 } 1086 if (size > 0) { 1087 seed = memremap(efi.rng_seed, sizeof(*seed) + size, 1088 MEMREMAP_WB); 1089 if (seed != NULL) { 1090 seed->size = size; 1091 get_random_bytes(seed->bits, seed->size); 1092 memunmap(seed); 1093 } else { 1094 pr_err("Could not map UEFI random seed!\n"); 1095 } 1096 } 1097 return NOTIFY_DONE; 1098 } 1099 1100 static struct notifier_block efi_random_seed_nb = { 1101 .notifier_call = update_efi_random_seed, 1102 }; 1103 1104 static int register_update_efi_random_seed(void) 1105 { 1106 if (efi.rng_seed == EFI_INVALID_TABLE_ADDR) 1107 return 0; 1108 return register_reboot_notifier(&efi_random_seed_nb); 1109 } 1110 late_initcall(register_update_efi_random_seed); 1111 #endif 1112