LoongArch: Add preparatory infrastructure for kexec_file

Add some preparatory infrastructure:
- Add command line processing.
- Add support for loading other segments.
- Other minor modifications.

This initrd will be passed to the second kernel via the command line
'initrd=start,size'.

The 'kexec_file' command line parameter indicates that the kernel is
loaded via kexec_file.

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

diff --git a/arch/loongarch/Kconfig b/arch/loongarch/Kconfig
index 0631a6b11281b95a4a75aaee6cd1a27f7ddc681c..aa1cb1fd3c525bc4d90364a008b6cc15f0cb911e 100644 (file)
--- a/arch/loongarch/Kconfig
+++ b/arch/loongarch/Kconfig
@@ -633,6 +633,15 @@ config CPU_HAS_PREFETCH
 config ARCH_SUPPORTS_KEXEC
        def_bool y
 
+config ARCH_SUPPORTS_KEXEC_FILE
+       def_bool 64BIT
+
+config ARCH_SELECTS_KEXEC_FILE
+       def_bool 64BIT
+       depends on KEXEC_FILE
+       select RELOCATABLE
+       select HAVE_IMA_KEXEC if IMA
+
 config ARCH_SUPPORTS_CRASH_DUMP
        def_bool y
 

diff --git a/arch/loongarch/include/asm/kexec.h b/arch/loongarch/include/asm/kexec.h
index cf95cd3eb2deaefb065719e970062a98a8356346..9442c7a1c3a60c1e52477791950e5f1c414e23ec 100644 (file)
--- a/arch/loongarch/include/asm/kexec.h
+++ b/arch/loongarch/include/asm/kexec.h
@@ -41,6 +41,16 @@ struct kimage_arch {
        unsigned long systable_ptr;
 };
 
