LoongArch: Add crash dump support for kexec_file

Enabling crash dump (kdump) includes:
- Prepare contents of ELF header of a core dump file, /proc/vmcore,
  using crash_prepare_elf64_headers().
- Add "mem=size@start" parameter to the command line and pass it to the
  capture kernel.  Limit the runtime memory area of the captured kernel
  to avoid disrupting the production kernel's runtime state.
- Add "elfcorehdr=size@start" parameter to the cmdline.

The basic usage for kdump (add the cmdline parameter crashkernel=512M
to grub.cfg for production kernel):

1) Load capture kernel image (vmlinux.efi or vmlinux can both be used):
 # kexec -s -p vmlinuz.efi --initrd=initrd.img --reuse-cmdline

2) Do something to crash, like:
 # echo c > /proc/sysrq-trigger

Signed-off-by: Youling Tang <tangyouling@kylinos.cn>
Signed-off-by: Huacai Chen <chenhuacai@loongson.cn>

diff --git a/arch/loongarch/kernel/machine_kexec_file.c b/arch/loongarch/kernel/machine_kexec_file.c
index fbb94da953225097c69690f625bab232c50bec59..dda236b51a881f1f61ad84c64ac31da8e6cc62de 100644 (file)
--- a/arch/loongarch/kernel/machine_kexec_file.c
+++ b/arch/loongarch/kernel/machine_kexec_file.c
@@ -55,6 +55,81 @@ static void cmdline_add_initrd(struct kimage *image, unsigned long *cmdline_tmpl
        *cmdline_tmplen += initrd_strlen;
 }
 
+#ifdef CONFIG_CRASH_DUMP
+
+static int prepare_elf_headers(void **addr, unsigned long *sz)
+{
+       int ret, nr_ranges;
+       uint64_t i;
+       phys_addr_t start, end;
+       struct crash_mem *cmem;
+
+       nr_ranges = 2; /* for exclusion of crashkernel region */
+       for_each_mem_range(i, &start, &end)
+               nr_ranges++;
+
+       cmem = kmalloc(struct_size(cmem, ranges, nr_ranges), GFP_KERNEL);
+       if (!cmem)
+               return -ENOMEM;
+
+       cmem->max_nr_ranges = nr_ranges;
+       cmem->nr_ranges = 0;
+       for_each_mem_range(i, &start, &end) {
+               cmem->ranges[cmem->nr_ranges].start = start;
+               cmem->ranges[cmem->nr_ranges].end = end - 1;
+               cmem->nr_ranges++;
+       }
+
+       /* Exclude crashkernel region */
+       ret = crash_exclude_mem_range(cmem, crashk_res.start, crashk_res.end);
+       if (ret < 0)
+               goto out;
+
+       if (crashk_low_res.end) {
+               ret = crash_exclude_mem_range(cmem, crashk_low_res.start, crashk_low_res.end);
+               if (ret < 0)
+                       goto out;
+       }
+
+       ret = crash_prepare_elf64_headers(cmem, true, addr, sz);
+
+out:
+       kfree(cmem);
+       return ret;
+}
+
+/*
+ * Add the "mem=size@start" command line parameter to command line, indicating the
+ * memory region the new kernel can use to boot into.
+ */
+static void cmdline_add_mem(unsigned long *cmdline_tmplen, char *modified_cmdline)
+{
+       int mem_strlen = 0;
+
+       mem_strlen = sprintf(modified_cmdline + (*cmdline_tmplen), "mem=0x%llx@0x%llx ",
+               crashk_res.end - crashk_res.start + 1, crashk_res.start);
+       *cmdline_tmplen += mem_strlen;
+
+       if (crashk_low_res.end) {
+               mem_strlen = sprintf(modified_cmdline + (*cmdline_tmplen), "mem=0x%llx@0x%llx ",
+                       crashk_low_res.end - crashk_low_res.start + 1, crashk_low_res.start);
+               *cmdline_tmplen += mem_strlen;
+       }
+}
+
+/* Add the "elfcorehdr=size@start" command line parameter to command line. */
+static void cmdline_add_elfcorehdr(struct kimage *image, unsigned long *cmdline_tmplen,
+                                  char *modified_cmdline, unsigned long elfcorehdr_sz)
+{
+       int elfcorehdr_strlen = 0;
+
+       elfcorehdr_strlen = sprintf(modified_cmdline + (*cmdline_tmplen), "elfcorehdr=0x%lx@0x%lx ",
+               elfcorehdr_sz, image->elf_load_addr);
+       *cmdline_tmplen += elfcorehdr_strlen;
+}
+
+#endif
+
 /*
  * Try to add the initrd to the image. If it is not possible to find valid
  * locations, this function will undo changes to the image and return non zero.
@@ -82,6 +157,46 @@ int load_other_segments(struct kimage *image,
        /* Ensure it's null terminated */
        modified_cmdline[COMMAND_LINE_SIZE - 1] = '\0';
 
+#ifdef CONFIG_CRASH_DUMP
+       /* Load elf core header */
+       if (image->type == KEXEC_TYPE_CRASH) {
+               void *headers;
+               unsigned long headers_sz;
+
+               ret = prepare_elf_headers(&headers, &headers_sz);
+               if (ret < 0) {
+                       pr_err("Preparing elf core header failed\n");
+                       goto out_err;
+               }
+
+               kbuf.buffer = headers;
+               kbuf.bufsz = headers_sz;
+               kbuf.mem = KEXEC_BUF_MEM_UNKNOWN;
+               kbuf.memsz = headers_sz;
+               kbuf.buf_align = SZ_64K; /* largest supported page size */
+               kbuf.buf_max = ULONG_MAX;
+               kbuf.top_down = true;
+
+               ret = kexec_add_buffer(&kbuf);
+               if (ret < 0) {
+                       vfree(headers);
+                       goto out_err;
+               }
+               image->elf_headers = headers;
+               image->elf_load_addr = kbuf.mem;
+               image->elf_headers_sz = headers_sz;
+
+               kexec_dprintk("Loaded elf core header at 0x%lx bufsz=0x%lx memsz=0x%lx\n",
+                             image->elf_load_addr, kbuf.bufsz, kbuf.memsz);
+
+               /* Add the mem=size@start parameter to the command line */
+               cmdline_add_mem(&cmdline_tmplen, modified_cmdline);
+
+               /* Add the elfcorehdr=size@start parameter to the command line */
+               cmdline_add_elfcorehdr(image, &cmdline_tmplen, modified_cmdline, headers_sz);
+       }
+#endif
+
        /* Load initrd */
        if (initrd) {
                kbuf.buffer = initrd;