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