x86/e820: Prepare e280 code for switch to dynamic storage

This patch turns e820 and e820_saved into pointers to e820 tables,
of the same size as before.

Signed-off-by: Denys Vlasenko <dvlasenk@redhat.com>
Acked-by: Thomas Gleixner <tglx@linutronix.de>
Cc: Andy Lutomirski <luto@amacapital.net>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Josh Poimboeuf <jpoimboe@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Yinghai Lu <yinghai@kernel.org>
Cc: linux-kernel@vger.kernel.org
Link: http://lkml.kernel.org/r/20160917213927.1787-2-dvlasenk@redhat.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>

diff --git a/arch/x86/include/asm/e820.h b/arch/x86/include/asm/e820.h
index 3ab0537872fb790e6864674efcf3130324687723..476b574de99ee37160c2f6a9924cf8bb23f8ddf7 100644 (file)
--- a/arch/x86/include/asm/e820.h
+++ b/arch/x86/include/asm/e820.h
@@ -10,8 +10,8 @@
 #include <uapi/asm/e820.h>
 #ifndef __ASSEMBLY__
 /* see comment in arch/x86/kernel/e820.c */
-extern struct e820map e820;
-extern struct e820map e820_saved;
+extern struct e820map *e820;
+extern struct e820map *e820_saved;
 
 extern unsigned long pci_mem_start;
 extern int e820_any_mapped(u64 start, u64 end, unsigned type);
@@ -53,6 +53,8 @@ extern void e820_reserve_resources_late(void);
 extern void setup_memory_map(void);
 extern char *default_machine_specific_memory_setup(void);
 
+extern void e820_reallocate_tables(void);
+
 /*
  * Returns true iff the specified range [s,e) is completely contained inside
  * the ISA region.

diff --git a/arch/x86/kernel/e820.c b/arch/x86/kernel/e820.c
index 4d3dd9a713c7cc6256d0a150981b1f39b1265efd..585000c98d3e57ff1a3c88fa34342b91536f2e53 100644 (file)
--- a/arch/x86/kernel/e820.c
+++ b/arch/x86/kernel/e820.c
@@ -40,8 +40,10 @@
  * user can e.g. boot the original kernel with mem=1G while still booting the
  * next kernel with full memory.
  */
-struct e820map e820;
-struct e820map e820_saved;
+static struct e820map initial_e820;
+static struct e820map initial_e820_saved;
+struct e820map *e820 = &initial_e820;
+struct e820map *e820_saved = &initial_e820_saved;
 
 /* For PCI or other memory-mapped resources */
 unsigned long pci_mem_start = 0xaeedbabe;
