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