Merge branch 'x86-kdump-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...

Pull x86 kdump updates from Ingo Molnar:
 "This solves a kdump artifact where encrypted memory contents are
  dumped, instead of unencrypted ones.

  The solution also happens to simplify the kdump code, to everyone's
  delight"

* 'x86-kdump-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  x86/crash: Align function arguments on opening braces
  x86/kdump: Remove the backup region handling
  x86/kdump: Always reserve the low 1M when the crashkernel option is specified
  x86/crash: Add a forward declaration of struct kimage

diff --git a/arch/x86/include/asm/crash.h b/arch/x86/include/asm/crash.h
index 089b2850f9d1ad8839d87f0f77219ce26eab80b0..f58de66091e5ea0aee91ced2a76e6a937f67d2e6 100644 (file)
--- a/arch/x86/include/asm/crash.h
+++ b/arch/x86/include/asm/crash.h
@@ -2,9 +2,17 @@
 #ifndef _ASM_X86_CRASH_H
 #define _ASM_X86_CRASH_H
 
+struct kimage;
+
 int crash_load_segments(struct kimage *image);
 int crash_setup_memmap_entries(struct kimage *image,
                struct boot_params *params);
 void crash_smp_send_stop(void);
 
+#ifdef CONFIG_KEXEC_CORE
+void __init crash_reserve_low_1M(void);
+#else
+static inline void __init crash_reserve_low_1M(void) { }
+#endif
+
 #endif /* _ASM_X86_CRASH_H */

diff --git a/arch/x86/include/asm/kexec.h b/arch/x86/include/asm/kexec.h
index 5e7d6b46de97d60316622d3f17630b9743742447..6802c59e82523bce637fb9fb011ca68a8e44e35e 100644 (file)
--- a/arch/x86/include/asm/kexec.h
+++ b/arch/x86/include/asm/kexec.h
@@ -66,10 +66,6 @@ struct kimage;
 # define KEXEC_ARCH KEXEC_ARCH_X86_64
 #endif
 
-/* Memory to backup during crash kdump */
-#define KEXEC_BACKUP_SRC_START (0UL)
-#define KEXEC_BACKUP_SRC_END   (640 * 1024UL - 1)      /* 640K */
-
 /*
  * This function is responsible for capturing register states if coming
  * via panic otherwise just fix up the ss and sp if coming via kernel
@@ -154,12 +150,6 @@ struct kimage_arch {
        pud_t *pud;
        pmd_t *pmd;
        pte_t *pte;
-       /* Details of backup region */
-       unsigned long backup_src_start;
-       unsigned long backup_src_sz;
-
-       /* Physical address of backup segment */
-       unsigned long backup_load_addr;
 
        /* Core ELF header buffer */
        void *elf_headers;

diff --git a/arch/x86/include/asm/purgatory.h b/arch/x86/include/asm/purgatory.h
index 92c34e517da18ef06348ee6a673181a4697ec66e..5528e93250494c1f2aab203d07319e13bedc1134 100644 (file)
--- a/arch/x86/include/asm/purgatory.h
+++ b/arch/x86/include/asm/purgatory.h
@@ -6,16 +6,6 @@
 #include <linux/purgatory.h>
 
 extern void purgatory(void);
-/*
- * These forward declarations serve two purposes:
- *
- * 1) Make sparse happy when checking arch/purgatory
- * 2) Document that these are required to be global so the symbol
- *    lookup in kexec works
- */
-extern unsigned long purgatory_backup_dest;
-extern unsigned long purgatory_backup_src;
-extern unsigned long purgatory_backup_sz;
 #endif /* __ASSEMBLY__ */
 
 #endif /* _ASM_PURGATORY_H */

diff --git a/arch/x86/kernel/crash.c b/arch/x86/kernel/crash.c
index eb651fbde92ac137f42bc0d93c00a98b40827030..00fc55ac7ffa848064c9368682dd198ec7590b0a 100644 (file)
--- a/arch/x86/kernel/crash.c
+++ b/arch/x86/kernel/crash.c
@@ -24,6 +24,7 @@
 #include <linux/export.h>
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
+#include <linux/memblock.h>
 
 #include <asm/processor.h>
 #include <asm/hardirq.h>
@@ -39,6 +40,7 @@
 #include <asm/virtext.h>
 #include <asm/intel_pt.h>
 #include <asm/crash.h>
+#include <asm/cmdline.h>
 
 /* Used while preparing memory map entries for second kernel */
 struct crash_memmap_data {
@@ -68,6 +70,19 @@ static inline void cpu_crash_vmclear_loaded_vmcss(void)
        rcu_read_unlock();
 }
 
