1 files changed, 209 insertions, 106 deletions

diff --git a/arch/x86/platform/efi/efi.c b/arch/x86/platform/efi/efi.c
index 395decedfa2b..43e7cf6c6111 100644
--- a/arch/x86/platform/efi/efi.c
+++ b/arch/x86/platform/efi/efi.c
@@ -52,6 +52,7 @@
 #include <asm/tlbflush.h>
 #include <asm/x86_init.h>
 #include <asm/rtc.h>
+#include <asm/uv/uv.h>
 
 #define EFI_DEBUG
 
@@ -67,9 +68,7 @@ struct efi_memory_map memmap;
 static struct efi efi_phys __initdata;
 static efi_system_table_t efi_systab __initdata;
 
-unsigned long x86_efi_facility;
-
-static __initdata efi_config_table_type_t arch_tables[] = {
+static efi_config_table_type_t arch_tables[] __initdata = {
 #ifdef CONFIG_X86_UV
         {UV_SYSTEM_TABLE_GUID, "UVsystab", &efi.uv_systab},
 #endif
@@ -78,16 +77,7 @@ static __initdata efi_config_table_type_t arch_tables[] = {
 
 u64 efi_setup;          /* efi setup_data physical address */
 
-/*
- * Returns 1 if 'facility' is enabled, 0 otherwise.
- */
-int efi_enabled(int facility)
-{
-        return test_bit(facility, &x86_efi_facility) != 0;
-}
-EXPORT_SYMBOL(efi_enabled);
-
-static bool __initdata disable_runtime = false;
+static bool disable_runtime __initdata = false;
 static int __init setup_noefi(char *arg)
 {
         disable_runtime = true;
@@ -274,9 +264,9 @@ static efi_status_t __init phys_efi_get_time(efi_time_t *tm,
 int efi_set_rtc_mmss(const struct timespec *now)
 {
         unsigned long nowtime = now->tv_sec;
-        efi_status_t    status;
-        efi_time_t      eft;
-        efi_time_cap_t  cap;
+        efi_status_t    status;
+        efi_time_t      eft;
+        efi_time_cap_t  cap;
         struct rtc_time tm;
 
         status = efi.get_time(&eft, &cap);
@@ -294,9 +284,8 @@ int efi_set_rtc_mmss(const struct timespec *now)
                 eft.second = tm.tm_sec;
                 eft.nanosecond = 0;
         } else {
-                printk(KERN_ERR
-                       "%s: Invalid EFI RTC value: write of %lx to EFI RTC failed\n",
-                       __FUNCTION__, nowtime);
+                pr_err("%s: Invalid EFI RTC value: write of %lx to EFI RTC failed\n",
+                       __func__, nowtime);
                 return -1;
         }
 
@@ -412,8 +401,7 @@ static void __init print_efi_memmap(void)
              p < memmap.map_end;
              p += memmap.desc_size, i++) {
                 md = p;
-                pr_info("mem%02u: type=%u, attr=0x%llx, "
-                        "range=[0x%016llx-0x%016llx) (%lluMB)\n",
+                pr_info("mem%02u: type=%u, attr=0x%llx, range=[0x%016llx-0x%016llx) (%lluMB)\n",
                         i, md->type, md->attribute, md->phys_addr,
                         md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT),
                         (md->num_pages >> (20 - EFI_PAGE_SHIFT)));
@@ -445,9 +433,8 @@ void __init efi_reserve_boot_services(void)
                         memblock_is_region_reserved(start, size)) {
                         /* Could not reserve, skip it */
                         md->num_pages = 0;
-                        memblock_dbg("Could not reserve boot range "
-                                        "[0x%010llx-0x%010llx]\n",
-                                                start, start+size-1);
+                        memblock_dbg("Could not reserve boot range [0x%010llx-0x%010llx]\n",
+                                     start, start+size-1);
                 } else
                         memblock_reserve(start, size);
         }
@@ -455,7 +442,7 @@ void __init efi_reserve_boot_services(void)
 
 void __init efi_unmap_memmap(void)
 {
-        clear_bit(EFI_MEMMAP, &x86_efi_facility);
+        clear_bit(EFI_MEMMAP, &efi.flags);
         if (memmap.map) {
                 early_iounmap(memmap.map, memmap.nr_map * memmap.desc_size);
                 memmap.map = NULL;
@@ -580,11 +567,12 @@ static int __init efi_systab_init(void *phys)
                 return -EINVAL;
         }
         if ((efi.systab->hdr.revision >> 16) == 0)
-                pr_err("Warning: System table version "
-                       "%d.%02d, expected 1.00 or greater!\n",
+                pr_err("Warning: System table version %d.%02d, expected 1.00 or greater!\n",
                        efi.systab->hdr.revision >> 16,
                        efi.systab->hdr.revision & 0xffff);
 
+        set_bit(EFI_SYSTEM_TABLES, &efi.flags);
+
         return 0;
 }
 
@@ -668,6 +656,8 @@ static int __init efi_runtime_init(void)
         if (rv)
                 return rv;
 
+        set_bit(EFI_RUNTIME_SERVICES, &efi.flags);
+
         return 0;
 }
 
@@ -685,6 +675,8 @@ static int __init efi_memmap_init(void)
         if (add_efi_memmap)
                 do_add_efi_memmap();
 
+        set_bit(EFI_MEMMAP, &efi.flags);
+
         return 0;
 }
 
@@ -767,7 +759,7 @@ void __init efi_init(void)
         if (efi_systab_init(efi_phys.systab))
                 return;
 
-        set_bit(EFI_SYSTEM_TABLES, &x86_efi_facility);
+        set_bit(EFI_SYSTEM_TABLES, &efi.flags);
 
         efi.config_table = (unsigned long)efi.systab->tables;
         efi.fw_vendor    = (unsigned long)efi.systab->fw_vendor;
@@ -795,8 +787,6 @@ void __init efi_init(void)
         if (efi_config_init(arch_tables))
                 return;
 
-        set_bit(EFI_CONFIG_TABLES, &x86_efi_facility);
-
         /*
          * Note: We currently don't support runtime services on an EFI
          * that doesn't match the kernel 32/64-bit mode.
@@ -807,12 +797,11 @@ void __init efi_init(void)
         else {
                 if (disable_runtime || efi_runtime_init())
                         return;
-                set_bit(EFI_RUNTIME_SERVICES, &x86_efi_facility);
         }
         if (efi_memmap_init())
                 return;
 
-        set_bit(EFI_MEMMAP, &x86_efi_facility);
+        set_bit(EFI_MEMMAP, &efi.flags);
 
         print_efi_memmap();
 }
@@ -952,8 +941,9 @@ static void __init get_systab_virt_addr(efi_memory_desc_t *md)
         }
 }
 
-static int __init save_runtime_map(void)
+static void __init save_runtime_map(void)
 {
+#ifdef CONFIG_KEXEC
         efi_memory_desc_t *md;
         void *tmp, *p, *q = NULL;
         int count = 0;
@@ -975,38 +965,44 @@ static int __init save_runtime_map(void)
         }
 
         efi_runtime_map_setup(q, count, memmap.desc_size);
+        return;
 
-        return 0;
 out:
         kfree(q);
-        return -ENOMEM;
+        pr_err("Error saving runtime map, efi runtime on kexec non-functional!!\n");
+#endif
 }
 
-/*
- * 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.
- */
-static void __init efi_map_regions_fixed(void)
+static void *realloc_pages(void *old_memmap, int old_shift)
 {
-        void *p;
-        efi_memory_desc_t *md;
+        void *ret;
 
-        for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
-                md = p;
-                efi_map_region_fixed(md); /* FIXME: add error handling */
-                get_systab_virt_addr(md);
-        }
+        ret = (void *)__get_free_pages(GFP_KERNEL, old_shift + 1);
+        if (!ret)
+                goto out;
 
+        /*
+         * A first-time allocation doesn't have anything to copy.
+         */
+        if (!old_memmap)
+                return ret;
+
+        memcpy(ret, old_memmap, PAGE_SIZE << old_shift);
+
+out:
+        free_pages((unsigned long)old_memmap, old_shift);
+        return ret;
 }
 
 /*
- * Map efi memory ranges for runtime serivce and update new_memmap with virtual
- * addresses.
+ * Map the efi memory ranges of the runtime services and update new_mmap with
+ * virtual addresses.
  */
-static void * __init efi_map_regions(int *count)
+static void * __init efi_map_regions(int *count, int *pg_shift)
 {
+        void *p, *new_memmap = NULL;
+        unsigned long left = 0;
         efi_memory_desc_t *md;
-        void *p, *tmp, *new_memmap = NULL;
 
         for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
                 md = p;
@@ -1021,20 +1017,80 @@ static void * __init efi_map_regions(int *count)
                 efi_map_region(md);
                 get_systab_virt_addr(md);
 
-                tmp = krealloc(new_memmap, (*count + 1) * memmap.desc_size,
-                               GFP_KERNEL);
-                if (!tmp)
-                        goto out;
-                new_memmap = tmp;
+                if (left < memmap.desc_size) {
+                        new_memmap = realloc_pages(new_memmap, *pg_shift);
+                        if (!new_memmap)
+                                return NULL;
+
+                        left += PAGE_SIZE << *pg_shift;
+                        (*pg_shift)++;
+                }
+
                 memcpy(new_memmap + (*count * memmap.desc_size), md,
                        memmap.desc_size);
+
+                left -= memmap.desc_size;
                 (*count)++;
         }
 
         return new_memmap;
-out:
-        kfree(new_memmap);
-        return NULL;
+}
+
+static void __init kexec_enter_virtual_mode(void)
+{
+#ifdef CONFIG_KEXEC
+        efi_memory_desc_t *md;
+        void *p;
+
+        efi.systab = NULL;
+
+        /*
+         * We don't do virtual mode, since we don't do runtime services, on
+         * non-native EFI
+         */
+        if (!efi_is_native()) {
+                efi_unmap_memmap();
+                return;
+        }
+
+        /*
+        * 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;
+                efi_map_region_fixed(md); /* FIXME: add error handling */
+                get_systab_virt_addr(md);
+        }
+
+        save_runtime_map();
+
+        BUG_ON(!efi.systab);
+
+        efi_sync_low_kernel_mappings();
+
+        /*
+         * Now that EFI is in virtual mode, update the function
+         * pointers in the runtime service table to the new virtual addresses.
+         *
+         * Call EFI services through wrapper functions.
+         */
+        efi.runtime_version = efi_systab.hdr.revision;
+
+        native_runtime_setup();
+
+        efi.set_virtual_address_map = NULL;
+
+        if (efi_enabled(EFI_OLD_MEMMAP) && (__supported_pte_mask & _PAGE_NX))
+                runtime_code_page_mkexec();
+
+        /* clean DUMMY object */
+        efi.set_variable(efi_dummy_name, &EFI_DUMMY_GUID,
+                         EFI_VARIABLE_NON_VOLATILE |
+                         EFI_VARIABLE_BOOTSERVICE_ACCESS |
+                         EFI_VARIABLE_RUNTIME_ACCESS,
+                         0, NULL);
+#endif
 }
 
 /*
@@ -1056,57 +1112,53 @@ out:
  *
  * Specially for kexec boot, efi runtime maps in previous kernel should
  * be passed in via setup_data. In that case runtime ranges will be mapped
- * to the same virtual addresses as the first kernel.
+ * to the same virtual addresses as the first kernel, see
+ * kexec_enter_virtual_mode().
  */
