Unverified Commit 8acea455 authored by Li Zhengyu's avatar Li Zhengyu Committed by Palmer Dabbelt
Browse files

RISC-V: Support for kexec_file on panic 



This patch adds support for loading a kexec on panic (kdump) kernel.
It has been tested with vmcore-dmesg on riscv64 QEMU on both an smp
and a non-smp system.

Signed-off-by: default avatarLi Zhengyu <lizhengyu3@huawei.com>
Link: https://lore.kernel.org/r/20220408100914.150110-5-lizhengyu3@huawei.com


Signed-off-by: default avatarPalmer Dabbelt <palmer@rivosinc.com>
parent 6261586e

arch/riscv/kernel/elf_kexec.c

+118 −1
Original line number Diff line number Diff line
@@ -18,6 +18,8 @@ 
#include <linux/of.h>

#include <linux/libfdt.h>

#include <linux/types.h>

#include <linux/memblock.h>

#include <asm/setup.h>



static int riscv_kexec_elf_load(struct kimage *image, struct elfhdr *ehdr,

				struct kexec_elf_info *elf_info, unsigned long old_pbase,
@@ -97,6 +99,79 @@ static int elf_find_pbase(struct kimage *image, unsigned long kernel_len, 
	return ret;

}



static int get_nr_ram_ranges_callback(struct resource *res, void *arg)

{

	unsigned int *nr_ranges = arg;



	(*nr_ranges)++;

	return 0;

}



static int prepare_elf64_ram_headers_callback(struct resource *res, void *arg)

{

	struct crash_mem *cmem = arg;



	cmem->ranges[cmem->nr_ranges].start = res->start;

	cmem->ranges[cmem->nr_ranges].end = res->end;

	cmem->nr_ranges++;



	return 0;

}



static int prepare_elf_headers(void **addr, unsigned long *sz)

{

	struct crash_mem *cmem;

	unsigned int nr_ranges;

	int ret;



	nr_ranges = 1; /* For exclusion of crashkernel region */

	walk_system_ram_res(0, -1, &nr_ranges, get_nr_ram_ranges_callback);



	cmem = kmalloc(struct_size(cmem, ranges, nr_ranges), GFP_KERNEL);

	if (!cmem)

		return -ENOMEM;



	cmem->max_nr_ranges = nr_ranges;

	cmem->nr_ranges = 0;

	ret = walk_system_ram_res(0, -1, cmem, prepare_elf64_ram_headers_callback);

	if (ret)

		goto out;



	/* Exclude crashkernel region */

	ret = crash_exclude_mem_range(cmem, crashk_res.start, crashk_res.end);

	if (!ret)

		ret = crash_prepare_elf64_headers(cmem, true, addr, sz);



out:

	kfree(cmem);

	return ret;

}



static char *setup_kdump_cmdline(struct kimage *image, char *cmdline,

				 unsigned long cmdline_len)

{

	int elfcorehdr_strlen;

	char *cmdline_ptr;



	cmdline_ptr = kzalloc(COMMAND_LINE_SIZE, GFP_KERNEL);

	if (!cmdline_ptr)

		return NULL;



	elfcorehdr_strlen = sprintf(cmdline_ptr, "elfcorehdr=0x%lx ",

		image->elf_load_addr);



	if (elfcorehdr_strlen + cmdline_len > COMMAND_LINE_SIZE) {

		pr_err("Appending elfcorehdr=<addr> exceeds cmdline size\n");

		kfree(cmdline_ptr);

		return NULL;

	}



	memcpy(cmdline_ptr + elfcorehdr_strlen, cmdline, cmdline_len);

	/* Ensure it's nul terminated */

	cmdline_ptr[COMMAND_LINE_SIZE - 1] = '\0';

	return cmdline_ptr;

}



static void *elf_kexec_load(struct kimage *image, char *kernel_buf,

			    unsigned long kernel_len, char *initrd,

			    unsigned long initrd_len, char *cmdline,
@@ -106,10 +181,12 @@ static void *elf_kexec_load(struct kimage *image, char *kernel_buf, 
	unsigned long old_kernel_pbase = ULONG_MAX;

	unsigned long new_kernel_pbase = 0UL;

	unsigned long initrd_pbase = 0UL;

	void *fdt;

	unsigned long headers_sz;

	void *fdt, *headers;

	struct elfhdr ehdr;

	struct kexec_buf kbuf;

	struct kexec_elf_info elf_info;

	char *modified_cmdline = NULL;



	ret = kexec_build_elf_info(kernel_buf, kernel_len, &ehdr, &elf_info);

	if (ret)
@@ -130,6 +207,45 @@ static void *elf_kexec_load(struct kimage *image, char *kernel_buf, 
	kbuf.image = image;

	kbuf.buf_min = new_kernel_pbase + kernel_len;

	kbuf.buf_max = ULONG_MAX;



	/* Add elfcorehdr */

	if (image->type == KEXEC_TYPE_CRASH) {

		ret = prepare_elf_headers(&headers, &headers_sz);

		if (ret) {

			pr_err("Preparing elf core header failed\n");

			goto out;

		}



		kbuf.buffer = headers;

		kbuf.bufsz = headers_sz;

		kbuf.mem = KEXEC_BUF_MEM_UNKNOWN;

		kbuf.memsz = headers_sz;

		kbuf.buf_align = ELF_CORE_HEADER_ALIGN;

		kbuf.top_down = true;



		ret = kexec_add_buffer(&kbuf);

		if (ret) {

			vfree(headers);

			goto out;

		}

		image->elf_headers = headers;

		image->elf_load_addr = kbuf.mem;

		image->elf_headers_sz = headers_sz;



		pr_debug("Loaded elf core header at 0x%lx bufsz=0x%lx memsz=0x%lx\n",

			 image->elf_load_addr, kbuf.bufsz, kbuf.memsz);



		/* Setup cmdline for kdump kernel case */

		modified_cmdline = setup_kdump_cmdline(image, cmdline,

						       cmdline_len);

		if (!modified_cmdline) {

			pr_err("Setting up cmdline for kdump kernel failed\n");

			ret = -EINVAL;

			goto out;

		}

		cmdline = modified_cmdline;

	}



	/* Add the initrd to the image */

	if (initrd != NULL) {

		kbuf.buffer = initrd;
@@ -170,6 +286,7 @@ static void *elf_kexec_load(struct kimage *image, char *kernel_buf, 
out_free_fdt:

	kvfree(fdt);

out:

	kfree(modified_cmdline);

	kexec_free_elf_info(&elf_info);

	return ret ? ERR_PTR(ret) : NULL;

}