+/*
+ * When the crashkernel option is specified, only use the low
+ * 1M for the real mode trampoline.
+ */
+void __init crash_reserve_low_1M(void)
+{
+       if (cmdline_find_option(boot_command_line, "crashkernel", NULL, 0) < 0)
+               return;
+
+       memblock_reserve(0, 1<<20);
+       pr_info("Reserving the low 1M of memory for crashkernel\n");
+}
+
 #if defined(CONFIG_SMP) && defined(CONFIG_X86_LOCAL_APIC)
 
 static void kdump_nmi_callback(int cpu, struct pt_regs *regs)
@@ -173,8 +188,6 @@ void native_machine_crash_shutdown(struct pt_regs *regs)
 
 #ifdef CONFIG_KEXEC_FILE
 
-static unsigned long crash_zero_bytes;
-
 static int get_nr_ram_ranges_callback(struct resource *res, void *arg)
 {
        unsigned int *nr_ranges = arg;
@@ -189,8 +202,7 @@ static struct crash_mem *fill_up_crash_elf_data(void)
        unsigned int nr_ranges = 0;
        struct crash_mem *cmem;
 
-       walk_system_ram_res(0, -1, &nr_ranges,
-                               get_nr_ram_ranges_callback);
+       walk_system_ram_res(0, -1, &nr_ranges, get_nr_ram_ranges_callback);
        if (!nr_ranges)
                return NULL;
 
@@ -217,15 +229,19 @@ static int elf_header_exclude_ranges(struct crash_mem *cmem)
 {
        int ret = 0;
 
+       /* Exclude the low 1M because it is always reserved */
+       ret = crash_exclude_mem_range(cmem, 0, 1<<20);
+       if (ret)
+               return ret;
+
        /* Exclude crashkernel region */
        ret = crash_exclude_mem_range(cmem, crashk_res.start, crashk_res.end);
        if (ret)
                return ret;
 
-       if (crashk_low_res.end) {
+       if (crashk_low_res.end)
                ret = crash_exclude_mem_range(cmem, crashk_low_res.start,
-                                                       crashk_low_res.end);
-       }
+                                             crashk_low_res.end);
 
        return ret;
 }
@@ -246,16 +262,13 @@ static int prepare_elf_headers(struct kimage *image, void **addr,
                                        unsigned long *sz)
 {
        struct crash_mem *cmem;
-       Elf64_Ehdr *ehdr;
-       Elf64_Phdr *phdr;
-       int ret, i;
+       int ret;
 
        cmem = fill_up_crash_elf_data();
        if (!cmem)
                return -ENOMEM;
 
-       ret = walk_system_ram_res(0, -1, cmem,
-                               prepare_elf64_ram_headers_callback);
+       ret = walk_system_ram_res(0, -1, cmem, prepare_elf64_ram_headers_callback);
        if (ret)
                goto out;
 
@@ -265,24 +278,8 @@ static int prepare_elf_headers(struct kimage *image, void **addr,
                goto out;
 
        /* By default prepare 64bit headers */
-       ret =  crash_prepare_elf64_headers(cmem,
-                               IS_ENABLED(CONFIG_X86_64), addr, sz);
-       if (ret)
-               goto out;
+       ret =  crash_prepare_elf64_headers(cmem, IS_ENABLED(CONFIG_X86_64), addr, sz);
 
-       /*
-        * If a range matches backup region, adjust offset to backup
-        * segment.
-        */
-       ehdr = (Elf64_Ehdr *)*addr;
-       phdr = (Elf64_Phdr *)(ehdr + 1);
-       for (i = 0; i < ehdr->e_phnum; phdr++, i++)
-               if (phdr->p_type == PT_LOAD &&
-                               phdr->p_paddr == image->arch.backup_src_start &&
-                               phdr->p_memsz == image->arch.backup_src_sz) {
-                       phdr->p_offset = image->arch.backup_load_addr;
-                       break;
-               }
 out:
        vfree(cmem);
        return ret;
@@ -296,8 +293,7 @@ static int add_e820_entry(struct boot_params *params, struct e820_entry *entry)
        if (nr_e820_entries >= E820_MAX_ENTRIES_ZEROPAGE)
                return 1;
 
-       memcpy(&params->e820_table[nr_e820_entries], entry,
-                       sizeof(struct e820_entry));
+       memcpy(&params->e820_table[nr_e820_entries], entry, sizeof(struct e820_entry));
        params->e820_entries++;
        return 0;
 }
@@ -321,19 +317,11 @@ static int memmap_exclude_ranges(struct kimage *image, struct crash_mem *cmem,
                                 unsigned long long mend)
 {
        unsigned long start, end;
-       int ret = 0;
 
        cmem->ranges[0].start = mstart;
        cmem->ranges[0].end = mend;
        cmem->nr_ranges = 1;
 
-       /* Exclude Backup region */
-       start = image->arch.backup_load_addr;
-       end = start + image->arch.backup_src_sz - 1;
-       ret = crash_exclude_mem_range(cmem, start, end);
-       if (ret)
-               return ret;
-
        /* Exclude elf header region */
        start = image->arch.elf_load_addr;
        end = start + image->arch.elf_headers_sz - 1;
@@ -356,28 +344,28 @@ int crash_setup_memmap_entries(struct kimage *image, struct boot_params *params)
        memset(&cmd, 0, sizeof(struct crash_memmap_data));
        cmd.params = params;
 
-       /* Add first 640K segment */
-       ei.addr = image->arch.backup_src_start;
-       ei.size = image->arch.backup_src_sz;
-       ei.type = E820_TYPE_RAM;
-       add_e820_entry(params, &ei);
+       /* Add the low 1M */
+       cmd.type = E820_TYPE_RAM;
+       flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
+       walk_iomem_res_desc(IORES_DESC_NONE, flags, 0, (1<<20)-1, &cmd,
+                           memmap_entry_callback);
 
        /* Add ACPI tables */
        cmd.type = E820_TYPE_ACPI;
        flags = IORESOURCE_MEM | IORESOURCE_BUSY;
        walk_iomem_res_desc(IORES_DESC_ACPI_TABLES, flags, 0, -1, &cmd,
-                      memmap_entry_callback);
+                           memmap_entry_callback);
 
        /* Add ACPI Non-volatile Storage */
        cmd.type = E820_TYPE_NVS;
        walk_iomem_res_desc(IORES_DESC_ACPI_NV_STORAGE, flags, 0, -1, &cmd,
-                       memmap_entry_callback);
+                           memmap_entry_callback);
 
        /* Add e820 reserved ranges */
        cmd.type = E820_TYPE_RESERVED;
        flags = IORESOURCE_MEM;
        walk_iomem_res_desc(IORES_DESC_RESERVED, flags, 0, -1, &cmd,
-                          memmap_entry_callback);
+                           memmap_entry_callback);
 
        /* Add crashk_low_res region */
        if (crashk_low_res.end) {
@@ -388,8 +376,7 @@ int crash_setup_memmap_entries(struct kimage *image, struct boot_params *params)
        }
 
        /* Exclude some ranges from crashk_res and add rest to memmap */