-void __init efi_enter_virtual_mode(void)
+static void __init __efi_enter_virtual_mode(void)
 {
-        efi_status_t status;
+        int count = 0, pg_shift = 0;
         void *new_memmap = NULL;
-        int err, count = 0;
+        efi_status_t status;
 
         efi.systab = NULL;
 
-        if (efi_setup) {
-                efi_map_regions_fixed();
-        } else {
-                efi_merge_regions();
-                new_memmap = efi_map_regions(&count);
-                if (!new_memmap) {
-                        pr_err("Error reallocating memory, EFI runtime non-functional!\n");
-                        return;
-                }
+        efi_merge_regions();
+        new_memmap = efi_map_regions(&count, &pg_shift);
+        if (!new_memmap) {
+                pr_err("Error reallocating memory, EFI runtime non-functional!\n");
+                return;
         }
 
-        err = save_runtime_map();
-        if (err)
-                pr_err("Error saving runtime map, efi runtime on kexec non-functional!!\n");
+        save_runtime_map();
 
         BUG_ON(!efi.systab);
 
-        efi_setup_page_tables();
-        efi_sync_low_kernel_mappings();
+        if (efi_setup_page_tables(__pa(new_memmap), 1 << pg_shift))
+                return;
 
-        if (!efi_setup) {
-                if (efi_is_native()) {
-                        status = phys_efi_set_virtual_address_map(
-                                        memmap.desc_size * count,
-                                        memmap.desc_size,
-                                        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_memory_desc_t *)__pa(new_memmap));
-                }
+        efi_sync_low_kernel_mappings();
+        efi_dump_pagetable();
+
+        if (efi_is_native()) {
+                status = phys_efi_set_virtual_address_map(
+                                memmap.desc_size * count,
+                                memmap.desc_size,
+                                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_memory_desc_t *)__pa(new_memmap));
+        }
 
-                if (status != EFI_SUCCESS) {
-                        pr_alert("Unable to switch EFI into virtual mode (status=%lx)!\n",
-                                 status);
-                        panic("EFI call to SetVirtualAddressMap() failed!");
-                }
+        if (status != EFI_SUCCESS) {
+                pr_alert("Unable to switch EFI into virtual mode (status=%lx)!\n",
+                         status);
+                panic("EFI call to SetVirtualAddressMap() failed!");
         }
 
         /*
@@ -1126,7 +1178,33 @@ void __init efi_enter_virtual_mode(void)
 
         efi_runtime_mkexec();
 
-        kfree(new_memmap);
+        /*
+         * We mapped the descriptor array into the EFI pagetable above but we're
+         * not unmapping it here. Here's why:
+         *
+         * We're copying select PGDs from the kernel page table to the EFI page
+         * table and when we do so and make changes to those PGDs like unmapping
+         * stuff from them, those changes appear in the kernel page table and we
+         * go boom.
+         *
+         * From setup_real_mode():
+         *
+         * ...
+         * trampoline_pgd[0] = init_level4_pgt[pgd_index(__PAGE_OFFSET)].pgd;
+         *
+         * In this particular case, our allocation is in PGD 0 of the EFI page
+         * table but we've copied that PGD from PGD[272] of the EFI page table:
+         *
+         *      pgd_index(__PAGE_OFFSET = 0xffff880000000000) = 272
+         *
+         * where the direct memory mapping in kernel space is.
+         *
+         * new_memmap's VA comes from that direct mapping and thus clearing it,
+         * it would get cleared in the kernel page table too.
+         *
+         * efi_cleanup_page_tables(__pa(new_memmap), 1 << pg_shift);
+         */
+        free_pages((unsigned long)new_memmap, pg_shift);
 
         /* clean DUMMY object */
         efi.set_variable(efi_dummy_name, &EFI_DUMMY_GUID,
@@ -1136,6 +1214,14 @@ void __init efi_enter_virtual_mode(void)
                          0, NULL);
 }
 
