From f4c1caaa97a2e019ccc00ab63e390c60d1c9454c Mon Sep 17 00:00:00 2001

From: Bhupesh Sharma <bhsharma@redhat.com>

Date: Mon, 15 Jul 2019 11:32:56 +0530

Subject: [PATCH 4/5] kexec/arm64: Add support for handling zlib compressed

 (Image.gz) image

Currently the kexec_file_load() support for arm64 doesn't allow

handling zlib compressed (i.e. Image.gz) image.

Since most distributions use 'make zinstall' rule inside

'arch/arm64/boot/Makefile' to install the arm64

Image.gz compressed file inside the boot destination directory (for e.g.

/boot), currently we cannot use kexec_file_load() to load vmlinuz (or

Image.gz):

 # file /boot/vmlinuz

   /boot/vmlinuz: gzip compressed data, was "Image", <..snip..>, max

   compression, from Unix, original size 21945120

 Now, since via kexec_file_load() we pass the 'fd' of Image.gz

 (compressed file) via the following command line ...

 # kexec -s -l /boot/vmlinuz-`uname -r` --initrd=/boot/initramfs-`uname

   -r`.img --reuse-cmdline

... kernel returns -EINVAL error value, as it is not able to locate

the magic number =0x644d5241, which is expected in the 64-byte header

of the decompressed kernel image.

We can fix this in user-space kexec-tools, which handles an

'Image.gz' being passed via kexec_file_load(), using an approach

as follows:

a). Copy the contents of Image.gz to a temporary file.

b). Decompress (gunzip-decompress) the contents inside the

    temporary file.

c). Pass the 'fd' of the temporary file to the kernel space. So

    basically the kernel space still gets a decompressed kernel

    image to load via kexec-tools

I tested this patch for the following three use-cases:

1. Uncompressed Image file:

 #kexec -s -l Image --initrd=/boot/initramfs-`uname -r`.img --reuse-cmdline

2. Signed Image file:

 #kexec -s -l Image.signed --initrd=/boot/initramfs-`uname -r`.img --reuse-cmdline

3. zlib compressed Image.gz file:

 #kexec -s -l /boot/vmlinuz-`uname -r` --initrd=/boot/initramfs-`uname -r`.img --reuse-cmdline

Signed-off-by: Bhupesh Sharma <bhsharma@redhat.com>

Signed-off-by: Simon Horman <horms@verge.net.au>

---

 kexec/arch/arm64/Makefile             |   3 +-

 kexec/arch/arm64/kexec-arm64.c        |   1 +

 kexec/arch/arm64/kexec-arm64.h        |   7 ++

 kexec/arch/arm64/kexec-image-arm64.c  |   4 +-

 kexec/arch/arm64/kexec-zImage-arm64.c | 226 ++++++++++++++++++++++++++++++++++

 kexec/kexec.c                         |  12 ++

 6 files changed, 250 insertions(+), 3 deletions(-)

 create mode 100644 kexec/arch/arm64/kexec-zImage-arm64.c

diff --git a/kexec/arch/arm64/Makefile b/kexec/arch/arm64/Makefile

index 9d9111caa8ed..d27c8ee1b5e7 100644

--- a/kexec/arch/arm64/Makefile

+++ b/kexec/arch/arm64/Makefile

@@ -15,7 +15,8 @@ arm64_KEXEC_SRCS += \

 	kexec/arch/arm64/kexec-arm64.c \

 	kexec/arch/arm64/kexec-elf-arm64.c \

 	kexec/arch/arm64/kexec-uImage-arm64.c \

-	kexec/arch/arm64/kexec-image-arm64.c

+	kexec/arch/arm64/kexec-image-arm64.c \

+	kexec/arch/arm64/kexec-zImage-arm64.c

 arm64_UIMAGE = kexec/kexec-uImage.c

diff --git a/kexec/arch/arm64/kexec-arm64.c b/kexec/arch/arm64/kexec-arm64.c

index 2992bce8139f..eb3a3a37307c 100644

--- a/kexec/arch/arm64/kexec-arm64.c

+++ b/kexec/arch/arm64/kexec-arm64.c

@@ -71,6 +71,7 @@ struct file_type file_type[] = {

 	{"vmlinux", elf_arm64_probe, elf_arm64_load, elf_arm64_usage},

 	{"Image", image_arm64_probe, image_arm64_load, image_arm64_usage},

 	{"uImage", uImage_arm64_probe, uImage_arm64_load, uImage_arm64_usage},

+	{"zImage", zImage_arm64_probe, zImage_arm64_load, zImage_arm64_usage},

 };

 int file_types = sizeof(file_type) / sizeof(file_type[0]);

diff --git a/kexec/arch/arm64/kexec-arm64.h b/kexec/arch/arm64/kexec-arm64.h

index cc3419f4c10f..628de79b7f70 100644

--- a/kexec/arch/arm64/kexec-arm64.h

+++ b/kexec/arch/arm64/kexec-arm64.h

@@ -38,11 +38,18 @@ int image_arm64_probe(const char *kernel_buf, off_t kernel_size);

 int image_arm64_load(int argc, char **argv, const char *kernel_buf,

 	off_t kernel_size, struct kexec_info *info);

 void image_arm64_usage(void);

+

 int uImage_arm64_probe(const char *buf, off_t len);

 int uImage_arm64_load(int argc, char **argv, const char *buf, off_t len,

 		      struct kexec_info *info);

 void uImage_arm64_usage(void);

+int zImage_arm64_probe(const char *kernel_buf, off_t kernel_size);

+int zImage_arm64_load(int argc, char **argv, const char *kernel_buf,

+	off_t kernel_size, struct kexec_info *info);

+void zImage_arm64_usage(void);

+

+

 off_t initrd_base;

 off_t initrd_size;

diff --git a/kexec/arch/arm64/kexec-image-arm64.c b/kexec/arch/arm64/kexec-image-arm64.c

index 685a99352e39..aa8f2e22d72b 100644

--- a/kexec/arch/arm64/kexec-image-arm64.c

+++ b/kexec/arch/arm64/kexec-image-arm64.c

@@ -114,6 +114,6 @@ exit:

 void image_arm64_usage(void)

 {

 	printf(

-"     An ARM64 binary image, compressed or not, big or little endian.\n"

-"     Typically an Image, Image.gz or Image.lzma file.\n\n");

+"     An ARM64 binary image, uncompressed, big or little endian.\n"

+"     Typically an Image file.\n\n");

 }

diff --git a/kexec/arch/arm64/kexec-zImage-arm64.c b/kexec/arch/arm64/kexec-zImage-arm64.c

new file mode 100644

index 000000000000..6ee82ff6c79e

--- /dev/null

+++ b/kexec/arch/arm64/kexec-zImage-arm64.c

@@ -0,0 +1,226 @@

+/*

+ * ARM64 kexec zImage (Image.gz) support.

+ *

+ * Several distros use 'make zinstall' rule inside

+ * 'arch/arm64/boot/Makefile' to install the arm64

+ * Image.gz compressed file inside the boot destination

+ * directory (for e.g. /boot).

+ *

+ * Currently we cannot use kexec_file_load() to load vmlinuz

+ * (or Image.gz).

+ *

+ * To support Image.gz, we should:

+ * a). Copy the contents of Image.gz to a temporary file.

+ * b). Decompress (gunzip-decompress) the contents inside the

+ *     temporary file.

+ * c). Pass the 'fd' of the temporary file to the kernel space.

+ *

+ * So basically the kernel space still gets a decompressed

+ * kernel image to load via kexec-tools.

+ */

+

+#define _GNU_SOURCE

+

+#include <errno.h>

+#include <fcntl.h>

+#include <limits.h>

+#include <stdlib.h>

+#include "crashdump-arm64.h"

+#include "image-header.h"

+#include "kexec.h"

+#include "kexec-arm64.h"

+#include "kexec-syscall.h"

+#include "kexec-zlib.h"

+#include "arch/options.h"

+

+#define FILENAME_IMAGE		"/tmp/ImageXXXXXX"

+

+/* Returns:

+ * -1 : in case of error/invalid format (not a valid Image.gz format.

+ * fd : File descriptor of the temp file containing the decompressed

+ *      Image.

+ */

+int zImage_arm64_probe(const char *kernel_buf, off_t kernel_size)

+{

+	int ret = -1;

+	int fd = 0;

+	int kernel_fd = 0;

+	char *fname = NULL;

+	char *kernel_uncompressed_buf = NULL;

+	const struct arm64_image_header *h;

+

+	if (!is_zlib_file(kernel_buf, &kernel_size)) {

+		dbgprintf("%s: Not an zImage file (Image.gz).\n", __func__);

+		return -1;

+	}

+

+	if (!(fname = strdup(FILENAME_IMAGE))) {

+		dbgprintf("%s: Can't duplicate strings %s\n", __func__,

+				fname);

+		return -1;

+	}

+

+	if ((fd = mkstemp(fname)) < 0) {

+		dbgprintf("%s: Can't open file %s\n", __func__,

+				fname);

+		ret = -1;

+		goto fail_mkstemp;

+	}

+

+	kernel_uncompressed_buf =

+		(char *) calloc(kernel_size, sizeof(off_t));

+	if (!kernel_uncompressed_buf) {

+		dbgprintf("%s: Can't calloc %ld bytes\n",

+				__func__, kernel_size);

+		ret= -ENOMEM;

+		goto fail_calloc;

+	}

+

+	/* slurp in the input kernel */

+	dbgprintf("%s: ", __func__);

+	kernel_uncompressed_buf = slurp_decompress_file(kernel_buf,

+							&kernel_size);

+

+	/* check for correct header magic */

+	if (kernel_size < sizeof(struct arm64_image_header)) {

+		dbgprintf("%s: No arm64 image header.\n", __func__);

+		ret = -1;

+		goto fail_bad_header;

+	}

+

+	h = (const struct arm64_image_header *)(kernel_uncompressed_buf);

+

+	if (!arm64_header_check_magic(h)) {

+		dbgprintf("%s: Bad arm64 image header.\n", __func__);

+		ret = -1;

+		goto fail_bad_header;

+	}

+

+	if (write(fd, kernel_uncompressed_buf,

+				kernel_size) != kernel_size) {

+		dbgprintf("%s: Can't write the uncompressed file %s\n",

+				__func__, fname);

+		ret = -1;

+		goto fail_bad_header;

+	}

+

+	close(fd);

+

+	/* Open the tmp file again, this time in O_RDONLY mode, as

+	 * opening the file in O_RDWR and calling kexec_file_load()

+	 * causes the kernel to return -ETXTBSY

+	 */

+	kernel_fd = open(fname, O_RDONLY);

+	if (kernel_fd == -1) {

+		dbgprintf("%s: Failed to open file %s\n",

+				__func__, fname);

+		ret = -1;

+		goto fail_bad_header;

+	}

+

+	unlink(fname);

+

+	free(kernel_uncompressed_buf);

+	free(fname);

+

+	return kernel_fd;

+

+fail_bad_header:

+	free(kernel_uncompressed_buf);

+

+fail_calloc:

+	if (fd >= 0)

+		close(fd);

+

+	unlink(fname);

+

+fail_mkstemp:

+	free(fname);

+

+	return ret;

+}

+

+int zImage_arm64_load(int argc, char **argv, const char *kernel_buf,

+	off_t kernel_size, struct kexec_info *info)

+{

+	const struct arm64_image_header *header;

+	unsigned long kernel_segment;

+	int result;

+

+	if (info->file_mode) {

+		if (arm64_opts.initrd) {

+			info->initrd_fd = open(arm64_opts.initrd, O_RDONLY);

+			if (info->initrd_fd == -1) {

+				fprintf(stderr,

+					"Could not open initrd file %s:%s\n",

+					arm64_opts.initrd, strerror(errno));

+				result = EFAILED;

+				goto exit;

+			}

+		}

+

+		if (arm64_opts.command_line) {

+			info->command_line = (char *)arm64_opts.command_line;

+			info->command_line_len =

+					strlen(arm64_opts.command_line) + 1;

+		}

+

+		return 0;

+	}

+

+	header = (const struct arm64_image_header *)(kernel_buf);

+

+	if (arm64_process_image_header(header))

+		return EFAILED;

+

+	kernel_segment = arm64_locate_kernel_segment(info);

+

+	if (kernel_segment == ULONG_MAX) {

+		dbgprintf("%s: Kernel segment is not allocated\n", __func__);

+		result = EFAILED;

+		goto exit;

+	}

+

+	dbgprintf("%s: kernel_segment: %016lx\n", __func__, kernel_segment);

+	dbgprintf("%s: text_offset:    %016lx\n", __func__,

+		arm64_mem.text_offset);

+	dbgprintf("%s: image_size:     %016lx\n", __func__,

+		arm64_mem.image_size);

+	dbgprintf("%s: phys_offset:    %016lx\n", __func__,

+		arm64_mem.phys_offset);

+	dbgprintf("%s: vp_offset:      %016lx\n", __func__,

+		arm64_mem.vp_offset);

+	dbgprintf("%s: PE format:      %s\n", __func__,

+		(arm64_header_check_pe_sig(header) ? "yes" : "no"));

+

+	/* create and initialize elf core header segment */

+	if (info->kexec_flags & KEXEC_ON_CRASH) {

+		result = load_crashdump_segments(info);

+		if (result) {

+			dbgprintf("%s: Creating eflcorehdr failed.\n",

+								__func__);

+			goto exit;

+		}

+	}

+

+	/* load the kernel */

+	add_segment_phys_virt(info, kernel_buf, kernel_size,

+			kernel_segment + arm64_mem.text_offset,

+			arm64_mem.image_size, 0);

+

+	/* load additional data */

+	result = arm64_load_other_segments(info, kernel_segment

+		+ arm64_mem.text_offset);

+

+exit:

+	if (result)

+		fprintf(stderr, "kexec: load failed.\n");

+	return result;

+}

+

+void zImage_arm64_usage(void)

+{

+	printf(

+"     An ARM64 zImage, compressed, big or little endian.\n"

+"     Typically an Image.gz or Image.lzma file.\n\n");

+}

diff --git a/kexec/kexec.c b/kexec/kexec.c

index 8ca3b457cac8..bc6ab3dbd10b 100644

--- a/kexec/kexec.c

+++ b/kexec/kexec.c

@@ -1206,8 +1206,20 @@ static int do_kexec_file_load(int fileind, int argc, char **argv,

 	kernel_buf = slurp_decompress_file(kernel, &kernel_size);

 	for (i = 0; i < file_types; i++) {

+#ifdef __aarch64__

+		/* handle Image.gz like cases */

+		if (is_zlib_file(kernel, &kernel_size)) {

+			if ((ret = file_type[i].probe(kernel, kernel_size)) >= 0) {

+				kernel_fd = ret;

+				break;

+			}

+		} else

+			if (file_type[i].probe(kernel_buf, kernel_size) >= 0)

+				break;

+#else

 		if (file_type[i].probe(kernel_buf, kernel_size) >= 0)

 			break;

+#endif

 	}

 	if (i == file_types) {

-- 

2.7.4