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