arch/arm64/kernel/efi.c

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