kexec: load and relocate purgatory at kernel load time

Load purgatory code in RAM and relocate it based on the location.
Relocation code has been inspired by module relocation code and purgatory
relocation code in kexec-tools.

Also compute the checksums of loaded kexec segments and store them in
purgatory.

Arch independent code provides this functionality so that arch dependent
bootloaders can make use of it.

Helper functions are provided to get/set symbol values in purgatory which
are used by bootloaders later to set things like stack and entry point of
second kernel etc.

Signed-off-by: Vivek Goyal <vgoyal@redhat.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: Michael Kerrisk <mtk.manpages@gmail.com>
Cc: Yinghai Lu <yinghai@kernel.org>
Cc: Eric Biederman <ebiederm@xmission.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Greg Kroah-Hartman <greg@kroah.com>
Cc: Dave Young <dyoung@redhat.com>
Cc: WANG Chao <chaowang@redhat.com>
Cc: Baoquan He <bhe@redhat.com>
Cc: Andy Lutomirski <luto@amacapital.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

10 files changed, 160 insertions, 0 deletions

diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
index 8e9dbcbcf5af..cacc8d5355b3 100644
--- a/arch/arm/Kconfig
+++ b/arch/arm/Kconfig
@@ -2065,6 +2065,8 @@ config XIP_PHYS_ADDR
 config KEXEC
         bool "Kexec system call (EXPERIMENTAL)"
         depends on (!SMP || PM_SLEEP_SMP)
+        select CRYPTO
+        select CRYPTO_SHA256
         help
           kexec is a system call that implements the ability to shutdown your
           current kernel, and to start another kernel.  It is like a reboot
diff --git a/arch/ia64/Kconfig b/arch/ia64/Kconfig
index c84c88bbbbd7..64aefb76bd69 100644
--- a/arch/ia64/Kconfig
+++ b/arch/ia64/Kconfig
@@ -549,6 +549,8 @@ source "drivers/sn/Kconfig"
 config KEXEC
         bool "kexec system call"
         depends on !IA64_HP_SIM && (!SMP || HOTPLUG_CPU)
+        select CRYPTO
+        select CRYPTO_SHA256
         help
           kexec is a system call that implements the ability to shutdown your
           current kernel, and to start another kernel.  It is like a reboot
diff --git a/arch/m68k/Kconfig b/arch/m68k/Kconfig
index 87b7c7581b1d..3ff8c9a25335 100644
--- a/arch/m68k/Kconfig
+++ b/arch/m68k/Kconfig
@@ -91,6 +91,8 @@ config MMU_SUN3
 config KEXEC
         bool "kexec system call"
         depends on M68KCLASSIC
+        select CRYPTO
+        select CRYPTO_SHA256
         help
           kexec is a system call that implements the ability to shutdown your
           current kernel, and to start another kernel.  It is like a reboot
diff --git a/arch/mips/Kconfig b/arch/mips/Kconfig
index 900c7e5333b6..df51e78a72cc 100644
--- a/arch/mips/Kconfig
+++ b/arch/mips/Kconfig
@@ -2396,6 +2396,8 @@ source "kernel/Kconfig.preempt"
 
 config KEXEC
         bool "Kexec system call"
+        select CRYPTO
+        select CRYPTO_SHA256
         help
           kexec is a system call that implements the ability to shutdown your
           current kernel, and to start another kernel.  It is like a reboot
diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig
index 4bc7b62fb4b6..a577609f8ed6 100644
--- a/arch/powerpc/Kconfig
+++ b/arch/powerpc/Kconfig
@@ -399,6 +399,8 @@ config PPC64_SUPPORTS_MEMORY_FAILURE
 config KEXEC
         bool "kexec system call"
         depends on (PPC_BOOK3S || FSL_BOOKE || (44x && !SMP))
+        select CRYPTO
+        select CRYPTO_SHA256
         help
           kexec is a system call that implements the ability to shutdown your
           current kernel, and to start another kernel.  It is like a reboot
diff --git a/arch/s390/Kconfig b/arch/s390/Kconfig
index 05c78bb5f570..ab39ceb89ecf 100644
--- a/arch/s390/Kconfig
+++ b/arch/s390/Kconfig
@@ -48,6 +48,8 @@ config ARCH_SUPPORTS_DEBUG_PAGEALLOC
 
 config KEXEC
         def_bool y
+        select CRYPTO
+        select CRYPTO_SHA256
 
 config AUDIT_ARCH
         def_bool y
diff --git a/arch/sh/Kconfig b/arch/sh/Kconfig
index aa2df3eaeb29..453fa5c09550 100644
--- a/arch/sh/Kconfig
+++ b/arch/sh/Kconfig
@@ -595,6 +595,8 @@ source kernel/Kconfig.hz
 config KEXEC
         bool "kexec system call (EXPERIMENTAL)"
         depends on SUPERH32 && MMU
+        select CRYPTO
+        select CRYPTO_SHA256
         help
           kexec is a system call that implements the ability to shutdown your
           current kernel, and to start another kernel.  It is like a reboot
diff --git a/arch/tile/Kconfig b/arch/tile/Kconfig
index 7fcd492adbfc..a3ffe2dd4832 100644
--- a/arch/tile/Kconfig
+++ b/arch/tile/Kconfig
@@ -191,6 +191,8 @@ source "kernel/Kconfig.hz"
 
 config KEXEC
         bool "kexec system call"
+        select CRYPTO
+        select CRYPTO_SHA256
         ---help---
           kexec is a system call that implements the ability to shutdown your
           current kernel, and to start another kernel.  It is like a reboot
diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index 98fe3df6df82..9558b9fcafbf 100644
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -1583,6 +1583,8 @@ source kernel/Kconfig.hz
 config KEXEC
         bool "kexec system call"
         select BUILD_BIN2C
+        select CRYPTO
+        select CRYPTO_SHA256
         ---help---
           kexec is a system call that implements the ability to shutdown your
           current kernel, and to start another kernel.  It is like a reboot
diff --git a/arch/x86/kernel/machine_kexec_64.c b/arch/x86/kernel/machine_kexec_64.c
index c8875b5545e1..88404c440727 100644
--- a/arch/x86/kernel/machine_kexec_64.c
+++ b/arch/x86/kernel/machine_kexec_64.c
@@ -6,6 +6,8 @@
  * Version 2.  See the file COPYING for more details.
  */
 
+#define pr_fmt(fmt)     "kexec: " fmt
+
 #include <linux/mm.h>
 #include <linux/kexec.h>
 #include <linux/string.h>
@@ -328,3 +330,143 @@ int arch_kimage_file_post_load_cleanup(struct kimage *image)
 
         return image->fops->cleanup(image);
 }
