Support for relocatable kdump kernel

This adds relocatable kernel support for kdump. With this one can use the same regular kernel to capture the kdump. A signature (0xfeed1234) is passed in r6 from panic code to the next kernel through kexec_sequence and purgatory code. The signature is used to differentiate between kdump kernel and non-kdump kernels.

The purgatory code compares the signature and sets the __kdump_flag in head_64.S. During the boot up, kernel code checks __kdump_flag and if it is set, the kernel will behave as relocatable kdump kernel. This kernel will boot at the address where it was loaded by kexec-tools ie. at the address reserved through crashkernel boot parameter.

CONFIG_CRASH_DUMP depends on CONFIG_RELOCATABLE option to build kdump kernel as relocatable. So the same kernel can be used as production and kdump kernel.

arch/powerpc/include/asm/kdump.h +0 -0

index f6c93c7..a503da9 100644

arch/powerpc/include/asm/kdump.h +4 -4

+#if defined(CONFIG_CRASH_DUMP) && !defined(CONFIG_RELOCATABLE)
 extern void reserve_kdump_trampoline(void);
 extern void setup_kdump_trampoline(void);
-
-#else /* !CONFIG_CRASH_DUMP */
-
+#else
+/* !CRASH_DUMP || RELOCATABLE */
 static inline void reserve_kdump_trampoline(void) { ; }
 static inline void setup_kdump_trampoline(void) { ; }
+#endif
 
-#endif /* CONFIG_CRASH_DUMP */
 #endif /* __ASSEMBLY__ */
 
 #endif /* __PPC64_KDUMP_H */

arch/powerpc/kernel/crash_dump.c +0 -0

index 97e0563..19671ac 100644

arch/powerpc/kernel/crash_dump.c +1 -0

 void __init reserve_kdump_trampoline(void)
 {
        lmb_reserve(0, KDUMP_RESERVE_LIMIT);

@@ -68,6 +69,7 @@ void __init setup_kdump_trampoline(void)
 
        DBG(" <- setup_kdump_trampoline()\n");
 }
+#endif /* CONFIG_RELOCATABLE */
 
 /*
  * Note: elfcorehdr_addr is not just limited to vmcore. It is also 

used by

arch/powerpc/kernel/head_64.S +1 -0

index 84856be..69489bd 100644
@@ -97,6 +97,12 @@ __secondary_hold_spinloop:
 __secondary_hold_acknowledge:
        .llong  0x0
 
+       /* This flag is set by purgatory if we should be a kdump 

kernel. */

arch/powerpc/kernel/head_64.S +5 -0

+       /* Do not move this variable as purgatory knows about it. */
+       .globl  __kdump_flag
+__kdump_flag:
+       .llong  0x0
+
 #ifdef CONFIG_PPC_ISERIES
        /*
         * At offset 0x20, there is a pointer to iSeries LPAR data.

@@ -1384,7 +1390,13 @@ _STATIC(__after_prom_start)
        /* process relocations for the final address of the kernel */
        lis     r25,PAGE_OFFSET at highest      /* compute virtual 

base of kernel */

        sldi    r25,r25,32

arch/powerpc/kernel/head_64.S +3 -1

-       mr      r3,r25
+#ifdef CONFIG_CRASH_DUMP
+       ld      r7,__kdump_flag-_stext(r26)
+       cmpldi  cr0,r7,1        /* kdump kernel ? - stay where we are 

*/

arch/powerpc/kernel/head_64.S +4 -0

+       bne     1f
+       add     r25,r25,r26
+#endif
+1:     mr      r3,r25
        bl      .relocate
 #endif

@@ -1398,11 +1410,26 @@ _STATIC(__after_prom_start)
        li      r3,0                    /* target addr */
        mr.     r4,r26                  /* In some cases the loader 

may */
beq 9f /* have already put us at zero
*/

arch/powerpc/kernel/head_64.S +0 -2

-       lis     r5,(copy_to_here - _stext)@ha
-       addi    r5,r5,(copy_to_here - _stext)@l /* # bytes of memory 

to copy */

        li      r6,0x100                /* Start offset, the first 
0x100 */
                                        /* bytes were copied earlier.  

*/

arch/powerpc/kernel/head_64.S +3 -0

+#ifdef CONFIG_CRASH_DUMP
+/*
+ * Check if the kernel has to be running as relocatable kernel based 

on the
+ * variable __kdump_flag, if it is set the kernel is treated as relocatable
+ * kernel, otherwise it will be moved to PHYSICAL_START
+ */