-       ret = memmap_exclude_ranges(image, cmem, crashk_res.start,
-                                               crashk_res.end);
+       ret = memmap_exclude_ranges(image, cmem, crashk_res.start, crashk_res.end);
        if (ret)
                goto out;
 
@@ -409,55 +396,12 @@ int crash_setup_memmap_entries(struct kimage *image, struct boot_params *params)
        return ret;
 }
 
-static int determine_backup_region(struct resource *res, void *arg)
-{
-       struct kimage *image = arg;
-
-       image->arch.backup_src_start = res->start;
-       image->arch.backup_src_sz = resource_size(res);
-
-       /* Expecting only one range for backup region */
-       return 1;
-}
-
 int crash_load_segments(struct kimage *image)
 {
        int ret;
        struct kexec_buf kbuf = { .image = image, .buf_min = 0,
                                  .buf_max = ULONG_MAX, .top_down = false };
 
-       /*
-        * Determine and load a segment for backup area. First 640K RAM
-        * region is backup source
-        */
-
-       ret = walk_system_ram_res(KEXEC_BACKUP_SRC_START, KEXEC_BACKUP_SRC_END,
-                               image, determine_backup_region);
-
-       /* Zero or postive return values are ok */
-       if (ret < 0)
-               return ret;
-
-       /* Add backup segment. */
-       if (image->arch.backup_src_sz) {
-               kbuf.buffer = &crash_zero_bytes;
-               kbuf.bufsz = sizeof(crash_zero_bytes);
-               kbuf.memsz = image->arch.backup_src_sz;
-               kbuf.buf_align = PAGE_SIZE;
-               /*
-                * Ideally there is no source for backup segment. This is
-                * copied in purgatory after crash. Just add a zero filled
-                * segment for now to make sure checksum logic works fine.
-                */
-               ret = kexec_add_buffer(&kbuf);
-               if (ret)
-                       return ret;
-               image->arch.backup_load_addr = kbuf.mem;
-               pr_debug("Loaded backup region at 0x%lx backup_start=0x%lx memsz=0x%lx\n",
-                        image->arch.backup_load_addr,
-                        image->arch.backup_src_start, kbuf.memsz);
-       }
-
        /* Prepare elf headers and add a segment */
        ret = prepare_elf_headers(image, &kbuf.buffer, &kbuf.bufsz);
        if (ret)

diff --git a/arch/x86/kernel/machine_kexec_64.c b/arch/x86/kernel/machine_kexec_64.c
index 5dcd438ad8f25f85869f7a25ff34928594f4abf4..16e125a50b333437d352fd63c17f5b6f76d5d515 100644 (file)
--- a/arch/x86/kernel/machine_kexec_64.c
+++ b/arch/x86/kernel/machine_kexec_64.c
@@ -298,48 +298,6 @@ static void load_segments(void)
                );
 }
 
