drivers/firmware/efi/fake_mem.c

   1 /*
   2  * fake_mem.c
   3  *
   4  * Copyright (C) 2015 FUJITSU LIMITED
   5  * Author: Taku Izumi <izumi.taku@jp.fujitsu.com>
   6  *
   7  * This code introduces new boot option named "efi_fake_mem"
   8  * By specifying this parameter, you can add arbitrary attribute to
   9  * specific memory range by updating original (firmware provided) EFI
  10  * memmap.
  11  *
  12  *  This program is free software; you can redistribute it and/or modify it
  13  *  under the terms and conditions of the GNU General Public License,
  14  *  version 2, as published by the Free Software Foundation.
  15  *
  16  *  This program is distributed in the hope it will be useful, but WITHOUT
  17  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18  *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  19  *  more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License along with
  22  *  this program; if not, see <http://www.gnu.org/licenses/>.
  23  *
  24  *  The full GNU General Public License is included in this distribution in
  25  *  the file called "COPYING".
  26  */
  27
  28 #include <linux/kernel.h>
  29 #include <linux/efi.h>
  30 #include <linux/init.h>
  31 #include <linux/memblock.h>
  32 #include <linux/types.h>
  33 #include <linux/sort.h>
  34 #include <asm/efi.h>
  35
  36 #define EFI_MAX_FAKEMEM CONFIG_EFI_MAX_FAKE_MEM
  37
  38 static struct efi_mem_range fake_mems[EFI_MAX_FAKEMEM];
  39 static int nr_fake_mem;
  40
  41 static int __init cmp_fake_mem(const void *x1, const void *x2)
  42 {
  43         const struct efi_mem_range *m1 = x1;
  44         const struct efi_mem_range *m2 = x2;
  45
  46         if (m1->range.start < m2->range.start)
  47                 return -1;
  48         if (m1->range.start > m2->range.start)
  49                 return 1;
  50         return 0;
  51 }
  52
  53 void __init efi_fake_memmap(void)
  54 {
  55         int new_nr_map = efi.memmap.nr_map;
  56         efi_memory_desc_t *md;
  57         phys_addr_t new_memmap_phy;
  58         void *new_memmap;
  59         int i;
  60
  61         if (!nr_fake_mem)
  62                 return;
  63
  64         /* count up the number of EFI memory descriptor */
  65         for (i = 0; i < nr_fake_mem; i++) {
  66                 for_each_efi_memory_desc(md) {
  67                         struct range *r = &fake_mems[i].range;
  68
  69                         new_nr_map += efi_memmap_split_count(md, r);
  70                 }
  71         }
  72
  73         /* allocate memory for new EFI memmap */
  74         new_memmap_phy = efi_memmap_alloc(new_nr_map);
  75         if (!new_memmap_phy)
  76                 return;
  77
  78         /* create new EFI memmap */
  79         new_memmap = early_memremap(new_memmap_phy,
  80                                     efi.memmap.desc_size * new_nr_map);
  81         if (!new_memmap) {
  82                 memblock_free(new_memmap_phy, efi.memmap.desc_size * new_nr_map);
  83                 return;
  84         }
  85
  86         for (i = 0; i < nr_fake_mem; i++)
  87                 efi_memmap_insert(&efi.memmap, new_memmap, &fake_mems[i]);
  88
  89         /* swap into new EFI memmap */
  90         early_memunmap(new_memmap, efi.memmap.desc_size * new_nr_map);
  91
  92         efi_memmap_install(new_memmap_phy, new_nr_map);
  93
  94         /* print new EFI memmap */
  95         efi_print_memmap();
  96 }
  97
  98 static int __init setup_fake_mem(char *p)
  99 {
 100         u64 start = 0, mem_size = 0, attribute = 0;
 101         int i;
 102
 103         if (!p)
 104                 return -EINVAL;
 105
 106         while (*p != '\0') {
 107                 mem_size = memparse(p, &p);
 108                 if (*p == '@')
 109                         start = memparse(p+1, &p);
 110                 else
 111                         break;
 112
 113                 if (*p == ':')
 114                         attribute = simple_strtoull(p+1, &p, 0);
 115                 else
 116                         break;
 117
 118                 if (nr_fake_mem >= EFI_MAX_FAKEMEM)
 119                         break;
 120
 121                 fake_mems[nr_fake_mem].range.start = start;
 122                 fake_mems[nr_fake_mem].range.end = start + mem_size - 1;
 123                 fake_mems[nr_fake_mem].attribute = attribute;
 124                 nr_fake_mem++;
 125
 126                 if (*p == ',')
 127                         p++;
 128         }
 129
 130         sort(fake_mems, nr_fake_mem, sizeof(struct efi_mem_range),
 131              cmp_fake_mem, NULL);
 132
 133         for (i = 0; i < nr_fake_mem; i++)
 134                 pr_info("efi_fake_mem: add attr=0x%016llx to [mem 0x%016llx-0x%016llx]",
 135                         fake_mems[i].attribute, fake_mems[i].range.start,
 136                         fake_mems[i].range.end);
 137
 138         return *p == '\0' ? 0 : -EINVAL;
 139 }
 140
 141 early_param("efi_fake_mem", setup_fake_mem);