drivers/firmware/efi/memattr.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2016 Linaro Ltd. <[email protected]>
   4  */
   5
   6 #define pr_fmt(fmt)     "efi: memattr: " fmt
   7
   8 #include <linux/efi.h>
   9 #include <linux/init.h>
  10 #include <linux/io.h>
  11 #include <linux/memblock.h>
  12
  13 #include <asm/early_ioremap.h>
  14
  15 static int __initdata tbl_size;
  16 unsigned long __ro_after_init efi_mem_attr_table = EFI_INVALID_TABLE_ADDR;
  17
  18 /*
  19  * Reserve the memory associated with the Memory Attributes configuration
  20  * table, if it exists.
  21  */
  22 int __init efi_memattr_init(void)
  23 {
  24         efi_memory_attributes_table_t *tbl;
  25         unsigned long size;
  26
  27         if (efi_mem_attr_table == EFI_INVALID_TABLE_ADDR)
  28                 return 0;
  29
  30         tbl = early_memremap(efi_mem_attr_table, sizeof(*tbl));
  31         if (!tbl) {
  32                 pr_err("Failed to map EFI Memory Attributes table @ 0x%lx\n",
  33                        efi_mem_attr_table);
  34                 return -ENOMEM;
  35         }
  36
  37         if (tbl->version > 2) {
  38                 pr_warn("Unexpected EFI Memory Attributes table version %d\n",
  39                         tbl->version);
  40                 goto unmap;
  41         }
  42
  43
  44         /*
  45          * Sanity check: the Memory Attributes Table contains up to 3 entries
  46          * for each entry of type EfiRuntimeServicesCode in the EFI memory map.
  47          * So if the size of the table exceeds 3x the size of the entire EFI
  48          * memory map, there is clearly something wrong, and the table should
  49          * just be ignored altogether.
  50          */
  51         size = tbl->num_entries * tbl->desc_size;
  52         if (size > 3 * efi.memmap.nr_map * efi.memmap.desc_size) {
  53                 pr_warn(FW_BUG "Corrupted EFI Memory Attributes Table detected! (version == %u, desc_size == %u, num_entries == %u)\n",
  54                         tbl->version, tbl->desc_size, tbl->num_entries);
  55                 goto unmap;
  56         }
  57
  58         tbl_size = sizeof(*tbl) + size;
  59         memblock_reserve(efi_mem_attr_table, tbl_size);
  60         set_bit(EFI_MEM_ATTR, &efi.flags);
  61
  62 unmap:
  63         early_memunmap(tbl, sizeof(*tbl));
  64         return 0;
  65 }
  66
  67 /*
  68  * Returns a copy @out of the UEFI memory descriptor @in if it is covered
  69  * entirely by a UEFI memory map entry with matching attributes. The virtual
  70  * address of @out is set according to the matching entry that was found.
  71  */
  72 static bool entry_is_valid(const efi_memory_desc_t *in, efi_memory_desc_t *out)
  73 {
  74         u64 in_paddr = in->phys_addr;
  75         u64 in_size = in->num_pages << EFI_PAGE_SHIFT;
  76         efi_memory_desc_t *md;
  77
  78         *out = *in;
  79
  80         if (in->type != EFI_RUNTIME_SERVICES_CODE &&
  81             in->type != EFI_RUNTIME_SERVICES_DATA) {
  82                 pr_warn("Entry type should be RuntimeServiceCode/Data\n");
  83                 return false;
  84         }
  85
  86         if (PAGE_SIZE > EFI_PAGE_SIZE &&
  87             (!PAGE_ALIGNED(in->phys_addr) ||
  88              !PAGE_ALIGNED(in->num_pages << EFI_PAGE_SHIFT))) {
  89                 /*
  90                  * Since arm64 may execute with page sizes of up to 64 KB, the
  91                  * UEFI spec mandates that RuntimeServices memory regions must
  92                  * be 64 KB aligned. We need to validate this here since we will
  93                  * not be able to tighten permissions on such regions without
  94                  * affecting adjacent regions.
  95                  */
  96                 pr_warn("Entry address region misaligned\n");
  97                 return false;
  98         }
  99
 100         for_each_efi_memory_desc(md) {
 101                 u64 md_paddr = md->phys_addr;
 102                 u64 md_size = md->num_pages << EFI_PAGE_SHIFT;
 103
 104                 if (!(md->attribute & EFI_MEMORY_RUNTIME))
 105                         continue;
 106                 if (md->virt_addr == 0 && md->phys_addr != 0) {
 107                         /* no virtual mapping has been installed by the stub */
 108                         break;
 109                 }
 110
 111                 if (md_paddr > in_paddr || (in_paddr - md_paddr) >= md_size)
 112                         continue;
 113
 114                 /*
 115                  * This entry covers the start of @in, check whether
 116                  * it covers the end as well.
 117                  */
 118                 if (md_paddr + md_size < in_paddr + in_size) {
 119                         pr_warn("Entry covers multiple EFI memory map regions\n");
 120                         return false;
 121                 }
 122
 123                 if (md->type != in->type) {
 124                         pr_warn("Entry type deviates from EFI memory map region type\n");
 125                         return false;
 126                 }
 127
 128                 out->virt_addr = in_paddr + (md->virt_addr - md_paddr);
 129
 130                 return true;
 131         }
 132
 133         pr_warn("No matching entry found in the EFI memory map\n");
 134         return false;
 135 }
 136
 137 /*
 138  * To be called after the EFI page tables have been populated. If a memory
 139  * attributes table is available, its contents will be used to update the
 140  * mappings with tightened permissions as described by the table.
 141  * This requires the UEFI memory map to have already been populated with
 142  * virtual addresses.
 143  */
 144 int __init efi_memattr_apply_permissions(struct mm_struct *mm,
 145                                          efi_memattr_perm_setter fn)
 146 {
 147         efi_memory_attributes_table_t *tbl;
 148         bool has_bti = false;
 149         int i, ret;
 150
 151         if (tbl_size <= sizeof(*tbl))
 152                 return 0;
 153
 154         /*
 155          * We need the EFI memory map to be setup so we can use it to
 156          * lookup the virtual addresses of all entries in the  of EFI
 157          * Memory Attributes table. If it isn't available, this
 158          * function should not be called.
 159          */
 160         if (WARN_ON(!efi_enabled(EFI_MEMMAP)))
 161                 return 0;
 162
 163         tbl = memremap(efi_mem_attr_table, tbl_size, MEMREMAP_WB);
 164         if (!tbl) {
 165                 pr_err("Failed to map EFI Memory Attributes table @ 0x%lx\n",
 166                        efi_mem_attr_table);
 167                 return -ENOMEM;
 168         }
 169
 170         if (tbl->version > 1 &&
 171             (tbl->flags & EFI_MEMORY_ATTRIBUTES_FLAGS_RT_FORWARD_CONTROL_FLOW_GUARD))
 172                 has_bti = true;
 173
 174         if (efi_enabled(EFI_DBG))
 175                 pr_info("Processing EFI Memory Attributes table:\n");
 176
 177         for (i = ret = 0; ret == 0 && i < tbl->num_entries; i++) {
 178                 efi_memory_desc_t md;
 179                 unsigned long size;
 180                 bool valid;
 181                 char buf[64];
 182
 183                 valid = entry_is_valid(efi_memdesc_ptr(tbl->entry, tbl->desc_size, i),
 184                                        &md);
 185                 size = md.num_pages << EFI_PAGE_SHIFT;
 186                 if (efi_enabled(EFI_DBG) || !valid)
 187                         pr_info("%s 0x%012llx-0x%012llx %s\n",
 188                                 valid ? "" : "!", md.phys_addr,
 189                                 md.phys_addr + size - 1,
 190                                 efi_md_typeattr_format(buf, sizeof(buf), &md));
 191
 192                 if (valid) {
 193                         ret = fn(mm, &md, has_bti);
 194                         if (ret)
 195                                 pr_err("Error updating mappings, skipping subsequent md's\n");
 196                 }
 197         }
 198         memunmap(tbl);
 199         return ret;
 200 }