arch/powerpc/kernel/head_64.S +5 -0

+       ld      r7,__kdump_flag-_stext(r26)
+       cmpldi  cr0,r7,1
+       bne     3f
+
+       li      r5,__end_interrupts - _stext    /* just copy 

interrupts */

arch/powerpc/kernel/head_64.S +5 -0

+       b       5f
+3:
+#endif
+       lis     r5,(copy_to_here - _stext)@ha
+       addi    r5,r5,(copy_to_here - _stext)@l /* # bytes of memory 

to copy */
+
bl .copy_and_flush /* copy the first n bytes
*/

                                        /* this includes the code 
being  */
                                        /* executed here.              

*/

arch/powerpc/kernel/head_64.S +3 -3

@@ -1411,15 +1438,15 @@ _STATIC(__after_prom_start)
        mtctr   r8
        bctr
 
+p_end: .llong  _end - _stext
+
 4:     /* Now copy the rest of the kernel up to _end */
        addis   r5,r26,(p_end - _stext)@ha
        ld      r5,(p_end - _stext)@l(r5)       /* get _end */
-       bl      .copy_and_flush         /* copy the rest */
+5:     bl      .copy_and_flush         /* copy the rest */
 
 9:     b       .start_here_multiplatform
 
-p_end: .llong  _end - _stext
-
 /*
  * Copy routine used to copy the kernel to start at physical address 0
  * and flush and invalidate the caches as needed.

arch/powerpc/kernel/iommu.c +0 -0

index ea1ba89..3857d7e 100644

arch/powerpc/kernel/iommu.c +1 -0

+               /* Clear the table in case firmware left allocations 

in it */

arch/powerpc/kernel/iommu.c +8 -0

+               ppc_md.tce_free(tbl, tbl->it_offset, tbl->it_size);
+               return;
+       }
 
+
+#ifdef CONFIG_CRASH_DUMP
+       if (ppc_md.tce_get) {
+               unsigned long index, tceval, tcecount = 0;
+

arch/powerpc/kernel/machine_kexec.c +0 -0

        crash_size = PAGE_ALIGN(crash_size);
        crashk_res.end = crashk_res.start + crash_size - 1;
 

arch/powerpc/kernel/machine_kexec_64.c +4 -1

index 4bd8b4f..e6efec7 100644
@@ -255,11 +255,14 @@ static union thread_union kexec_stack
 /* Our assembly helper, in kexec_stub.S */
 extern NORET_TYPE void kexec_sequence(void *newstack, unsigned long 
 start,
                                        void *image, void *control,
-                                       void (*clear_all)(void)) 
 ATTRIB_NORET;
+                                       void (*clear_all)(void),
+                                       unsigned long kdump_flag) 
 ATTRIB_NORET;
 
 /* too late to fail here */
 void default_machine_kexec(struct kimage *image)
 {
+       unsigned long kdump_flag = 0;
+

        /* prepare control code if any */

        /*

arch/powerpc/kernel/machine_kexec_64.c +4 -2

@@ -270,8 +273,10 @@ void default_machine_kexec(struct kimage *image)
         * using debugger IPI.
         */
 
-       if (crashing_cpu == -1)
-               kexec_prepare_cpus();
+       if (crashing_cpu == -1)
+               kexec_prepare_cpus();
+       else
+               kdump_flag = KDUMP_SIGNATURE;
 
        /* switch to a staticly allocated stack.  Based on irq stack 

code.
* XXX: the task struct will likely be invalid once we do the
copy!

arch/powerpc/kernel/machine_kexec_64.c +1 -1

@@ -284,7 +289,7 @@ void default_machine_kexec(struct kimage *image)
         */
        kexec_sequence(&kexec_stack, image->start, image,
                        page_address(image->control_code_page),
-                       ppc_md.hpte_clear_all);
+                       ppc_md.hpte_clear_all, kdump_flag);
        /* NOTREACHED */
 }
 

arch/powerpc/kernel/misc_64.S +3 -1

index 3053fe5..a243fd0 100644
@@ -611,10 +611,12 @@ real_mode:        /* assume normal blr return */
 
 
 /*
- * kexec_sequence(newstack, start, image, control, clear_all())
+ * kexec_sequence(newstack, start, image, control, clear_all(), 
 kdump_flag)
  *
  * does the grungy work with stack switching and real mode switches
  * also does simple calls to other code
+ *
+ * kdump_flag says whether the next kernel should be a kdump kernel.
  */
 

