powerpc: 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.

This patch incorporates the changes suggested by Paul Mackerras to avoid
GOT use and to avoid two copies of the code.

Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Mohan Kumar M <mohan@in.ibm.com>
Signed-off-by: Michael Ellerman <michael@ellerman.id.au>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>

1 files changed, 37 insertions, 32 deletions

diff --git a/arch/powerpc/kernel/iommu.c b/arch/powerpc/kernel/iommu.c
index ea1ba89f9c90..3857d7e2af0c 100644
--- a/arch/powerpc/kernel/iommu.c
+++ b/arch/powerpc/kernel/iommu.c
@@ -458,6 +458,42 @@ void iommu_unmap_sg(struct iommu_table *tbl, struct scatterlist *sglist,
         spin_unlock_irqrestore(&(tbl->it_lock), flags);
 }
 
+static void iommu_table_clear(struct iommu_table *tbl)
+{
+        if (!__kdump_flag) {
+                /* Clear the table in case firmware left allocations in it */
+                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;
+
+                /* Reserve the existing mappings left by the first kernel. */
+                for (index = 0; index < tbl->it_size; index++) {
+                        tceval = ppc_md.tce_get(tbl, index + tbl->it_offset);
+                        /*
+                         * Freed TCE entry contains 0x7fffffffffffffff on JS20
+                         */
+                        if (tceval && (tceval != 0x7fffffffffffffffUL)) {
+                                __set_bit(index, tbl->it_map);
+                                tcecount++;
+                        }
+                }
+
+                if ((tbl->it_size - tcecount) < KDUMP_MIN_TCE_ENTRIES) {
+                        printk(KERN_WARNING "TCE table is full; freeing ");
+                        printk(KERN_WARNING "%d entries for the kdump boot\n",
+                                KDUMP_MIN_TCE_ENTRIES);
+                        for (index = tbl->it_size - KDUMP_MIN_TCE_ENTRIES;
+                                index < tbl->it_size; index++)
+                                __clear_bit(index, tbl->it_map);
+                }
+        }
+#endif
+}
+
 /*
  * Build a iommu_table structure.  This contains a bit map which
  * is used to manage allocation of the tce space.
@@ -484,38 +520,7 @@ struct iommu_table *iommu_init_table(struct iommu_table *tbl, int nid)
         tbl->it_largehint = tbl->it_halfpoint;
         spin_lock_init(&tbl->it_lock);
 
-#ifdef CONFIG_CRASH_DUMP
-        if (ppc_md.tce_get) {
-                unsigned long index;
-                unsigned long tceval;
-                unsigned long tcecount = 0;
-
-                /*
-                 * Reserve the existing mappings left by the first kernel.
-                 */
-                for (index = 0; index < tbl->it_size; index++) {
-                        tceval = ppc_md.tce_get(tbl, index + tbl->it_offset);
-                        /*
-                         * Freed TCE entry contains 0x7fffffffffffffff on JS20
-                         */
-                        if (tceval && (tceval != 0x7fffffffffffffffUL)) {
-                                __set_bit(index, tbl->it_map);
-                                tcecount++;
-                        }
-                }
-                if ((tbl->it_size - tcecount) < KDUMP_MIN_TCE_ENTRIES) {
-                        printk(KERN_WARNING "TCE table is full; ");
-                        printk(KERN_WARNING "freeing %d entries for the kdump boot\n",
-                                KDUMP_MIN_TCE_ENTRIES);
-                        for (index = tbl->it_size - KDUMP_MIN_TCE_ENTRIES;
-                                index < tbl->it_size; index++)
-                                __clear_bit(index, tbl->it_map);
-                }
-        }
-#else
-        /* Clear the hardware table in case firmware left allocations in it */
-        ppc_md.tce_free(tbl, tbl->it_offset, tbl->it_size);
-#endif
+        iommu_table_clear(tbl);
 
         if (!welcomed) {
                 printk(KERN_INFO "IOMMU table initialized, virtual merging %s\n",