MIPS: kernel kexec crashdump, 64-bit support, SMP etc.

This patch updates kernel part of kexec for MIPS platform to support kdump, 64-bit, SMP and simplify code adaptation to new boards. It does the following:

- hooks for machine-specific actions are introduced (_machine_kexec_prepare,
_machine_kexec_shutdown, _machine_crash_shutdown);
- kexec reboot on SMP machine is implemented;
- add boot parameters passing to new kernel (array kexec_args[] is copied to
registers a0-a3 on reboot );
- crash dump functionality is added (boot kernel with non-default physical start, parse "crashkernel=..." command line parameter, copy_oldmem_page() is implemeted to read memory dump after reboot-on-crashi,
crash_setup_regs()
is updated to correctly store registers on crash);

kexec/kdump funtionality was tested on several Cavium Octeon boards (mips64 SMP). The way we do it was the following:
- _machine_kexec_prepare was find kexec segment with command line and save it's pointed into internal bootloader structure.
- _machine_kexec_shutdown was used to stop boards IO and make all non-boot CPUs spin in function relocated_kexec_smp_wait()
- _machine_crash_shutdown just calls default_machine_crash_shutdown() We tested 1) 'common' kexec reboot (by 'kexec -e'), 2) kexec-on-panic ('kexec -p ...') and 3) access to/proc/vmcore (with gdb).

---

arch/mips/Kconfig                  |   23 +++++++++
arch/mips/Makefile                 |    4 ++
arch/mips/kernel/Makefile          |    3 +-
arch/mips/kernel/crash.c           |   91 
++++++++++++++++++++++++++++++++++
arch/mips/kernel/crash_dump.c      |   96 
++++++++++++++++++++++++++++++++++++
arch/mips/kernel/machine_kexec.c   |   52 ++++++++++++++++++-
arch/mips/kernel/relocate_kernel.S |   93 
++++++++++++++++++++++++++++++++++-
arch/mips/kernel/setup.c           |   10 +++-
include/asm-mips/kexec.h           |   21 ++++++++-
9 files changed, 386 insertions(+), 7 deletions(-)

create mode 100644 arch/mips/kernel/crash.c
create mode 100644 arch/mips/kernel/crash_dump.c

index e5a7c5d..50d9cfb 100644
@@ -1945,6 +1945,29 @@ config KEXEC
      support.  As of this writing the exact hardware interface is
      strongly in flux, so no good recommendation can be made.
 
+config CRASH_DUMP
+    bool "kernel crash dumps (EXPERIMENTAL)"
+    depends on EXPERIMENTAL
+    help
+      Generate crash dump after being started by kexec.
+          This should be normally only set in special crash dump kernels
+      which are loaded in the main kernel with kexec-tools into
+      a specially reserved region and then later executed after
+      a crash by kdump/kexec. The crash dump kernel must be compiled
+          to a memory address not used by the main kernel or BIOS using
+          PHYSICAL_START.
+
+config PHYSICAL_START
+    hex "Physical address where the kernel is loaded"
+    default "0xffffffff84000000"
+    depends on CRASH_DUMP
+    help
+      This gives the CKSEG0 or KSEG0 address where the kernel is loaded.
+      If you plan to use kernel for capturing the crash dump change
+      this value to start of the reserved region (the "X" value as
+      specified in the "crashkernel=YM@XM" command line boot parameter
+      passed to the panic-ed kernel).
+

config SECCOMP
bool "Enable seccomp to safely compute untrusted bytecode" depends on PROC_FS

index ad36c94..6f0c69a 100644
@@ -597,6 +597,10 @@ core-$(CONFIG_TOSHIBA_RBTX4938) += 

arch/mips/tx4938/common/ cflags-$(CONFIG_TOSHIBA_RBTX4938) += -Iinclude/asm-mips/mach-tx49xx load-$(CONFIG_TOSHIBA_RBTX4938) += 0xffffffff80100000

+ifdef CONFIG_PHYSICAL_START
+load-y = $(CONFIG_PHYSICAL_START)
+endif
+
cflags-y += -Iinclude/asm-mips/mach-generic
drivers-$(CONFIG_PCI) += arch/mips/pci/

index 65e46a6..b02266f 100644
@@ -84,7 +84,8 @@ obj-$(CONFIG_I8253)        += i8253.o
 