@@ -58,8 +60,8 @@ e820_any_mapped(u64 start, u64 end, unsigned type)
 {
        int i;
 
-       for (i = 0; i < e820.nr_map; i++) {
-               struct e820entry *ei = &e820.map[i];
+       for (i = 0; i < e820->nr_map; i++) {
+               struct e820entry *ei = &e820->map[i];
 
                if (type && ei->type != type)
                        continue;
@@ -81,8 +83,8 @@ int __init e820_all_mapped(u64 start, u64 end, unsigned type)
 {
        int i;
 
-       for (i = 0; i < e820.nr_map; i++) {
-               struct e820entry *ei = &e820.map[i];
+       for (i = 0; i < e820->nr_map; i++) {
+               struct e820entry *ei = &e820->map[i];
 
                if (type && ei->type != type)
                        continue;
@@ -128,7 +130,7 @@ static void __init __e820_add_region(struct e820map *e820x, u64 start, u64 size,
 
 void __init e820_add_region(u64 start, u64 size, int type)
 {
-       __e820_add_region(&e820, start, size, type);
+       __e820_add_region(e820, start, size, type);
 }
 
 static void __init e820_print_type(u32 type)
@@ -164,12 +166,12 @@ void __init e820_print_map(char *who)
 {
        int i;
 
-       for (i = 0; i < e820.nr_map; i++) {
+       for (i = 0; i < e820->nr_map; i++) {
                printk(KERN_INFO "%s: [mem %#018Lx-%#018Lx] ", who,
-                      (unsigned long long) e820.map[i].addr,
+                      (unsigned long long) e820->map[i].addr,
                       (unsigned long long)
-                      (e820.map[i].addr + e820.map[i].size - 1));
-               e820_print_type(e820.map[i].type);
+                      (e820->map[i].addr + e820->map[i].size - 1));
+               e820_print_type(e820->map[i].type);
                printk(KERN_CONT "\n");
        }
 }
@@ -493,13 +495,13 @@ static u64 __init __e820_update_range(struct e820map *e820x, u64 start,
 u64 __init e820_update_range(u64 start, u64 size, unsigned old_type,
                             unsigned new_type)
 {
-       return __e820_update_range(&e820, start, size, old_type, new_type);
+       return __e820_update_range(e820, start, size, old_type, new_type);
 }
 
 static u64 __init e820_update_range_saved(u64 start, u64 size,
                                          unsigned old_type, unsigned new_type)
 {
-       return __e820_update_range(&e820_saved, start, size, old_type,
+       return __e820_update_range(e820_saved, start, size, old_type,
                                     new_type);
 }
 
@@ -521,8 +523,8 @@ u64 __init e820_remove_range(u64 start, u64 size, unsigned old_type,
                e820_print_type(old_type);
        printk(KERN_CONT "\n");
 
-       for (i = 0; i < e820.nr_map; i++) {
-               struct e820entry *ei = &e820.map[i];
+       for (i = 0; i < e820->nr_map; i++) {
+               struct e820entry *ei = &e820->map[i];
                u64 final_start, final_end;
                u64 ei_end;
 
@@ -566,15 +568,15 @@ u64 __init e820_remove_range(u64 start, u64 size, unsigned old_type,
 
 void __init update_e820(void)
 {
-       if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map))
+       if (sanitize_e820_map(e820->map, ARRAY_SIZE(e820->map), &e820->nr_map))
                return;
        printk(KERN_INFO "e820: modified physical RAM map:\n");
        e820_print_map("modified");
 }
 static void __init update_e820_saved(void)
 {
-       sanitize_e820_map(e820_saved.map, ARRAY_SIZE(e820_saved.map),
-                               &e820_saved.nr_map);
+       sanitize_e820_map(e820_saved->map, ARRAY_SIZE(e820_saved->map),
+                               &e820_saved->nr_map);
 }
 #define MAX_GAP_END 0x100000000ull
 /*
@@ -584,14 +586,14 @@ __init int e820_search_gap(unsigned long *gapstart, unsigned long *gapsize,
                unsigned long start_addr, unsigned long long end_addr)
 {
        unsigned long long last;
-       int i = e820.nr_map;
+       int i = e820->nr_map;
        int found = 0;
 
        last = (end_addr && end_addr < MAX_GAP_END) ? end_addr : MAX_GAP_END;
 
        while (--i >= 0) {
-               unsigned long long start = e820.map[i].addr;
-               unsigned long long end = start + e820.map[i].size;
+               unsigned long long start = e820->map[i].addr;
+               unsigned long long end = start + e820->map[i].size;
 
                if (end < start_addr)
                        continue;
@@ -649,6 +651,33 @@ __init void e820_setup_gap(void)
               gapstart, gapstart + gapsize - 1);
 }
 
+/*
+ * Called late during init, in free_initmem().
+ *
+ * Initial e820 and e820_saved are largish __initdata arrays.
+ * Copy them to (usually much smaller) dynamically allocated area.
+ * This is done after all tweaks we ever do to them:
+ * all functions which modify them are __init functions,
+ * they won't exist after this point.
+ */
+__init void e820_reallocate_tables(void)
+{
+       struct e820map *n;
+       int size;
+
+       size = offsetof(struct e820map, map) + sizeof(struct e820entry) * e820->nr_map;
+       n = kmalloc(size, GFP_KERNEL);
+       BUG_ON(!n);
+       memcpy(n, e820, size);
+       e820 = n;
+
+       size = offsetof(struct e820map, map) + sizeof(struct e820entry) * e820_saved->nr_map;
+       n = kmalloc(size, GFP_KERNEL);
+       BUG_ON(!n);
+       memcpy(n, e820_saved, size);
+       e820_saved = n;
+}
+
 /**
  * Because of the size limitation of struct boot_params, only first
  * 128 E820 memory entries are passed to kernel via
@@ -665,7 +694,7 @@ void __init parse_e820_ext(u64 phys_addr, u32 data_len)
        entries = sdata->len / sizeof(struct e820entry);
        extmap = (struct e820entry *)(sdata->data);
        __append_e820_map(extmap, entries);
-       sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
+       sanitize_e820_map(e820->map, ARRAY_SIZE(e820->map), &e820->nr_map);
        early_memunmap(sdata, data_len);
        printk(KERN_INFO "e820: extended physical RAM map:\n");
        e820_print_map("extended");
@@ -686,8 +715,8 @@ void __init e820_mark_nosave_regions(unsigned long limit_pfn)
        int i;
        unsigned long pfn = 0;
 
-       for (i = 0; i < e820.nr_map; i++) {
-               struct e820entry *ei = &e820.map[i];
+       for (i = 0; i < e820->nr_map; i++) {
+               struct e820entry *ei = &e820->map[i];
 
                if (pfn < PFN_UP(ei->addr))
                        register_nosave_region(pfn, PFN_UP(ei->addr));
@@ -712,8 +741,8 @@ static int __init e820_mark_nvs_memory(void)
 {
        int i;
 
-       for (i = 0; i < e820.nr_map; i++) {
-               struct e820entry *ei = &e820.map[i];
+       for (i = 0; i < e820->nr_map; i++) {
+               struct e820entry *ei = &e820->map[i];
 
                if (ei->type == E820_NVS)
                        acpi_nvs_register(ei->addr, ei->size);
@@ -760,8 +789,8 @@ static unsigned long __init e820_end_pfn(unsigned long limit_pfn)
        unsigned long last_pfn = 0;
        unsigned long max_arch_pfn = MAX_ARCH_PFN;
 
-       for (i = 0; i < e820.nr_map; i++) {
-               struct e820entry *ei = &e820.map[i];
+       for (i = 0; i < e820->nr_map; i++) {
+               struct e820entry *ei = &e820->map[i];
                unsigned long start_pfn;
                unsigned long end_pfn;
 
@@ -856,7 +885,7 @@ static int __init parse_memmap_one(char *p)
                 */
                saved_max_pfn = e820_end_of_ram_pfn();
 #endif
-               e820.nr_map = 0;
+               e820->nr_map = 0;
                userdef = 1;
                return 0;
        }
@@ -903,8 +932,8 @@ early_param("memmap", parse_memmap_opt);
 void __init finish_e820_parsing(void)
 {
        if (userdef) {
-               if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map),
-                                       &e820.nr_map) < 0)
+               if (sanitize_e820_map(e820->map, ARRAY_SIZE(e820->map),
+                                       &e820->nr_map) < 0)
                        early_panic("Invalid user supplied memory map");
 
                printk(KERN_INFO "e820: user-defined physical RAM map:\n");
@@ -991,35 +1020,35 @@ void __init e820_reserve_resources(void)
        struct resource *res;
        u64 end;
 
-       res = alloc_bootmem(sizeof(struct resource) * e820.nr_map);
+       res = alloc_bootmem(sizeof(struct resource) * e820->nr_map);
        e820_res = res;
-       for (i = 0; i < e820.nr_map; i++) {
-               end = e820.map[i].addr + e820.map[i].size - 1;
+       for (i = 0; i < e820->nr_map; i++) {
+               end = e820->map[i].addr + e820->map[i].size - 1;
                if (end != (resource_size_t)end) {
                        res++;
                        continue;
                }
-               res->name = e820_type_to_string(e820.map[i].type);
-               res->start = e820.map[i].addr;
+               res->name = e820_type_to_string(e820->map[i].type);
+               res->start = e820->map[i].addr;
                res->end = end;
 
-               res->flags = e820_type_to_iomem_type(e820.map[i].type);
-               res->desc = e820_type_to_iores_desc(e820.map[i].type);
+               res->flags = e820_type_to_iomem_type(e820->map[i].type);
+               res->desc = e820_type_to_iores_desc(e820->map[i].type);
 
                /*
                 * don't register the region that could be conflicted with
                 * pci device BAR resource and insert them later in
                 * pcibios_resource_survey()
                 */
-               if (do_mark_busy(e820.map[i].type, res)) {
+               if (do_mark_busy(e820->map[i].type, res)) {
                        res->flags |= IORESOURCE_BUSY;
                        insert_resource(&iomem_resource, res);
                }
                res++;
        }
 
-       for (i = 0; i < e820_saved.nr_map; i++) {
-               struct e820entry *entry = &e820_saved.map[i];
+       for (i = 0; i < e820_saved->nr_map; i++) {
+               struct e820entry *entry = &e820_saved->map[i];
                firmware_map_add_early(entry->addr,
                        entry->addr + entry->size,
                        e820_type_to_string(entry->type));
@@ -1051,7 +1080,7 @@ void __init e820_reserve_resources_late(void)
        struct resource *res;
 
        res = e820_res;
-       for (i = 0; i < e820.nr_map; i++) {
+       for (i = 0; i < e820->nr_map; i++) {
                if (!res->parent && res->end)
                        insert_resource_expand_to_fit(&iomem_resource, res);
                res++;
@@ -1061,8 +1090,8 @@ void __init e820_reserve_resources_late(void)
         * Try to bump up RAM regions to reasonable boundaries to
         * avoid stolen RAM:
         */
-       for (i = 0; i < e820.nr_map; i++) {
-               struct e820entry *entry = &e820.map[i];
+       for (i = 0; i < e820->nr_map; i++) {
+               struct e820entry *entry = &e820->map[i];
                u64 start, end;
 
                if (entry->type != E820_RAM)
@@ -1110,7 +1139,7 @@ char *__init default_machine_specific_memory_setup(void)
                        who = "BIOS-e801";
                }
 
-               e820.nr_map = 0;
+               e820->nr_map = 0;
                e820_add_region(0, LOWMEMSIZE(), E820_RAM);
                e820_add_region(HIGH_MEMORY, mem_size << 10, E820_RAM);
        }
@@ -1124,7 +1153,7 @@ void __init setup_memory_map(void)
        char *who;
 
        who = x86_init.resources.memory_setup();
-       memcpy(&e820_saved, &e820, sizeof(struct e820map));
+       memcpy(e820_saved, e820, sizeof(struct e820map));
        printk(KERN_INFO "e820: BIOS-provided physical RAM map:\n");
        e820_print_map(who);
 }
@@ -1141,8 +1170,8 @@ void __init memblock_x86_fill(void)
         */
        memblock_allow_resize();
 
-       for (i = 0; i < e820.nr_map; i++) {
-               struct e820entry *ei = &e820.map[i];
+       for (i = 0; i < e820->nr_map; i++) {
+               struct e820entry *ei = &e820->map[i];
 
                end = ei->addr + ei->size;
                if (end != (resource_size_t)end)

diff --git a/arch/x86/kernel/early-quirks.c b/arch/x86/kernel/early-quirks.c
index de7501edb21ce5de48db107191cd87a7c2515c65..18bb3a639197cf27e04475cee3d939508a868249 100644 (file)
--- a/arch/x86/kernel/early-quirks.c
+++ b/arch/x86/kernel/early-quirks.c
@@ -555,7 +555,7 @@ intel_graphics_stolen(int num, int slot, int func,
 
        /* Mark this space as reserved */
        e820_add_region(base, size, E820_RESERVED);
-       sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
+       sanitize_e820_map(e820->map, ARRAY_SIZE(e820->map), &e820->nr_map);
 }
 
 static void __init intel_graphics_quirks(int num, int slot, int func)

diff --git a/arch/x86/kernel/kexec-bzimage64.c b/arch/x86/kernel/kexec-bzimage64.c
index f2356bda2b0546c245f9274f22cd2e429c29b52b..3407b148c2401342caed9fb57f3e8a0e4c1689e4 100644 (file)
--- a/arch/x86/kernel/kexec-bzimage64.c
+++ b/arch/x86/kernel/kexec-bzimage64.c
@@ -99,14 +99,14 @@ static int setup_e820_entries(struct boot_params *params)
 {
        unsigned int nr_e820_entries;
 
-       nr_e820_entries = e820_saved.nr_map;
+       nr_e820_entries = e820_saved->nr_map;
 
        /* TODO: Pass entries more than E820MAX in bootparams setup data */
        if (nr_e820_entries > E820MAX)
                nr_e820_entries = E820MAX;
 
        params->e820_entries = nr_e820_entries;
-       memcpy(&params->e820_map, &e820_saved.map,
+       memcpy(&params->e820_map, &e820_saved->map,
               nr_e820_entries * sizeof(struct e820entry));
 
        return 0;

diff --git a/arch/x86/kernel/resource.c b/arch/x86/kernel/resource.c
index 80eab01c1a68a735538bd0b6c479520f10f853aa..2408c1603438ca360a72c0fe6434427d1295beb4 100644 (file)
--- a/arch/x86/kernel/resource.c
+++ b/arch/x86/kernel/resource.c
@@ -27,8 +27,8 @@ static void remove_e820_regions(struct resource *avail)
        int i;
        struct e820entry *entry;
 
-       for (i = 0; i < e820.nr_map; i++) {
-               entry = &e820.map[i];
+       for (i = 0; i < e820->nr_map; i++) {
+               entry = &e820->map[i];
 
                resource_clip(avail, entry->addr,
                              entry->addr + entry->size - 1);

diff --git a/arch/x86/kernel/setup.c b/arch/x86/kernel/setup.c
index 0fa60f5f5a1641dc8eb2c82968dbadd650ed6e37..cc43d660c990d672d3a340d735755fe30943121c 100644 (file)
--- a/arch/x86/kernel/setup.c
+++ b/arch/x86/kernel/setup.c
@@ -458,8 +458,8 @@ static void __init e820_reserve_setup_data(void)
                early_memunmap(data, sizeof(*data));
        }
 
-       sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
-       memcpy(&e820_saved, &e820, sizeof(struct e820map));
+       sanitize_e820_map(e820->map, ARRAY_SIZE(e820->map), &e820->nr_map);
+       memcpy(e820_saved, e820, sizeof(struct e820map));
        printk(KERN_INFO "extended physical RAM map:\n");
        e820_print_map("reserve setup_data");
 }
@@ -763,7 +763,7 @@ static void __init trim_bios_range(void)
         */
        e820_remove_range(BIOS_BEGIN, BIOS_END - BIOS_BEGIN, E820_RAM, 1);
 
-       sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
+       sanitize_e820_map(e820->map, ARRAY_SIZE(e820->map), &e820->nr_map);
 }
 
 /* called before trim_bios_range() to spare extra sanitize */
@@ -1032,7 +1032,7 @@ void __init setup_arch(char **cmdline_p)
        if (ppro_with_ram_bug()) {
                e820_update_range(0x70000000ULL, 0x40000ULL, E820_RAM,
                                  E820_RESERVED);
-               sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
+               sanitize_e820_map(e820->map, ARRAY_SIZE(e820->map), &e820->nr_map);
                printk(KERN_INFO "fixed physical RAM map:\n");
                e820_print_map("bad_ppro");
        }

diff --git a/arch/x86/kernel/tboot.c b/arch/x86/kernel/tboot.c
index 654f6c66fe45b2426c0e2a74a50e478c135eb216..8402907825b02706f87283c45b5e27086a9cce0b 100644 (file)
--- a/arch/x86/kernel/tboot.c
+++ b/arch/x86/kernel/tboot.c
@@ -188,12 +188,12 @@ static int tboot_setup_sleep(void)
 
        tboot->num_mac_regions = 0;
 
-       for (i = 0; i < e820.nr_map; i++) {
-               if ((e820.map[i].type != E820_RAM)
-                && (e820.map[i].type != E820_RESERVED_KERN))
+       for (i = 0; i < e820->nr_map; i++) {
+               if ((e820->map[i].type != E820_RAM)
+                && (e820->map[i].type != E820_RESERVED_KERN))
                        continue;
 
-               add_mac_region(e820.map[i].addr, e820.map[i].size);
+               add_mac_region(e820->map[i].addr, e820->map[i].size);
        }
 
        tboot->acpi_sinfo.kernel_s3_resume_vector =

diff --git a/arch/x86/mm/init.c b/arch/x86/mm/init.c
index d28a2d741f9e9e74e989272101b4a50e1ffa3050..167deae767cb80d960b62c5208f4f030e2e13951 100644 (file)
--- a/arch/x86/mm/init.c
+++ b/arch/x86/mm/init.c
@@ -701,6 +701,8 @@ void free_init_pages(char *what, unsigned long begin, unsigned long end)
 
 void free_initmem(void)
 {
+       /* e820_reallocate_tables(); - disabled for now */
+
        free_init_pages("unused kernel",
                        (unsigned long)(&__init_begin),
                        (unsigned long)(&__init_end));

diff --git a/arch/x86/platform/efi/efi.c b/arch/x86/platform/efi/efi.c
index 1fbb408e2e721837e7d28a9cdfdf59ffd96973d3..2e3433444b659483b7c1de10a6e9fc0145527ecb 100644 (file)
--- a/arch/x86/platform/efi/efi.c
+++ b/arch/x86/platform/efi/efi.c
@@ -166,7 +166,7 @@ static void __init do_add_efi_memmap(void)
                }
                e820_add_region(start, size, e820_type);
        }
-       sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
+       sanitize_e820_map(e820->map, ARRAY_SIZE(e820->map), &e820->nr_map);
 }
 
 int __init efi_memblock_x86_reserve_range(void)

diff --git a/arch/x86/xen/setup.c b/arch/x86/xen/setup.c
index 176425233e4d4d07ecb6633d38806d37a2598db0..f8960fca08273b9e808ecb81db70d371052eb957 100644 (file)
--- a/arch/x86/xen/setup.c
+++ b/arch/x86/xen/setup.c
@@ -861,7 +861,7 @@ char * __init xen_memory_setup(void)
        e820_add_region(ISA_START_ADDRESS, ISA_END_ADDRESS - ISA_START_ADDRESS,
                        E820_RESERVED);
 
-       sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
+       sanitize_e820_map(e820->map, ARRAY_SIZE(e820->map), &e820->nr_map);
 
        /*
         * Check whether the kernel itself conflicts with the target E820 map.