_GLOBAL(kexec_sequence)

arch/powerpc/kernel/misc_64.S +1 -1

@@ -647,7 +649,7 @@ _GLOBAL(kexec_sequence)
        mr      r29,r5                  /* image (virt) */
        mr      r28,r6                  /* control, unused */
        mr      r27,r7                  /* clear_all() fn desc */
-       mr      r26,r8                  /* spare */
+       mr      r26,r8                  /* kdump flag */
        lhz     r25,PACAHWCPUID(r13)    /* get our phys cpu from paca 
 */
 

        /* disable interrupts, we are overwriting kernel data next */

arch/powerpc/kernel/misc_64.S +2 -1

@@ -709,5 +711,6 @@ _GLOBAL(kexec_sequence)
        mr      r4,r30  # start, aka phys mem offset
        mtlr    4
        li      r5,0
-       blr     /* image->start(physid, image->start, 0); */
+       mr      r6,r26                  /* kdump_flag */
+       blr     /* image->start(physid, image->start, 0, kdump_flag); 
 */

#endif /* CONFIG_KEXEC */

arch/powerpc/platforms/cell/ras.c +1 -0

index 2a14b05..665af1c 100644
@@ -21,6 +21,7 @@
 #include <asm/machdep.h>
 #include <asm/rtas.h>
 #include <asm/cell-regs.h>
+#include <asm/kdump.h>
 
 #include "ras.h"
 

arch/powerpc/platforms/cell/ras.c +0 -0

        area = kmalloc(sizeof(*area), GFP_KERNEL);

        if (!area)

arch/powerpc/platforms/pseries/iommu.c +1 -0

index a8c4466..d56491d 100644
@@ -44,6 +44,7 @@
 #include <asm/tce.h>
 #include <asm/ppc-pci.h>
 #include <asm/udbg.h>
+#include <asm/kdump.h>
 
 #include "plpar_wrappers.h"
 

The relocatable kernel kdump patch (54622f10a6aabb8bb2bdacf3dd070046f03dc246) added a magic flag value in a register to tell purgatory that it should be a panic kernel. This part is wrong and is reverted by this patch.

The kernel gets a list of memory blocks and a entry point from user space. Its job is to copy the blocks into place and then branch to the designated entry point (after turning "off" the mmu).

The user space tool inserts a trampoline, called purgatory, that runs
before the user supplied code. Its job is to establish the entry
environment for the new kernel or other application based on the contents of memory. The purgatory code is compiled and embedded in the tool, where it is later patched using the elf symbol table using elf symbols.

Since the tool knows it is creating a purgatory that will run after a kernel crash, it should just patch purgatory (or the kernel directly) if something needs to happen.

The __kdump_flag ABI is overly constraining for future development.

As of 2.6.27, the kernel entry point has 4 constraints: Offset 0 is the starting point for the master (boot) cpu (entered with r3 pointing to the device tree structure), offset 0x60 is code for the slave cpus (entered with r3 set to their device tree physical id), offset 0x20 is used by the iseries hypervisor, and secondary cpus must be well behaved when the first 256 bytes are copied to address 0.

Placing the __kdump_flag at 0x18 is bad because:

- It was taking the last 8 bytes before the iseries hypervisor data.
- It was 8 bytes for a boolean flag
- It had no way of identifying that the flag was present
- It does leave any room for the master to add any additional code before branching, which hurts debug.
- It will be unnecessarily hard for 32 bit code to be common (8 bytes)

Now that we have eliminated the use of __kdump_flag in favor of the standard is_kdump_kernel(), this flag only controls run without relocating the kernel to PHYSICAL_START (0), so rename it __run_at_load.

Move the flag to 0x5c, 1 word before the secondary cpu entry point at 0x60. Use the copy at address 0 not the one in the base kernel image to make it easier on kexec-tools. Initialize it with "run0" to say it will run at 0 unless it is set to 1. It only exists if we are relocatable.

Signed-off-by Milton Miller <[email protected]>

---
I left it global so it appears that way in System.map, but it would not need to be.

I kept the guards with CONFIG_CRASH_DUMP for now. They could be relaxed to just CONFIG_RELOCATABLE.

Tested with normal kexec (kernel moved to 0) and a custom boot-loader (kernel stayed at loaded 16MB start).

Index: next.git/arch/powerpc/kernel/head_64.S
===================================================================
--- next.git.orig/arch/powerpc/kernel/head_64.S 2008-10-22 04:30:08.000

