drivers/firmware/efi/fake_mem.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * fake_mem.c
   4  *
   5  * Copyright (C) 2015 FUJITSU LIMITED
   6  * Author: Taku Izumi <izumi.taku@jp.fujitsu.com>
   7  *
   8  * This code introduces new boot option named "efi_fake_mem"
   9  * By specifying this parameter, you can add arbitrary attribute to
  10  * specific memory range by updating original (firmware provided) EFI
  11  * memmap.
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/efi.h>
  16 #include <linux/init.h>
  17 #include <linux/memblock.h>
  18 #include <linux/types.h>
  19 #include <linux/sort.h>
  20 #include "fake_mem.h"
  21
  22 struct efi_mem_range efi_fake_mems[EFI_MAX_FAKEMEM];
  23 int nr_fake_mem;
  24
  25 static int __init cmp_fake_mem(const void *x1, const void *x2)
  26 {
  27         const struct efi_mem_range *m1 = x1;
  28         const struct efi_mem_range *m2 = x2;
  29
  30         if (m1->range.start < m2->range.start)
  31                 return -1;
  32         if (m1->range.start > m2->range.start)
  33                 return 1;
  34         return 0;
  35 }
  36
  37 void __init efi_fake_memmap(void)
  38 {
  39         int new_nr_map = efi.memmap.nr_map;
  40         efi_memory_desc_t *md;
  41         phys_addr_t new_memmap_phy;
  42         void *new_memmap;
  43         int i;
  44
  45         if (!efi_enabled(EFI_MEMMAP) || !nr_fake_mem)
  46                 return;
  47
  48         /* count up the number of EFI memory descriptor */
  49         for (i = 0; i < nr_fake_mem; i++) {
  50                 for_each_efi_memory_desc(md) {
  51                         struct range *r = &efi_fake_mems[i].range;
  52
  53                         new_nr_map += efi_memmap_split_count(md, r);
  54                 }
  55         }
  56
  57         /* allocate memory for new EFI memmap */
  58         new_memmap_phy = efi_memmap_alloc(new_nr_map);
  59         if (!new_memmap_phy)
  60                 return;
  61
  62         /* create new EFI memmap */
  63         new_memmap = early_memremap(new_memmap_phy,
  64                                     efi.memmap.desc_size * new_nr_map);
  65         if (!new_memmap) {
  66                 memblock_free(new_memmap_phy, efi.memmap.desc_size * new_nr_map);
  67                 return;
  68         }
  69
  70         for (i = 0; i < nr_fake_mem; i++)
  71                 efi_memmap_insert(&efi.memmap, new_memmap, &efi_fake_mems[i]);
  72
  73         /* swap into new EFI memmap */
  74         early_memunmap(new_memmap, efi.memmap.desc_size * new_nr_map);
  75
  76         efi_memmap_install(new_memmap_phy, new_nr_map);
  77
  78         /* print new EFI memmap */
  79         efi_print_memmap();
  80 }
  81
  82 static int __init setup_fake_mem(char *p)
  83 {
  84         u64 start = 0, mem_size = 0, attribute = 0;
  85         int i;
  86
  87         if (!p)
  88                 return -EINVAL;
  89
  90         while (*p != '\0') {
  91                 mem_size = memparse(p, &p);
  92                 if (*p == '@')
  93                         start = memparse(p+1, &p);
  94                 else
  95                         break;
  96
  97                 if (*p == ':')
  98                         attribute = simple_strtoull(p+1, &p, 0);
  99                 else
 100                         break;
 101
 102                 if (nr_fake_mem >= EFI_MAX_FAKEMEM)
 103                         break;
 104
 105                 efi_fake_mems[nr_fake_mem].range.start = start;
 106                 efi_fake_mems[nr_fake_mem].range.end = start + mem_size - 1;
 107                 efi_fake_mems[nr_fake_mem].attribute = attribute;
 108                 nr_fake_mem++;
 109
 110                 if (*p == ',')
 111                         p++;
 112         }
 113
 114         sort(efi_fake_mems, nr_fake_mem, sizeof(struct efi_mem_range),
 115              cmp_fake_mem, NULL);
 116
 117         for (i = 0; i < nr_fake_mem; i++)
 118                 pr_info("efi_fake_mem: add attr=0x%016llx to [mem 0x%016llx-0x%016llx]",
 119                         efi_fake_mems[i].attribute, efi_fake_mems[i].range.start,
 120                         efi_fake_mems[i].range.end);
 121
 122         return *p == '\0' ? 0 : -EINVAL;
 123 }
 124
 125 early_param("efi_fake_mem", setup_fake_mem);