+void __init efi_enter_virtual_mode(void)
+{
+        if (efi_setup)
+                kexec_enter_virtual_mode();
+        else
+                __efi_enter_virtual_mode();
+}
+
 /*
  * Convenience functions to obtain memory types and attributes
  */
@@ -1173,9 +1259,8 @@ u64 efi_mem_attributes(unsigned long phys_addr)
 }
 
 /*
- * Some firmware has serious problems when using more than 50% of the EFI
- * variable store, i.e. it triggers bugs that can brick machines. Ensure that
- * we never use more than this safe limit.
+ * Some firmware implementations refuse to boot if there's insufficient space
+ * in the variable store. Ensure that we never use more than a safe limit.
  *
  * Return EFI_SUCCESS if it is safe to write 'size' bytes to the variable
  * store.
@@ -1194,10 +1279,9 @@ efi_status_t efi_query_variable_store(u32 attributes, unsigned long size)
                 return status;
 
         /*
-         * Some firmware implementations refuse to boot if there's insufficient
-         * space in the variable store. We account for that by refusing the
-         * write if permitting it would reduce the available space to under
-         * 5KB. This figure was provided by Samsung, so should be safe.
+         * We account for that by refusing the write if permitting it would
+         * reduce the available space to under 5KB. This figure was provided by
+         * Samsung, so should be safe.
          */
         if ((remaining_size - size < EFI_MIN_RESERVE) &&
                 !efi_no_storage_paranoia) {
@@ -1260,8 +1344,27 @@ static int __init parse_efi_cmdline(char *str)
                 str++;
 
         if (!strncmp(str, "old_map", 7))
-                set_bit(EFI_OLD_MEMMAP, &x86_efi_facility);
+                set_bit(EFI_OLD_MEMMAP, &efi.flags);
 
         return 0;
 }
 early_param("efi", parse_efi_cmdline);
+
+void __init efi_apply_memmap_quirks(void)
+{
+        /*
+         * Once setup is done earlier, unmap the EFI memory map on mismatched
+         * firmware/kernel architectures since there is no support for runtime
+         * services.
+         */
+        if (!efi_runtime_supported()) {
+                pr_info("efi: Setup done, disabling due to 32/64-bit mismatch\n");
+                efi_unmap_memmap();
+        }
+
+        /*
+         * UV doesn't support the new EFI pagetable mapping yet.
+         */
+        if (is_uv_system())
+                set_bit(EFI_OLD_MEMMAP, &efi.flags);
+}