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