obj-$(CONFIG_GPIO_TXX9) += gpio_txx9.o

-obj-$(CONFIG_KEXEC) += machine_kexec.o relocate_kernel.o
+obj-$(CONFIG_KEXEC) += machine_kexec.o relocate_kernel.o crash.o
+obj-$(CONFIG_CRASH_DUMP) += crash_dump.o
obj-$(CONFIG_EARLY_PRINTK) += early_printk.o

CFLAGS_cpu-bugs64.o = $(shell if $(CC) $(KBUILD_CFLAGS) -Wa,-mdaddi
-c -o /dev/null -xc /dev/null >/dev/null 2>&1; then echo "-DHAVE_AS_SET_DADDI"; fi)

cpu */
+
+ smp_call_function (crash_shutdown_secondary, NULL, 0, 0);
+ smp_wmb();
+
+ /*

+     * FIXME: Until we will have the way to stop other CPUSs reliabally,
+     * the crash CPU will send an IPI and wait for other CPUs to
+     * respond.
+     * Delay of at least 10 seconds.
+     */
+    printk(KERN_EMERG "Sending IPI to other cpus...\n");
+    msecs = 10000;
+    while ((cpus_weight(cpus_in_crash) < ncpus) && (--msecs > 0)) {

+ cpu_relax();
+ mdelay(1);
+ }
+
+}
+
+#else
+static void crash_kexec_prepare_cpus() {} +#endif
+
+void default_machine_crash_shutdown(struct pt_regs *regs) +{

+    local_irq_disable();
+    crashing_cpu = smp_processor_id();
+    crash_save_cpu(regs, crashing_cpu);
+    crash_kexec_prepare_cpus();
+    cpu_set(crashing_cpu, cpus_in_crash);

+}

user
+ * space in non-atomic context.
+ */
+ssize_t copy_oldmem_page(unsigned long pfn, char *buf,
+ size_t csize, unsigned long offset, int
userbuf)
+{
+ void *vaddr;
+
+ if (!csize)
+ return 0;
+
+ vaddr = kmap_atomic_pfn(pfn, KM_PTE0);
+
+ if (!userbuf) {
+ memcpy(buf, (vaddr + offset), csize);
+ kunmap_atomic(vaddr, KM_PTE0);
+ } else {
+ if (!kdump_buf_page) {
+ printk(KERN_WARNING "Kdump: Kdump buffer page not"
+ " allocated\n");
+ return -EFAULT;

+        }
+        copy_page(kdump_buf_page, vaddr);
+        kunmap_atomic(vaddr, KM_PTE0);
+        if (copy_to_user(buf, (kdump_buf_page + offset), csize))

+ return -EFAULT;
+ }
+
+ return csize;
+}
+
+static int __init kdump_buf_page_init(void)
+{
+ int ret = 0;
+
+ kdump_buf_page = kmalloc(PAGE_SIZE, GFP_KERNEL);
+ if (!kdump_buf_page) {
+ printk(KERN_WARNING "Kdump: Failed to allocate kdump buffer"
+ " page\n");
+ ret = -ENOMEM;
+ }
+
+ return ret;
+}
+arch_initcall(kdump_buf_page_init);

b/arch/mips/kernel/machine_kexec.c
index 85beb9b..5b52da8 100644

@@ -19,9 +19,19 @@ extern const size_t relocate_new_kernel_size;

extern unsigned long kexec_start_address;
extern unsigned long kexec_indirection_page;

+int (*_machine_kexec_prepare)(struct kimage *) = NULL; +void (*_machine_kexec_shutdown)(void) = NULL;
+void (*_machine_crash_shutdown)(struct pt_regs *regs) = NULL; +#ifdef CONFIG_SMP
+void (*relocated_kexec_smp_wait) (void *); +atomic_t kexec_ready_to_reboot = ATOMIC_INIT(0); +#endif
+
int
machine_kexec_prepare(struct kimage *kimage)
{
+ if (_machine_kexec_prepare)

+        return _machine_kexec_prepare(kimage);
    return 0;
}

@@ -33,13 +43,18 @@ machine_kexec_cleanup(struct kimage *kimage) void
machine_shutdown(void)
{
+ if (_machine_kexec_shutdown)
+ _machine_kexec_shutdown();
}

