drivers/firmware/efi/libstub/arm64-stub.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2013, 2014 Linaro Ltd;  <roy.franz@linaro.org>
   4  *
   5  * This file implements the EFI boot stub for the arm64 kernel.
   6  * Adapted from ARM version by Mark Salter <msalter@redhat.com>
   7  */
   8
   9
  10 #include <linux/efi.h>
  11 #include <asm/efi.h>
  12 #include <asm/memory.h>
  13 #include <asm/sections.h>
  14
  15 #include "efistub.h"
  16
  17 /*
  18  * Distro versions of GRUB may ignore the BSS allocation entirely (i.e., fail
  19  * to provide space, and fail to zero it). Check for this condition by double
  20  * checking that the first and the last byte of the image are covered by the
  21  * same EFI memory map entry.
  22  */
  23 static bool check_image_region(u64 base, u64 size)
  24 {
  25         struct efi_boot_memmap *map;
  26         efi_status_t status;
  27         bool ret = false;
  28         int map_offset;
  29
  30         status = efi_get_memory_map(&map, false);
  31         if (status != EFI_SUCCESS)
  32                 return false;
  33
  34         for (map_offset = 0; map_offset < map->map_size; map_offset += map->desc_size) {
  35                 efi_memory_desc_t *md = (void *)map->map + map_offset;
  36                 u64 end = md->phys_addr + md->num_pages * EFI_PAGE_SIZE;
  37
  38                 /*
  39                  * Find the region that covers base, and return whether
  40                  * it covers base+size bytes.
  41                  */
  42                 if (base >= md->phys_addr && base < end) {
  43                         ret = (base + size) <= end;
  44                         break;
  45                 }
  46         }
  47
  48         efi_bs_call(free_pool, map);
  49
  50         return ret;
  51 }
  52
  53 efi_status_t handle_kernel_image(unsigned long *image_addr,
  54                                  unsigned long *image_size,
  55                                  unsigned long *reserve_addr,
  56                                  unsigned long *reserve_size,
  57                                  efi_loaded_image_t *image,
  58                                  efi_handle_t image_handle)
  59 {
  60         efi_status_t status;
  61         unsigned long kernel_size, kernel_codesize, kernel_memsize;
  62         u32 phys_seed = 0;
  63         u64 min_kimg_align = efi_get_kimg_min_align();
  64
  65         if (IS_ENABLED(CONFIG_RANDOMIZE_BASE)) {
  66                 efi_guid_t li_fixed_proto = LINUX_EFI_LOADED_IMAGE_FIXED_GUID;
  67                 void *p;
  68
  69                 if (efi_nokaslr) {
  70                         efi_info("KASLR disabled on kernel command line\n");
  71                 } else if (efi_bs_call(handle_protocol, image_handle,
  72                                        &li_fixed_proto, &p) == EFI_SUCCESS) {
  73                         efi_info("Image placement fixed by loader\n");
  74                 } else {
  75                         status = efi_get_random_bytes(sizeof(phys_seed),
  76                                                       (u8 *)&phys_seed);
  77                         if (status == EFI_NOT_FOUND) {
  78                                 efi_info("EFI_RNG_PROTOCOL unavailable\n");
  79                                 efi_nokaslr = true;
  80                         } else if (status != EFI_SUCCESS) {
  81                                 efi_err("efi_get_random_bytes() failed (0x%lx)\n",
  82                                         status);
  83                                 efi_nokaslr = true;
  84                         }
  85                 }
  86         }
  87
  88         if (image->image_base != _text) {
  89                 efi_err("FIRMWARE BUG: efi_loaded_image_t::image_base has bogus value\n");
  90                 image->image_base = _text;
  91         }
  92
  93         if (!IS_ALIGNED((u64)_text, SEGMENT_ALIGN))
  94                 efi_err("FIRMWARE BUG: kernel image not aligned on %dk boundary\n",
  95                         SEGMENT_ALIGN >> 10);
  96
  97         kernel_size = _edata - _text;
  98         kernel_codesize = __inittext_end - _text;
  99         kernel_memsize = kernel_size + (_end - _edata);
 100         *reserve_size = kernel_memsize;
 101
 102         if (IS_ENABLED(CONFIG_RANDOMIZE_BASE) && phys_seed != 0) {
 103                 /*
 104                  * If KASLR is enabled, and we have some randomness available,
 105                  * locate the kernel at a randomized offset in physical memory.
 106                  */
 107                 status = efi_random_alloc(*reserve_size, min_kimg_align,
 108                                           reserve_addr, phys_seed,
 109                                           EFI_LOADER_CODE, EFI_ALLOC_LIMIT);
 110                 if (status != EFI_SUCCESS)
 111                         efi_warn("efi_random_alloc() failed: 0x%lx\n", status);
 112         } else {
 113                 status = EFI_OUT_OF_RESOURCES;
 114         }
 115
 116         if (status != EFI_SUCCESS) {
 117                 if (!check_image_region((u64)_text, kernel_memsize)) {
 118                         efi_err("FIRMWARE BUG: Image BSS overlaps adjacent EFI memory region\n");
 119                 } else if (IS_ALIGNED((u64)_text, min_kimg_align) &&
 120                            (u64)_end < EFI_ALLOC_LIMIT) {
 121                         /*
 122                          * Just execute from wherever we were loaded by the
 123                          * UEFI PE/COFF loader if the placement is suitable.
 124                          */
 125                         *image_addr = (u64)_text;
 126                         *reserve_size = 0;
 127                         return EFI_SUCCESS;
 128                 }
 129
 130                 status = efi_allocate_pages_aligned(*reserve_size, reserve_addr,
 131                                                     ULONG_MAX, min_kimg_align,
 132                                                     EFI_LOADER_CODE);
 133
 134                 if (status != EFI_SUCCESS) {
 135                         efi_err("Failed to relocate kernel\n");
 136                         *reserve_size = 0;
 137                         return status;
 138                 }
 139         }
 140
 141         *image_addr = *reserve_addr;
 142         memcpy((void *)*image_addr, _text, kernel_size);
 143         caches_clean_inval_pou(*image_addr, *image_addr + kernel_codesize);
 144         efi_remap_image(*image_addr, *reserve_size, kernel_codesize);
 145
 146         return EFI_SUCCESS;
 147 }
 148
 149 asmlinkage void primary_entry(void);
 150
 151 unsigned long primary_entry_offset(void)
 152 {
 153         /*
 154          * When built as part of the kernel, the EFI stub cannot branch to the
 155          * kernel proper via the image header, as the PE/COFF header is
 156          * strictly not part of the in-memory presentation of the image, only
 157          * of the file representation. So instead, we need to jump to the
 158          * actual entrypoint in the .text region of the image.
 159          */
 160         return (char *)primary_entry - _text;
 161 }