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