void
machine_crash_shutdown(struct pt_regs *regs)
{
+ if (_machine_crash_shutdown)
+ _machine_crash_shutdown(regs);
+ else
+ default_machine_crash_shutdown(regs);
}
-
typedef void (*noretfun_t)(void) __attribute__((noreturn));

void
@@ -52,7 +67,9 @@ machine_kexec(struct kimage *image)

    reboot_code_buffer =
      (unsigned long)page_address(image->control_code_page);

- kexec_start_address = image->start;
+ kexec_start_address =
+ (unsigned long) phys_to_virt(image->start);
+

    kexec_indirection_page =
        (unsigned long) phys_to_virt(image->head & PAGE_MASK);

@@ -63,7 +80,7 @@ machine_kexec(struct kimage *image)
* The generic kexec code builds a page list with physical
* addresses. they are directly accessible through KSEG0 (or
* CKSEG0 or XPHYS if on 64bit system), hence the
- * pys_to_virt() call.
+ * phys_to_virt() call.

     */
    for (ptr = &image->head; (entry = *ptr) && !(entry &IND_DONE);
         ptr = (entry & IND_INDIRECTION) ?
@@ -81,5 +98,34 @@ machine_kexec(struct kimage *image)
    printk("Will call new kernel at %08lx\n", image->start);
    printk("Bye ...\n");
    __flush_cache_all();

+#ifdef CONFIG_SMP
+ /* All secondary cpus now may jump to kexec_wait cycle */
+ relocated_kexec_smp_wait = reboot_code_buffer +
+ (kexec_smp_wait - relocate_new_kernel);
+ smp_wmb();
+ atomic_set(&kexec_ready_to_reboot,1);
+#endif

    ((noretfun_t) reboot_code_buffer)();
}

+
+/* crashkernel=size@addr specifies the location to reserve for
+ * a crash kernel. By reserving this memory we guarantee
+ * that linux never sets it up as a DMA target.
+ * Useful for holding code to do something appropriate
+ * after a kernel panic.
+ */
+static int __init parse_crashkernel(char *arg)
+{

+    unsigned long size, base;
+    size = memparse(arg, &arg);
+    if (*arg == '@') {

+ base = memparse(arg+1, &arg);
+ /* FIXME: Do I want a sanity check
+ * to validate the memory range?
+ */
+ crashk_res.start = base;
+ crashk_res.end = base + size - 1;
+ }
+ return 0;
+}
+early_param("crashkernel", parse_crashkernel);

b/arch/mips/kernel/relocate_kernel.S
index 87481f9..314288e 100644

@@ -14,7 +14,13 @@

#include <asm/stackframe.h>
#include <asm/addrspace.h>

+
LEAF(relocate_new_kernel)

+     PTR_L a0,    arg0
+     PTR_L a1,    arg1
+     PTR_L a2,    arg2
+     PTR_L a3,    arg3

+
PTR_L s0, kexec_indirection_page
PTR_L s1, kexec_start_address

@@ -26,7 +32,6 @@ process_entry:

    and        s3, s2, 0x1
    beq        s3, zero, 1f
    and        s4, s2, ~0x1    /* store destination addr in s4 */

- move a0, s4
b process_entry

1:
@@ -60,10 +65,96 @@ copy_word:
b process_entry

done:
+#ifdef CONFIG_SMP
+ /* kexec_flag reset is signal to other CPUs what kernel
+ was moved to it's location. Note - we need relocated address
+ of kexec_flag. */
+
+ bal 1f
+ 1: move t1,ra;

+     PTR_LA        t2,1b
+     PTR_LA        t0,kexec_flag
+     PTR_SUB        t0,t0,t2;
+     PTR_ADD        t0,t1,t0;
+     LONG_S        zero,(t0)

+#endif
+
+ /* Some platforms need I-cache to be flushed before
+ * jumping to new kernel.
+ */
+

    /* jump to kexec_start_address */
    j        s1
    END(relocate_new_kernel)

+#ifdef CONFIG_SMP
+/*
+ * Other CPUs should wait until code is relocated and
+ * then start at entry point.
+ */
+LEAF(kexec_smp_wait)