+++ next.git/arch/powerpc/kernel/head_64.S 2008-10-22 04:59:55.000000000 -

arch/powerpc/kernel/head_64.S +14 -6

@@ -97,12 +97,6 @@ __secondary_hold_spinloop:
 __secondary_hold_acknowledge:
 	.llong	0x0
 
-	/* This flag is set by purgatory if we should be a kdump kernel. */
-	/* Do not move this variable as purgatory knows about it. */
-	.globl	__kdump_flag
-__kdump_flag:
-	.llong	0x0
-
 #ifdef CONFIG_PPC_ISERIES
 	/*
 	 * At offset 0x20, there is a pointer to iSeries LPAR data.

@@ -112,6 +106,20 @@ __kdump_flag:
 	.llong hvReleaseData-KERNELBASE
 #endif /* CONFIG_PPC_ISERIES */
 
+#ifdef CONFIG_CRASH_DUMP
+	/* This flag is set to 1 by a loader if the kernel should run
+	 * at the loaded address instead of the linked address.  This
+	 * is used by kexec-tools to keep the the kdump kernel in the
+	 * crash_kernel region.  The loader is responsible for
+	 * observing the alignment requirement.
+	 */
+	/* Do not move this variable as kexec-tools knows about it. */
+	. = 0x5c
+	.globl	__run_at_load
+__run_at_load:
+	.long	0x72756e30	/* "run0" -- relocate to 0 by default */
+#endif
+
 	. = 0x60
 /*
  * The following code is used to hold secondary processors

arch/powerpc/kernel/head_64.S +3 -3

 	bne	1f
 	add	r25,r25,r26
 #endif

@@ -1416,11 +1424,11 @@ _STATIC(__after_prom_start)
 #ifdef CONFIG_CRASH_DUMP
 /*
  * Check if the kernel has to be running as relocatable kernel based on the
- * variable __kdump_flag, if it is set the kernel is treated as relocatable
+ * variable __run_at_load, if it is set the kernel is treated as relocatable
  * kernel, otherwise it will be moved to PHYSICAL_START
  */
-	ld	r7,__kdump_flag-_stext(r26)
-	cmpldi	cr0,r7,1
+	lwz	r7,__run_at_load-_stext(0)
+	cmplwi	cr0,r7,1
 	bne	3f
 
 	li	r5,__end_interrupts - _stext	/* just copy interrupts */

_______________________________________________
Linuxppc-dev mailing list
[email protected]
https://ozlabs.org/mailman/listinfo/linuxppc-dev

Move the flag to 0x5c, 1 word before the secondary cpu entry point at 0x60. Use the copy at address 0 not the one in the base kernel image to make it easier on kexec-tools.

Quoted 3 lines · Milton Miller

Move the flag to 0x5c, 1 word before the secondary cpu entry point at 0x60. Use the copy at address 0 not the one in the base kernel image to make it easier on kexec-tools.

Why is it easier on kexec-tools? Doesn't kexec-tools know where it put the kernel?

I'd much rather keep the flag inside the kdump kernel image, rather than having kexec/kdump start using random fixed locations outside the new kernel image.

Quoted 7 lines · Paul Mackerras

Quoted 3 lines · Milton Miller

Move the flag to 0x5c, 1 word before the secondary cpu entry point at 0x60. Use the copy at address 0 not the one in the base kernel image to make it easier on kexec-tools.

Why is it easier on kexec-tools? Doesn't kexec-tools know where it put the kernel?

Quoted 4 lines

I'd much rather keep the flag inside the kdump kernel image, rather than having kexec/kdump start using random fixed locations outside the new kernel image.

In fact the cliching argument is that when the kernel is loaded by OF or yaboot, we have no way to tell what will be at location 0x5c, whereas we know that the word at offset 0x5c in the kernel image will have been initialized to 0. So we had better put the flag inside the kernel image.

The __kdump_flag ABI is overly constraining for future development.

As of 2.6.27, the kernel entry point has 4 constraints: Offset 0 is the starting point for the master (boot) cpu (entered with r3 pointing to the device tree structure), offset 0x60 is code for the slave cpus (entered with r3 set to their device tree physical id), offset 0x20 is used by the iseries hypervisor, and secondary cpus must be well behaved when the first 256 bytes are copied to address 0.

Placing the __kdump_flag at 0x18 is bad because:

