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         struct efi_memory_map_data data = { 0 };
  40         int new_nr_map = efi.memmap.nr_map;
  41         efi_memory_desc_t *md;
  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         if (efi_memmap_alloc(new_nr_map, &data) != 0)
  59                 return;
  60
  61         /* create new EFI memmap */
  62         new_memmap = early_memremap(data.phys_map, data.size);
  63         if (!new_memmap) {
  64                 memblock_free(data.phys_map, data.size);
  65                 return;
  66         }
  67
  68         for (i = 0; i < nr_fake_mem; i++)
  69                 efi_memmap_insert(&efi.memmap, new_memmap, &efi_fake_mems[i]);
  70
  71         /* swap into new EFI memmap */
  72         early_memunmap(new_memmap, data.size);
  73
  74         efi_memmap_install(&data);
  75
  76         /* print new EFI memmap */
  77         efi_print_memmap();
  78 }
  79
  80 static int __init setup_fake_mem(char *p)
  81 {
  82         u64 start = 0, mem_size = 0, attribute = 0;
  83         int i;
  84
  85         if (!p)
  86                 return -EINVAL;
  87
  88         while (*p != '\0') {
  89                 mem_size = memparse(p, &p);
  90                 if (*p == '@')
  91                         start = memparse(p+1, &p);
  92                 else
  93                         break;
  94
  95                 if (*p == ':')
  96                         attribute = simple_strtoull(p+1, &p, 0);
  97                 else
  98                         break;
  99
 100                 if (nr_fake_mem >= EFI_MAX_FAKEMEM)
 101                         break;
 102
 103                 efi_fake_mems[nr_fake_mem].range.start = start;
 104                 efi_fake_mems[nr_fake_mem].range.end = start + mem_size - 1;
 105                 efi_fake_mems[nr_fake_mem].attribute = attribute;
 106                 nr_fake_mem++;
 107
 108                 if (*p == ',')
 109                         p++;
 110         }
 111
 112         sort(efi_fake_mems, nr_fake_mem, sizeof(struct efi_mem_range),
 113              cmp_fake_mem, NULL);
 114
 115         for (i = 0; i < nr_fake_mem; i++)
 116                 pr_info("efi_fake_mem: add attr=0x%016llx to [mem 0x%016llx-0x%016llx]",
 117                         efi_fake_mems[i].attribute, efi_fake_mems[i].range.start,
 118                         efi_fake_mems[i].range.end);
 119
 120         return *p == '\0' ? 0 : -EINVAL;
 121 }
 122
 123 early_param("efi_fake_mem", setup_fake_mem);