1 files changed, 62 insertions, 71 deletions

diff --git a/arch/x86/platform/efi/efi.c b/arch/x86/platform/efi/efi.c
index 994a7df84a7b..f93545e7dc54 100644
--- a/arch/x86/platform/efi/efi.c
+++ b/arch/x86/platform/efi/efi.c
@@ -54,10 +54,6 @@
 #include <asm/rtc.h>
 #include <asm/uv/uv.h>
 
-#define EFI_DEBUG
-
-struct efi_memory_map memmap;
-
 static struct efi efi_phys __initdata;
 static efi_system_table_t efi_systab __initdata;
 
@@ -119,11 +115,10 @@ void efi_get_time(struct timespec *now)
 
 void __init efi_find_mirror(void)
 {
-        void *p;
+        efi_memory_desc_t *md;
         u64 mirror_size = 0, total_size = 0;
 
-        for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
-                efi_memory_desc_t *md = p;
+        for_each_efi_memory_desc(md) {
                 unsigned long long start = md->phys_addr;
                 unsigned long long size = md->num_pages << EFI_PAGE_SHIFT;
 
@@ -146,10 +141,9 @@ void __init efi_find_mirror(void)
 
 static void __init do_add_efi_memmap(void)
 {
-        void *p;
+        efi_memory_desc_t *md;
 
-        for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
-                efi_memory_desc_t *md = p;
+        for_each_efi_memory_desc(md) {
                 unsigned long long start = md->phys_addr;
                 unsigned long long size = md->num_pages << EFI_PAGE_SHIFT;
                 int e820_type;
@@ -209,47 +203,47 @@ int __init efi_memblock_x86_reserve_range(void)
 #else
         pmap = (e->efi_memmap | ((__u64)e->efi_memmap_hi << 32));
 #endif
-        memmap.phys_map         = pmap;
-        memmap.nr_map           = e->efi_memmap_size /
+        efi.memmap.phys_map     = pmap;
+        efi.memmap.nr_map       = e->efi_memmap_size /
                                   e->efi_memdesc_size;
-        memmap.desc_size        = e->efi_memdesc_size;
-        memmap.desc_version     = e->efi_memdesc_version;
+        efi.memmap.desc_size    = e->efi_memdesc_size;
+        efi.memmap.desc_version = e->efi_memdesc_version;
 
-        memblock_reserve(pmap, memmap.nr_map * memmap.desc_size);
+        WARN(efi.memmap.desc_version != 1,
+             "Unexpected EFI_MEMORY_DESCRIPTOR version %ld",
+             efi.memmap.desc_version);
 
-        efi.memmap = &memmap;
+        memblock_reserve(pmap, efi.memmap.nr_map * efi.memmap.desc_size);
 
         return 0;
 }
 
 void __init efi_print_memmap(void)
 {
-#ifdef EFI_DEBUG
         efi_memory_desc_t *md;
-        void *p;
-        int i;
+        int i = 0;
 
-        for (p = memmap.map, i = 0;
-             p < memmap.map_end;
-             p += memmap.desc_size, i++) {
+        for_each_efi_memory_desc(md) {
                 char buf[64];
 
-                md = p;
                 pr_info("mem%02u: %s range=[0x%016llx-0x%016llx] (%lluMB)\n",
-                        i, efi_md_typeattr_format(buf, sizeof(buf), md),
+                        i++, efi_md_typeattr_format(buf, sizeof(buf), md),
                         md->phys_addr,
                         md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT) - 1,
                         (md->num_pages >> (20 - EFI_PAGE_SHIFT)));
         }
-#endif  /*  EFI_DEBUG  */
 }
 
 void __init efi_unmap_memmap(void)
 {
+        unsigned long size;
+
         clear_bit(EFI_MEMMAP, &efi.flags);
-        if (memmap.map) {
-                early_memunmap(memmap.map, memmap.nr_map * memmap.desc_size);
-                memmap.map = NULL;
+
+        size = efi.memmap.nr_map * efi.memmap.desc_size;
+        if (efi.memmap.map) {
+                early_memunmap(efi.memmap.map, size);
+                efi.memmap.map = NULL;
         }
 }
 
@@ -352,8 +346,6 @@ static int __init efi_systab_init(void *phys)
                        efi.systab->hdr.revision >> 16,
                        efi.systab->hdr.revision & 0xffff);
 
-        set_bit(EFI_SYSTEM_TABLES, &efi.flags);
-
         return 0;
 }
 
@@ -440,17 +432,22 @@ static int __init efi_runtime_init(void)
 
 static int __init efi_memmap_init(void)
 {
+        unsigned long addr, size;
+
         if (efi_enabled(EFI_PARAVIRT))
                 return 0;
 
         /* Map the EFI memory map */
-        memmap.map = early_memremap((unsigned long)memmap.phys_map,
-                                   memmap.nr_map * memmap.desc_size);
-        if (memmap.map == NULL) {
+        size = efi.memmap.nr_map * efi.memmap.desc_size;
+        addr = (unsigned long)efi.memmap.phys_map;
+
+        efi.memmap.map = early_memremap(addr, size);
+        if (efi.memmap.map == NULL) {
                 pr_err("Could not map the memory map!\n");
                 return -ENOMEM;
         }
-        memmap.map_end = memmap.map + (memmap.nr_map * memmap.desc_size);
+
+        efi.memmap.map_end = efi.memmap.map + size;
 
         if (add_efi_memmap)
                 do_add_efi_memmap();
@@ -552,12 +549,9 @@ void __init efi_set_executable(efi_memory_desc_t *md, bool executable)
 void __init runtime_code_page_mkexec(void)
 {
         efi_memory_desc_t *md;
-        void *p;
 
         /* Make EFI runtime service code area executable */
-        for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
-                md = p;
-
+        for_each_efi_memory_desc(md) {
                 if (md->type != EFI_RUNTIME_SERVICES_CODE)
                         continue;
 
@@ -604,12 +598,10 @@ void __init old_map_region(efi_memory_desc_t *md)
 /* Merge contiguous regions of the same type and attribute */
 static void __init efi_merge_regions(void)
 {
-        void *p;
         efi_memory_desc_t *md, *prev_md = NULL;
 
-        for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
+        for_each_efi_memory_desc(md) {
                 u64 prev_size;
-                md = p;
 
                 if (!prev_md) {
                         prev_md = md;
@@ -651,30 +643,31 @@ static void __init get_systab_virt_addr(efi_memory_desc_t *md)
 static void __init save_runtime_map(void)
 {
 #ifdef CONFIG_KEXEC_CORE
+        unsigned long desc_size;
         efi_memory_desc_t *md;
-        void *tmp, *p, *q = NULL;
+        void *tmp, *q = NULL;
         int count = 0;
 
         if (efi_enabled(EFI_OLD_MEMMAP))
                 return;
 
-        for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
-                md = p;
+        desc_size = efi.memmap.desc_size;
 
+        for_each_efi_memory_desc(md) {
                 if (!(md->attribute & EFI_MEMORY_RUNTIME) ||
                     (md->type == EFI_BOOT_SERVICES_CODE) ||
                     (md->type == EFI_BOOT_SERVICES_DATA))
                         continue;
-                tmp = krealloc(q, (count + 1) * memmap.desc_size, GFP_KERNEL);
+                tmp = krealloc(q, (count + 1) * desc_size, GFP_KERNEL);
                 if (!tmp)
                         goto out;
                 q = tmp;
 
-                memcpy(q + count * memmap.desc_size, md, memmap.desc_size);
+                memcpy(q + count * desc_size, md, desc_size);
                 count++;
         }
 
-        efi_runtime_map_setup(q, count, memmap.desc_size);
+        efi_runtime_map_setup(q, count, desc_size);
         return;
 
 out:
@@ -714,10 +707,10 @@ static inline void *efi_map_next_entry_reverse(void *entry)
 {
         /* Initial call */
         if (!entry)
-                return memmap.map_end - memmap.desc_size;
+                return efi.memmap.map_end - efi.memmap.desc_size;
 
-        entry -= memmap.desc_size;
-        if (entry < memmap.map)
+        entry -= efi.memmap.desc_size;
+        if (entry < efi.memmap.map)
                 return NULL;
 
         return entry;
@@ -759,10 +752,10 @@ static void *efi_map_next_entry(void *entry)
 
         /* Initial call */
         if (!entry)
-                return memmap.map;
+                return efi.memmap.map;
 
-        entry += memmap.desc_size;
-        if (entry >= memmap.map_end)
+        entry += efi.memmap.desc_size;
+        if (entry >= efi.memmap.map_end)
                 return NULL;
 
         return entry;
@@ -776,8 +769,11 @@ static void * __init efi_map_regions(int *count, int *pg_shift)
 {
         void *p, *new_memmap = NULL;
         unsigned long left = 0;
+        unsigned long desc_size;
         efi_memory_desc_t *md;
 
+        desc_size = efi.memmap.desc_size;
+
         p = NULL;
         while ((p = efi_map_next_entry(p))) {
                 md = p;
@@ -792,7 +788,7 @@ static void * __init efi_map_regions(int *count, int *pg_shift)
                 efi_map_region(md);
                 get_systab_virt_addr(md);
 
-                if (left < memmap.desc_size) {
+                if (left < desc_size) {
                         new_memmap = realloc_pages(new_memmap, *pg_shift);
                         if (!new_memmap)
                                 return NULL;
@@ -801,10 +797,9 @@ static void * __init efi_map_regions(int *count, int *pg_shift)
                         (*pg_shift)++;
                 }
 
-                memcpy(new_memmap + (*count * memmap.desc_size), md,
-                       memmap.desc_size);
+                memcpy(new_memmap + (*count * desc_size), md, desc_size);
 
-                left -= memmap.desc_size;
+                left -= desc_size;
                 (*count)++;
         }
 
@@ -816,7 +811,6 @@ static void __init kexec_enter_virtual_mode(void)
 #ifdef CONFIG_KEXEC_CORE
         efi_memory_desc_t *md;
         unsigned int num_pages;
-        void *p;
 
         efi.systab = NULL;
 
@@ -840,8 +834,7 @@ static void __init kexec_enter_virtual_mode(void)
         * Map efi regions which were passed via setup_data. The virt_addr is a
         * fixed addr which was used in first kernel of a kexec boot.
         */
-        for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
-                md = p;
+        for_each_efi_memory_desc(md) {
                 efi_map_region_fixed(md); /* FIXME: add error handling */
                 get_systab_virt_addr(md);
         }
@@ -850,10 +843,10 @@ static void __init kexec_enter_virtual_mode(void)
 
         BUG_ON(!efi.systab);
 
-        num_pages = ALIGN(memmap.nr_map * memmap.desc_size, PAGE_SIZE);
+        num_pages = ALIGN(efi.memmap.nr_map * efi.memmap.desc_size, PAGE_SIZE);
         num_pages >>= PAGE_SHIFT;
 
-        if (efi_setup_page_tables(memmap.phys_map, num_pages)) {
+        if (efi_setup_page_tables(efi.memmap.phys_map, num_pages)) {
                 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
                 return;
         }
@@ -937,16 +930,16 @@ static void __init __efi_enter_virtual_mode(void)
 
         if (efi_is_native()) {
                 status = phys_efi_set_virtual_address_map(
-                                memmap.desc_size * count,
-                                memmap.desc_size,
-                                memmap.desc_version,
+                                efi.memmap.desc_size * count,
+                                efi.memmap.desc_size,
+                                efi.memmap.desc_version,
                                 (efi_memory_desc_t *)__pa(new_memmap));
         } else {
                 status = efi_thunk_set_virtual_address_map(
                                 efi_phys.set_virtual_address_map,
-                                memmap.desc_size * count,
-                                memmap.desc_size,
-                                memmap.desc_version,
+                                efi.memmap.desc_size * count,
+                                efi.memmap.desc_size,
+                                efi.memmap.desc_version,
                                 (efi_memory_desc_t *)__pa(new_memmap));
         }
 
@@ -1011,13 +1004,11 @@ void __init efi_enter_virtual_mode(void)
 u32 efi_mem_type(unsigned long phys_addr)
 {
         efi_memory_desc_t *md;
-        void *p;
 
         if (!efi_enabled(EFI_MEMMAP))
                 return 0;
 
-        for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
-                md = p;
+        for_each_efi_memory_desc(md) {
                 if ((md->phys_addr <= phys_addr) &&
                     (phys_addr < (md->phys_addr +
                                   (md->num_pages << EFI_PAGE_SHIFT))))