-#ifdef CONFIG_KEXEC_FILE
-/* Update purgatory as needed after various image segments have been prepared */
-static int arch_update_purgatory(struct kimage *image)
-{
-       int ret = 0;
-
-       if (!image->file_mode)
-               return 0;
-
-       /* Setup copying of backup region */
-       if (image->type == KEXEC_TYPE_CRASH) {
-               ret = kexec_purgatory_get_set_symbol(image,
-                               "purgatory_backup_dest",
-                               &image->arch.backup_load_addr,
-                               sizeof(image->arch.backup_load_addr), 0);
-               if (ret)
-                       return ret;
-
-               ret = kexec_purgatory_get_set_symbol(image,
-                               "purgatory_backup_src",
-                               &image->arch.backup_src_start,
-                               sizeof(image->arch.backup_src_start), 0);
-               if (ret)
-                       return ret;
-
-               ret = kexec_purgatory_get_set_symbol(image,
-                               "purgatory_backup_sz",
-                               &image->arch.backup_src_sz,
-                               sizeof(image->arch.backup_src_sz), 0);
-               if (ret)
-                       return ret;
-       }
-
-       return ret;
-}
-#else /* !CONFIG_KEXEC_FILE */
-static inline int arch_update_purgatory(struct kimage *image)
-{
-       return 0;
-}
-#endif /* CONFIG_KEXEC_FILE */
-
 int machine_kexec_prepare(struct kimage *image)
 {
        unsigned long start_pgtable;
@@ -353,11 +311,6 @@ int machine_kexec_prepare(struct kimage *image)
        if (result)
                return result;
 
-       /* update purgatory as needed */
-       result = arch_update_purgatory(image);
-       if (result)
-               return result;
-
        return 0;
 }
 

diff --git a/arch/x86/purgatory/purgatory.c b/arch/x86/purgatory/purgatory.c
index 3b95410ff0f887469b2392f949a9da7539aab8e9..2961234d0795229bea3889bea1a38745da8dd828 100644 (file)
--- a/arch/x86/purgatory/purgatory.c
+++ b/arch/x86/purgatory/purgatory.c
@@ -14,28 +14,10 @@
 
 #include "../boot/string.h"
 
-unsigned long purgatory_backup_dest __section(.kexec-purgatory);
-unsigned long purgatory_backup_src __section(.kexec-purgatory);
-unsigned long purgatory_backup_sz __section(.kexec-purgatory);
-
 u8 purgatory_sha256_digest[SHA256_DIGEST_SIZE] __section(.kexec-purgatory);
 
 struct kexec_sha_region purgatory_sha_regions[KEXEC_SEGMENT_MAX] __section(.kexec-purgatory);
 
-/*
- * On x86, second kernel requries first 640K of memory to boot. Copy
- * first 640K to a backup region in reserved memory range so that second
- * kernel can use first 640K.
- */
-static int copy_backup_region(void)
-{
-       if (purgatory_backup_dest) {
-               memcpy((void *)purgatory_backup_dest,
-                      (void *)purgatory_backup_src, purgatory_backup_sz);
-       }
-       return 0;
-}
-
 static int verify_sha256_digest(void)
 {
        struct kexec_sha_region *ptr, *end;
@@ -66,7 +48,6 @@ void purgatory(void)
                for (;;)
                        ;
        }
-       copy_backup_region();
 }
 
 /*

diff --git a/arch/x86/realmode/init.c b/arch/x86/realmode/init.c
index 7dce39c8c034a8a9f2481aff02590a793ff86498..262f83cad35516d0286ae82a3e4a58fd428360fd 100644 (file)
--- a/arch/x86/realmode/init.c
+++ b/arch/x86/realmode/init.c
@@ -8,6 +8,7 @@
 #include <asm/pgtable.h>
 #include <asm/realmode.h>
 #include <asm/tlbflush.h>
+#include <asm/crash.h>
 
 struct real_mode_header *real_mode_header;
 u32 *trampoline_cr4_features;
@@ -34,6 +35,7 @@ void __init reserve_real_mode(void)
 
        memblock_reserve(mem, size);
        set_real_mode_mem(mem);
+       crash_reserve_low_1M();
 }
 
 static void __init setup_real_mode(void)