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_XP || type != EFI_RUNTIME_SERVICES_CODE) 52 return pgprot_val(PAGE_KERNEL); 53 54 /* RWX */ 55 return pgprot_val(PAGE_KERNEL_EXEC); 56 } 57 58 /* we will fill this structure from the stub, so don't put it in .bss */ 59 struct screen_info screen_info __section(.data); 60 61 int __init efi_create_mapping(struct mm_struct *mm, efi_memory_desc_t *md) 62 { 63 pteval_t prot_val = create_mapping_protection(md); 64 bool page_mappings_only = (md->type == EFI_RUNTIME_SERVICES_CODE || 65 md->type == EFI_RUNTIME_SERVICES_DATA); 66 67 if (!PAGE_ALIGNED(md->phys_addr) || 68 !PAGE_ALIGNED(md->num_pages << EFI_PAGE_SHIFT)) { 69 /* 70 * If the end address of this region is not aligned to page 71 * size, the mapping is rounded up, and may end up sharing a 72 * page frame with the next UEFI memory region. If we create 73 * a block entry now, we may need to split it again when mapping 74 * the next region, and support for that is going to be removed 75 * from the MMU routines. So avoid block mappings altogether in 76 * that case. 77 */ 78 page_mappings_only = true; 79 } 80 81 create_pgd_mapping(mm, md->phys_addr, md->virt_addr, 82 md->num_pages << EFI_PAGE_SHIFT, 83 __pgprot(prot_val | PTE_NG), page_mappings_only); 84 return 0; 85 } 86 87 static int __init set_permissions(pte_t *ptep, pgtable_t token, 88 unsigned long addr, void *data) 89 { 90 efi_memory_desc_t *md = data; 91 pte_t pte = *ptep; 92 93 if (md->attribute & EFI_MEMORY_RO) 94 pte = set_pte_bit(pte, __pgprot(PTE_RDONLY)); 95 if (md->attribute & EFI_MEMORY_XP) 96 pte = set_pte_bit(pte, __pgprot(PTE_PXN)); 97 set_pte(ptep, pte); 98 return 0; 99 } 100 101 int __init efi_set_mapping_permissions(struct mm_struct *mm, 102 efi_memory_desc_t *md) 103 { 104 BUG_ON(md->type != EFI_RUNTIME_SERVICES_CODE && 105 md->type != EFI_RUNTIME_SERVICES_DATA); 106 107 /* 108 * Calling apply_to_page_range() is only safe on regions that are 109 * guaranteed to be mapped down to pages. Since we are only called 110 * for regions that have been mapped using efi_create_mapping() above 111 * (and this is checked by the generic Memory Attributes table parsing 112 * routines), there is no need to check that again here. 113 */ 114 return apply_to_page_range(mm, md->virt_addr, 115 md->num_pages << EFI_PAGE_SHIFT, 116 set_permissions, md); 117 } 118 119 /* 120 * UpdateCapsule() depends on the system being shutdown via 121 * ResetSystem(). 122 */ 123 bool efi_poweroff_required(void) 124 { 125 return efi_enabled(EFI_RUNTIME_SERVICES); 126 } 127