drivers/firmware/efi/efi.c

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