arch/arm64/kernel/efi.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Extensible Firmware Interface
   4  *
   5  * Based on Extensible Firmware Interface Specification version 2.4
   6  *
   7  * Copyright (C) 2013, 2014 Linaro Ltd.
   8  */
   9
  10 #include <linux/efi.h>
  11 #include <linux/init.h>
  12
  13 #include <asm/efi.h>
  14
  15 /*
  16  * Only regions of type EFI_RUNTIME_SERVICES_CODE need to be
  17  * executable, everything else can be mapped with the XN bits
  18  * set. Also take the new (optional) RO/XP bits into account.
  19  */
  20 static __init pteval_t create_mapping_protection(efi_memory_desc_t *md)
  21 {
  22         u64 attr = md->attribute;
  23         u32 type = md->type;
  24
  25         if (type == EFI_MEMORY_MAPPED_IO)
  26                 return PROT_DEVICE_nGnRE;
  27
  28         if (WARN_ONCE(!PAGE_ALIGNED(md->phys_addr),
  29                       "UEFI Runtime regions are not aligned to 64 KB -- buggy firmware?"))
  30                 /*
  31                  * If the region is not aligned to the page size of the OS, we
  32                  * can not use strict permissions, since that would also affect
  33                  * the mapping attributes of the adjacent regions.
  34                  */
  35                 return pgprot_val(PAGE_KERNEL_EXEC);
  36
  37         /* R-- */
  38         if ((attr & (EFI_MEMORY_XP | EFI_MEMORY_RO)) ==
  39             (EFI_MEMORY_XP | EFI_MEMORY_RO))
  40                 return pgprot_val(PAGE_KERNEL_RO);
  41
  42         /* R-X */
  43         if (attr & EFI_MEMORY_RO)
  44                 return pgprot_val(PAGE_KERNEL_ROX);
  45
  46         /* RW- */
  47         if (((attr & (EFI_MEMORY_RP | EFI_MEMORY_WP | EFI_MEMORY_XP)) ==
  48              EFI_MEMORY_XP) ||
  49             type != EFI_RUNTIME_SERVICES_CODE)
  50                 return pgprot_val(PAGE_KERNEL);
  51
  52         /* RWX */
  53         return pgprot_val(PAGE_KERNEL_EXEC);
  54 }
  55
  56 /* we will fill this structure from the stub, so don't put it in .bss */
  57 struct screen_info screen_info __section(.data);
  58
  59 int __init efi_create_mapping(struct mm_struct *mm, efi_memory_desc_t *md)
  60 {
  61         pteval_t prot_val = create_mapping_protection(md);
  62         bool page_mappings_only = (md->type == EFI_RUNTIME_SERVICES_CODE ||
  63                                    md->type == EFI_RUNTIME_SERVICES_DATA);
  64
  65         if (!PAGE_ALIGNED(md->phys_addr) ||
  66             !PAGE_ALIGNED(md->num_pages << EFI_PAGE_SHIFT)) {
  67                 /*
  68                  * If the end address of this region is not aligned to page
  69                  * size, the mapping is rounded up, and may end up sharing a
  70                  * page frame with the next UEFI memory region. If we create
  71                  * a block entry now, we may need to split it again when mapping
  72                  * the next region, and support for that is going to be removed
  73                  * from the MMU routines. So avoid block mappings altogether in
  74                  * that case.
  75                  */
  76                 page_mappings_only = true;
  77         }
  78
  79         create_pgd_mapping(mm, md->phys_addr, md->virt_addr,
  80                            md->num_pages << EFI_PAGE_SHIFT,
  81                            __pgprot(prot_val | PTE_NG), page_mappings_only);
  82         return 0;
  83 }
  84
  85 static int __init set_permissions(pte_t *ptep, pgtable_t token,
  86                                   unsigned long addr, void *data)
  87 {
  88         efi_memory_desc_t *md = data;
  89         pte_t pte = READ_ONCE(*ptep);
  90
  91         if (md->attribute & EFI_MEMORY_RO)
  92                 pte = set_pte_bit(pte, __pgprot(PTE_RDONLY));
  93         if (md->attribute & EFI_MEMORY_XP)
  94                 pte = set_pte_bit(pte, __pgprot(PTE_PXN));
  95         set_pte(ptep, pte);
  96         return 0;
  97 }
  98
  99 int __init efi_set_mapping_permissions(struct mm_struct *mm,
 100                                        efi_memory_desc_t *md)
 101 {
 102         BUG_ON(md->type != EFI_RUNTIME_SERVICES_CODE &&
 103                md->type != EFI_RUNTIME_SERVICES_DATA);
 104
 105         /*
 106          * Calling apply_to_page_range() is only safe on regions that are
 107          * guaranteed to be mapped down to pages. Since we are only called
 108          * for regions that have been mapped using efi_create_mapping() above
 109          * (and this is checked by the generic Memory Attributes table parsing
 110          * routines), there is no need to check that again here.
 111          */
 112         return apply_to_page_range(mm, md->virt_addr,
 113                                    md->num_pages << EFI_PAGE_SHIFT,
 114                                    set_permissions, md);
 115 }
 116
 117 /*
 118  * UpdateCapsule() depends on the system being shutdown via
 119  * ResetSystem().
 120  */
 121 bool efi_poweroff_required(void)
 122 {
 123         return efi_enabled(EFI_RUNTIME_SERVICES);
 124 }
 125
 126 asmlinkage efi_status_t efi_handle_corrupted_x18(efi_status_t s, const char *f)
 127 {
 128         pr_err_ratelimited(FW_BUG "register x18 corrupted by EFI %s\n", f);
 129         return s;
 130 }