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