- It was taking the last 8 bytes before the iseries hypervisor data.
- It was 8 bytes for a boolean flag
- It had no way of identifying that the flag was present
- It does leave any room for the master to add any additional code before branching, which hurts debug.
- It will be unnecessarily hard for 32 bit code to be common (8 bytes)

Now that we have eliminated the use of __kdump_flag in favor of the standard is_kdump_kernel(), this flag only controls run without relocating the kernel to PHYSICAL_START (0), so rename it __run_at_load.

Hi Milton,
My suggestions:

Quoted 1 line · Milton Miller

The __kdump_flag ABI is overly constraining for future development.

Quoted 4 lines

Now that we have eliminated the use of __kdump_flag in favor of the standard is_kdump_kernel(), this flag only controls run without relocating the kernel to PHYSICAL_START (0), so rename it __run_at_load.

We could try both of our approaches. Instead of passing the information that next kernel should be relocatable from kexec_sequence to purgatory code, we will do it from kexec-tools path (following your approach). But instead of setting the __run_at_load value in the purgatory code (ie at physical address 0x5c), we will set the variable __run_at_load at kernel image itself.

i.e.,
[code snip 1]

	lwz	r7,__run_at_load-_stext(r26)
	cmplwi	cr0,r7,1	/* kdump kernel ? - stay where we are */

arch/powerpc/kernel/head_64.S +0 -0

 	bne	1f
 	add	r25,r25,r26

	lwz	r7,__run_at_load-_stext(r26)
	cmplwi	cr0,r7,1

bne 3f

kexec-tools
[code snip 2]

	LOADADDR(6,run_at_load)
	ld	18,0(6)
	cmpd	18,1
	bne	skip
	li	7,1
	stw	7,92(4)		# mark __run_at_load flag at kernel
skip:
	lwz	7,0(4)		# get the first instruction that we stole
	stw	7,0(0)		# and put it in the slave loop at 0
 				# skip cache flush, do we care?

[code snip 3]

	if (info->kexec_flags & KEXEC_ON_CRASH) {
		....
		elf_rel_set_symbol(&info->rhdr, "run_at_load",
                                &my_run_at_load, 							 
sizeof(my_run_at_load));
	}

Using this approach we are not breaking the kexec_sequence ABI and we directly modifying the flag in kernel image.

Regards,
Mohan.

Quoted 28 lines · Mohan Kumar M

Hi Milton,
My suggestions:
Milton Miller wrote:

i.e.,
[code snip 1]

	lwz	r7,__run_at_load-_stext(r26)
	cmplwi	cr0,r7,1	/* kdump kernel ? - stay where we are */

arch/powerpc/kernel/head_64.S +0 -0

 	bne	1f
 	add	r25,r25,r26

	lwz	r7,__run_at_load-_stext(r26)
	cmplwi	cr0,r7,1

bne 3f

kexec-tools
[code snip 2]

	LOADADDR(6,run_at_load)
	ld	18,0(6)
	cmpd	18,1
	bne	skip
	li	7,1
	stw	7,92(4)		# mark __run_at_load flag at kernel
skip:
	lwz	7,0(4)		# get the first instruction that we stole
	stw	7,0(0)		# and put it in the slave loop at 0
 				# skip cache flush, do we care?

Quoted 7 lines

[code snip 3]

	if (info->kexec_flags & KEXEC_ON_CRASH) {
		....
		elf_rel_set_symbol(&info->rhdr, "run_at_load",
                                &my_run_at_load, 							 
sizeof(my_run_at_load));
	}

This elf_rel_set_symbol sets the copy in purgatory, after we have copied the code from the kernel. It is this copy that gets copied to address 0.

However this information is not in the code that is at the start of the kernel. We don't have any symbols for the kernel itself, it might be stripped. So we can't use the elf_set_symbol api. (The kernel may not be relocatable either).

Yes, elf_ret_symbol sets the copy in purgatory. But the following code in purgatory (to be introduced)

(quoted diff) +0 -0

 	LOADADDR(6,run_at_load)
 	ld	18,0(6)
 	cmpd	18,1
 	bne	skip
 	li	7,1
 	stw	7,92(4)		# mark __run_at_load flag at kernel

will set the __run_at_load in the kernel image (ie where ever kernel is loaded + 0x5c(92). Or am I missing some thing?

Every time add_segment is called, the segments are sorted. If the first hole in memory is not big enough for the kernel then something besides the kernel may be at

---
Found during custom environment testing with several reserved blocks of memory, not the usual case.