1 files changed, 281 insertions, 4 deletions

diff --git a/kernel/kexec.c b/kernel/kexec.c
index 25db14b89e82..aa74a1ef2da8 100644
--- a/kernel/kexec.c
+++ b/kernel/kexec.c
@@ -17,21 +17,30 @@
 #include <linux/highmem.h>
 #include <linux/syscalls.h>
 #include <linux/reboot.h>
-#include <linux/syscalls.h>
 #include <linux/ioport.h>
 #include <linux/hardirq.h>
 #include <linux/elf.h>
 #include <linux/elfcore.h>
+#include <linux/utsrelease.h>
+#include <linux/utsname.h>
+#include <linux/numa.h>
 
 #include <asm/page.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 #include <asm/system.h>
 #include <asm/semaphore.h>
+#include <asm/sections.h>
 
 /* Per cpu memory for storing cpu states in case of system crash. */
 note_buf_t* crash_notes;
 
+/* vmcoreinfo stuff */
+unsigned char vmcoreinfo_data[VMCOREINFO_BYTES];
+u32 vmcoreinfo_note[VMCOREINFO_NOTE_SIZE/4];
+size_t vmcoreinfo_size;
+size_t vmcoreinfo_max_size = sizeof(vmcoreinfo_data);
+
 /* Location of the reserved area for the crash kernel */
 struct resource crashk_res = {
         .name  = "Crash kernel",
@@ -42,7 +51,7 @@ struct resource crashk_res = {
 
 int kexec_should_crash(struct task_struct *p)
 {
-        if (in_interrupt() || !p->pid || is_init(p) || panic_on_oops)
+        if (in_interrupt() || !p->pid || is_global_init(p) || panic_on_oops)
                 return 1;
         return 0;
 }
@@ -776,7 +785,7 @@ static int kimage_load_normal_segment(struct kimage *image,
                 size_t uchunk, mchunk;
 
                 page = kimage_alloc_page(image, GFP_HIGHUSER, maddr);
-                if (page == 0) {
+                if (!page) {
                         result  = -ENOMEM;
                         goto out;
                 }
@@ -835,7 +844,7 @@ static int kimage_load_crash_segment(struct kimage *image,
                 size_t uchunk, mchunk;
 
                 page = pfn_to_page(maddr >> PAGE_SHIFT);
-                if (page == 0) {
+                if (!page) {
                         result  = -ENOMEM;
                         goto out;
                 }
@@ -1061,6 +1070,7 @@ void crash_kexec(struct pt_regs *regs)
                 if (kexec_crash_image) {
                         struct pt_regs fixed_regs;
                         crash_setup_regs(&fixed_regs, regs);
+                        crash_save_vmcoreinfo();
                         machine_crash_shutdown(&fixed_regs);
                         machine_kexec(kexec_crash_image);
                 }
@@ -1135,3 +1145,270 @@ static int __init crash_notes_memory_init(void)
         return 0;
 }
 module_init(crash_notes_memory_init)
+
+
+/*
+ * parsing the "crashkernel" commandline
+ *
+ * this code is intended to be called from architecture specific code
+ */
+
+
+/*
+ * This function parses command lines in the format
+ *
+ *   crashkernel=ramsize-range:size[,...][@offset]
+ *
+ * The function returns 0 on success and -EINVAL on failure.
+ */
+static int __init parse_crashkernel_mem(char                    *cmdline,
+                                        unsigned long long      system_ram,
+                                        unsigned long long      *crash_size,
+                                        unsigned long long      *crash_base)
+{
+        char *cur = cmdline, *tmp;
+
+        /* for each entry of the comma-separated list */
+        do {
+                unsigned long long start, end = ULLONG_MAX, size;
+
+                /* get the start of the range */
+                start = memparse(cur, &tmp);
+                if (cur == tmp) {
+                        pr_warning("crashkernel: Memory value expected\n");
+                        return -EINVAL;
+                }
+                cur = tmp;
+                if (*cur != '-') {
+                        pr_warning("crashkernel: '-' expected\n");
+                        return -EINVAL;
+                }
+                cur++;
+
+                /* if no ':' is here, than we read the end */
+                if (*cur != ':') {
+                        end = memparse(cur, &tmp);
+                        if (cur == tmp) {
+                                pr_warning("crashkernel: Memory "
+                                                "value expected\n");
+                                return -EINVAL;
+                        }
+                        cur = tmp;
+                        if (end <= start) {
+                                pr_warning("crashkernel: end <= start\n");
+                                return -EINVAL;
+                        }
+                }
+
+                if (*cur != ':') {
+                        pr_warning("crashkernel: ':' expected\n");
+                        return -EINVAL;
+                }
+                cur++;
+
+                size = memparse(cur, &tmp);
+                if (cur == tmp) {
+                        pr_warning("Memory value expected\n");
+                        return -EINVAL;
+                }
+                cur = tmp;
+                if (size >= system_ram) {
+                        pr_warning("crashkernel: invalid size\n");
+                        return -EINVAL;
+                }
+
+                /* match ? */
+                if (system_ram >= start && system_ram <= end) {
+                        *crash_size = size;
+                        break;
+                }
+        } while (*cur++ == ',');
+
+        if (*crash_size > 0) {
+                while (*cur != ' ' && *cur != '@')
+                        cur++;
+                if (*cur == '@') {
+                        cur++;
+                        *crash_base = memparse(cur, &tmp);
+                        if (cur == tmp) {
+                                pr_warning("Memory value expected "
+                                                "after '@'\n");
+                                return -EINVAL;
+                        }
+                }
+        }
+
+        return 0;
+}
+
+/*
+ * That function parses "simple" (old) crashkernel command lines like
+ *
+ *      crashkernel=size[@offset]
+ *
+ * It returns 0 on success and -EINVAL on failure.
+ */
+static int __init parse_crashkernel_simple(char                 *cmdline,
+                                           unsigned long long   *crash_size,
+                                           unsigned long long   *crash_base)
+{
+        char *cur = cmdline;
+
+        *crash_size = memparse(cmdline, &cur);
+        if (cmdline == cur) {
+                pr_warning("crashkernel: memory value expected\n");
+                return -EINVAL;
+        }
+
+        if (*cur == '@')
+                *crash_base = memparse(cur+1, &cur);
+
+        return 0;
+}
+
+/*
+ * That function is the entry point for command line parsing and should be
+ * called from the arch-specific code.
+ */
+int __init parse_crashkernel(char                *cmdline,
+                             unsigned long long system_ram,
+                             unsigned long long *crash_size,
+                             unsigned long long *crash_base)
+{
+        char    *p = cmdline, *ck_cmdline = NULL;
+        char    *first_colon, *first_space;
+
+        BUG_ON(!crash_size || !crash_base);
+        *crash_size = 0;
+        *crash_base = 0;
+
+        /* find crashkernel and use the last one if there are more */
+        p = strstr(p, "crashkernel=");
+        while (p) {
+                ck_cmdline = p;
+                p = strstr(p+1, "crashkernel=");
+        }
+
+        if (!ck_cmdline)
+                return -EINVAL;
+
+        ck_cmdline += 12; /* strlen("crashkernel=") */
+
+        /*
+         * if the commandline contains a ':', then that's the extended
+         * syntax -- if not, it must be the classic syntax
+         */
+        first_colon = strchr(ck_cmdline, ':');
+        first_space = strchr(ck_cmdline, ' ');
+        if (first_colon && (!first_space || first_colon < first_space))
+                return parse_crashkernel_mem(ck_cmdline, system_ram,
+                                crash_size, crash_base);
+        else
+                return parse_crashkernel_simple(ck_cmdline, crash_size,
+                                crash_base);
+
+        return 0;
+}
+
+
+
+void crash_save_vmcoreinfo(void)
+{
+        u32 *buf;
+
+        if (!vmcoreinfo_size)
+                return;
+
+        vmcoreinfo_append_str("CRASHTIME=%ld", get_seconds());
+
+        buf = (u32 *)vmcoreinfo_note;
+
+        buf = append_elf_note(buf, VMCOREINFO_NOTE_NAME, 0, vmcoreinfo_data,
+                              vmcoreinfo_size);
+
+        final_note(buf);
+}
+
+void vmcoreinfo_append_str(const char *fmt, ...)
+{
+        va_list args;
+        char buf[0x50];
+        int r;
+
+        va_start(args, fmt);
+        r = vsnprintf(buf, sizeof(buf), fmt, args);
+        va_end(args);
+
+        if (r + vmcoreinfo_size > vmcoreinfo_max_size)
+                r = vmcoreinfo_max_size - vmcoreinfo_size;
+
+        memcpy(&vmcoreinfo_data[vmcoreinfo_size], buf, r);
+
+        vmcoreinfo_size += r;
+}
+
+/*
+ * provide an empty default implementation here -- architecture
+ * code may override this
+ */
+void __attribute__ ((weak)) arch_crash_save_vmcoreinfo(void)
+{}
+
+unsigned long __attribute__ ((weak)) paddr_vmcoreinfo_note(void)
+{
+        return __pa((unsigned long)(char *)&vmcoreinfo_note);
+}
+
+static int __init crash_save_vmcoreinfo_init(void)
+{
+        vmcoreinfo_append_str("OSRELEASE=%s\n", init_uts_ns.name.release);
+        vmcoreinfo_append_str("PAGESIZE=%ld\n", PAGE_SIZE);
+
+        VMCOREINFO_SYMBOL(init_uts_ns);
+        VMCOREINFO_SYMBOL(node_online_map);
+        VMCOREINFO_SYMBOL(swapper_pg_dir);
+        VMCOREINFO_SYMBOL(_stext);
+
+#ifndef CONFIG_NEED_MULTIPLE_NODES
+        VMCOREINFO_SYMBOL(mem_map);
+        VMCOREINFO_SYMBOL(contig_page_data);
+#endif
+#ifdef CONFIG_SPARSEMEM
+        VMCOREINFO_SYMBOL(mem_section);
+        VMCOREINFO_LENGTH(mem_section, NR_SECTION_ROOTS);
+        VMCOREINFO_SIZE(mem_section);
+        VMCOREINFO_OFFSET(mem_section, section_mem_map);
+#endif
+        VMCOREINFO_SIZE(page);
+        VMCOREINFO_SIZE(pglist_data);
+        VMCOREINFO_SIZE(zone);
+        VMCOREINFO_SIZE(free_area);
+        VMCOREINFO_SIZE(list_head);
+        VMCOREINFO_TYPEDEF_SIZE(nodemask_t);
+        VMCOREINFO_OFFSET(page, flags);
+        VMCOREINFO_OFFSET(page, _count);
+        VMCOREINFO_OFFSET(page, mapping);
+        VMCOREINFO_OFFSET(page, lru);
+        VMCOREINFO_OFFSET(pglist_data, node_zones);
+        VMCOREINFO_OFFSET(pglist_data, nr_zones);
+#ifdef CONFIG_FLAT_NODE_MEM_MAP
+        VMCOREINFO_OFFSET(pglist_data, node_mem_map);
+#endif
+        VMCOREINFO_OFFSET(pglist_data, node_start_pfn);
+        VMCOREINFO_OFFSET(pglist_data, node_spanned_pages);
+        VMCOREINFO_OFFSET(pglist_data, node_id);
+        VMCOREINFO_OFFSET(zone, free_area);
+        VMCOREINFO_OFFSET(zone, vm_stat);
+        VMCOREINFO_OFFSET(zone, spanned_pages);
+        VMCOREINFO_OFFSET(free_area, free_list);
+        VMCOREINFO_OFFSET(list_head, next);
+        VMCOREINFO_OFFSET(list_head, prev);
+        VMCOREINFO_LENGTH(zone.free_area, MAX_ORDER);
+        VMCOREINFO_NUMBER(NR_FREE_PAGES);
+
+        arch_crash_save_vmcoreinfo();
+
+        return 0;
+}
+
+module_init(crash_save_vmcoreinfo_init)