+    PTR_L        a0, s_arg0
+    PTR_L        a1, s_arg1
+    PTR_L        a2, s_arg2
+    PTR_L        a3, s_arg3
+    PTR_L        s1, kexec_start_address
+
+    /* Non-relocated address works for args and kexec_start_address ( old
+     * kernel is not overwritten). But we need relocated address of
+     * kexec_flag.
+     */
+
+    bal        1f
+1:    move        t1,ra;
+    PTR_LA        t2,1b
+    PTR_LA        t0,kexec_flag
+    PTR_SUB        t0,t0,t2;
+    PTR_ADD        t0,t1,t0;

+
+1: LONG_L s0, (t0)
+ bne s0, zero,1b
+
+ j s1
+ END(kexec_smp_wait)
+#endif
+
+
+#ifdef __mips64
+ /* all PTR's must be aligned to 8 byte in 64-bit mode */
+ .align 3
+#endif
+
+/* All parameters to new kernel are passed in registers a0-a3.
+ * kexec_args[0..3] are uses to prepare register values.
+ */
+
+kexec_args:
+ EXPORT(kexec_args)

+arg0:    PTR        0x0
+arg1:    PTR        0x0
+arg2:    PTR        0x0
+arg3:    PTR        0x0

+ .size kexec_args,PTRSIZE*4
+
+#ifdef CONFIG_SMP
+/*
+ * Secondary CPUs may have different kernel parameters in
+ * their registers a0-a3. secondary_kexec_args[0..3] are used
+ * to prepare register values.
+ */
+secondary_kexec_args:
+ EXPORT(secondary_kexec_args)

+s_arg0:    PTR        0x0
+s_arg1:    PTR        0x0
+s_arg2:    PTR        0x0
+s_arg3:    PTR        0x0

+ .size secondary_kexec_args,PTRSIZE*4
+kexec_flag:
+ LONG 0x1
+
+#endif
+
+
kexec_start_address:

    EXPORT(kexec_start_address)
    PTR        0x0

index c6a063b..4054f15 100644
@@ -21,7 +21,7 @@

#include <linux/console.h>
#include <linux/pfn.h>
#include <linux/debugfs.h>
-
+#include <linux/kexec.h>
#include <asm/addrspace.h>
#include <asm/bootinfo.h>
#include <asm/bugs.h>
@@ -494,6 +494,11 @@ static void __init arch_mem_init(char **cmdline_p)

    }

    bootmem_init();

+#ifdef CONFIG_KEXEC
+ if (crashk_res.start != crashk_res.end)
+ reserve_bootmem(crashk_res.start,
+ crashk_res.end - crashk_res.start + 1);
+#endif

    sparse_init();
    paging_init();
}
@@ -548,6 +553,9 @@ static void __init resource_init(void)
         */
        request_resource(res, &code_resource);
        request_resource(res, &data_resource);
+#ifdef CONFIG_KEXEC
+        request_resource(res, &crashk_res);
+#endif
    }
}

index cdbab43..51554cb 100644
@@ -9,6 +9,8 @@

#ifndef _MIPS_KEXEC

# define _MIPS_KEXEC

+#include <asm/stacktrace.h>
+
/* Maximum physical address we can use pages from */ #define KEXEC_SOURCE_MEMORY_LIMIT (0x20000000)
/* Maximum address we can reach in physical address mode */ @@ -24,7 +26,24 @@
static inline void crash_setup_regs(struct pt_regs *newregs,
struct pt_regs *oldregs)
{
- /* Dummy implementation for now */
+ if (oldregs)
+ memcpy(newregs, oldregs, sizeof(*newregs));
+ else
+ prepare_frametrace(newregs);
}

+#ifdef CONFIG_KEXEC
+struct kimage;
+extern unsigned long kexec_args[4];
+extern int (*_machine_kexec_prepare)(struct kimage *); +extern void (*_machine_kexec_shutdown)(void);
+extern void (*_machine_crash_shutdown)(struct pt_regs *regs); +extern void default_machine_crash_shutdown(struct pt_regs *regs); +#ifdef CONFIG_SMP
+extern const unsigned char kexec_smp_wait[];
+extern unsigned long secondary_kexec_args[4];
+extern void (*relocated_kexec_smp_wait) (void *); +extern atomic_t kexec_ready_to_reboot;
+#endif
+#endif
#endif /* !_MIPS_KEXEC */

1.5.5.3




_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec

Hi,

Nice :) could you also send this patch to the linux-mips
mailing-list ?

Apprently all tabs in the patch have been converted to spaces and some lines seem to have been wrapped by your mailer.

Regards,

Nicolas Schichan




_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec