parisc: Include compressed vmlinux file in vmlinuz boot kernel

Change the parisc vmlinuz boot code to include and process the real
compressed vmlinux.gz ELF file instead of a compressed memory dump.
This brings parisc in sync on how it's done on x86_64.

The benefit of this change is that, e.g. for debugging purposes, one can
then extract the vmlinux file out of the vmlinuz which was booted which
wasn't possible before. This can be archieved with the existing
scripts/extract-vmlinux script, which just needs a small tweak to prefer
to extract a compressed file before trying the existing given binary.

The downside of this approach is that due to the extra round of
decompression/ELF processing we need more physical memory installed to
be able to boot a kernel.

Signed-off-by: Helge Deller <deller@gmx.de>

4 files changed, 91 insertions, 30 deletions

diff --git a/arch/parisc/boot/compressed/Makefile b/arch/parisc/boot/compressed/Makefile
index 7d7e594bda36..777533cdea31 100644
--- a/arch/parisc/boot/compressed/Makefile
+++ b/arch/parisc/boot/compressed/Makefile
@@ -14,7 +14,7 @@ targets += misc.o piggy.o sizes.h head.o real2.o firmware.o
 
 KBUILD_CFLAGS := -D__KERNEL__ -O2 -DBOOTLOADER
 KBUILD_CFLAGS += -DDISABLE_BRANCH_PROFILING
-KBUILD_CFLAGS += $(cflags-y) -fno-delete-null-pointer-checks
+KBUILD_CFLAGS += $(cflags-y) -fno-delete-null-pointer-checks -fno-builtin-printf
 KBUILD_CFLAGS += -fno-PIE -mno-space-regs -mdisable-fpregs -Os
 ifndef CONFIG_64BIT
 KBUILD_CFLAGS += -mfast-indirect-calls
@@ -22,7 +22,6 @@ endif
 
 OBJECTS += $(obj)/head.o $(obj)/real2.o $(obj)/firmware.o $(obj)/misc.o $(obj)/piggy.o
 
-# LDFLAGS_vmlinux := -X --whole-archive -e startup -T
 LDFLAGS_vmlinux := -X -e startup --as-needed -T
 $(obj)/vmlinux: $(obj)/vmlinux.lds $(OBJECTS) $(LIBGCC)
         $(call if_changed,ld)
@@ -55,7 +54,6 @@ $(obj)/misc.o: $(obj)/sizes.h
 CPPFLAGS_vmlinux.lds += -I$(objtree)/$(obj) -DBOOTLOADER
 $(obj)/vmlinux.lds: $(obj)/sizes.h
 
-OBJCOPYFLAGS_vmlinux.bin := -O binary -R .comment -S
 $(obj)/vmlinux.bin: vmlinux
         $(call if_changed,objcopy)
 
diff --git a/arch/parisc/boot/compressed/misc.c b/arch/parisc/boot/compressed/misc.c
index f57118e1f6b4..2556bb181813 100644
--- a/arch/parisc/boot/compressed/misc.c
+++ b/arch/parisc/boot/compressed/misc.c
@@ -5,6 +5,7 @@
  */
 
 #include <linux/uaccess.h>
+#include <linux/elf.h>
 #include <asm/unaligned.h>
 #include <asm/page.h>
 #include "sizes.h"
@@ -227,13 +228,62 @@ static void flush_data_cache(char *start, unsigned long length)
         asm ("sync");
 }
 
+static void parse_elf(void *output)
+{
+#ifdef CONFIG_64BIT
+        Elf64_Ehdr ehdr;
+        Elf64_Phdr *phdrs, *phdr;
+#else
+        Elf32_Ehdr ehdr;
+        Elf32_Phdr *phdrs, *phdr;
+#endif
+        void *dest;
+        int i;
+
+        memcpy(&ehdr, output, sizeof(ehdr));
+        if (ehdr.e_ident[EI_MAG0] != ELFMAG0 ||
+           ehdr.e_ident[EI_MAG1] != ELFMAG1 ||
+           ehdr.e_ident[EI_MAG2] != ELFMAG2 ||
+           ehdr.e_ident[EI_MAG3] != ELFMAG3) {
+                error("Kernel is not a valid ELF file");
+                return;
+        }
+
+#ifdef DEBUG
+        printf("Parsing ELF... ");
+#endif
+
+        phdrs = malloc(sizeof(*phdrs) * ehdr.e_phnum);
+        if (!phdrs)
+                error("Failed to allocate space for phdrs");
+
+        memcpy(phdrs, output + ehdr.e_phoff, sizeof(*phdrs) * ehdr.e_phnum);
+
+        for (i = 0; i < ehdr.e_phnum; i++) {
+                phdr = &phdrs[i];
+
+                switch (phdr->p_type) {
+                case PT_LOAD:
+                        dest = (void *)((unsigned long) phdr->p_paddr &
+                                        (__PAGE_OFFSET_DEFAULT-1));
+                        memmove(dest, output + phdr->p_offset, phdr->p_filesz);
+                        break;
+                default:
+                        break;
+                }
+        }
+
+        free(phdrs);
+}
+
 unsigned long decompress_kernel(unsigned int started_wide,
                 unsigned int command_line,
                 const unsigned int rd_start,
                 const unsigned int rd_end)
 {
         char *output;
-        unsigned long len, len_all;
+        unsigned long vmlinux_addr, vmlinux_len;
+        unsigned long kernel_addr, kernel_len;
 
 #ifdef CONFIG_64BIT
         parisc_narrow_firmware = 0;
@@ -241,27 +291,29 @@ unsigned long decompress_kernel(unsigned int started_wide,
 
         set_firmware_width_unlocked();
 
-        putchar('U');   /* if you get this p and no more, string storage */
+        putchar('D');   /* if you get this D and no more, string storage */
                         /* in $GLOBAL$ is wrong or %dp is wrong */
-        puts("ncompressing ...\n");
-
-        output = (char *) KERNEL_BINARY_TEXT_START;
-        len_all = __pa(SZ_end) - __pa(SZparisc_kernel_start);
+        puts("ecompressing Linux... ");
 
-        if ((unsigned long) &_startcode_end > (unsigned long) output)
+        /* where the final bits are stored */
+        kernel_addr = KERNEL_BINARY_TEXT_START;
+        kernel_len = __pa(SZ_end) - __pa(SZparisc_kernel_start);
+        if ((unsigned long) &_startcode_end > kernel_addr)
                 error("Bootcode overlaps kernel code");
 
-        len = get_unaligned_le32(&output_len);
-        if (len > len_all)
-                error("Output len too big.");
-        else
-                memset(&output[len], 0, len_all - len);
+        /*
+         * Calculate addr to where the vmlinux ELF file shall be decompressed.
+         * Assembly code in head.S positioned the stack directly behind bss, so
+         * leave 2 MB for the stack.
+         */
+        vmlinux_addr = (unsigned long) &_ebss + 2*1024*1024;
+        vmlinux_len = get_unaligned_le32(&output_len);
+        output = (char *) vmlinux_addr;
 
         /*
          * Initialize free_mem_ptr and free_mem_end_ptr.
          */
-        free_mem_ptr = (unsigned long) &_ebss;
-        free_mem_ptr += 2*1024*1024;    /* leave 2 MB for stack */
+        free_mem_ptr = vmlinux_addr + vmlinux_len;
 
         /* Limit memory for bootoader to 1GB */
         #define ARTIFICIAL_LIMIT (1*1024*1024*1024)
@@ -275,7 +327,11 @@ unsigned long decompress_kernel(unsigned int started_wide,
                 free_mem_end_ptr = rd_start;
 #endif
 
+        if (free_mem_ptr >= free_mem_end_ptr)
+                error("Kernel too big for machine.");
+
 #ifdef DEBUG
+        printf("\n");
         printf("startcode_end = %x\n", &_startcode_end);
         printf("commandline   = %x\n", command_line);
         printf("rd_start      = %x\n", rd_start);
@@ -287,16 +343,19 @@ unsigned long decompress_kernel(unsigned int started_wide,
         printf("input_data    = %x\n", input_data);
         printf("input_len     = %x\n", input_len);
         printf("output        = %x\n", output);
-        printf("output_len    = %x\n", len);
-        printf("output_max    = %x\n", len_all);
+        printf("output_len    = %x\n", vmlinux_len);
+        printf("kernel_addr   = %x\n", kernel_addr);
+        printf("kernel_len    = %x\n", kernel_len);
 #endif
 
         __decompress(input_data, input_len, NULL, NULL,
                         output, 0, NULL, error);
+        parse_elf(output);