+
+/*
+ * Apply purgatory relocations.
+ *
+ * ehdr: Pointer to elf headers
+ * sechdrs: Pointer to section headers.
+ * relsec: section index of SHT_RELA section.
+ *
+ * TODO: Some of the code belongs to generic code. Move that in kexec.c.
+ */
+int arch_kexec_apply_relocations_add(const Elf64_Ehdr *ehdr,
+                                     Elf64_Shdr *sechdrs, unsigned int relsec)
+{
+        unsigned int i;
+        Elf64_Rela *rel;
+        Elf64_Sym *sym;
+        void *location;
+        Elf64_Shdr *section, *symtabsec;
+        unsigned long address, sec_base, value;
+        const char *strtab, *name, *shstrtab;
+
+        /*
+         * ->sh_offset has been modified to keep the pointer to section
+         * contents in memory
+         */
+        rel = (void *)sechdrs[relsec].sh_offset;
+
+        /* Section to which relocations apply */
+        section = &sechdrs[sechdrs[relsec].sh_info];
+
+        pr_debug("Applying relocate section %u to %u\n", relsec,
+                 sechdrs[relsec].sh_info);
+
+        /* Associated symbol table */
+        symtabsec = &sechdrs[sechdrs[relsec].sh_link];
+
+        /* String table */
+        if (symtabsec->sh_link >= ehdr->e_shnum) {
+                /* Invalid strtab section number */
+                pr_err("Invalid string table section index %d\n",
+                       symtabsec->sh_link);
+                return -ENOEXEC;
+        }
+
+        strtab = (char *)sechdrs[symtabsec->sh_link].sh_offset;
+
+        /* section header string table */
+        shstrtab = (char *)sechdrs[ehdr->e_shstrndx].sh_offset;
+
+        for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
+
+                /*
+                 * rel[i].r_offset contains byte offset from beginning
+                 * of section to the storage unit affected.
+                 *
+                 * This is location to update (->sh_offset). This is temporary
+                 * buffer where section is currently loaded. This will finally
+                 * be loaded to a different address later, pointed to by
+                 * ->sh_addr. kexec takes care of moving it
+                 *  (kexec_load_segment()).
+                 */
+                location = (void *)(section->sh_offset + rel[i].r_offset);
+
+                /* Final address of the location */
+                address = section->sh_addr + rel[i].r_offset;
+
+                /*
+                 * rel[i].r_info contains information about symbol table index
+                 * w.r.t which relocation must be made and type of relocation
+                 * to apply. ELF64_R_SYM() and ELF64_R_TYPE() macros get
+                 * these respectively.
+                 */
+                sym = (Elf64_Sym *)symtabsec->sh_offset +
+                                ELF64_R_SYM(rel[i].r_info);
+
+                if (sym->st_name)
+                        name = strtab + sym->st_name;
+                else
+                        name = shstrtab + sechdrs[sym->st_shndx].sh_name;
+
+                pr_debug("Symbol: %s info: %02x shndx: %02x value=%llx size: %llx\n",
+                         name, sym->st_info, sym->st_shndx, sym->st_value,
+                         sym->st_size);
+
+                if (sym->st_shndx == SHN_UNDEF) {
+                        pr_err("Undefined symbol: %s\n", name);
+                        return -ENOEXEC;
+                }
+
+                if (sym->st_shndx == SHN_COMMON) {
+                        pr_err("symbol '%s' in common section\n", name);
+                        return -ENOEXEC;
+                }
+
+                if (sym->st_shndx == SHN_ABS)
+                        sec_base = 0;
+                else if (sym->st_shndx >= ehdr->e_shnum) {
+                        pr_err("Invalid section %d for symbol %s\n",
+                               sym->st_shndx, name);
+                        return -ENOEXEC;
+                } else
+                        sec_base = sechdrs[sym->st_shndx].sh_addr;
+
+                value = sym->st_value;
+                value += sec_base;
+                value += rel[i].r_addend;
+
+                switch (ELF64_R_TYPE(rel[i].r_info)) {
+                case R_X86_64_NONE:
+                        break;
+                case R_X86_64_64:
+                        *(u64 *)location = value;
+                        break;
+                case R_X86_64_32:
+                        *(u32 *)location = value;
+                        if (value != *(u32 *)location)
+                                goto overflow;
+                        break;
+                case R_X86_64_32S:
+                        *(s32 *)location = value;
+                        if ((s64)value != *(s32 *)location)
+                                goto overflow;
+                        break;
+                case R_X86_64_PC32:
+                        value -= (u64)address;
+                        *(u32 *)location = value;
+                        break;
+                default:
+                        pr_err("Unknown rela relocation: %llu\n",
+                               ELF64_R_TYPE(rel[i].r_info));
+                        return -ENOEXEC;
+                }
+        }
+        return 0;
+
+overflow:
+        pr_err("Overflow in relocation type %d value 0x%lx\n",
+               (int)ELF64_R_TYPE(rel[i].r_info), value);
+        return -ENOEXEC;
+}