+#ifdef CONFIG_KEXEC_FILE
+
+int arch_kimage_file_post_load_cleanup(struct kimage *image);
+#define arch_kimage_file_post_load_cleanup arch_kimage_file_post_load_cleanup
+
+extern int load_other_segments(struct kimage *image,
+               unsigned long kernel_load_addr, unsigned long kernel_size,
+               char *initrd, unsigned long initrd_len, char *cmdline, unsigned long cmdline_len);
+#endif
+
 typedef void (*do_kexec_t)(unsigned long efi_boot,
                           unsigned long cmdline_ptr,
                           unsigned long systable_ptr,

diff --git a/arch/loongarch/kernel/Makefile b/arch/loongarch/kernel/Makefile
index 6f5a4574a911d5b7ca68a2e67d52625d4637906f..67b9b214d212da1421903822e7b63dae245d9dbf 100644 (file)
--- a/arch/loongarch/kernel/Makefile
+++ b/arch/loongarch/kernel/Makefile
@@ -62,6 +62,7 @@ obj-$(CONFIG_MAGIC_SYSRQ)     += sysrq.o
 obj-$(CONFIG_RELOCATABLE)      += relocate.o
 
 obj-$(CONFIG_KEXEC_CORE)       += machine_kexec.o relocate_kernel.o
+obj-$(CONFIG_KEXEC_FILE)       += machine_kexec_file.o
 obj-$(CONFIG_CRASH_DUMP)       += crash_dump.o
 
 obj-$(CONFIG_UNWINDER_GUESS)   += unwind_guess.o

diff --git a/arch/loongarch/kernel/machine_kexec.c b/arch/loongarch/kernel/machine_kexec.c
index f9381800e291cc2989bc9d6a01a44a049e8191d0..e4b2bbc47e6235e555b34ad4b2e2c71a1fc364a1 100644 (file)
--- a/arch/loongarch/kernel/machine_kexec.c
+++ b/arch/loongarch/kernel/machine_kexec.c
@@ -70,18 +70,28 @@ int machine_kexec_prepare(struct kimage *kimage)
        kimage->arch.efi_boot = fw_arg0;
        kimage->arch.systable_ptr = fw_arg2;
 
-       /* Find the command line */
-       for (i = 0; i < kimage->nr_segments; i++) {
-               if (!strncmp(bootloader, (char __user *)kimage->segment[i].buf, strlen(bootloader))) {
-                       if (!copy_from_user(cmdline_ptr, kimage->segment[i].buf, COMMAND_LINE_SIZE))
-                               kimage->arch.cmdline_ptr = (unsigned long)cmdline_ptr;
-                       break;
+       if (kimage->file_mode == 1) {
+               /*
+                * kimage->cmdline_buf will be released in kexec_file_load, so copy
+                * to the KEXEC_CMDLINE_ADDR safe area.
+                */
+               memcpy((void *)KEXEC_CMDLINE_ADDR, (void *)kimage->arch.cmdline_ptr,
+                                       strlen((char *)kimage->arch.cmdline_ptr) + 1);
+               kimage->arch.cmdline_ptr = (unsigned long)KEXEC_CMDLINE_ADDR;
+       } else {
+               /* Find the command line */
+               for (i = 0; i < kimage->nr_segments; i++) {
+                       if (!strncmp(bootloader, (char __user *)kimage->segment[i].buf, strlen(bootloader))) {
+                               if (!copy_from_user(cmdline_ptr, kimage->segment[i].buf, COMMAND_LINE_SIZE))
+                                       kimage->arch.cmdline_ptr = (unsigned long)cmdline_ptr;
+                               break;
+                       }
                }
-       }
 
-       if (!kimage->arch.cmdline_ptr) {
-               pr_err("Command line not included in the provided image\n");
-               return -EINVAL;
+               if (!kimage->arch.cmdline_ptr) {
+                       pr_err("Command line not included in the provided image\n");
+                       return -EINVAL;
+               }
        }
 
        /* kexec/kdump need a safe page to save reboot_code_buffer */
@@ -287,9 +297,10 @@ void machine_kexec(struct kimage *image)
        /* We do not want to be bothered. */
        local_irq_disable();
 
-       pr_notice("EFI boot flag 0x%lx\n", efi_boot);
-       pr_notice("Command line at 0x%lx\n", cmdline_ptr);
-       pr_notice("System table at 0x%lx\n", systable_ptr);
+       pr_notice("EFI boot flag: 0x%lx\n", efi_boot);
+       pr_notice("Command line addr: 0x%lx\n", cmdline_ptr);
+       pr_notice("Command line string: %s\n", (char *)cmdline_ptr);
+       pr_notice("System table addr: 0x%lx\n", systable_ptr);
        pr_notice("We will call new kernel at 0x%lx\n", start_addr);
        pr_notice("Bye ...\n");
 

diff --git a/arch/loongarch/kernel/machine_kexec_file.c b/arch/loongarch/kernel/machine_kexec_file.c
new file mode 100644 (file)
index 0000000..8e99d2f
--- /dev/null
+++ b/arch/loongarch/kernel/machine_kexec_file.c
@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * kexec_file for LoongArch
+ *
+ * Author: Youling Tang <tangyouling@kylinos.cn>
+ * Copyright (C) 2025 KylinSoft Corporation.
+ *
+ * Most code is derived from LoongArch port of kexec-tools
+ */
+
+#define pr_fmt(fmt) "kexec_file: " fmt
+
+#include <linux/ioport.h>
+#include <linux/kernel.h>
+#include <linux/kexec.h>
+#include <linux/memblock.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/types.h>
+#include <linux/vmalloc.h>
+#include <asm/bootinfo.h>
+
+const struct kexec_file_ops * const kexec_file_loaders[] = {
+       NULL
+};
+
+int arch_kimage_file_post_load_cleanup(struct kimage *image)
+{
+       vfree(image->elf_headers);
+       image->elf_headers = NULL;
+       image->elf_headers_sz = 0;
+
+       return kexec_image_post_load_cleanup_default(image);
+}
+
+/* Add the "kexec_file" command line parameter to command line. */
+static void cmdline_add_loader(unsigned long *cmdline_tmplen, char *modified_cmdline)
+{
+       int loader_strlen;
+
+       loader_strlen = sprintf(modified_cmdline + (*cmdline_tmplen), "kexec_file ");
+       *cmdline_tmplen += loader_strlen;
+}
+
+/* Add the "initrd=start,size" command line parameter to command line. */
+static void cmdline_add_initrd(struct kimage *image, unsigned long *cmdline_tmplen,
+                               char *modified_cmdline, unsigned long initrd)
+{
+       int initrd_strlen;
+
+       initrd_strlen = sprintf(modified_cmdline + (*cmdline_tmplen), "initrd=0x%lx,0x%lx ",
+               initrd, image->initrd_buf_len);
+       *cmdline_tmplen += initrd_strlen;
+}
+
+/*
+ * 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.
+ */
+int load_other_segments(struct kimage *image,
+                       unsigned long kernel_load_addr, unsigned long kernel_size,
+                       char *initrd, unsigned long initrd_len, char *cmdline, unsigned long cmdline_len)
+{
+       int ret = 0;
+       unsigned long cmdline_tmplen = 0;
+       unsigned long initrd_load_addr = 0;
+       unsigned long orig_segments = image->nr_segments;
+       char *modified_cmdline = NULL;
+       struct kexec_buf kbuf;
+
+       kbuf.image = image;
+       /* Don't allocate anything below the kernel */
+       kbuf.buf_min = kernel_load_addr + kernel_size;
+
+       modified_cmdline = kzalloc(COMMAND_LINE_SIZE, GFP_KERNEL);
+       if (!modified_cmdline)
+               return -EINVAL;
+
+       cmdline_add_loader(&cmdline_tmplen, modified_cmdline);
+       /* Ensure it's null terminated */
+       modified_cmdline[COMMAND_LINE_SIZE - 1] = '\0';
+
+       /* Load initrd */
+       if (initrd) {
+               kbuf.buffer = initrd;
+               kbuf.bufsz = initrd_len;
+               kbuf.mem = KEXEC_BUF_MEM_UNKNOWN;
+               kbuf.memsz = initrd_len;
+               kbuf.buf_align = 0;
+               /* within 1GB-aligned window of up to 32GB in size */
+               kbuf.buf_max = round_down(kernel_load_addr, SZ_1G) + (unsigned long)SZ_1G * 32;
+               kbuf.top_down = false;
+
+               ret = kexec_add_buffer(&kbuf);
+               if (ret < 0)
+                       goto out_err;
+               initrd_load_addr = kbuf.mem;
+
+               kexec_dprintk("Loaded initrd at 0x%lx bufsz=0x%lx memsz=0x%lx\n",
+                             initrd_load_addr, kbuf.bufsz, kbuf.memsz);
+
+               /* Add the initrd=start,size parameter to the command line */
+               cmdline_add_initrd(image, &cmdline_tmplen, modified_cmdline, initrd_load_addr);
+       }
+
+       if (cmdline_len + cmdline_tmplen > COMMAND_LINE_SIZE) {
+               pr_err("Appending command line exceeds COMMAND_LINE_SIZE\n");
+               ret = -EINVAL;
+               goto out_err;
+       }
+
+       memcpy(modified_cmdline + cmdline_tmplen, cmdline, cmdline_len);
+       cmdline = modified_cmdline;
+       image->arch.cmdline_ptr = (unsigned long)cmdline;
+
+       return 0;
+
+out_err:
+       image->nr_segments = orig_segments;
+       kfree(modified_cmdline);
+       return ret;
+}