drivers/firmware/efi/libstub/mem.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 #include <linux/efi.h>
   4 #include <asm/efi.h>
   5
   6 #include "efistub.h"
   7
   8 /**
   9  * efi_get_memory_map() - get memory map
  10  * @map:                pointer to memory map pointer to which to assign the
  11  *                      newly allocated memory map
  12  * @install_cfg_tbl:    whether or not to install the boot memory map as a
  13  *                      configuration table
  14  *
  15  * Retrieve the UEFI memory map. The allocated memory leaves room for
  16  * up to EFI_MMAP_NR_SLACK_SLOTS additional memory map entries.
  17  *
  18  * Return:      status code
  19  */
  20 efi_status_t efi_get_memory_map(struct efi_boot_memmap **map,
  21                                 bool install_cfg_tbl)
  22 {
  23         int memtype = install_cfg_tbl ? EFI_ACPI_RECLAIM_MEMORY
  24                                       : EFI_LOADER_DATA;
  25         efi_guid_t tbl_guid = LINUX_EFI_BOOT_MEMMAP_GUID;
  26         struct efi_boot_memmap *m, tmp;
  27         efi_status_t status;
  28         unsigned long size;
  29
  30         tmp.map_size = 0;
  31         status = efi_bs_call(get_memory_map, &tmp.map_size, NULL, &tmp.map_key,
  32                              &tmp.desc_size, &tmp.desc_ver);
  33         if (status != EFI_BUFFER_TOO_SMALL)
  34                 return EFI_LOAD_ERROR;
  35
  36         size = tmp.map_size + tmp.desc_size * EFI_MMAP_NR_SLACK_SLOTS;
  37         status = efi_bs_call(allocate_pool, memtype, sizeof(*m) + size,
  38                              (void **)&m);
  39         if (status != EFI_SUCCESS)
  40                 return status;
  41
  42         if (install_cfg_tbl) {
  43                 /*
  44                  * Installing a configuration table might allocate memory, and
  45                  * this may modify the memory map. This means we should install
  46                  * the configuration table first, and re-install or delete it
  47                  * as needed.
  48                  */
  49                 status = efi_bs_call(install_configuration_table, &tbl_guid, m);
  50                 if (status != EFI_SUCCESS)
  51                         goto free_map;
  52         }
  53
  54         m->buff_size = m->map_size = size;
  55         status = efi_bs_call(get_memory_map, &m->map_size, m->map, &m->map_key,
  56                              &m->desc_size, &m->desc_ver);
  57         if (status != EFI_SUCCESS)
  58                 goto uninstall_table;
  59
  60         *map = m;
  61         return EFI_SUCCESS;
  62
  63 uninstall_table:
  64         if (install_cfg_tbl)
  65                 efi_bs_call(install_configuration_table, &tbl_guid, NULL);
  66 free_map:
  67         efi_bs_call(free_pool, m);
  68         return status;
  69 }
  70
  71 /**
  72  * efi_allocate_pages() - Allocate memory pages
  73  * @size:       minimum number of bytes to allocate
  74  * @addr:       On return the address of the first allocated page. The first
  75  *              allocated page has alignment EFI_ALLOC_ALIGN which is an
  76  *              architecture dependent multiple of the page size.
  77  * @max:        the address that the last allocated memory page shall not
  78  *              exceed
  79  *
  80  * Allocate pages as EFI_LOADER_DATA. The allocated pages are aligned according
  81  * to EFI_ALLOC_ALIGN. The last allocated page will not exceed the address
  82  * given by @max.
  83  *
  84  * Return:      status code
  85  */
  86 efi_status_t efi_allocate_pages(unsigned long size, unsigned long *addr,
  87                                 unsigned long max)
  88 {
  89         efi_physical_addr_t alloc_addr;
  90         efi_status_t status;
  91
  92         max = min(max, EFI_ALLOC_LIMIT);
  93
  94         if (EFI_ALLOC_ALIGN > EFI_PAGE_SIZE)
  95                 return efi_allocate_pages_aligned(size, addr, max,
  96                                                   EFI_ALLOC_ALIGN,
  97                                                   EFI_LOADER_DATA);
  98
  99         alloc_addr = ALIGN_DOWN(max + 1, EFI_ALLOC_ALIGN) - 1;
 100         status = efi_bs_call(allocate_pages, EFI_ALLOCATE_MAX_ADDRESS,
 101                              EFI_LOADER_DATA, DIV_ROUND_UP(size, EFI_PAGE_SIZE),
 102                              &alloc_addr);
 103         if (status != EFI_SUCCESS)
 104                 return status;
 105
 106         *addr = alloc_addr;
 107         return EFI_SUCCESS;
 108 }
 109
 110 /**
 111  * efi_free() - free memory pages
 112  * @size:       size of the memory area to free in bytes
 113  * @addr:       start of the memory area to free (must be EFI_PAGE_SIZE
 114  *              aligned)
 115  *
 116  * @size is rounded up to a multiple of EFI_ALLOC_ALIGN which is an
 117  * architecture specific multiple of EFI_PAGE_SIZE. So this function should
 118  * only be used to return pages allocated with efi_allocate_pages() or
 119  * efi_low_alloc_above().
 120  */
 121 void efi_free(unsigned long size, unsigned long addr)
 122 {
 123         unsigned long nr_pages;
 124
 125         if (!size)
 126                 return;
 127
 128         nr_pages = round_up(size, EFI_ALLOC_ALIGN) / EFI_PAGE_SIZE;
 129         efi_bs_call(free_pages, addr, nr_pages);
 130 }