[PATCH 0/3] LoongArch: Add kexec/kdump support

[PATCH 0/3] LoongArch: Add kexec/kdump support

[Youling Tang]

This patch series to support kexec/kdump (only 64bit).

Kexec is a system call that enables you to load and boot into another kernel
from the currently running kernel. This is useful for kernel developers or
other people who need to reboot very quickly without waiting for the whole
BIOS boot process to finish. 

Kdump uses kexec to quickly boot to a dump-capture kernel whenever a
dump of the system kernel's memory needs to be taken (for example, when
the system panics). The system kernel's memory image is preserved across
the reboot and is accessible to the dump-capture kernel.

For details, see Documentation/admin-guide/kdump/kdump.rst.

User tools kexec-tools see link [1].

TODO:
Currently kdump does not support the same binary image, the production kernel
and the capture kernel will be generated with different configurations. I will
support kernel relocation support in the near future. Then will go to implement
the same binary support based on kernel relocation support.

[1] Link: https://github.com/tangyouling/kexec-tools


Youling Tang (3):
  LoongArch: Add kexec support
  LoongArch: Add kdump support
  LoongArch: Enable CONFIG_KEXEC

 arch/loongarch/Kconfig                     |  33 ++++
 arch/loongarch/Makefile                    |   4 +
 arch/loongarch/configs/loongson3_defconfig |   1 +
 arch/loongarch/include/asm/kexec.h         |  58 +++++++
 arch/loongarch/kernel/Makefile             |   3 +
 arch/loongarch/kernel/crash.c              | 100 ++++++++++++
 arch/loongarch/kernel/crash_dump.c         |  19 +++
 arch/loongarch/kernel/head.S               |   7 +-
 arch/loongarch/kernel/machine_kexec.c      | 176 +++++++++++++++++++++
 arch/loongarch/kernel/mem.c                |   6 +
 arch/loongarch/kernel/relocate_kernel.S    | 131 +++++++++++++++
 arch/loongarch/kernel/setup.c              |  49 ++++++
 arch/loongarch/kernel/traps.c              |   4 +
 13 files changed, 590 insertions(+), 1 deletion(-)
 create mode 100644 arch/loongarch/include/asm/kexec.h
 create mode 100644 arch/loongarch/kernel/crash.c
 create mode 100644 arch/loongarch/kernel/crash_dump.c
 create mode 100644 arch/loongarch/kernel/machine_kexec.c
 create mode 100644 arch/loongarch/kernel/relocate_kernel.S

-- 
2.36.0

[PATCH 1/3] LoongArch: Add kexec support

[Youling Tang]

Add three new files, kexec.h, machine_kexec.c and relocate_kernel.S to the
LoongArch architecture that add support for the kexec re-boot mechanis
(CONFIG_KEXEC) on LoongArch platforms.

Supports loading vmlinux (vmlinux.elf) in ELF format and vmlinux.efi in
PE format.

I tested this on  LoongArch 3A5000 machine and works as expected,

 $ sudo kexec -l /boot/vmlinux.efi --reuse-cmdline
 $ sudo kexec -e

Signed-off-by: Youling Tang <tangyouling@loongson.cn>
---
 arch/loongarch/Kconfig                  |  11 ++
 arch/loongarch/include/asm/kexec.h      |  58 ++++++++
 arch/loongarch/kernel/Makefile          |   2 +
 arch/loongarch/kernel/head.S            |   7 +-
 arch/loongarch/kernel/machine_kexec.c   | 178 ++++++++++++++++++++++++
 arch/loongarch/kernel/relocate_kernel.S | 125 +++++++++++++++++
 6 files changed, 380 insertions(+), 1 deletion(-)
 create mode 100644 arch/loongarch/include/asm/kexec.h
 create mode 100644 arch/loongarch/kernel/machine_kexec.c
 create mode 100644 arch/loongarch/kernel/relocate_kernel.S

diff --git a/arch/loongarch/Kconfig b/arch/loongarch/Kconfig
index 45364cffc793..903c82fa958d 100644
--- a/arch/loongarch/Kconfig
+++ b/arch/loongarch/Kconfig
@@ -409,6 +409,17 @@ config FORCE_MAX_ZONEORDER
 	  The page size is not necessarily 4KB.  Keep this in mind
 	  when choosing a value for this option.
 
+config KEXEC
+	bool "Kexec system call"
+	select KEXEC_CORE
+	help
+	  kexec is a system call that implements the ability to shutdown your
+	  current kernel, and to start another kernel.  It is like a reboot
+	  but it is independent of the system firmware.   And like a reboot
+	  you can start any kernel with it, not just Linux.
+
+	  The name comes from the similarity to the exec system call.
+
 config SECCOMP
 	bool "Enable seccomp to safely compute untrusted bytecode"
 	depends on PROC_FS
diff --git a/arch/loongarch/include/asm/kexec.h b/arch/loongarch/include/asm/kexec.h
new file mode 100644
index 000000000000..5c9e7b5eccb8
--- /dev/null
+++ b/arch/loongarch/include/asm/kexec.h
@@ -0,0 +1,58 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * kexec.h for kexec
+ *
+ * Copyright (C) 2022 Loongson Technology Corporation Limited
+ */
+
+#ifndef _ASM_KEXEC_H
+#define _ASM_KEXEC_H
+
+#include <asm/stacktrace.h>
+#include <asm/page.h>
+
+/* Maximum physical address we can use pages from */
+#define KEXEC_SOURCE_MEMORY_LIMIT (-1UL)
+/* Maximum address we can reach in physical address mode */
+#define KEXEC_DESTINATION_MEMORY_LIMIT (-1UL)
+ /* Maximum address we can use for the control code buffer */
+#define KEXEC_CONTROL_MEMORY_LIMIT (-1UL)
+
+/* Reserve a page for the control code buffer */
+#define KEXEC_CONTROL_PAGE_SIZE PAGE_SIZE
+
+/* The native architecture */
+#define KEXEC_ARCH KEXEC_ARCH_LOONGARCH
+
+static inline void crash_setup_regs(struct pt_regs *newregs,
+				    struct pt_regs *oldregs)
+{
+	if (oldregs)
+		memcpy(newregs, oldregs, sizeof(*newregs));
+	else
+		prepare_frametrace(newregs);
+}
+
+#define ARCH_HAS_KIMAGE_ARCH
+
+struct kimage_arch {
+	unsigned long boot_flag;
+	unsigned long fdt_addr;
+};
+
+typedef void (*do_kexec_t)(unsigned long boot_flag,
+			   unsigned long fdt_addr,
+			   unsigned long first_ind_entry,
+			   unsigned long jump_addr);
+
+struct kimage;
+extern const unsigned char relocate_new_kernel[];
+extern const size_t relocate_new_kernel_size;
+
+#ifdef CONFIG_SMP
+extern atomic_t kexec_ready_to_reboot;
+extern const unsigned char kexec_smp_wait[];
+extern void kexec_reboot(void);
+#endif
+
+#endif /* !_ASM_KEXEC_H */
diff --git a/arch/loongarch/kernel/Makefile b/arch/loongarch/kernel/Makefile
index a213e994db68..20b64ac3f128 100644
--- a/arch/loongarch/kernel/Makefile
+++ b/arch/loongarch/kernel/Makefile
@@ -17,6 +17,8 @@ obj-$(CONFIG_CPU_HAS_FPU)	+= fpu.o
 obj-$(CONFIG_MODULES)		+= module.o module-sections.o
 obj-$(CONFIG_STACKTRACE)	+= stacktrace.o
 
+obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o
+
 obj-$(CONFIG_PROC_FS)		+= proc.o
 
 obj-$(CONFIG_SMP)		+= smp.o
diff --git a/arch/loongarch/kernel/head.S b/arch/loongarch/kernel/head.S
index 01bac62a6442..22bdf4928325 100644
--- a/arch/loongarch/kernel/head.S
+++ b/arch/loongarch/kernel/head.S
@@ -20,7 +20,12 @@
 
 _head:
 	.word	MZ_MAGIC		/* "MZ", MS-DOS header */
-	.org	0x3c			/* 0x04 ~ 0x3b reserved */
+	.org	0x8
+	.quad	0			/* Image load offset from start of RAM */
+	.dword	_end - _text		/* Effective size of kernel image */
+	.quad	0
+	.dword	kernel_entry		/* Kernel entry point */
+	.org	0x3c			/* 0x28 ~ 0x3b reserved */
 	.long	pe_header - _head	/* Offset to the PE header */
 
 pe_header:
diff --git a/arch/loongarch/kernel/machine_kexec.c b/arch/loongarch/kernel/machine_kexec.c
new file mode 100644
index 000000000000..4ffcd4cd9c8c
--- /dev/null
+++ b/arch/loongarch/kernel/machine_kexec.c
@@ -0,0 +1,178 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * machine_kexec.c for kexec
+ *
+ * Copyright (C) 2022 Loongson Technology Corporation Limited
+ */
+#include <linux/compiler.h>
+#include <linux/cpu.h>
+#include <linux/kexec.h>
+#include <linux/mm.h>
+#include <linux/delay.h>
+#include <linux/libfdt.h>
+#include <linux/of_fdt.h>
+
+#include <asm/bootinfo.h>
+#include <asm/cacheflush.h>
+#include <asm/page.h>
+
+/* 0x100000 ~ 0x200000 is safe */
+#define KEXEC_CTRL_CODE	TO_CACHE(0x100000UL)
+#define KEXEC_BLOB_ADDR	TO_CACHE(0x108000UL)
+
+static unsigned long reboot_code_buffer;
+#ifdef CONFIG_SMP
+void (*relocated_kexec_smp_wait)(void *);
+atomic_t kexec_ready_to_reboot = ATOMIC_INIT(0);
+#endif
+
+static unsigned long jump_addr;
+static unsigned long first_ind_entry;
+static unsigned long boot_flag;
+static unsigned long fdt_addr;
+
+static void kexec_image_info(const struct kimage *kimage)
+{
+	unsigned long i;
+
+	pr_debug("kexec kimage info:\n");
+	pr_debug("\ttype:        %d\n", kimage->type);
+	pr_debug("\tstart:       %lx\n", kimage->start);
+	pr_debug("\thead:        %lx\n", kimage->head);
+	pr_debug("\tnr_segments: %lu\n", kimage->nr_segments);
+
+	for (i = 0; i < kimage->nr_segments; i++) {
+		pr_debug("\t    segment[%lu]: %016lx - %016lx", i,
+			kimage->segment[i].mem,
+			kimage->segment[i].mem + kimage->segment[i].memsz);
+		pr_debug("\t\t0x%lx bytes, %lu pages\n",
+			(unsigned long)kimage->segment[i].memsz,
+			(unsigned long)kimage->segment[i].memsz /  PAGE_SIZE);
+	}
+}
+
+int machine_kexec_prepare(struct kimage *kimage)
+{
+	int i;
+	void *dtb = (void *)KEXEC_BLOB_ADDR;
+
+	kexec_image_info(kimage);
+
+	/* Find the Flattened Device Tree */
+	for (i = 0; i < kimage->nr_segments; i++) {
+		if (!fdt_check_header(kimage->segment[i].buf)) {
+			memcpy(dtb, kimage->segment[i].buf, SZ_64K);
+			kimage->arch.boot_flag = fw_arg0;
+			kimage->arch.fdt_addr = (unsigned long) dtb;
+			break;
+		}
+		continue;
+	}
+
+	/* kexec need a safe page to save reboot_code_buffer */
+	kimage->control_code_page = virt_to_page((void *)KEXEC_CTRL_CODE);
+
+	reboot_code_buffer =
+	  (unsigned long)page_address(kimage->control_code_page);
+	memcpy((void *)reboot_code_buffer, relocate_new_kernel,
+	       relocate_new_kernel_size);
+
+	/* All secondary cpus now may jump to kexec_smp_wait cycle */
+	relocated_kexec_smp_wait = reboot_code_buffer +
+		(void *)(kexec_smp_wait - relocate_new_kernel);
+
+	return 0;
+}
+
+void machine_kexec_cleanup(struct kimage *kimage)
+{
+}
+
+#ifdef CONFIG_SMP
+void kexec_reboot(void)
+{
+	do_kexec_t do_kexec = NULL;
+
+	/* All secondary cpus go to kexec_smp_wait */
+	if (smp_processor_id() > 0) {
+		relocated_kexec_smp_wait(NULL);
+		unreachable();
+	}
+
+	do_kexec = (void *)reboot_code_buffer;
+	do_kexec(boot_flag, fdt_addr, first_ind_entry, jump_addr);
+
+	unreachable();
+}
+
+static void kexec_shutdown_secondary(void *)
+{
+	local_irq_disable();
+	while (!atomic_read(&kexec_ready_to_reboot))
+		cpu_relax();
+
+	kexec_reboot();
+}
+
+void machine_crash_shutdown(struct pt_regs *regs)
+{
+}
+#endif
+
+void machine_shutdown(void)
+{
+	smp_call_function(kexec_shutdown_secondary, NULL, 0);
+}
+
+void machine_kexec(struct kimage *image)
+{
+	unsigned long entry;
+	unsigned long *ptr;
+	struct kimage_arch *internal = &image->arch;
+
+	boot_flag = internal->boot_flag;
+	fdt_addr = internal->fdt_addr;
+
+	jump_addr = (unsigned long)phys_to_virt(image->start);
+
+	first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
+
+	/*
+	 * The generic kexec code builds a page list with physical
+	 * addresses. they are directly accessible through XKPRANGE
+	 * hence the phys_to_virt() call.
+	 */
+	for (ptr = &image->head; (entry = *ptr) && !(entry & IND_DONE);
+	     ptr = (entry & IND_INDIRECTION) ?
+	       phys_to_virt(entry & PAGE_MASK) : ptr + 1) {
+		if (*ptr & IND_SOURCE || *ptr & IND_INDIRECTION ||
+		    *ptr & IND_DESTINATION)
+			*ptr = (unsigned long) phys_to_virt(*ptr);
+	}
+
+	/* Mark offline before disabling local irq. */
+	set_cpu_online(smp_processor_id(), false);
+
+	/* we do not want to be bothered. */
+	local_irq_disable();
+
+	pr_notice("Will call new kernel at %lx\n", jump_addr);
+	pr_notice("FDT image at %lx\n", fdt_addr);
+	pr_notice("Bye ...\n");
+
+	/* Make reboot code buffer available to the boot CPU. */
+	flush_cache_all();
+
+	atomic_set(&kexec_ready_to_reboot, 1);
+
+	/*
+	 * We know we were online, and there will be no incoming IPIs at
+	 * this point.
+	 */
+	set_cpu_online(smp_processor_id(), true);
+
+	/* Ensure remote CPUs observe that we're online before rebooting. */
+	smp_mb__after_atomic();
+
+	kexec_reboot();
+}
diff --git a/arch/loongarch/kernel/relocate_kernel.S b/arch/loongarch/kernel/relocate_kernel.S
new file mode 100644
index 000000000000..d1f242f74ea8
--- /dev/null
+++ b/arch/loongarch/kernel/relocate_kernel.S
@@ -0,0 +1,125 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * relocate_kernel.S for kexec
+ *
+ * Copyright (C) 2022 Loongson Technology Corporation Limited
+ */
+
+#include <linux/kexec.h>
+
+#include <asm/asm.h>
+#include <asm/asmmacro.h>
+#include <asm/regdef.h>
+#include <asm/loongarch.h>
+#include <asm/stackframe.h>
+#include <asm/addrspace.h>
+
+#define IPI_REG_BASE 0x1fe01000
+
+SYM_CODE_START(relocate_new_kernel)
+	/*
+	 * s0: Boot flag passed to the new kernel
+	 * s1: Virt address of the FDT image
+	 * s2: Pointer to the current entry
+	 * s3: Virt address to jump to after relocation
+	 */
+	move		s0, a0
+	move		s1, a1
+	move		s2, a2
+	move		s3, a3
+
+process_entry:
+	PTR_L		s4, s2, 0
+	PTR_ADDI	s2, s2, SZREG
+
+	/* destination page */
+	andi		s5, s4, IND_DESTINATION
+	beqz		s5, 1f
+	li.w		t0, ~0x1
+	and		s6, s4, t0	/* store destination addr in s6 */
+	b		process_entry
+
+1:
+	/* indirection page, update s2	*/
+	andi		s5, s4, IND_INDIRECTION
+	beqz		s5, 1f
+	li.w		t0, ~0x2
+	and		s2, s4, t0
+	b		process_entry
+
+1:
+	/* done page */
+	andi		s5, s4, IND_DONE
+	beqz		s5, 1f
+	b		done
+1:
+	/* source page */
+	andi		s5, s4, IND_SOURCE
+	beqz		s5, process_entry
+	li.w		t0, ~0x8
+	and		s4, s4, t0
+	li.w		s8, (1 << _PAGE_SHIFT) / SZREG
+
+copy_word:
+	/* copy page word by word */
+	REG_L		s7, s4, 0
+	REG_S		s7, s6, 0
+	PTR_ADDI	s6, s6, SZREG
+	PTR_ADDI	s4, s4, SZREG
+	LONG_ADDI	s8, s8, -1
+	beqz		s8, process_entry
+	b		copy_word
+	b		process_entry
+
+done:
+	dbar		0
+
+	move		a0, s0
+	move		a1, s1
+	/* jump to the new kernel */
+	jr		s3
+SYM_CODE_END(relocate_new_kernel)
+
+#ifdef CONFIG_SMP
+/*
+ * Other CPUs should wait until code is relocated and
+ * then start at entry (?) point.
+ */
+SYM_CODE_START(kexec_smp_wait)
+	li.d		t0, IPI_REG_BASE
+	li.d		t1, UNCACHE_BASE
+	or		t0, t0, t1
+
+	/*
+	 * s1:initfn
+	 * t0:base t1:cpuid t2:node t3:core t4:count
+	 */
+	csrrd		t1, LOONGARCH_CSR_CPUID
+	andi		t1, t1, CSR_CPUID_COREID
+	andi		t3, t1, 0x3
+	slli.w		t3, t3, 8              /* get core id */
+	or		t0, t0, t3
+	andi		t2, t1, 0x3c
+	slli.d		t2, t2, 42             /* get node id */
+	or		t0, t0, t2
+
+1:	li.w		t4, 0x100              /* wait for init loop */
+2:	addi.w		t4, t4, -1             /* limit mailbox access */
+	bnez		t4, 2b
+	ld.w		s1, t0, 0x20           /* check PC as an indicator */
+	beqz		s1, 1b
+	ld.d		s1, t0, 0x20           /* get PC via mailbox */
+	ld.d		sp, t0, 0x28           /* get SP via mailbox */
+	ld.d		tp, t0, 0x30           /* get TP via mailbox */
+
+	li.d		t0, CACHE_BASE
+	or		s1, s1, t0
+	jr		s1                     /* jump to initial PC */
+SYM_CODE_END(kexec_smp_wait)
+#endif
+
+relocate_new_kernel_end:
+
+SYM_DATA_START(relocate_new_kernel_size)
+	PTR		relocate_new_kernel_end - relocate_new_kernel
+SYM_DATA_END(relocate_new_kernel_size)
-- 
2.36.0

Re: [PATCH 1/3] LoongArch: Add kexec support

[Jinyang He]

Hi, Youling,


On 08/29/2022 12:37 PM, Youling Tang wrote:
> Add three new files, kexec.h, machine_kexec.c and relocate_kernel.S to the
> LoongArch architecture that add support for the kexec re-boot mechanis
> (CONFIG_KEXEC) on LoongArch platforms.
>
> Supports loading vmlinux (vmlinux.elf) in ELF format and vmlinux.efi in
> PE format.
>
> I tested this on  LoongArch 3A5000 machine and works as expected,
>
>   $ sudo kexec -l /boot/vmlinux.efi --reuse-cmdline
>   $ sudo kexec -e
>
> Signed-off-by: Youling Tang <tangyouling@loongson.cn>
> ---
>   arch/loongarch/Kconfig                  |  11 ++
>   arch/loongarch/include/asm/kexec.h      |  58 ++++++++
>   arch/loongarch/kernel/Makefile          |   2 +
>   arch/loongarch/kernel/head.S            |   7 +-
>   arch/loongarch/kernel/machine_kexec.c   | 178 ++++++++++++++++++++++++
>   arch/loongarch/kernel/relocate_kernel.S | 125 +++++++++++++++++
>   6 files changed, 380 insertions(+), 1 deletion(-)
>   create mode 100644 arch/loongarch/include/asm/kexec.h
>   create mode 100644 arch/loongarch/kernel/machine_kexec.c
>   create mode 100644 arch/loongarch/kernel/relocate_kernel.S
>
> diff --git a/arch/loongarch/Kconfig b/arch/loongarch/Kconfig
> index 45364cffc793..903c82fa958d 100644
> --- a/arch/loongarch/Kconfig
> +++ b/arch/loongarch/Kconfig
> @@ -409,6 +409,17 @@ config FORCE_MAX_ZONEORDER
>   	  The page size is not necessarily 4KB.  Keep this in mind
>   	  when choosing a value for this option.
>   
> +config KEXEC
> +	bool "Kexec system call"
> +	select KEXEC_CORE
> +	help
> +	  kexec is a system call that implements the ability to shutdown your
> +	  current kernel, and to start another kernel.  It is like a reboot
> +	  but it is independent of the system firmware.   And like a reboot
> +	  you can start any kernel with it, not just Linux.
> +
> +	  The name comes from the similarity to the exec system call.
> +
>   config SECCOMP
>   	bool "Enable seccomp to safely compute untrusted bytecode"
>   	depends on PROC_FS
> diff --git a/arch/loongarch/include/asm/kexec.h b/arch/loongarch/include/asm/kexec.h
> new file mode 100644
> index 000000000000..5c9e7b5eccb8
> --- /dev/null
> +++ b/arch/loongarch/include/asm/kexec.h
> @@ -0,0 +1,58 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +/*
> + * kexec.h for kexec
> + *
> + * Copyright (C) 2022 Loongson Technology Corporation Limited
> + */
> +
> +#ifndef _ASM_KEXEC_H
> +#define _ASM_KEXEC_H
> +
> +#include <asm/stacktrace.h>
> +#include <asm/page.h>
> +
> +/* Maximum physical address we can use pages from */
> +#define KEXEC_SOURCE_MEMORY_LIMIT (-1UL)
> +/* Maximum address we can reach in physical address mode */
> +#define KEXEC_DESTINATION_MEMORY_LIMIT (-1UL)
> + /* Maximum address we can use for the control code buffer */
> +#define KEXEC_CONTROL_MEMORY_LIMIT (-1UL)
> +
> +/* Reserve a page for the control code buffer */
> +#define KEXEC_CONTROL_PAGE_SIZE PAGE_SIZE
> +
> +/* The native architecture */
> +#define KEXEC_ARCH KEXEC_ARCH_LOONGARCH
> +
> +static inline void crash_setup_regs(struct pt_regs *newregs,
> +				    struct pt_regs *oldregs)
> +{
> +	if (oldregs)
> +		memcpy(newregs, oldregs, sizeof(*newregs));
> +	else
> +		prepare_frametrace(newregs);
> +}
> +
> +#define ARCH_HAS_KIMAGE_ARCH
> +
> +struct kimage_arch {
> +	unsigned long boot_flag;
> +	unsigned long fdt_addr;
> +};
> +
> +typedef void (*do_kexec_t)(unsigned long boot_flag,
> +			   unsigned long fdt_addr,
> +			   unsigned long first_ind_entry,
> +			   unsigned long jump_addr);
> +
> +struct kimage;
> +extern const unsigned char relocate_new_kernel[];
> +extern const size_t relocate_new_kernel_size;
> +
> +#ifdef CONFIG_SMP
> +extern atomic_t kexec_ready_to_reboot;
> +extern const unsigned char kexec_smp_wait[];
> +extern void kexec_reboot(void);
> +#endif
> +
> +#endif /* !_ASM_KEXEC_H */
> diff --git a/arch/loongarch/kernel/Makefile b/arch/loongarch/kernel/Makefile
> index a213e994db68..20b64ac3f128 100644
> --- a/arch/loongarch/kernel/Makefile
> +++ b/arch/loongarch/kernel/Makefile
> @@ -17,6 +17,8 @@ obj-$(CONFIG_CPU_HAS_FPU)	+= fpu.o
>   obj-$(CONFIG_MODULES)		+= module.o module-sections.o
>   obj-$(CONFIG_STACKTRACE)	+= stacktrace.o
>   
> +obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o
> +
>   obj-$(CONFIG_PROC_FS)		+= proc.o
>   
>   obj-$(CONFIG_SMP)		+= smp.o
> diff --git a/arch/loongarch/kernel/head.S b/arch/loongarch/kernel/head.S
> index 01bac62a6442..22bdf4928325 100644
> --- a/arch/loongarch/kernel/head.S
> +++ b/arch/loongarch/kernel/head.S
> @@ -20,7 +20,12 @@
>   
>   _head:
>   	.word	MZ_MAGIC		/* "MZ", MS-DOS header */
> -	.org	0x3c			/* 0x04 ~ 0x3b reserved */
> +	.org	0x8
> +	.quad	0			/* Image load offset from start of RAM */
> +	.dword	_end - _text		/* Effective size of kernel image */
> +	.quad	0
> +	.dword	kernel_entry		/* Kernel entry point */
> +	.org	0x3c			/* 0x28 ~ 0x3b reserved */
>   	.long	pe_header - _head	/* Offset to the PE header */
>   
>   pe_header:
> diff --git a/arch/loongarch/kernel/machine_kexec.c b/arch/loongarch/kernel/machine_kexec.c
> new file mode 100644
> index 000000000000..4ffcd4cd9c8c
> --- /dev/null
> +++ b/arch/loongarch/kernel/machine_kexec.c
> @@ -0,0 +1,178 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * machine_kexec.c for kexec
> + *
> + * Copyright (C) 2022 Loongson Technology Corporation Limited
> + */
> +#include <linux/compiler.h>
> +#include <linux/cpu.h>
> +#include <linux/kexec.h>
> +#include <linux/mm.h>
> +#include <linux/delay.h>
> +#include <linux/libfdt.h>
> +#include <linux/of_fdt.h>
> +
> +#include <asm/bootinfo.h>
> +#include <asm/cacheflush.h>
> +#include <asm/page.h>
> +
> +/* 0x100000 ~ 0x200000 is safe */
> +#define KEXEC_CTRL_CODE	TO_CACHE(0x100000UL)
> +#define KEXEC_BLOB_ADDR	TO_CACHE(0x108000UL)
> +
> +static unsigned long reboot_code_buffer;
> +#ifdef CONFIG_SMP
> +void (*relocated_kexec_smp_wait)(void *);
> +atomic_t kexec_ready_to_reboot = ATOMIC_INIT(0);
> +#endif
> +
> +static unsigned long jump_addr;
> +static unsigned long first_ind_entry;
> +static unsigned long boot_flag;
> +static unsigned long fdt_addr;
> +
> +static void kexec_image_info(const struct kimage *kimage)
> +{
> +	unsigned long i;
> +
> +	pr_debug("kexec kimage info:\n");
> +	pr_debug("\ttype:        %d\n", kimage->type);
> +	pr_debug("\tstart:       %lx\n", kimage->start);
> +	pr_debug("\thead:        %lx\n", kimage->head);
> +	pr_debug("\tnr_segments: %lu\n", kimage->nr_segments);
> +
> +	for (i = 0; i < kimage->nr_segments; i++) {
> +		pr_debug("\t    segment[%lu]: %016lx - %016lx", i,
> +			kimage->segment[i].mem,
> +			kimage->segment[i].mem + kimage->segment[i].memsz);
> +		pr_debug("\t\t0x%lx bytes, %lu pages\n",
> +			(unsigned long)kimage->segment[i].memsz,
> +			(unsigned long)kimage->segment[i].memsz /  PAGE_SIZE);
> +	}
> +}
> +
> +int machine_kexec_prepare(struct kimage *kimage)
> +{
> +	int i;
> +	void *dtb = (void *)KEXEC_BLOB_ADDR;
> +
> +	kexec_image_info(kimage);
> +
> +	/* Find the Flattened Device Tree */
> +	for (i = 0; i < kimage->nr_segments; i++) {
> +		if (!fdt_check_header(kimage->segment[i].buf)) {
> +			memcpy(dtb, kimage->segment[i].buf, SZ_64K);
> +			kimage->arch.boot_flag = fw_arg0;
> +			kimage->arch.fdt_addr = (unsigned long) dtb;
> +			break;
> +		}
> +		continue;
> +	}
> +
> +	/* kexec need a safe page to save reboot_code_buffer */
> +	kimage->control_code_page = virt_to_page((void *)KEXEC_CTRL_CODE);
> +
> +	reboot_code_buffer =
> +	  (unsigned long)page_address(kimage->control_code_page);
> +	memcpy((void *)reboot_code_buffer, relocate_new_kernel,
> +	       relocate_new_kernel_size);
It copys same content to KEXEC_CTRL_CODE each time, could we do this at 
boot time?

BTW, our system always keep the low-2MB no used, on mips-loongson or
LoongArch. Is that necessary on LoongArch? We cannot use parameter
'mem=YYM' normally but 'mem=YYM@2M' is ok. And the low-2MB is not
in virtual memory management, although we can get it in kernel.

In kexec/kdump process, we can follows kimage_alloc_control_pages().
When the boot cpu copy complete the second-kernels, all cpus can jump
to a kernel-entry-trampoline which is in kernel image. Then we don't
worry about the code can be destroyed. The kernel-entry-trampoline
get its cpuid, keep non-boot cpus do as kexec_smp_wait and let boot
cpu go kernel-entry. In this way we can drop the low-2MB IMO.

> +
> +	/* All secondary cpus now may jump to kexec_smp_wait cycle */
> +	relocated_kexec_smp_wait = reboot_code_buffer +
> +		(void *)(kexec_smp_wait - relocate_new_kernel);
> +
> +	return 0;
> +}
> +
> +void machine_kexec_cleanup(struct kimage *kimage)
> +{
> +}
> +
> +#ifdef CONFIG_SMP
> +void kexec_reboot(void)
> +{
> +	do_kexec_t do_kexec = NULL;
> +
> +	/* All secondary cpus go to kexec_smp_wait */
> +	if (smp_processor_id() > 0) {
> +		relocated_kexec_smp_wait(NULL);
> +		unreachable();
> +	}
> +
> +	do_kexec = (void *)reboot_code_buffer;
> +	do_kexec(boot_flag, fdt_addr, first_ind_entry, jump_addr);
> +
> +	unreachable();
> +}
> +
> +static void kexec_shutdown_secondary(void *)
> +{
> +	local_irq_disable();
> +	while (!atomic_read(&kexec_ready_to_reboot))
> +		cpu_relax();
> +
> +	kexec_reboot();
> +}
> +
> +void machine_crash_shutdown(struct pt_regs *regs)
> +{
> +}
> +#endif
> +
> +void machine_shutdown(void)
> +{
> +	smp_call_function(kexec_shutdown_secondary, NULL, 0);
> +}
> +
> +void machine_kexec(struct kimage *image)
> +{
> +	unsigned long entry;
> +	unsigned long *ptr;
> +	struct kimage_arch *internal = &image->arch;
> +
> +	boot_flag = internal->boot_flag;
> +	fdt_addr = internal->fdt_addr;
> +
> +	jump_addr = (unsigned long)phys_to_virt(image->start);
> +
> +	first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
> +
> +	/*
> +	 * The generic kexec code builds a page list with physical
> +	 * addresses. they are directly accessible through XKPRANGE
> +	 * hence the phys_to_virt() call.
> +	 */
> +	for (ptr = &image->head; (entry = *ptr) && !(entry & IND_DONE);
> +	     ptr = (entry & IND_INDIRECTION) ?
> +	       phys_to_virt(entry & PAGE_MASK) : ptr + 1) {
> +		if (*ptr & IND_SOURCE || *ptr & IND_INDIRECTION ||
> +		    *ptr & IND_DESTINATION)
> +			*ptr = (unsigned long) phys_to_virt(*ptr);
> +	}
> +
> +	/* Mark offline before disabling local irq. */
> +	set_cpu_online(smp_processor_id(), false);
> +
> +	/* we do not want to be bothered. */
> +	local_irq_disable();
> +
> +	pr_notice("Will call new kernel at %lx\n", jump_addr);
> +	pr_notice("FDT image at %lx\n", fdt_addr);
> +	pr_notice("Bye ...\n");
> +
> +	/* Make reboot code buffer available to the boot CPU. */
> +	flush_cache_all();
> +
> +	atomic_set(&kexec_ready_to_reboot, 1);
> +
> +	/*
> +	 * We know we were online, and there will be no incoming IPIs at
> +	 * this point.
> +	 */
> +	set_cpu_online(smp_processor_id(), true);
> +
> +	/* Ensure remote CPUs observe that we're online before rebooting. */
> +	smp_mb__after_atomic();
> +
> +	kexec_reboot();
> +}
> diff --git a/arch/loongarch/kernel/relocate_kernel.S b/arch/loongarch/kernel/relocate_kernel.S
> new file mode 100644
> index 000000000000..d1f242f74ea8
> --- /dev/null
> +++ b/arch/loongarch/kernel/relocate_kernel.S
> @@ -0,0 +1,125 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +/*
> + * relocate_kernel.S for kexec
> + *
> + * Copyright (C) 2022 Loongson Technology Corporation Limited
> + */
> +
> +#include <linux/kexec.h>
> +
> +#include <asm/asm.h>
> +#include <asm/asmmacro.h>
> +#include <asm/regdef.h>
> +#include <asm/loongarch.h>
> +#include <asm/stackframe.h>
> +#include <asm/addrspace.h>
> +
> +#define IPI_REG_BASE 0x1fe01000
> +
> +SYM_CODE_START(relocate_new_kernel)
> +	/*
> +	 * s0: Boot flag passed to the new kernel
> +	 * s1: Virt address of the FDT image
> +	 * s2: Pointer to the current entry
> +	 * s3: Virt address to jump to after relocation
> +	 */
> +	move		s0, a0
> +	move		s1, a1
> +	move		s2, a2
> +	move		s3, a3
> +
> +process_entry:
> +	PTR_L		s4, s2, 0
> +	PTR_ADDI	s2, s2, SZREG
> +
> +	/* destination page */
> +	andi		s5, s4, IND_DESTINATION
> +	beqz		s5, 1f
> +	li.w		t0, ~0x1
> +	and		s6, s4, t0	/* store destination addr in s6 */
> +	b		process_entry
> +
> +1:
> +	/* indirection page, update s2	*/
> +	andi		s5, s4, IND_INDIRECTION
> +	beqz		s5, 1f
> +	li.w		t0, ~0x2
> +	and		s2, s4, t0
> +	b		process_entry
> +
> +1:
> +	/* done page */
> +	andi		s5, s4, IND_DONE
> +	beqz		s5, 1f
> +	b		done
> +1:
> +	/* source page */
> +	andi		s5, s4, IND_SOURCE
> +	beqz		s5, process_entry
> +	li.w		t0, ~0x8
> +	and		s4, s4, t0
> +	li.w		s8, (1 << _PAGE_SHIFT) / SZREG
> +
> +copy_word:
> +	/* copy page word by word */
> +	REG_L		s7, s4, 0
> +	REG_S		s7, s6, 0
> +	PTR_ADDI	s6, s6, SZREG
> +	PTR_ADDI	s4, s4, SZREG
> +	LONG_ADDI	s8, s8, -1
> +	beqz		s8, process_entry
> +	b		copy_word
> +	b		process_entry
> +
> +done:
> +	dbar		0
ibar, too?
> +
> +	move		a0, s0
> +	move		a1, s1
> +	/* jump to the new kernel */
> +	jr		s3
> +SYM_CODE_END(relocate_new_kernel)
> +
> +#ifdef CONFIG_SMP
> +/*
> + * Other CPUs should wait until code is relocated and
> + * then start at entry (?) point.
> + */
> +SYM_CODE_START(kexec_smp_wait)
> +	li.d		t0, IPI_REG_BASE
> +	li.d		t1, UNCACHE_BASE
> +	or		t0, t0, t1
> +
> +	/*
> +	 * s1:initfn
> +	 * t0:base t1:cpuid t2:node t3:core t4:count
> +	 */
> +	csrrd		t1, LOONGARCH_CSR_CPUID
> +	andi		t1, t1, CSR_CPUID_COREID
> +	andi		t3, t1, 0x3
> +	slli.w		t3, t3, 8              /* get core id */
> +	or		t0, t0, t3
> +	andi		t2, t1, 0x3c
> +	slli.d		t2, t2, 42             /* get node id */
> +	or		t0, t0, t2
> +
> +1:	li.w		t4, 0x100              /* wait for init loop */
> +2:	addi.w		t4, t4, -1             /* limit mailbox access */
> +	bnez		t4, 2b
> +	ld.w		s1, t0, 0x20           /* check PC as an indicator */
Can we do this with iocsr*?

Thanks,
Jinyang
> +	beqz		s1, 1b
> +	ld.d		s1, t0, 0x20           /* get PC via mailbox */
> +	ld.d		sp, t0, 0x28           /* get SP via mailbox */
> +	ld.d		tp, t0, 0x30           /* get TP via mailbox */
> +
> +	li.d		t0, CACHE_BASE
> +	or		s1, s1, t0
> +	jr		s1                     /* jump to initial PC */
> +SYM_CODE_END(kexec_smp_wait)
> +#endif
> +
> +relocate_new_kernel_end:
> +
> +SYM_DATA_START(relocate_new_kernel_size)
> +	PTR		relocate_new_kernel_end - relocate_new_kernel
> +SYM_DATA_END(relocate_new_kernel_size)

Re: [PATCH 1/3] LoongArch: Add kexec support

[Youling Tang]

Hi, Jinyang

On 08/30/2022 09:53 AM, Jinyang He wrote:
> Hi, Youling,
>
>
> On 08/29/2022 12:37 PM, Youling Tang wrote:
>> Add three new files, kexec.h, machine_kexec.c and relocate_kernel.S to
>> the
>> LoongArch architecture that add support for the kexec re-boot mechanis
>> (CONFIG_KEXEC) on LoongArch platforms.
>>
>> Supports loading vmlinux (vmlinux.elf) in ELF format and vmlinux.efi in
>> PE format.
>>
>> I tested this on  LoongArch 3A5000 machine and works as expected,
>>
>>   $ sudo kexec -l /boot/vmlinux.efi --reuse-cmdline
>>   $ sudo kexec -e
>>
>> Signed-off-by: Youling Tang <tangyouling@loongson.cn>
>> ---
>>   arch/loongarch/Kconfig                  |  11 ++
>>   arch/loongarch/include/asm/kexec.h      |  58 ++++++++
>>   arch/loongarch/kernel/Makefile          |   2 +
>>   arch/loongarch/kernel/head.S            |   7 +-
>>   arch/loongarch/kernel/machine_kexec.c   | 178 ++++++++++++++++++++++++
>>   arch/loongarch/kernel/relocate_kernel.S | 125 +++++++++++++++++
>>   6 files changed, 380 insertions(+), 1 deletion(-)
>>   create mode 100644 arch/loongarch/include/asm/kexec.h
>>   create mode 100644 arch/loongarch/kernel/machine_kexec.c
>>   create mode 100644 arch/loongarch/kernel/relocate_kernel.S
>>
>> diff --git a/arch/loongarch/Kconfig b/arch/loongarch/Kconfig
>> index 45364cffc793..903c82fa958d 100644
>> --- a/arch/loongarch/Kconfig
>> +++ b/arch/loongarch/Kconfig
>> @@ -409,6 +409,17 @@ config FORCE_MAX_ZONEORDER
>>         The page size is not necessarily 4KB.  Keep this in mind
>>         when choosing a value for this option.
>>   +config KEXEC
>> +    bool "Kexec system call"
>> +    select KEXEC_CORE
>> +    help
>> +      kexec is a system call that implements the ability to shutdown
>> your
>> +      current kernel, and to start another kernel.  It is like a reboot
>> +      but it is independent of the system firmware.   And like a reboot
>> +      you can start any kernel with it, not just Linux.
>> +
>> +      The name comes from the similarity to the exec system call.
>> +
>>   config SECCOMP
>>       bool "Enable seccomp to safely compute untrusted bytecode"
>>       depends on PROC_FS
>> diff --git a/arch/loongarch/include/asm/kexec.h
>> b/arch/loongarch/include/asm/kexec.h
>> new file mode 100644
>> index 000000000000..5c9e7b5eccb8
>> --- /dev/null
>> +++ b/arch/loongarch/include/asm/kexec.h
>> @@ -0,0 +1,58 @@
>> +/* SPDX-License-Identifier: GPL-2.0 */
>> +/*
>> + * kexec.h for kexec
>> + *
>> + * Copyright (C) 2022 Loongson Technology Corporation Limited
>> + */
>> +
>> +#ifndef _ASM_KEXEC_H
>> +#define _ASM_KEXEC_H
>> +
>> +#include <asm/stacktrace.h>
>> +#include <asm/page.h>
>> +
>> +/* Maximum physical address we can use pages from */
>> +#define KEXEC_SOURCE_MEMORY_LIMIT (-1UL)
>> +/* Maximum address we can reach in physical address mode */
>> +#define KEXEC_DESTINATION_MEMORY_LIMIT (-1UL)
>> + /* Maximum address we can use for the control code buffer */
>> +#define KEXEC_CONTROL_MEMORY_LIMIT (-1UL)
>> +
>> +/* Reserve a page for the control code buffer */
>> +#define KEXEC_CONTROL_PAGE_SIZE PAGE_SIZE
>> +
>> +/* The native architecture */
>> +#define KEXEC_ARCH KEXEC_ARCH_LOONGARCH
>> +
>> +static inline void crash_setup_regs(struct pt_regs *newregs,
>> +                    struct pt_regs *oldregs)
>> +{
>> +    if (oldregs)
>> +        memcpy(newregs, oldregs, sizeof(*newregs));
>> +    else
>> +        prepare_frametrace(newregs);
>> +}
>> +
>> +#define ARCH_HAS_KIMAGE_ARCH
>> +
>> +struct kimage_arch {
>> +    unsigned long boot_flag;
>> +    unsigned long fdt_addr;
>> +};
>> +
>> +typedef void (*do_kexec_t)(unsigned long boot_flag,
>> +               unsigned long fdt_addr,
>> +               unsigned long first_ind_entry,
>> +               unsigned long jump_addr);
>> +
>> +struct kimage;
>> +extern const unsigned char relocate_new_kernel[];
>> +extern const size_t relocate_new_kernel_size;
>> +
>> +#ifdef CONFIG_SMP
>> +extern atomic_t kexec_ready_to_reboot;
>> +extern const unsigned char kexec_smp_wait[];
>> +extern void kexec_reboot(void);
>> +#endif
>> +
>> +#endif /* !_ASM_KEXEC_H */
>> diff --git a/arch/loongarch/kernel/Makefile
>> b/arch/loongarch/kernel/Makefile
>> index a213e994db68..20b64ac3f128 100644
>> --- a/arch/loongarch/kernel/Makefile
>> +++ b/arch/loongarch/kernel/Makefile
>> @@ -17,6 +17,8 @@ obj-$(CONFIG_CPU_HAS_FPU)    += fpu.o
>>   obj-$(CONFIG_MODULES)        += module.o module-sections.o
>>   obj-$(CONFIG_STACKTRACE)    += stacktrace.o
>>   +obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o
>> +
>>   obj-$(CONFIG_PROC_FS)        += proc.o
>>     obj-$(CONFIG_SMP)        += smp.o
>> diff --git a/arch/loongarch/kernel/head.S b/arch/loongarch/kernel/head.S
>> index 01bac62a6442..22bdf4928325 100644
>> --- a/arch/loongarch/kernel/head.S
>> +++ b/arch/loongarch/kernel/head.S
>> @@ -20,7 +20,12 @@
>>     _head:
>>       .word    MZ_MAGIC        /* "MZ", MS-DOS header */
>> -    .org    0x3c            /* 0x04 ~ 0x3b reserved */
>> +    .org    0x8
>> +    .quad    0            /* Image load offset from start of RAM */
>> +    .dword    _end - _text        /* Effective size of kernel image */
>> +    .quad    0
>> +    .dword    kernel_entry        /* Kernel entry point */
>> +    .org    0x3c            /* 0x28 ~ 0x3b reserved */
>>       .long    pe_header - _head    /* Offset to the PE header */
>>     pe_header:
>> diff --git a/arch/loongarch/kernel/machine_kexec.c
>> b/arch/loongarch/kernel/machine_kexec.c
>> new file mode 100644
>> index 000000000000..4ffcd4cd9c8c
>> --- /dev/null
>> +++ b/arch/loongarch/kernel/machine_kexec.c
>> @@ -0,0 +1,178 @@
>> +// SPDX-License-Identifier: GPL-2.0-only
>> +/*
>> + * machine_kexec.c for kexec
>> + *
>> + * Copyright (C) 2022 Loongson Technology Corporation Limited
>> + */
>> +#include <linux/compiler.h>
>> +#include <linux/cpu.h>
>> +#include <linux/kexec.h>
>> +#include <linux/mm.h>
>> +#include <linux/delay.h>
>> +#include <linux/libfdt.h>
>> +#include <linux/of_fdt.h>
>> +
>> +#include <asm/bootinfo.h>
>> +#include <asm/cacheflush.h>
>> +#include <asm/page.h>
>> +
>> +/* 0x100000 ~ 0x200000 is safe */
>> +#define KEXEC_CTRL_CODE    TO_CACHE(0x100000UL)
>> +#define KEXEC_BLOB_ADDR    TO_CACHE(0x108000UL)
>> +
>> +static unsigned long reboot_code_buffer;
>> +#ifdef CONFIG_SMP
>> +void (*relocated_kexec_smp_wait)(void *);
>> +atomic_t kexec_ready_to_reboot = ATOMIC_INIT(0);
>> +#endif
>> +
>> +static unsigned long jump_addr;
>> +static unsigned long first_ind_entry;
>> +static unsigned long boot_flag;
>> +static unsigned long fdt_addr;
>> +
>> +static void kexec_image_info(const struct kimage *kimage)
>> +{
>> +    unsigned long i;
>> +
>> +    pr_debug("kexec kimage info:\n");
>> +    pr_debug("\ttype:        %d\n", kimage->type);
>> +    pr_debug("\tstart:       %lx\n", kimage->start);
>> +    pr_debug("\thead:        %lx\n", kimage->head);
>> +    pr_debug("\tnr_segments: %lu\n", kimage->nr_segments);
>> +
>> +    for (i = 0; i < kimage->nr_segments; i++) {
>> +        pr_debug("\t    segment[%lu]: %016lx - %016lx", i,
>> +            kimage->segment[i].mem,
>> +            kimage->segment[i].mem + kimage->segment[i].memsz);
>> +        pr_debug("\t\t0x%lx bytes, %lu pages\n",
>> +            (unsigned long)kimage->segment[i].memsz,
>> +            (unsigned long)kimage->segment[i].memsz /  PAGE_SIZE);
>> +    }
>> +}
>> +
>> +int machine_kexec_prepare(struct kimage *kimage)
>> +{
>> +    int i;
>> +    void *dtb = (void *)KEXEC_BLOB_ADDR;
>> +
>> +    kexec_image_info(kimage);
>> +
>> +    /* Find the Flattened Device Tree */
>> +    for (i = 0; i < kimage->nr_segments; i++) {
>> +        if (!fdt_check_header(kimage->segment[i].buf)) {
>> +            memcpy(dtb, kimage->segment[i].buf, SZ_64K);
>> +            kimage->arch.boot_flag = fw_arg0;
>> +            kimage->arch.fdt_addr = (unsigned long) dtb;
>> +            break;
>> +        }
>> +        continue;
>> +    }
>> +
>> +    /* kexec need a safe page to save reboot_code_buffer */
>> +    kimage->control_code_page = virt_to_page((void *)KEXEC_CTRL_CODE);
>> +
>> +    reboot_code_buffer =
>> +      (unsigned long)page_address(kimage->control_code_page);
>> +    memcpy((void *)reboot_code_buffer, relocate_new_kernel,
>> +           relocate_new_kernel_size);
> It copys same content to KEXEC_CTRL_CODE each time, could we do this at
> boot time?
I think it's possible to have the copy action happen at boot-time or
during the prepare phase. (RISCV in prepare, MIPS in boot-time)

>
> BTW, our system always keep the low-2MB no used, on mips-loongson or
> LoongArch. Is that necessary on LoongArch? We cannot use parameter
> 'mem=YYM' normally but 'mem=YYM@2M' is ok. And the low-2MB is not
> in virtual memory management, although we can get it in kernel.
For existing kernels, the low 2M has been reserved by
memblock_reserve(PHYS_OFFSET, 0x200000), maybe it is acceptable to keep
the low 2M behavior.

Yes, we need to use "mem=YM@2M" if the low 2M is reserved.

>
> In kexec/kdump process, we can follows kimage_alloc_control_pages().
> When the boot cpu copy complete the second-kernels, all cpus can jump
> to a kernel-entry-trampoline which is in kernel image. Then we don't
> worry about the code can be destroyed. The kernel-entry-trampoline
> get its cpuid, keep non-boot cpus do as kexec_smp_wait and let boot
> cpu go kernel-entry. In this way we can drop the low-2MB IMO.

It is also feasible to dynamically allocate control pages, but it is
easier to use a low 2M approach. What do you think, Huacai?

>
>> +
>> +    /* All secondary cpus now may jump to kexec_smp_wait cycle */
>> +    relocated_kexec_smp_wait = reboot_code_buffer +
>> +        (void *)(kexec_smp_wait - relocate_new_kernel);
>> +
>> +    return 0;
>> +}
>> +
>> +void machine_kexec_cleanup(struct kimage *kimage)
>> +{
>> +}
>> +
>> +#ifdef CONFIG_SMP
>> +void kexec_reboot(void)
>> +{
>> +    do_kexec_t do_kexec = NULL;
>> +
>> +    /* All secondary cpus go to kexec_smp_wait */
>> +    if (smp_processor_id() > 0) {
>> +        relocated_kexec_smp_wait(NULL);
>> +        unreachable();
>> +    }
>> +
>> +    do_kexec = (void *)reboot_code_buffer;
>> +    do_kexec(boot_flag, fdt_addr, first_ind_entry, jump_addr);
>> +
>> +    unreachable();
>> +}
>> +
>> +static void kexec_shutdown_secondary(void *)
>> +{
>> +    local_irq_disable();
>> +    while (!atomic_read(&kexec_ready_to_reboot))
>> +        cpu_relax();
>> +
>> +    kexec_reboot();
>> +}
>> +
>> +void machine_crash_shutdown(struct pt_regs *regs)
>> +{
>> +}
>> +#endif
>> +
>> +void machine_shutdown(void)
>> +{
>> +    smp_call_function(kexec_shutdown_secondary, NULL, 0);
>> +}
>> +
>> +void machine_kexec(struct kimage *image)
>> +{
>> +    unsigned long entry;
>> +    unsigned long *ptr;
>> +    struct kimage_arch *internal = &image->arch;
>> +
>> +    boot_flag = internal->boot_flag;
>> +    fdt_addr = internal->fdt_addr;
>> +
>> +    jump_addr = (unsigned long)phys_to_virt(image->start);
>> +
>> +    first_ind_entry = (unsigned long)phys_to_virt(image->head &
>> PAGE_MASK);
>> +
>> +    /*
>> +     * The generic kexec code builds a page list with physical
>> +     * addresses. they are directly accessible through XKPRANGE
>> +     * hence the phys_to_virt() call.
>> +     */
>> +    for (ptr = &image->head; (entry = *ptr) && !(entry & IND_DONE);
>> +         ptr = (entry & IND_INDIRECTION) ?
>> +           phys_to_virt(entry & PAGE_MASK) : ptr + 1) {
>> +        if (*ptr & IND_SOURCE || *ptr & IND_INDIRECTION ||
>> +            *ptr & IND_DESTINATION)
>> +            *ptr = (unsigned long) phys_to_virt(*ptr);
>> +    }
>> +
>> +    /* Mark offline before disabling local irq. */
>> +    set_cpu_online(smp_processor_id(), false);
>> +
>> +    /* we do not want to be bothered. */
>> +    local_irq_disable();
>> +
>> +    pr_notice("Will call new kernel at %lx\n", jump_addr);
>> +    pr_notice("FDT image at %lx\n", fdt_addr);
>> +    pr_notice("Bye ...\n");
>> +
>> +    /* Make reboot code buffer available to the boot CPU. */
>> +    flush_cache_all();
>> +
>> +    atomic_set(&kexec_ready_to_reboot, 1);
>> +
>> +    /*
>> +     * We know we were online, and there will be no incoming IPIs at
>> +     * this point.
>> +     */
>> +    set_cpu_online(smp_processor_id(), true);
>> +
>> +    /* Ensure remote CPUs observe that we're online before rebooting. */
>> +    smp_mb__after_atomic();
>> +
>> +    kexec_reboot();
>> +}
>> diff --git a/arch/loongarch/kernel/relocate_kernel.S
>> b/arch/loongarch/kernel/relocate_kernel.S
>> new file mode 100644
>> index 000000000000..d1f242f74ea8
>> --- /dev/null
>> +++ b/arch/loongarch/kernel/relocate_kernel.S
>> @@ -0,0 +1,125 @@
>> +/* SPDX-License-Identifier: GPL-2.0 */
>> +/*
>> + * relocate_kernel.S for kexec
>> + *
>> + * Copyright (C) 2022 Loongson Technology Corporation Limited
>> + */
>> +
>> +#include <linux/kexec.h>
>> +
>> +#include <asm/asm.h>
>> +#include <asm/asmmacro.h>
>> +#include <asm/regdef.h>
>> +#include <asm/loongarch.h>
>> +#include <asm/stackframe.h>
>> +#include <asm/addrspace.h>
>> +
>> +#define IPI_REG_BASE 0x1fe01000
>> +
>> +SYM_CODE_START(relocate_new_kernel)
>> +    /*
>> +     * s0: Boot flag passed to the new kernel
>> +     * s1: Virt address of the FDT image
>> +     * s2: Pointer to the current entry
>> +     * s3: Virt address to jump to after relocation
>> +     */
>> +    move        s0, a0
>> +    move        s1, a1
>> +    move        s2, a2
>> +    move        s3, a3
>> +
>> +process_entry:
>> +    PTR_L        s4, s2, 0
>> +    PTR_ADDI    s2, s2, SZREG
>> +
>> +    /* destination page */
>> +    andi        s5, s4, IND_DESTINATION
>> +    beqz        s5, 1f
>> +    li.w        t0, ~0x1
>> +    and        s6, s4, t0    /* store destination addr in s6 */
>> +    b        process_entry
>> +
>> +1:
>> +    /* indirection page, update s2    */
>> +    andi        s5, s4, IND_INDIRECTION
>> +    beqz        s5, 1f
>> +    li.w        t0, ~0x2
>> +    and        s2, s4, t0
>> +    b        process_entry
>> +
>> +1:
>> +    /* done page */
>> +    andi        s5, s4, IND_DONE
>> +    beqz        s5, 1f
>> +    b        done
>> +1:
>> +    /* source page */
>> +    andi        s5, s4, IND_SOURCE
>> +    beqz        s5, process_entry
>> +    li.w        t0, ~0x8
>> +    and        s4, s4, t0
>> +    li.w        s8, (1 << _PAGE_SHIFT) / SZREG
>> +
>> +copy_word:
>> +    /* copy page word by word */
>> +    REG_L        s7, s4, 0
>> +    REG_S        s7, s6, 0
>> +    PTR_ADDI    s6, s6, SZREG
>> +    PTR_ADDI    s4, s4, SZREG
>> +    LONG_ADDI    s8, s8, -1
>> +    beqz        s8, process_entry
>> +    b        copy_word
>> +    b        process_entry
>> +
>> +done:
>> +    dbar        0
> ibar, too?

Will add ibar 0.

>> +
>> +    move        a0, s0
>> +    move        a1, s1
>> +    /* jump to the new kernel */
>> +    jr        s3
>> +SYM_CODE_END(relocate_new_kernel)
>> +
>> +#ifdef CONFIG_SMP
>> +/*
>> + * Other CPUs should wait until code is relocated and
>> + * then start at entry (?) point.
>> + */
>> +SYM_CODE_START(kexec_smp_wait)
>> +    li.d        t0, IPI_REG_BASE
>> +    li.d        t1, UNCACHE_BASE
>> +    or        t0, t0, t1
>> +
>> +    /*
>> +     * s1:initfn
>> +     * t0:base t1:cpuid t2:node t3:core t4:count
>> +     */
>> +    csrrd        t1, LOONGARCH_CSR_CPUID
>> +    andi        t1, t1, CSR_CPUID_COREID
>> +    andi        t3, t1, 0x3
>> +    slli.w        t3, t3, 8              /* get core id */
>> +    or        t0, t0, t3
>> +    andi        t2, t1, 0x3c
>> +    slli.d        t2, t2, 42             /* get node id */
>> +    or        t0, t0, t2
>> +
>> +1:    li.w        t4, 0x100              /* wait for init loop */
>> +2:    addi.w        t4, t4, -1             /* limit mailbox access */
>> +    bnez        t4, 2b
>> +    ld.w        s1, t0, 0x20           /* check PC as an indicator */
> Can we do this with iocsr*?

OK, I will consider the implementation in the iocsr way.

Thanks,
Youling
>
> Thanks,
> Jinyang
>> +    beqz        s1, 1b
>> +    ld.d        s1, t0, 0x20           /* get PC via mailbox */
>> +    ld.d        sp, t0, 0x28           /* get SP via mailbox */
>> +    ld.d        tp, t0, 0x30           /* get TP via mailbox */
>> +
>> +    li.d        t0, CACHE_BASE
>> +    or        s1, s1, t0
>> +    jr        s1                     /* jump to initial PC */
>> +SYM_CODE_END(kexec_smp_wait)
>> +#endif
>> +
>> +relocate_new_kernel_end:
>> +
>> +SYM_DATA_START(relocate_new_kernel_size)
>> +    PTR        relocate_new_kernel_end - relocate_new_kernel
>> +SYM_DATA_END(relocate_new_kernel_size)
>

Re: [PATCH 1/3] LoongArch: Add kexec support

[Huacai Chen]

On Tue, Aug 30, 2022 at 11:26 AM Youling Tang <tangyouling@loongson.cn> wrote:
>
> Hi, Jinyang
>
> On 08/30/2022 09:53 AM, Jinyang He wrote:
> > Hi, Youling,
> >
> >
> > On 08/29/2022 12:37 PM, Youling Tang wrote:
> >> Add three new files, kexec.h, machine_kexec.c and relocate_kernel.S to
> >> the
> >> LoongArch architecture that add support for the kexec re-boot mechanis
> >> (CONFIG_KEXEC) on LoongArch platforms.
> >>
> >> Supports loading vmlinux (vmlinux.elf) in ELF format and vmlinux.efi in
> >> PE format.
> >>
> >> I tested this on  LoongArch 3A5000 machine and works as expected,
> >>
> >>   $ sudo kexec -l /boot/vmlinux.efi --reuse-cmdline
> >>   $ sudo kexec -e
> >>
> >> Signed-off-by: Youling Tang <tangyouling@loongson.cn>
> >> ---
> >>   arch/loongarch/Kconfig                  |  11 ++
> >>   arch/loongarch/include/asm/kexec.h      |  58 ++++++++
> >>   arch/loongarch/kernel/Makefile          |   2 +
> >>   arch/loongarch/kernel/head.S            |   7 +-
> >>   arch/loongarch/kernel/machine_kexec.c   | 178 ++++++++++++++++++++++++
> >>   arch/loongarch/kernel/relocate_kernel.S | 125 +++++++++++++++++
> >>   6 files changed, 380 insertions(+), 1 deletion(-)
> >>   create mode 100644 arch/loongarch/include/asm/kexec.h
> >>   create mode 100644 arch/loongarch/kernel/machine_kexec.c
> >>   create mode 100644 arch/loongarch/kernel/relocate_kernel.S
> >>
> >> diff --git a/arch/loongarch/Kconfig b/arch/loongarch/Kconfig
> >> index 45364cffc793..903c82fa958d 100644
> >> --- a/arch/loongarch/Kconfig
> >> +++ b/arch/loongarch/Kconfig
> >> @@ -409,6 +409,17 @@ config FORCE_MAX_ZONEORDER
> >>         The page size is not necessarily 4KB.  Keep this in mind
> >>         when choosing a value for this option.
> >>   +config KEXEC
> >> +    bool "Kexec system call"
> >> +    select KEXEC_CORE
> >> +    help
> >> +      kexec is a system call that implements the ability to shutdown
> >> your
> >> +      current kernel, and to start another kernel.  It is like a reboot
> >> +      but it is independent of the system firmware.   And like a reboot
> >> +      you can start any kernel with it, not just Linux.
> >> +
> >> +      The name comes from the similarity to the exec system call.
> >> +
> >>   config SECCOMP
> >>       bool "Enable seccomp to safely compute untrusted bytecode"
> >>       depends on PROC_FS
> >> diff --git a/arch/loongarch/include/asm/kexec.h
> >> b/arch/loongarch/include/asm/kexec.h
> >> new file mode 100644
> >> index 000000000000..5c9e7b5eccb8
> >> --- /dev/null
> >> +++ b/arch/loongarch/include/asm/kexec.h
> >> @@ -0,0 +1,58 @@
> >> +/* SPDX-License-Identifier: GPL-2.0 */
> >> +/*
> >> + * kexec.h for kexec
> >> + *
> >> + * Copyright (C) 2022 Loongson Technology Corporation Limited
> >> + */
> >> +
> >> +#ifndef _ASM_KEXEC_H
> >> +#define _ASM_KEXEC_H
> >> +
> >> +#include <asm/stacktrace.h>
> >> +#include <asm/page.h>
> >> +
> >> +/* Maximum physical address we can use pages from */
> >> +#define KEXEC_SOURCE_MEMORY_LIMIT (-1UL)
> >> +/* Maximum address we can reach in physical address mode */
> >> +#define KEXEC_DESTINATION_MEMORY_LIMIT (-1UL)
> >> + /* Maximum address we can use for the control code buffer */
> >> +#define KEXEC_CONTROL_MEMORY_LIMIT (-1UL)
> >> +
> >> +/* Reserve a page for the control code buffer */
> >> +#define KEXEC_CONTROL_PAGE_SIZE PAGE_SIZE
> >> +
> >> +/* The native architecture */
> >> +#define KEXEC_ARCH KEXEC_ARCH_LOONGARCH
> >> +
> >> +static inline void crash_setup_regs(struct pt_regs *newregs,
> >> +                    struct pt_regs *oldregs)
> >> +{
> >> +    if (oldregs)
> >> +        memcpy(newregs, oldregs, sizeof(*newregs));
> >> +    else
> >> +        prepare_frametrace(newregs);
> >> +}
> >> +
> >> +#define ARCH_HAS_KIMAGE_ARCH
> >> +
> >> +struct kimage_arch {
> >> +    unsigned long boot_flag;
> >> +    unsigned long fdt_addr;
> >> +};
> >> +
> >> +typedef void (*do_kexec_t)(unsigned long boot_flag,
> >> +               unsigned long fdt_addr,
> >> +               unsigned long first_ind_entry,
> >> +               unsigned long jump_addr);
> >> +
> >> +struct kimage;
> >> +extern const unsigned char relocate_new_kernel[];
> >> +extern const size_t relocate_new_kernel_size;
> >> +
> >> +#ifdef CONFIG_SMP
> >> +extern atomic_t kexec_ready_to_reboot;
> >> +extern const unsigned char kexec_smp_wait[];
> >> +extern void kexec_reboot(void);
> >> +#endif
> >> +
> >> +#endif /* !_ASM_KEXEC_H */
> >> diff --git a/arch/loongarch/kernel/Makefile
> >> b/arch/loongarch/kernel/Makefile
> >> index a213e994db68..20b64ac3f128 100644
> >> --- a/arch/loongarch/kernel/Makefile
> >> +++ b/arch/loongarch/kernel/Makefile
> >> @@ -17,6 +17,8 @@ obj-$(CONFIG_CPU_HAS_FPU)    += fpu.o
> >>   obj-$(CONFIG_MODULES)        += module.o module-sections.o
> >>   obj-$(CONFIG_STACKTRACE)    += stacktrace.o
> >>   +obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o
> >> +
> >>   obj-$(CONFIG_PROC_FS)        += proc.o
> >>     obj-$(CONFIG_SMP)        += smp.o
> >> diff --git a/arch/loongarch/kernel/head.S b/arch/loongarch/kernel/head.S
> >> index 01bac62a6442..22bdf4928325 100644
> >> --- a/arch/loongarch/kernel/head.S
> >> +++ b/arch/loongarch/kernel/head.S
> >> @@ -20,7 +20,12 @@
> >>     _head:
> >>       .word    MZ_MAGIC        /* "MZ", MS-DOS header */
> >> -    .org    0x3c            /* 0x04 ~ 0x3b reserved */
> >> +    .org    0x8
> >> +    .quad    0            /* Image load offset from start of RAM */
> >> +    .dword    _end - _text        /* Effective size of kernel image */
> >> +    .quad    0
> >> +    .dword    kernel_entry        /* Kernel entry point */
> >> +    .org    0x3c            /* 0x28 ~ 0x3b reserved */
> >>       .long    pe_header - _head    /* Offset to the PE header */
> >>     pe_header:
> >> diff --git a/arch/loongarch/kernel/machine_kexec.c
> >> b/arch/loongarch/kernel/machine_kexec.c
> >> new file mode 100644
> >> index 000000000000..4ffcd4cd9c8c
> >> --- /dev/null
> >> +++ b/arch/loongarch/kernel/machine_kexec.c
> >> @@ -0,0 +1,178 @@
> >> +// SPDX-License-Identifier: GPL-2.0-only
> >> +/*
> >> + * machine_kexec.c for kexec
> >> + *
> >> + * Copyright (C) 2022 Loongson Technology Corporation Limited
> >> + */
> >> +#include <linux/compiler.h>
> >> +#include <linux/cpu.h>
> >> +#include <linux/kexec.h>
> >> +#include <linux/mm.h>
> >> +#include <linux/delay.h>
> >> +#include <linux/libfdt.h>
> >> +#include <linux/of_fdt.h>
> >> +
> >> +#include <asm/bootinfo.h>
> >> +#include <asm/cacheflush.h>
> >> +#include <asm/page.h>
> >> +
> >> +/* 0x100000 ~ 0x200000 is safe */
> >> +#define KEXEC_CTRL_CODE    TO_CACHE(0x100000UL)
> >> +#define KEXEC_BLOB_ADDR    TO_CACHE(0x108000UL)
> >> +
> >> +static unsigned long reboot_code_buffer;
> >> +#ifdef CONFIG_SMP
> >> +void (*relocated_kexec_smp_wait)(void *);
> >> +atomic_t kexec_ready_to_reboot = ATOMIC_INIT(0);
> >> +#endif
> >> +
> >> +static unsigned long jump_addr;
> >> +static unsigned long first_ind_entry;
> >> +static unsigned long boot_flag;
> >> +static unsigned long fdt_addr;
> >> +
> >> +static void kexec_image_info(const struct kimage *kimage)
> >> +{
> >> +    unsigned long i;
> >> +
> >> +    pr_debug("kexec kimage info:\n");
> >> +    pr_debug("\ttype:        %d\n", kimage->type);
> >> +    pr_debug("\tstart:       %lx\n", kimage->start);
> >> +    pr_debug("\thead:        %lx\n", kimage->head);
> >> +    pr_debug("\tnr_segments: %lu\n", kimage->nr_segments);
> >> +
> >> +    for (i = 0; i < kimage->nr_segments; i++) {
> >> +        pr_debug("\t    segment[%lu]: %016lx - %016lx", i,
> >> +            kimage->segment[i].mem,
> >> +            kimage->segment[i].mem + kimage->segment[i].memsz);
> >> +        pr_debug("\t\t0x%lx bytes, %lu pages\n",
> >> +            (unsigned long)kimage->segment[i].memsz,
> >> +            (unsigned long)kimage->segment[i].memsz /  PAGE_SIZE);
> >> +    }
> >> +}
> >> +
> >> +int machine_kexec_prepare(struct kimage *kimage)
> >> +{
> >> +    int i;
> >> +    void *dtb = (void *)KEXEC_BLOB_ADDR;
> >> +
> >> +    kexec_image_info(kimage);
> >> +
> >> +    /* Find the Flattened Device Tree */
> >> +    for (i = 0; i < kimage->nr_segments; i++) {
> >> +        if (!fdt_check_header(kimage->segment[i].buf)) {
> >> +            memcpy(dtb, kimage->segment[i].buf, SZ_64K);
> >> +            kimage->arch.boot_flag = fw_arg0;
> >> +            kimage->arch.fdt_addr = (unsigned long) dtb;
> >> +            break;
> >> +        }
> >> +        continue;
> >> +    }
> >> +
> >> +    /* kexec need a safe page to save reboot_code_buffer */
> >> +    kimage->control_code_page = virt_to_page((void *)KEXEC_CTRL_CODE);
> >> +
> >> +    reboot_code_buffer =
> >> +      (unsigned long)page_address(kimage->control_code_page);
> >> +    memcpy((void *)reboot_code_buffer, relocate_new_kernel,
> >> +           relocate_new_kernel_size);
> > It copys same content to KEXEC_CTRL_CODE each time, could we do this at
> > boot time?
> I think it's possible to have the copy action happen at boot-time or
> during the prepare phase. (RISCV in prepare, MIPS in boot-time)
>
> >
> > BTW, our system always keep the low-2MB no used, on mips-loongson or
> > LoongArch. Is that necessary on LoongArch? We cannot use parameter
> > 'mem=YYM' normally but 'mem=YYM@2M' is ok. And the low-2MB is not
> > in virtual memory management, although we can get it in kernel.
> For existing kernels, the low 2M has been reserved by
> memblock_reserve(PHYS_OFFSET, 0x200000), maybe it is acceptable to keep
> the low 2M behavior.
>
> Yes, we need to use "mem=YM@2M" if the low 2M is reserved.
>
> >
> > In kexec/kdump process, we can follows kimage_alloc_control_pages().
> > When the boot cpu copy complete the second-kernels, all cpus can jump
> > to a kernel-entry-trampoline which is in kernel image. Then we don't
> > worry about the code can be destroyed. The kernel-entry-trampoline
> > get its cpuid, keep non-boot cpus do as kexec_smp_wait and let boot
> > cpu go kernel-entry. In this way we can drop the low-2MB IMO.
>
> It is also feasible to dynamically allocate control pages, but it is
> easier to use a low 2M approach. What do you think, Huacai?
I prefer to use the low 2MB.

Huacai
>
> >
> >> +
> >> +    /* All secondary cpus now may jump to kexec_smp_wait cycle */
> >> +    relocated_kexec_smp_wait = reboot_code_buffer +
> >> +        (void *)(kexec_smp_wait - relocate_new_kernel);
> >> +
> >> +    return 0;
> >> +}
> >> +
> >> +void machine_kexec_cleanup(struct kimage *kimage)
> >> +{
> >> +}
> >> +
> >> +#ifdef CONFIG_SMP
> >> +void kexec_reboot(void)
> >> +{
> >> +    do_kexec_t do_kexec = NULL;
> >> +
> >> +    /* All secondary cpus go to kexec_smp_wait */
> >> +    if (smp_processor_id() > 0) {
> >> +        relocated_kexec_smp_wait(NULL);
> >> +        unreachable();
> >> +    }
> >> +
> >> +    do_kexec = (void *)reboot_code_buffer;
> >> +    do_kexec(boot_flag, fdt_addr, first_ind_entry, jump_addr);
> >> +
> >> +    unreachable();
> >> +}
> >> +
> >> +static void kexec_shutdown_secondary(void *)
> >> +{
> >> +    local_irq_disable();
> >> +    while (!atomic_read(&kexec_ready_to_reboot))
> >> +        cpu_relax();
> >> +
> >> +    kexec_reboot();
> >> +}
> >> +
> >> +void machine_crash_shutdown(struct pt_regs *regs)
> >> +{
> >> +}
> >> +#endif
> >> +
> >> +void machine_shutdown(void)
> >> +{
> >> +    smp_call_function(kexec_shutdown_secondary, NULL, 0);
> >> +}
> >> +
> >> +void machine_kexec(struct kimage *image)
> >> +{
> >> +    unsigned long entry;
> >> +    unsigned long *ptr;
> >> +    struct kimage_arch *internal = &image->arch;
> >> +
> >> +    boot_flag = internal->boot_flag;
> >> +    fdt_addr = internal->fdt_addr;
> >> +
> >> +    jump_addr = (unsigned long)phys_to_virt(image->start);
> >> +
> >> +    first_ind_entry = (unsigned long)phys_to_virt(image->head &
> >> PAGE_MASK);
> >> +
> >> +    /*
> >> +     * The generic kexec code builds a page list with physical
> >> +     * addresses. they are directly accessible through XKPRANGE
> >> +     * hence the phys_to_virt() call.
> >> +     */
> >> +    for (ptr = &image->head; (entry = *ptr) && !(entry & IND_DONE);
> >> +         ptr = (entry & IND_INDIRECTION) ?
> >> +           phys_to_virt(entry & PAGE_MASK) : ptr + 1) {
> >> +        if (*ptr & IND_SOURCE || *ptr & IND_INDIRECTION ||
> >> +            *ptr & IND_DESTINATION)
> >> +            *ptr = (unsigned long) phys_to_virt(*ptr);
> >> +    }
> >> +
> >> +    /* Mark offline before disabling local irq. */
> >> +    set_cpu_online(smp_processor_id(), false);
> >> +
> >> +    /* we do not want to be bothered. */
> >> +    local_irq_disable();
> >> +
> >> +    pr_notice("Will call new kernel at %lx\n", jump_addr);
> >> +    pr_notice("FDT image at %lx\n", fdt_addr);
> >> +    pr_notice("Bye ...\n");
> >> +
> >> +    /* Make reboot code buffer available to the boot CPU. */
> >> +    flush_cache_all();
> >> +
> >> +    atomic_set(&kexec_ready_to_reboot, 1);
> >> +
> >> +    /*
> >> +     * We know we were online, and there will be no incoming IPIs at
> >> +     * this point.
> >> +     */
> >> +    set_cpu_online(smp_processor_id(), true);
> >> +
> >> +    /* Ensure remote CPUs observe that we're online before rebooting. */
> >> +    smp_mb__after_atomic();
> >> +
> >> +    kexec_reboot();
> >> +}
> >> diff --git a/arch/loongarch/kernel/relocate_kernel.S
> >> b/arch/loongarch/kernel/relocate_kernel.S
> >> new file mode 100644
> >> index 000000000000..d1f242f74ea8
> >> --- /dev/null
> >> +++ b/arch/loongarch/kernel/relocate_kernel.S
> >> @@ -0,0 +1,125 @@
> >> +/* SPDX-License-Identifier: GPL-2.0 */
> >> +/*
> >> + * relocate_kernel.S for kexec
> >> + *
> >> + * Copyright (C) 2022 Loongson Technology Corporation Limited
> >> + */
> >> +
> >> +#include <linux/kexec.h>
> >> +
> >> +#include <asm/asm.h>
> >> +#include <asm/asmmacro.h>
> >> +#include <asm/regdef.h>
> >> +#include <asm/loongarch.h>
> >> +#include <asm/stackframe.h>
> >> +#include <asm/addrspace.h>
> >> +
> >> +#define IPI_REG_BASE 0x1fe01000
> >> +
> >> +SYM_CODE_START(relocate_new_kernel)
> >> +    /*
> >> +     * s0: Boot flag passed to the new kernel
> >> +     * s1: Virt address of the FDT image
> >> +     * s2: Pointer to the current entry
> >> +     * s3: Virt address to jump to after relocation
> >> +     */
> >> +    move        s0, a0
> >> +    move        s1, a1
> >> +    move        s2, a2
> >> +    move        s3, a3
> >> +
> >> +process_entry:
> >> +    PTR_L        s4, s2, 0
> >> +    PTR_ADDI    s2, s2, SZREG
> >> +
> >> +    /* destination page */
> >> +    andi        s5, s4, IND_DESTINATION
> >> +    beqz        s5, 1f
> >> +    li.w        t0, ~0x1
> >> +    and        s6, s4, t0    /* store destination addr in s6 */
> >> +    b        process_entry
> >> +
> >> +1:
> >> +    /* indirection page, update s2    */
> >> +    andi        s5, s4, IND_INDIRECTION
> >> +    beqz        s5, 1f
> >> +    li.w        t0, ~0x2
> >> +    and        s2, s4, t0
> >> +    b        process_entry
> >> +
> >> +1:
> >> +    /* done page */
> >> +    andi        s5, s4, IND_DONE
> >> +    beqz        s5, 1f
> >> +    b        done
> >> +1:
> >> +    /* source page */
> >> +    andi        s5, s4, IND_SOURCE
> >> +    beqz        s5, process_entry
> >> +    li.w        t0, ~0x8
> >> +    and        s4, s4, t0
> >> +    li.w        s8, (1 << _PAGE_SHIFT) / SZREG
> >> +
> >> +copy_word:
> >> +    /* copy page word by word */
> >> +    REG_L        s7, s4, 0
> >> +    REG_S        s7, s6, 0
> >> +    PTR_ADDI    s6, s6, SZREG
> >> +    PTR_ADDI    s4, s4, SZREG
> >> +    LONG_ADDI    s8, s8, -1
> >> +    beqz        s8, process_entry
> >> +    b        copy_word
> >> +    b        process_entry
> >> +
> >> +done:
> >> +    dbar        0
> > ibar, too?
>
> Will add ibar 0.
>
> >> +
> >> +    move        a0, s0
> >> +    move        a1, s1
> >> +    /* jump to the new kernel */
> >> +    jr        s3
> >> +SYM_CODE_END(relocate_new_kernel)
> >> +
> >> +#ifdef CONFIG_SMP
> >> +/*
> >> + * Other CPUs should wait until code is relocated and
> >> + * then start at entry (?) point.
> >> + */
> >> +SYM_CODE_START(kexec_smp_wait)
> >> +    li.d        t0, IPI_REG_BASE
> >> +    li.d        t1, UNCACHE_BASE
> >> +    or        t0, t0, t1
> >> +
> >> +    /*
> >> +     * s1:initfn
> >> +     * t0:base t1:cpuid t2:node t3:core t4:count
> >> +     */
> >> +    csrrd        t1, LOONGARCH_CSR_CPUID
> >> +    andi        t1, t1, CSR_CPUID_COREID
> >> +    andi        t3, t1, 0x3
> >> +    slli.w        t3, t3, 8              /* get core id */
> >> +    or        t0, t0, t3
> >> +    andi        t2, t1, 0x3c
> >> +    slli.d        t2, t2, 42             /* get node id */
> >> +    or        t0, t0, t2
> >> +
> >> +1:    li.w        t4, 0x100              /* wait for init loop */
> >> +2:    addi.w        t4, t4, -1             /* limit mailbox access */
> >> +    bnez        t4, 2b
> >> +    ld.w        s1, t0, 0x20           /* check PC as an indicator */
> > Can we do this with iocsr*?
>
> OK, I will consider the implementation in the iocsr way.
>
> Thanks,
> Youling
> >
> > Thanks,
> > Jinyang
> >> +    beqz        s1, 1b
> >> +    ld.d        s1, t0, 0x20           /* get PC via mailbox */
> >> +    ld.d        sp, t0, 0x28           /* get SP via mailbox */
> >> +    ld.d        tp, t0, 0x30           /* get TP via mailbox */
> >> +
> >> +    li.d        t0, CACHE_BASE
> >> +    or        s1, s1, t0
> >> +    jr        s1                     /* jump to initial PC */
> >> +SYM_CODE_END(kexec_smp_wait)
> >> +#endif
> >> +
> >> +relocate_new_kernel_end:
> >> +
> >> +SYM_DATA_START(relocate_new_kernel_size)
> >> +    PTR        relocate_new_kernel_end - relocate_new_kernel
> >> +SYM_DATA_END(relocate_new_kernel_size)
> >
>

Re: [PATCH 1/3] LoongArch: Add kexec support

[Jinyang He]

On 08/30/2022 11:42 AM, Huacai Chen wrote:

> On Tue, Aug 30, 2022 at 11:26 AM Youling Tang <tangyouling@loongson.cn> wrote:
>> Hi, Jinyang
>>
>> On 08/30/2022 09:53 AM, Jinyang He wrote:
>>> Hi, Youling,
>>>
>>>
>>> On 08/29/2022 12:37 PM, Youling Tang wrote:
>>>> Add three new files, kexec.h, machine_kexec.c and relocate_kernel.S to
>>>> the
>>>> LoongArch architecture that add support for the kexec re-boot mechanis
>>>> (CONFIG_KEXEC) on LoongArch platforms.
>>>>
>>>> Supports loading vmlinux (vmlinux.elf) in ELF format and vmlinux.efi in
>>>> PE format.
>>>>
>>>> I tested this on  LoongArch 3A5000 machine and works as expected,
>>>>
>>>>    $ sudo kexec -l /boot/vmlinux.efi --reuse-cmdline
>>>>    $ sudo kexec -e
>>>>
>>>> Signed-off-by: Youling Tang <tangyouling@loongson.cn>
>>>> ---
>>>>    arch/loongarch/Kconfig                  |  11 ++
>>>>    arch/loongarch/include/asm/kexec.h      |  58 ++++++++
>>>>    arch/loongarch/kernel/Makefile          |   2 +
>>>>    arch/loongarch/kernel/head.S            |   7 +-
>>>>    arch/loongarch/kernel/machine_kexec.c   | 178 ++++++++++++++++++++++++
>>>>    arch/loongarch/kernel/relocate_kernel.S | 125 +++++++++++++++++
>>>>    6 files changed, 380 insertions(+), 1 deletion(-)
>>>>    create mode 100644 arch/loongarch/include/asm/kexec.h
>>>>    create mode 100644 arch/loongarch/kernel/machine_kexec.c
>>>>    create mode 100644 arch/loongarch/kernel/relocate_kernel.S
>>>>
>>>> diff --git a/arch/loongarch/Kconfig b/arch/loongarch/Kconfig
>>>> index 45364cffc793..903c82fa958d 100644
>>>> --- a/arch/loongarch/Kconfig
>>>> +++ b/arch/loongarch/Kconfig
>>>> @@ -409,6 +409,17 @@ config FORCE_MAX_ZONEORDER
>>>>          The page size is not necessarily 4KB.  Keep this in mind
>>>>          when choosing a value for this option.
>>>>    +config KEXEC
>>>> +    bool "Kexec system call"
>>>> +    select KEXEC_CORE
>>>> +    help
>>>> +      kexec is a system call that implements the ability to shutdown
>>>> your
>>>> +      current kernel, and to start another kernel.  It is like a reboot
>>>> +      but it is independent of the system firmware.   And like a reboot
>>>> +      you can start any kernel with it, not just Linux.
>>>> +
>>>> +      The name comes from the similarity to the exec system call.
>>>> +
>>>>    config SECCOMP
>>>>        bool "Enable seccomp to safely compute untrusted bytecode"
>>>>        depends on PROC_FS
>>>> diff --git a/arch/loongarch/include/asm/kexec.h
>>>> b/arch/loongarch/include/asm/kexec.h
>>>> new file mode 100644
>>>> index 000000000000..5c9e7b5eccb8
>>>> --- /dev/null
>>>> +++ b/arch/loongarch/include/asm/kexec.h
>>>> @@ -0,0 +1,58 @@
>>>> +/* SPDX-License-Identifier: GPL-2.0 */
>>>> +/*
>>>> + * kexec.h for kexec
>>>> + *
>>>> + * Copyright (C) 2022 Loongson Technology Corporation Limited
>>>> + */
>>>> +
>>>> +#ifndef _ASM_KEXEC_H
>>>> +#define _ASM_KEXEC_H
>>>> +
>>>> +#include <asm/stacktrace.h>
>>>> +#include <asm/page.h>
>>>> +
>>>> +/* Maximum physical address we can use pages from */
>>>> +#define KEXEC_SOURCE_MEMORY_LIMIT (-1UL)
>>>> +/* Maximum address we can reach in physical address mode */
>>>> +#define KEXEC_DESTINATION_MEMORY_LIMIT (-1UL)
>>>> + /* Maximum address we can use for the control code buffer */
>>>> +#define KEXEC_CONTROL_MEMORY_LIMIT (-1UL)
>>>> +
>>>> +/* Reserve a page for the control code buffer */
>>>> +#define KEXEC_CONTROL_PAGE_SIZE PAGE_SIZE
>>>> +
>>>> +/* The native architecture */
>>>> +#define KEXEC_ARCH KEXEC_ARCH_LOONGARCH
>>>> +
>>>> +static inline void crash_setup_regs(struct pt_regs *newregs,
>>>> +                    struct pt_regs *oldregs)
>>>> +{
>>>> +    if (oldregs)
>>>> +        memcpy(newregs, oldregs, sizeof(*newregs));
>>>> +    else
>>>> +        prepare_frametrace(newregs);
>>>> +}
>>>> +
>>>> +#define ARCH_HAS_KIMAGE_ARCH
>>>> +
>>>> +struct kimage_arch {
>>>> +    unsigned long boot_flag;
>>>> +    unsigned long fdt_addr;
>>>> +};
>>>> +
>>>> +typedef void (*do_kexec_t)(unsigned long boot_flag,
>>>> +               unsigned long fdt_addr,
>>>> +               unsigned long first_ind_entry,
>>>> +               unsigned long jump_addr);
>>>> +
>>>> +struct kimage;
>>>> +extern const unsigned char relocate_new_kernel[];
>>>> +extern const size_t relocate_new_kernel_size;
>>>> +
>>>> +#ifdef CONFIG_SMP
>>>> +extern atomic_t kexec_ready_to_reboot;
>>>> +extern const unsigned char kexec_smp_wait[];
>>>> +extern void kexec_reboot(void);
>>>> +#endif
>>>> +
>>>> +#endif /* !_ASM_KEXEC_H */
>>>> diff --git a/arch/loongarch/kernel/Makefile
>>>> b/arch/loongarch/kernel/Makefile
>>>> index a213e994db68..20b64ac3f128 100644
>>>> --- a/arch/loongarch/kernel/Makefile
>>>> +++ b/arch/loongarch/kernel/Makefile
>>>> @@ -17,6 +17,8 @@ obj-$(CONFIG_CPU_HAS_FPU)    += fpu.o
>>>>    obj-$(CONFIG_MODULES)        += module.o module-sections.o
>>>>    obj-$(CONFIG_STACKTRACE)    += stacktrace.o
>>>>    +obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o
>>>> +
>>>>    obj-$(CONFIG_PROC_FS)        += proc.o
>>>>      obj-$(CONFIG_SMP)        += smp.o
>>>> diff --git a/arch/loongarch/kernel/head.S b/arch/loongarch/kernel/head.S
>>>> index 01bac62a6442..22bdf4928325 100644
>>>> --- a/arch/loongarch/kernel/head.S
>>>> +++ b/arch/loongarch/kernel/head.S
>>>> @@ -20,7 +20,12 @@
>>>>      _head:
>>>>        .word    MZ_MAGIC        /* "MZ", MS-DOS header */
>>>> -    .org    0x3c            /* 0x04 ~ 0x3b reserved */
>>>> +    .org    0x8
>>>> +    .quad    0            /* Image load offset from start of RAM */
>>>> +    .dword    _end - _text        /* Effective size of kernel image */
>>>> +    .quad    0
>>>> +    .dword    kernel_entry        /* Kernel entry point */
>>>> +    .org    0x3c            /* 0x28 ~ 0x3b reserved */
>>>>        .long    pe_header - _head    /* Offset to the PE header */
>>>>      pe_header:
>>>> diff --git a/arch/loongarch/kernel/machine_kexec.c
>>>> b/arch/loongarch/kernel/machine_kexec.c
>>>> new file mode 100644
>>>> index 000000000000..4ffcd4cd9c8c
>>>> --- /dev/null
>>>> +++ b/arch/loongarch/kernel/machine_kexec.c
>>>> @@ -0,0 +1,178 @@
>>>> +// SPDX-License-Identifier: GPL-2.0-only
>>>> +/*
>>>> + * machine_kexec.c for kexec
>>>> + *
>>>> + * Copyright (C) 2022 Loongson Technology Corporation Limited
>>>> + */
>>>> +#include <linux/compiler.h>
>>>> +#include <linux/cpu.h>
>>>> +#include <linux/kexec.h>
>>>> +#include <linux/mm.h>
>>>> +#include <linux/delay.h>
>>>> +#include <linux/libfdt.h>
>>>> +#include <linux/of_fdt.h>
>>>> +
>>>> +#include <asm/bootinfo.h>
>>>> +#include <asm/cacheflush.h>
>>>> +#include <asm/page.h>
>>>> +
>>>> +/* 0x100000 ~ 0x200000 is safe */
>>>> +#define KEXEC_CTRL_CODE    TO_CACHE(0x100000UL)
>>>> +#define KEXEC_BLOB_ADDR    TO_CACHE(0x108000UL)
>>>> +
>>>> +static unsigned long reboot_code_buffer;
>>>> +#ifdef CONFIG_SMP
>>>> +void (*relocated_kexec_smp_wait)(void *);
>>>> +atomic_t kexec_ready_to_reboot = ATOMIC_INIT(0);
>>>> +#endif
>>>> +
>>>> +static unsigned long jump_addr;
>>>> +static unsigned long first_ind_entry;
>>>> +static unsigned long boot_flag;
>>>> +static unsigned long fdt_addr;
>>>> +
>>>> +static void kexec_image_info(const struct kimage *kimage)
>>>> +{
>>>> +    unsigned long i;
>>>> +
>>>> +    pr_debug("kexec kimage info:\n");
>>>> +    pr_debug("\ttype:        %d\n", kimage->type);
>>>> +    pr_debug("\tstart:       %lx\n", kimage->start);
>>>> +    pr_debug("\thead:        %lx\n", kimage->head);
>>>> +    pr_debug("\tnr_segments: %lu\n", kimage->nr_segments);
>>>> +
>>>> +    for (i = 0; i < kimage->nr_segments; i++) {
>>>> +        pr_debug("\t    segment[%lu]: %016lx - %016lx", i,
>>>> +            kimage->segment[i].mem,
>>>> +            kimage->segment[i].mem + kimage->segment[i].memsz);
>>>> +        pr_debug("\t\t0x%lx bytes, %lu pages\n",
>>>> +            (unsigned long)kimage->segment[i].memsz,
>>>> +            (unsigned long)kimage->segment[i].memsz /  PAGE_SIZE);
>>>> +    }
>>>> +}
>>>> +
>>>> +int machine_kexec_prepare(struct kimage *kimage)
>>>> +{
>>>> +    int i;
>>>> +    void *dtb = (void *)KEXEC_BLOB_ADDR;
>>>> +
>>>> +    kexec_image_info(kimage);
>>>> +
>>>> +    /* Find the Flattened Device Tree */
>>>> +    for (i = 0; i < kimage->nr_segments; i++) {
>>>> +        if (!fdt_check_header(kimage->segment[i].buf)) {
>>>> +            memcpy(dtb, kimage->segment[i].buf, SZ_64K);
>>>> +            kimage->arch.boot_flag = fw_arg0;
>>>> +            kimage->arch.fdt_addr = (unsigned long) dtb;
>>>> +            break;
>>>> +        }
>>>> +        continue;
>>>> +    }
>>>> +
>>>> +    /* kexec need a safe page to save reboot_code_buffer */
>>>> +    kimage->control_code_page = virt_to_page((void *)KEXEC_CTRL_CODE);
>>>> +
>>>> +    reboot_code_buffer =
>>>> +      (unsigned long)page_address(kimage->control_code_page);
>>>> +    memcpy((void *)reboot_code_buffer, relocate_new_kernel,
>>>> +           relocate_new_kernel_size);
>>> It copys same content to KEXEC_CTRL_CODE each time, could we do this at
>>> boot time?
>> I think it's possible to have the copy action happen at boot-time or
>> during the prepare phase. (RISCV in prepare, MIPS in boot-time)
>>
>>> BTW, our system always keep the low-2MB no used, on mips-loongson or
>>> LoongArch. Is that necessary on LoongArch? We cannot use parameter
>>> 'mem=YYM' normally but 'mem=YYM@2M' is ok. And the low-2MB is not
>>> in virtual memory management, although we can get it in kernel.
>> For existing kernels, the low 2M has been reserved by
>> memblock_reserve(PHYS_OFFSET, 0x200000), maybe it is acceptable to keep
>> the low 2M behavior.
>>
>> Yes, we need to use "mem=YM@2M" if the low 2M is reserved.
>>
>>> In kexec/kdump process, we can follows kimage_alloc_control_pages().
>>> When the boot cpu copy complete the second-kernels, all cpus can jump
>>> to a kernel-entry-trampoline which is in kernel image. Then we don't
>>> worry about the code can be destroyed. The kernel-entry-trampoline
>>> get its cpuid, keep non-boot cpus do as kexec_smp_wait and let boot
>>> cpu go kernel-entry. In this way we can drop the low-2MB IMO.
>> It is also feasible to dynamically allocate control pages, but it is
>> easier to use a low 2M approach. What do you think, Huacai?
> I prefer to use the low 2MB.
>
> Huacai
Low 2MB also is ok for me, like a trick. And should it free
control_code_page here?

>>>> +
>>>> +    /* All secondary cpus now may jump to kexec_smp_wait cycle */
>>>> +    relocated_kexec_smp_wait = reboot_code_buffer +
>>>> +        (void *)(kexec_smp_wait - relocate_new_kernel);
>>>> +
>>>> +    return 0;
>>>> +}
>>>> +
>>>> +void machine_kexec_cleanup(struct kimage *kimage)
>>>> +{
>>>> +}
>>>> +
>>>> +#ifdef CONFIG_SMP
>>>> +void kexec_reboot(void)
>>>> +{
>>>> +    do_kexec_t do_kexec = NULL;
>>>> +
>>>> +    /* All secondary cpus go to kexec_smp_wait */
>>>> +    if (smp_processor_id() > 0) {
>>>> +        relocated_kexec_smp_wait(NULL);
>>>> +        unreachable();
>>>> +    }
>>>> +
>>>> +    do_kexec = (void *)reboot_code_buffer;
>>>> +    do_kexec(boot_flag, fdt_addr, first_ind_entry, jump_addr);
>>>> +
>>>> +    unreachable();
>>>> +}
>>>> +
>>>> +static void kexec_shutdown_secondary(void *)
>>>> +{
>>>> +    local_irq_disable();
>>>> +    while (!atomic_read(&kexec_ready_to_reboot))
>>>> +        cpu_relax();
>>>> +
>>>> +    kexec_reboot();
>>>> +}
>>>> +
>>>> +void machine_crash_shutdown(struct pt_regs *regs)
>>>> +{
>>>> +}
>>>> +#endif
>>>> +
>>>> +void machine_shutdown(void)
>>>> +{
>>>> +    smp_call_function(kexec_shutdown_secondary, NULL, 0);
>>>> +}
>>>> +
>>>> +void machine_kexec(struct kimage *image)
>>>> +{
>>>> +    unsigned long entry;
>>>> +    unsigned long *ptr;
>>>> +    struct kimage_arch *internal = &image->arch;
>>>> +
>>>> +    boot_flag = internal->boot_flag;
>>>> +    fdt_addr = internal->fdt_addr;
>>>> +
>>>> +    jump_addr = (unsigned long)phys_to_virt(image->start);
>>>> +
>>>> +    first_ind_entry = (unsigned long)phys_to_virt(image->head &
>>>> PAGE_MASK);
>>>> +
>>>> +    /*
>>>> +     * The generic kexec code builds a page list with physical
>>>> +     * addresses. they are directly accessible through XKPRANGE
>>>> +     * hence the phys_to_virt() call.
>>>> +     */
>>>> +    for (ptr = &image->head; (entry = *ptr) && !(entry & IND_DONE);
>>>> +         ptr = (entry & IND_INDIRECTION) ?
>>>> +           phys_to_virt(entry & PAGE_MASK) : ptr + 1) {
>>>> +        if (*ptr & IND_SOURCE || *ptr & IND_INDIRECTION ||
>>>> +            *ptr & IND_DESTINATION)
>>>> +            *ptr = (unsigned long) phys_to_virt(*ptr);
>>>> +    }
>>>> +
>>>> +    /* Mark offline before disabling local irq. */
>>>> +    set_cpu_online(smp_processor_id(), false);
>>>> +
>>>> +    /* we do not want to be bothered. */
>>>> +    local_irq_disable();
>>>> +
>>>> +    pr_notice("Will call new kernel at %lx\n", jump_addr);
>>>> +    pr_notice("FDT image at %lx\n", fdt_addr);
>>>> +    pr_notice("Bye ...\n");
>>>> +
>>>> +    /* Make reboot code buffer available to the boot CPU. */
>>>> +    flush_cache_all();
>>>> +
>>>> +    atomic_set(&kexec_ready_to_reboot, 1);
>>>> +
>>>> +    /*
>>>> +     * We know we were online, and there will be no incoming IPIs at
>>>> +     * this point.
>>>> +     */
>>>> +    set_cpu_online(smp_processor_id(), true);
>>>> +
>>>> +    /* Ensure remote CPUs observe that we're online before rebooting. */
>>>> +    smp_mb__after_atomic();
>>>> +
>>>> +    kexec_reboot();
>>>> +}
>>>> diff --git a/arch/loongarch/kernel/relocate_kernel.S
>>>> b/arch/loongarch/kernel/relocate_kernel.S
>>>> new file mode 100644
>>>> index 000000000000..d1f242f74ea8
>>>> --- /dev/null
>>>> +++ b/arch/loongarch/kernel/relocate_kernel.S
>>>> @@ -0,0 +1,125 @@
>>>> +/* SPDX-License-Identifier: GPL-2.0 */
>>>> +/*
>>>> + * relocate_kernel.S for kexec
>>>> + *
>>>> + * Copyright (C) 2022 Loongson Technology Corporation Limited
>>>> + */
>>>> +
>>>> +#include <linux/kexec.h>
>>>> +
>>>> +#include <asm/asm.h>
>>>> +#include <asm/asmmacro.h>
>>>> +#include <asm/regdef.h>
>>>> +#include <asm/loongarch.h>
>>>> +#include <asm/stackframe.h>
>>>> +#include <asm/addrspace.h>
>>>> +
>>>> +#define IPI_REG_BASE 0x1fe01000
>>>> +
>>>> +SYM_CODE_START(relocate_new_kernel)
>>>> +    /*
>>>> +     * s0: Boot flag passed to the new kernel
>>>> +     * s1: Virt address of the FDT image
>>>> +     * s2: Pointer to the current entry
>>>> +     * s3: Virt address to jump to after relocation
>>>> +     */
>>>> +    move        s0, a0
>>>> +    move        s1, a1
>>>> +    move        s2, a2
>>>> +    move        s3, a3
>>>> +
>>>> +process_entry:
>>>> +    PTR_L        s4, s2, 0
>>>> +    PTR_ADDI    s2, s2, SZREG
>>>> +
>>>> +    /* destination page */
>>>> +    andi        s5, s4, IND_DESTINATION
>>>> +    beqz        s5, 1f
>>>> +    li.w        t0, ~0x1
>>>> +    and        s6, s4, t0    /* store destination addr in s6 */
>>>> +    b        process_entry
>>>> +
>>>> +1:
>>>> +    /* indirection page, update s2    */
>>>> +    andi        s5, s4, IND_INDIRECTION
>>>> +    beqz        s5, 1f
>>>> +    li.w        t0, ~0x2
>>>> +    and        s2, s4, t0
>>>> +    b        process_entry
>>>> +
>>>> +1:
>>>> +    /* done page */
>>>> +    andi        s5, s4, IND_DONE
>>>> +    beqz        s5, 1f
>>>> +    b        done
>>>> +1:
>>>> +    /* source page */
>>>> +    andi        s5, s4, IND_SOURCE
>>>> +    beqz        s5, process_entry
>>>> +    li.w        t0, ~0x8
>>>> +    and        s4, s4, t0
>>>> +    li.w        s8, (1 << _PAGE_SHIFT) / SZREG
>>>> +
>>>> +copy_word:
>>>> +    /* copy page word by word */
>>>> +    REG_L        s7, s4, 0
>>>> +    REG_S        s7, s6, 0
>>>> +    PTR_ADDI    s6, s6, SZREG
>>>> +    PTR_ADDI    s4, s4, SZREG
>>>> +    LONG_ADDI    s8, s8, -1
>>>> +    beqz        s8, process_entry
>>>> +    b        copy_word
>>>> +    b        process_entry
>>>> +
>>>> +done:
>>>> +    dbar        0
>>> ibar, too?
>> Will add ibar 0.
>>
>>>> +
>>>> +    move        a0, s0
>>>> +    move        a1, s1
>>>> +    /* jump to the new kernel */
>>>> +    jr        s3
>>>> +SYM_CODE_END(relocate_new_kernel)
>>>> +
>>>> +#ifdef CONFIG_SMP
>>>> +/*
>>>> + * Other CPUs should wait until code is relocated and
>>>> + * then start at entry (?) point.
>>>> + */
>>>> +SYM_CODE_START(kexec_smp_wait)
>>>> +    li.d        t0, IPI_REG_BASE
>>>> +    li.d        t1, UNCACHE_BASE
>>>> +    or        t0, t0, t1
>>>> +
>>>> +    /*
>>>> +     * s1:initfn
>>>> +     * t0:base t1:cpuid t2:node t3:core t4:count
>>>> +     */
>>>> +    csrrd        t1, LOONGARCH_CSR_CPUID
>>>> +    andi        t1, t1, CSR_CPUID_COREID
>>>> +    andi        t3, t1, 0x3
>>>> +    slli.w        t3, t3, 8              /* get core id */
>>>> +    or        t0, t0, t3
>>>> +    andi        t2, t1, 0x3c
>>>> +    slli.d        t2, t2, 42             /* get node id */
>>>> +    or        t0, t0, t2
>>>> +
>>>> +1:    li.w        t4, 0x100              /* wait for init loop */
>>>> +2:    addi.w        t4, t4, -1             /* limit mailbox access */
>>>> +    bnez        t4, 2b
>>>> +    ld.w        s1, t0, 0x20           /* check PC as an indicator */
>>> Can we do this with iocsr*?
>> OK, I will consider the implementation in the iocsr way.
>>
>> Thanks,
>> Youling
>>> Thanks,
>>> Jinyang
>>>> +    beqz        s1, 1b
>>>> +    ld.d        s1, t0, 0x20           /* get PC via mailbox */
>>>> +    ld.d        sp, t0, 0x28           /* get SP via mailbox */
>>>> +    ld.d        tp, t0, 0x30           /* get TP via mailbox */
>>>> +
>>>> +    li.d        t0, CACHE_BASE
>>>> +    or        s1, s1, t0
>>>> +    jr        s1                     /* jump to initial PC */
>>>> +SYM_CODE_END(kexec_smp_wait)
>>>> +#endif
>>>> +
>>>> +relocate_new_kernel_end:
>>>> +
>>>> +SYM_DATA_START(relocate_new_kernel_size)
>>>> +    PTR        relocate_new_kernel_end - relocate_new_kernel
>>>> +SYM_DATA_END(relocate_new_kernel_size)

Re: [PATCH 1/3] LoongArch: Add kexec support

[Youling Tang]

On 08/30/2022 11:25 AM, Youling Tang wrote:
> Hi, Jinyang
>
> On 08/30/2022 09:53 AM, Jinyang He wrote:
>> Hi, Youling,
>>
>>
>> On 08/29/2022 12:37 PM, Youling Tang wrote:
>>> Add three new files, kexec.h, machine_kexec.c and relocate_kernel.S to
>>> the
>>> LoongArch architecture that add support for the kexec re-boot mechanis
>>> (CONFIG_KEXEC) on LoongArch platforms.
>>>
>>> Supports loading vmlinux (vmlinux.elf) in ELF format and vmlinux.efi in
>>> PE format.
>>>
>>> I tested this on  LoongArch 3A5000 machine and works as expected,
>>>
>>>   $ sudo kexec -l /boot/vmlinux.efi --reuse-cmdline
>>>   $ sudo kexec -e
>>>
>>> Signed-off-by: Youling Tang <tangyouling@loongson.cn>
>>> ---
>>>   arch/loongarch/Kconfig                  |  11 ++
>>>   arch/loongarch/include/asm/kexec.h      |  58 ++++++++
>>>   arch/loongarch/kernel/Makefile          |   2 +
>>>   arch/loongarch/kernel/head.S            |   7 +-
>>>   arch/loongarch/kernel/machine_kexec.c   | 178 ++++++++++++++++++++++++
>>>   arch/loongarch/kernel/relocate_kernel.S | 125 +++++++++++++++++
>>>   6 files changed, 380 insertions(+), 1 deletion(-)
>>>   create mode 100644 arch/loongarch/include/asm/kexec.h
>>>   create mode 100644 arch/loongarch/kernel/machine_kexec.c
>>>   create mode 100644 arch/loongarch/kernel/relocate_kernel.S
>>>
>>> diff --git a/arch/loongarch/Kconfig b/arch/loongarch/Kconfig
>>> index 45364cffc793..903c82fa958d 100644
>>> --- a/arch/loongarch/Kconfig
>>> +++ b/arch/loongarch/Kconfig
>>> @@ -409,6 +409,17 @@ config FORCE_MAX_ZONEORDER
>>>         The page size is not necessarily 4KB.  Keep this in mind
>>>         when choosing a value for this option.
>>>   +config KEXEC
>>> +    bool "Kexec system call"
>>> +    select KEXEC_CORE
>>> +    help
>>> +      kexec is a system call that implements the ability to shutdown
>>> your
>>> +      current kernel, and to start another kernel.  It is like a reboot
>>> +      but it is independent of the system firmware.   And like a reboot
>>> +      you can start any kernel with it, not just Linux.
>>> +
>>> +      The name comes from the similarity to the exec system call.
>>> +
>>>   config SECCOMP
>>>       bool "Enable seccomp to safely compute untrusted bytecode"
>>>       depends on PROC_FS
>>> diff --git a/arch/loongarch/include/asm/kexec.h
>>> b/arch/loongarch/include/asm/kexec.h
>>> new file mode 100644
>>> index 000000000000..5c9e7b5eccb8
>>> --- /dev/null
>>> +++ b/arch/loongarch/include/asm/kexec.h
>>> @@ -0,0 +1,58 @@
>>> +/* SPDX-License-Identifier: GPL-2.0 */
>>> +/*
>>> + * kexec.h for kexec
>>> + *
>>> + * Copyright (C) 2022 Loongson Technology Corporation Limited
>>> + */
>>> +
>>> +#ifndef _ASM_KEXEC_H
>>> +#define _ASM_KEXEC_H
>>> +
>>> +#include <asm/stacktrace.h>
>>> +#include <asm/page.h>
>>> +
>>> +/* Maximum physical address we can use pages from */
>>> +#define KEXEC_SOURCE_MEMORY_LIMIT (-1UL)
>>> +/* Maximum address we can reach in physical address mode */
>>> +#define KEXEC_DESTINATION_MEMORY_LIMIT (-1UL)
>>> + /* Maximum address we can use for the control code buffer */
>>> +#define KEXEC_CONTROL_MEMORY_LIMIT (-1UL)
>>> +
>>> +/* Reserve a page for the control code buffer */
>>> +#define KEXEC_CONTROL_PAGE_SIZE PAGE_SIZE
>>> +
>>> +/* The native architecture */
>>> +#define KEXEC_ARCH KEXEC_ARCH_LOONGARCH
>>> +
>>> +static inline void crash_setup_regs(struct pt_regs *newregs,
>>> +                    struct pt_regs *oldregs)
>>> +{
>>> +    if (oldregs)
>>> +        memcpy(newregs, oldregs, sizeof(*newregs));
>>> +    else
>>> +        prepare_frametrace(newregs);
>>> +}
>>> +
>>> +#define ARCH_HAS_KIMAGE_ARCH
>>> +
>>> +struct kimage_arch {
>>> +    unsigned long boot_flag;
>>> +    unsigned long fdt_addr;
>>> +};
>>> +
>>> +typedef void (*do_kexec_t)(unsigned long boot_flag,
>>> +               unsigned long fdt_addr,
>>> +               unsigned long first_ind_entry,
>>> +               unsigned long jump_addr);
>>> +
>>> +struct kimage;
>>> +extern const unsigned char relocate_new_kernel[];
>>> +extern const size_t relocate_new_kernel_size;
>>> +
>>> +#ifdef CONFIG_SMP
>>> +extern atomic_t kexec_ready_to_reboot;
>>> +extern const unsigned char kexec_smp_wait[];
>>> +extern void kexec_reboot(void);
>>> +#endif
>>> +
>>> +#endif /* !_ASM_KEXEC_H */
>>> diff --git a/arch/loongarch/kernel/Makefile
>>> b/arch/loongarch/kernel/Makefile
>>> index a213e994db68..20b64ac3f128 100644
>>> --- a/arch/loongarch/kernel/Makefile
>>> +++ b/arch/loongarch/kernel/Makefile
>>> @@ -17,6 +17,8 @@ obj-$(CONFIG_CPU_HAS_FPU)    += fpu.o
>>>   obj-$(CONFIG_MODULES)        += module.o module-sections.o
>>>   obj-$(CONFIG_STACKTRACE)    += stacktrace.o
>>>   +obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o
>>> +
>>>   obj-$(CONFIG_PROC_FS)        += proc.o
>>>     obj-$(CONFIG_SMP)        += smp.o
>>> diff --git a/arch/loongarch/kernel/head.S b/arch/loongarch/kernel/head.S
>>> index 01bac62a6442..22bdf4928325 100644
>>> --- a/arch/loongarch/kernel/head.S
>>> +++ b/arch/loongarch/kernel/head.S
>>> @@ -20,7 +20,12 @@
>>>     _head:
>>>       .word    MZ_MAGIC        /* "MZ", MS-DOS header */
>>> -    .org    0x3c            /* 0x04 ~ 0x3b reserved */
>>> +    .org    0x8
>>> +    .quad    0            /* Image load offset from start of RAM */
>>> +    .dword    _end - _text        /* Effective size of kernel image */
>>> +    .quad    0
>>> +    .dword    kernel_entry        /* Kernel entry point */
>>> +    .org    0x3c            /* 0x28 ~ 0x3b reserved */
>>>       .long    pe_header - _head    /* Offset to the PE header */
>>>     pe_header:
>>> diff --git a/arch/loongarch/kernel/machine_kexec.c
>>> b/arch/loongarch/kernel/machine_kexec.c
>>> new file mode 100644
>>> index 000000000000..4ffcd4cd9c8c
>>> --- /dev/null
>>> +++ b/arch/loongarch/kernel/machine_kexec.c
>>> @@ -0,0 +1,178 @@
>>> +// SPDX-License-Identifier: GPL-2.0-only
>>> +/*
>>> + * machine_kexec.c for kexec
>>> + *
>>> + * Copyright (C) 2022 Loongson Technology Corporation Limited
>>> + */
>>> +#include <linux/compiler.h>
>>> +#include <linux/cpu.h>
>>> +#include <linux/kexec.h>
>>> +#include <linux/mm.h>
>>> +#include <linux/delay.h>
>>> +#include <linux/libfdt.h>
>>> +#include <linux/of_fdt.h>
>>> +
>>> +#include <asm/bootinfo.h>
>>> +#include <asm/cacheflush.h>
>>> +#include <asm/page.h>
>>> +
>>> +/* 0x100000 ~ 0x200000 is safe */
>>> +#define KEXEC_CTRL_CODE    TO_CACHE(0x100000UL)
>>> +#define KEXEC_BLOB_ADDR    TO_CACHE(0x108000UL)
>>> +
>>> +static unsigned long reboot_code_buffer;
>>> +#ifdef CONFIG_SMP
>>> +void (*relocated_kexec_smp_wait)(void *);
>>> +atomic_t kexec_ready_to_reboot = ATOMIC_INIT(0);
>>> +#endif
>>> +
>>> +static unsigned long jump_addr;
>>> +static unsigned long first_ind_entry;
>>> +static unsigned long boot_flag;
>>> +static unsigned long fdt_addr;
>>> +
>>> +static void kexec_image_info(const struct kimage *kimage)
>>> +{
>>> +    unsigned long i;
>>> +
>>> +    pr_debug("kexec kimage info:\n");
>>> +    pr_debug("\ttype:        %d\n", kimage->type);
>>> +    pr_debug("\tstart:       %lx\n", kimage->start);
>>> +    pr_debug("\thead:        %lx\n", kimage->head);
>>> +    pr_debug("\tnr_segments: %lu\n", kimage->nr_segments);
>>> +
>>> +    for (i = 0; i < kimage->nr_segments; i++) {
>>> +        pr_debug("\t    segment[%lu]: %016lx - %016lx", i,
>>> +            kimage->segment[i].mem,
>>> +            kimage->segment[i].mem + kimage->segment[i].memsz);
>>> +        pr_debug("\t\t0x%lx bytes, %lu pages\n",
>>> +            (unsigned long)kimage->segment[i].memsz,
>>> +            (unsigned long)kimage->segment[i].memsz /  PAGE_SIZE);
>>> +    }
>>> +}
>>> +
>>> +int machine_kexec_prepare(struct kimage *kimage)
>>> +{
>>> +    int i;
>>> +    void *dtb = (void *)KEXEC_BLOB_ADDR;
>>> +
>>> +    kexec_image_info(kimage);
>>> +
>>> +    /* Find the Flattened Device Tree */
>>> +    for (i = 0; i < kimage->nr_segments; i++) {
>>> +        if (!fdt_check_header(kimage->segment[i].buf)) {
>>> +            memcpy(dtb, kimage->segment[i].buf, SZ_64K);
>>> +            kimage->arch.boot_flag = fw_arg0;
>>> +            kimage->arch.fdt_addr = (unsigned long) dtb;
>>> +            break;
>>> +        }
>>> +        continue;
>>> +    }
>>> +
>>> +    /* kexec need a safe page to save reboot_code_buffer */
>>> +    kimage->control_code_page = virt_to_page((void *)KEXEC_CTRL_CODE);
>>> +
>>> +    reboot_code_buffer =
>>> +      (unsigned long)page_address(kimage->control_code_page);
>>> +    memcpy((void *)reboot_code_buffer, relocate_new_kernel,
>>> +           relocate_new_kernel_size);
>> It copys same content to KEXEC_CTRL_CODE each time, could we do this at
>> boot time?
> I think it's possible to have the copy action happen at boot-time or
> during the prepare phase. (RISCV in prepare, MIPS in boot-time)
>
>>
>> BTW, our system always keep the low-2MB no used, on mips-loongson or
>> LoongArch. Is that necessary on LoongArch? We cannot use parameter
>> 'mem=YYM' normally but 'mem=YYM@2M' is ok. And the low-2MB is not
>> in virtual memory management, although we can get it in kernel.
> For existing kernels, the low 2M has been reserved by
> memblock_reserve(PHYS_OFFSET, 0x200000), maybe it is acceptable to keep
> the low 2M behavior.
>
> Yes, we need to use "mem=YM@2M" if the low 2M is reserved.
>
>>
>> In kexec/kdump process, we can follows kimage_alloc_control_pages().
>> When the boot cpu copy complete the second-kernels, all cpus can jump
>> to a kernel-entry-trampoline which is in kernel image. Then we don't
>> worry about the code can be destroyed. The kernel-entry-trampoline
>> get its cpuid, keep non-boot cpus do as kexec_smp_wait and let boot
>> cpu go kernel-entry. In this way we can drop the low-2MB IMO.
>
> It is also feasible to dynamically allocate control pages, but it is
> easier to use a low 2M approach. What do you think, Huacai?
>
>>
>>> +
>>> +    /* All secondary cpus now may jump to kexec_smp_wait cycle */
>>> +    relocated_kexec_smp_wait = reboot_code_buffer +
>>> +        (void *)(kexec_smp_wait - relocate_new_kernel);
>>> +
>>> +    return 0;
>>> +}
>>> +
>>> +void machine_kexec_cleanup(struct kimage *kimage)
>>> +{
>>> +}
>>> +
>>> +#ifdef CONFIG_SMP
>>> +void kexec_reboot(void)
>>> +{
>>> +    do_kexec_t do_kexec = NULL;
>>> +
>>> +    /* All secondary cpus go to kexec_smp_wait */
>>> +    if (smp_processor_id() > 0) {
>>> +        relocated_kexec_smp_wait(NULL);
>>> +        unreachable();
>>> +    }
>>> +
>>> +    do_kexec = (void *)reboot_code_buffer;
>>> +    do_kexec(boot_flag, fdt_addr, first_ind_entry, jump_addr);
>>> +
>>> +    unreachable();
>>> +}
>>> +
>>> +static void kexec_shutdown_secondary(void *)
>>> +{
>>> +    local_irq_disable();
>>> +    while (!atomic_read(&kexec_ready_to_reboot))
>>> +        cpu_relax();
>>> +
>>> +    kexec_reboot();
>>> +}
>>> +
>>> +void machine_crash_shutdown(struct pt_regs *regs)
>>> +{
>>> +}
>>> +#endif
>>> +
>>> +void machine_shutdown(void)
>>> +{
>>> +    smp_call_function(kexec_shutdown_secondary, NULL, 0);
>>> +}
>>> +
>>> +void machine_kexec(struct kimage *image)
>>> +{
>>> +    unsigned long entry;
>>> +    unsigned long *ptr;
>>> +    struct kimage_arch *internal = &image->arch;
>>> +
>>> +    boot_flag = internal->boot_flag;
>>> +    fdt_addr = internal->fdt_addr;
>>> +
>>> +    jump_addr = (unsigned long)phys_to_virt(image->start);
>>> +
>>> +    first_ind_entry = (unsigned long)phys_to_virt(image->head &
>>> PAGE_MASK);
>>> +
>>> +    /*
>>> +     * The generic kexec code builds a page list with physical
>>> +     * addresses. they are directly accessible through XKPRANGE
>>> +     * hence the phys_to_virt() call.
>>> +     */
>>> +    for (ptr = &image->head; (entry = *ptr) && !(entry & IND_DONE);
>>> +         ptr = (entry & IND_INDIRECTION) ?
>>> +           phys_to_virt(entry & PAGE_MASK) : ptr + 1) {
>>> +        if (*ptr & IND_SOURCE || *ptr & IND_INDIRECTION ||
>>> +            *ptr & IND_DESTINATION)
>>> +            *ptr = (unsigned long) phys_to_virt(*ptr);
>>> +    }
>>> +
>>> +    /* Mark offline before disabling local irq. */
>>> +    set_cpu_online(smp_processor_id(), false);
>>> +
>>> +    /* we do not want to be bothered. */
>>> +    local_irq_disable();
>>> +
>>> +    pr_notice("Will call new kernel at %lx\n", jump_addr);
>>> +    pr_notice("FDT image at %lx\n", fdt_addr);
>>> +    pr_notice("Bye ...\n");
>>> +
>>> +    /* Make reboot code buffer available to the boot CPU. */
>>> +    flush_cache_all();
>>> +
>>> +    atomic_set(&kexec_ready_to_reboot, 1);
>>> +
>>> +    /*
>>> +     * We know we were online, and there will be no incoming IPIs at
>>> +     * this point.
>>> +     */
>>> +    set_cpu_online(smp_processor_id(), true);
>>> +
>>> +    /* Ensure remote CPUs observe that we're online before
>>> rebooting. */
>>> +    smp_mb__after_atomic();
>>> +
>>> +    kexec_reboot();
>>> +}
>>> diff --git a/arch/loongarch/kernel/relocate_kernel.S
>>> b/arch/loongarch/kernel/relocate_kernel.S
>>> new file mode 100644
>>> index 000000000000..d1f242f74ea8
>>> --- /dev/null
>>> +++ b/arch/loongarch/kernel/relocate_kernel.S
>>> @@ -0,0 +1,125 @@
>>> +/* SPDX-License-Identifier: GPL-2.0 */
>>> +/*
>>> + * relocate_kernel.S for kexec
>>> + *
>>> + * Copyright (C) 2022 Loongson Technology Corporation Limited
>>> + */
>>> +
>>> +#include <linux/kexec.h>
>>> +
>>> +#include <asm/asm.h>
>>> +#include <asm/asmmacro.h>
>>> +#include <asm/regdef.h>
>>> +#include <asm/loongarch.h>
>>> +#include <asm/stackframe.h>
>>> +#include <asm/addrspace.h>
>>> +
>>> +#define IPI_REG_BASE 0x1fe01000
>>> +
>>> +SYM_CODE_START(relocate_new_kernel)
>>> +    /*
>>> +     * s0: Boot flag passed to the new kernel
>>> +     * s1: Virt address of the FDT image
>>> +     * s2: Pointer to the current entry
>>> +     * s3: Virt address to jump to after relocation
>>> +     */
>>> +    move        s0, a0
>>> +    move        s1, a1
>>> +    move        s2, a2
>>> +    move        s3, a3
>>> +
>>> +process_entry:
>>> +    PTR_L        s4, s2, 0
>>> +    PTR_ADDI    s2, s2, SZREG
>>> +
>>> +    /* destination page */
>>> +    andi        s5, s4, IND_DESTINATION
>>> +    beqz        s5, 1f
>>> +    li.w        t0, ~0x1
>>> +    and        s6, s4, t0    /* store destination addr in s6 */
>>> +    b        process_entry
>>> +
>>> +1:
>>> +    /* indirection page, update s2    */
>>> +    andi        s5, s4, IND_INDIRECTION
>>> +    beqz        s5, 1f
>>> +    li.w        t0, ~0x2
>>> +    and        s2, s4, t0
>>> +    b        process_entry
>>> +
>>> +1:
>>> +    /* done page */
>>> +    andi        s5, s4, IND_DONE
>>> +    beqz        s5, 1f
>>> +    b        done
>>> +1:
>>> +    /* source page */
>>> +    andi        s5, s4, IND_SOURCE
>>> +    beqz        s5, process_entry
>>> +    li.w        t0, ~0x8
>>> +    and        s4, s4, t0
>>> +    li.w        s8, (1 << _PAGE_SHIFT) / SZREG
>>> +
>>> +copy_word:
>>> +    /* copy page word by word */
>>> +    REG_L        s7, s4, 0
>>> +    REG_S        s7, s6, 0
>>> +    PTR_ADDI    s6, s6, SZREG
>>> +    PTR_ADDI    s4, s4, SZREG
>>> +    LONG_ADDI    s8, s8, -1
>>> +    beqz        s8, process_entry
>>> +    b        copy_word
>>> +    b        process_entry
>>> +
>>> +done:
>>> +    dbar        0
>> ibar, too?
>
> Will add ibar 0.
>
>>> +
>>> +    move        a0, s0
>>> +    move        a1, s1
>>> +    /* jump to the new kernel */
>>> +    jr        s3
>>> +SYM_CODE_END(relocate_new_kernel)
>>> +
>>> +#ifdef CONFIG_SMP
>>> +/*
>>> + * Other CPUs should wait until code is relocated and
>>> + * then start at entry (?) point.
>>> + */
>>> +SYM_CODE_START(kexec_smp_wait)
>>> +    li.d        t0, IPI_REG_BASE
>>> +    li.d        t1, UNCACHE_BASE
>>> +    or        t0, t0, t1
>>> +
>>> +    /*
>>> +     * s1:initfn
>>> +     * t0:base t1:cpuid t2:node t3:core t4:count
>>> +     */
>>> +    csrrd        t1, LOONGARCH_CSR_CPUID
>>> +    andi        t1, t1, CSR_CPUID_COREID
>>> +    andi        t3, t1, 0x3
>>> +    slli.w        t3, t3, 8              /* get core id */
>>> +    or        t0, t0, t3
>>> +    andi        t2, t1, 0x3c
>>> +    slli.d        t2, t2, 42             /* get node id */
>>> +    or        t0, t0, t2
>>> +
>>> +1:    li.w        t4, 0x100              /* wait for init loop */
>>> +2:    addi.w        t4, t4, -1             /* limit mailbox access */
>>> +    bnez        t4, 2b
>>> +    ld.w        s1, t0, 0x20           /* check PC as an indicator */
>> Can we do this with iocsr*?
>
> OK, I will consider the implementation in the iocsr way.
>

The kexec_smp_wait implementation will be modified in the next release
as follows：

SYM_CODE_START(kexec_smp_wait)
1:      li.w            t0, 0x100                       /* wait for init 
loop */
2:      addi.w          t0, t0, -1                      /* limit mailbox 
access */
         bnez            t0, 2b
         li.w            t1, LOONGARCH_IOCSR_MBUF0
         iocsrrd.w       s1, t1                          /* check PC as 
an indicator */
         beqz            s1, 1b
         iocsrrd.d       s1, t1                          /* get PC via 
mailbox */

         li.d            t0, CACHE_BASE
         or              s1, s1, t0
         jr              s1                              /* jump to 
initial PC */
SYM_CODE_END(kexec_smp_wait)

1) Using the iocsr method
2) Remove sp, tp settings. sp, tp will be obtained from cpuboot_data in
smpboot_entry.

Thanks again Jinyang for the suggestion.


Youling.

> Thanks,
> Youling
>>
>> Thanks,
>> Jinyang
>>> +    beqz        s1, 1b
>>> +    ld.d        s1, t0, 0x20           /* get PC via mailbox */
>>> +    ld.d        sp, t0, 0x28           /* get SP via mailbox */
>>> +    ld.d        tp, t0, 0x30           /* get TP via mailbox */
>>> +
>>> +    li.d        t0, CACHE_BASE
>>> +    or        s1, s1, t0
>>> +    jr        s1                     /* jump to initial PC */
>>> +SYM_CODE_END(kexec_smp_wait)
>>> +#endif
>>> +
>>> +relocate_new_kernel_end:
>>> +
>>> +SYM_DATA_START(relocate_new_kernel_size)
>>> +    PTR        relocate_new_kernel_end - relocate_new_kernel
>>> +SYM_DATA_END(relocate_new_kernel_size)
>>
>

Re: [PATCH 1/3] LoongArch: Add kexec support

[Youling Tang]

On 08/29/2022 12:37 PM, Youling Tang wrote:
> Add three new files, kexec.h, machine_kexec.c and relocate_kernel.S to the
> LoongArch architecture that add support for the kexec re-boot mechanis
> (CONFIG_KEXEC) on LoongArch platforms.
>
> Supports loading vmlinux (vmlinux.elf) in ELF format and vmlinux.efi in
> PE format.
>
> I tested this on  LoongArch 3A5000 machine and works as expected,
>
>  $ sudo kexec -l /boot/vmlinux.efi --reuse-cmdline
>  $ sudo kexec -e
>
> Signed-off-by: Youling Tang <tangyouling@loongson.cn>
> ---
>  arch/loongarch/Kconfig                  |  11 ++
>  arch/loongarch/include/asm/kexec.h      |  58 ++++++++
>  arch/loongarch/kernel/Makefile          |   2 +
>  arch/loongarch/kernel/head.S            |   7 +-
>  arch/loongarch/kernel/machine_kexec.c   | 178 ++++++++++++++++++++++++
>  arch/loongarch/kernel/relocate_kernel.S | 125 +++++++++++++++++
>  6 files changed, 380 insertions(+), 1 deletion(-)
>  create mode 100644 arch/loongarch/include/asm/kexec.h
>  create mode 100644 arch/loongarch/kernel/machine_kexec.c
>  create mode 100644 arch/loongarch/kernel/relocate_kernel.S
>
> diff --git a/arch/loongarch/Kconfig b/arch/loongarch/Kconfig
> index 45364cffc793..903c82fa958d 100644
> --- a/arch/loongarch/Kconfig
> +++ b/arch/loongarch/Kconfig
> @@ -409,6 +409,17 @@ config FORCE_MAX_ZONEORDER
>  	  The page size is not necessarily 4KB.  Keep this in mind
>  	  when choosing a value for this option.
>
> +config KEXEC
> +	bool "Kexec system call"
> +	select KEXEC_CORE
> +	help
> +	  kexec is a system call that implements the ability to shutdown your
> +	  current kernel, and to start another kernel.  It is like a reboot
> +	  but it is independent of the system firmware.   And like a reboot
> +	  you can start any kernel with it, not just Linux.
> +
> +	  The name comes from the similarity to the exec system call.
> +
>  config SECCOMP
>  	bool "Enable seccomp to safely compute untrusted bytecode"
>  	depends on PROC_FS
> diff --git a/arch/loongarch/include/asm/kexec.h b/arch/loongarch/include/asm/kexec.h
> new file mode 100644
> index 000000000000..5c9e7b5eccb8
> --- /dev/null
> +++ b/arch/loongarch/include/asm/kexec.h
> @@ -0,0 +1,58 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +/*
> + * kexec.h for kexec
> + *
> + * Copyright (C) 2022 Loongson Technology Corporation Limited
> + */
> +
> +#ifndef _ASM_KEXEC_H
> +#define _ASM_KEXEC_H
> +
> +#include <asm/stacktrace.h>
> +#include <asm/page.h>
> +
> +/* Maximum physical address we can use pages from */
> +#define KEXEC_SOURCE_MEMORY_LIMIT (-1UL)
> +/* Maximum address we can reach in physical address mode */
> +#define KEXEC_DESTINATION_MEMORY_LIMIT (-1UL)
> + /* Maximum address we can use for the control code buffer */
> +#define KEXEC_CONTROL_MEMORY_LIMIT (-1UL)
> +
> +/* Reserve a page for the control code buffer */
> +#define KEXEC_CONTROL_PAGE_SIZE PAGE_SIZE
> +
> +/* The native architecture */
> +#define KEXEC_ARCH KEXEC_ARCH_LOONGARCH
> +
> +static inline void crash_setup_regs(struct pt_regs *newregs,
> +				    struct pt_regs *oldregs)
> +{
> +	if (oldregs)
> +		memcpy(newregs, oldregs, sizeof(*newregs));
> +	else
> +		prepare_frametrace(newregs);
> +}
> +
> +#define ARCH_HAS_KIMAGE_ARCH
> +
> +struct kimage_arch {
> +	unsigned long boot_flag;
> +	unsigned long fdt_addr;
> +};
> +
> +typedef void (*do_kexec_t)(unsigned long boot_flag,
> +			   unsigned long fdt_addr,
> +			   unsigned long first_ind_entry,
> +			   unsigned long jump_addr);
> +
> +struct kimage;
> +extern const unsigned char relocate_new_kernel[];
> +extern const size_t relocate_new_kernel_size;
> +
> +#ifdef CONFIG_SMP
> +extern atomic_t kexec_ready_to_reboot;
> +extern const unsigned char kexec_smp_wait[];
> +extern void kexec_reboot(void);
> +#endif
> +
> +#endif /* !_ASM_KEXEC_H */
> diff --git a/arch/loongarch/kernel/Makefile b/arch/loongarch/kernel/Makefile
> index a213e994db68..20b64ac3f128 100644
> --- a/arch/loongarch/kernel/Makefile
> +++ b/arch/loongarch/kernel/Makefile
> @@ -17,6 +17,8 @@ obj-$(CONFIG_CPU_HAS_FPU)	+= fpu.o
>  obj-$(CONFIG_MODULES)		+= module.o module-sections.o
>  obj-$(CONFIG_STACKTRACE)	+= stacktrace.o
>
> +obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o
> +
>  obj-$(CONFIG_PROC_FS)		+= proc.o
>
>  obj-$(CONFIG_SMP)		+= smp.o
> diff --git a/arch/loongarch/kernel/head.S b/arch/loongarch/kernel/head.S
> index 01bac62a6442..22bdf4928325 100644
> --- a/arch/loongarch/kernel/head.S
> +++ b/arch/loongarch/kernel/head.S
> @@ -20,7 +20,12 @@
>
>  _head:
>  	.word	MZ_MAGIC		/* "MZ", MS-DOS header */
> -	.org	0x3c			/* 0x04 ~ 0x3b reserved */
> +	.org	0x8
> +	.quad	0			/* Image load offset from start of RAM */
> +	.dword	_end - _text		/* Effective size of kernel image */
> +	.quad	0
> +	.dword	kernel_entry		/* Kernel entry point */
> +	.org	0x3c			/* 0x28 ~ 0x3b reserved */
>  	.long	pe_header - _head	/* Offset to the PE header */
>
>  pe_header:
> diff --git a/arch/loongarch/kernel/machine_kexec.c b/arch/loongarch/kernel/machine_kexec.c
> new file mode 100644
> index 000000000000..4ffcd4cd9c8c
> --- /dev/null
> +++ b/arch/loongarch/kernel/machine_kexec.c
> @@ -0,0 +1,178 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * machine_kexec.c for kexec
> + *
> + * Copyright (C) 2022 Loongson Technology Corporation Limited
> + */
> +#include <linux/compiler.h>
> +#include <linux/cpu.h>
> +#include <linux/kexec.h>
> +#include <linux/mm.h>
> +#include <linux/delay.h>
> +#include <linux/libfdt.h>
> +#include <linux/of_fdt.h>
> +
> +#include <asm/bootinfo.h>
> +#include <asm/cacheflush.h>
> +#include <asm/page.h>
> +
> +/* 0x100000 ~ 0x200000 is safe */
> +#define KEXEC_CTRL_CODE	TO_CACHE(0x100000UL)
> +#define KEXEC_BLOB_ADDR	TO_CACHE(0x108000UL)
> +
> +static unsigned long reboot_code_buffer;
> +#ifdef CONFIG_SMP
> +void (*relocated_kexec_smp_wait)(void *);
> +atomic_t kexec_ready_to_reboot = ATOMIC_INIT(0);
> +#endif
> +
> +static unsigned long jump_addr;
> +static unsigned long first_ind_entry;
> +static unsigned long boot_flag;
> +static unsigned long fdt_addr;
> +
> +static void kexec_image_info(const struct kimage *kimage)
> +{
> +	unsigned long i;
> +
> +	pr_debug("kexec kimage info:\n");
> +	pr_debug("\ttype:        %d\n", kimage->type);
> +	pr_debug("\tstart:       %lx\n", kimage->start);
> +	pr_debug("\thead:        %lx\n", kimage->head);
> +	pr_debug("\tnr_segments: %lu\n", kimage->nr_segments);
> +
> +	for (i = 0; i < kimage->nr_segments; i++) {
> +		pr_debug("\t    segment[%lu]: %016lx - %016lx", i,
> +			kimage->segment[i].mem,
> +			kimage->segment[i].mem + kimage->segment[i].memsz);
> +		pr_debug("\t\t0x%lx bytes, %lu pages\n",
> +			(unsigned long)kimage->segment[i].memsz,
> +			(unsigned long)kimage->segment[i].memsz /  PAGE_SIZE);
> +	}
> +}
> +
> +int machine_kexec_prepare(struct kimage *kimage)
> +{
> +	int i;
> +	void *dtb = (void *)KEXEC_BLOB_ADDR;
> +
> +	kexec_image_info(kimage);
> +
> +	/* Find the Flattened Device Tree */
> +	for (i = 0; i < kimage->nr_segments; i++) {
> +		if (!fdt_check_header(kimage->segment[i].buf)) {
> +			memcpy(dtb, kimage->segment[i].buf, SZ_64K);
> +			kimage->arch.boot_flag = fw_arg0;
> +			kimage->arch.fdt_addr = (unsigned long) dtb;
> +			break;
> +		}
> +		continue;
> +	}
> +
> +	/* kexec need a safe page to save reboot_code_buffer */
> +	kimage->control_code_page = virt_to_page((void *)KEXEC_CTRL_CODE);
> +
> +	reboot_code_buffer =
> +	  (unsigned long)page_address(kimage->control_code_page);
> +	memcpy((void *)reboot_code_buffer, relocate_new_kernel,
> +	       relocate_new_kernel_size);
> +
> +	/* All secondary cpus now may jump to kexec_smp_wait cycle */
> +	relocated_kexec_smp_wait = reboot_code_buffer +
> +		(void *)(kexec_smp_wait - relocate_new_kernel);
> +
> +	return 0;
> +}
> +
> +void machine_kexec_cleanup(struct kimage *kimage)
> +{
> +}
> +
> +#ifdef CONFIG_SMP
> +void kexec_reboot(void)
> +{
> +	do_kexec_t do_kexec = NULL;
> +
> +	/* All secondary cpus go to kexec_smp_wait */
> +	if (smp_processor_id() > 0) {
> +		relocated_kexec_smp_wait(NULL);
> +		unreachable();
> +	}
> +
> +	do_kexec = (void *)reboot_code_buffer;
> +	do_kexec(boot_flag, fdt_addr, first_ind_entry, jump_addr);
> +
> +	unreachable();
> +}

self-check,
kexec_reboot() is in! SMP needs to be used, modified as follows:

void kexec_reboot(void)
{
         do_kexec_t do_kexec = NULL;

#ifdef CONFIG_SMP
         /* All secondary cpus go to kexec_smp_wait */
         if (smp_processor_id() > 0) {
                 relocated_kexec_smp_wait(NULL);
                 unreachable();
         }
#endif

         do_kexec = (void *)reboot_code_buffer;
         do_kexec(boot_flag, fdt_addr, first_ind_entry, jump_addr);

         unreachable();
}

Youling

[PATCH 2/3] LoongArch: Add kdump support

[Youling Tang]

This patch adds support for kdump, the kernel will reserve a region
for the crash kernel and jump there on panic.

Arch-specific functions are added to allow for implementing a crash
dump file interface, /proc/vmcore, which can be viewed as a ELF file.

A user space tool, like kexec-tools, is responsible for allocating a
separate region for the core's ELF header within crash kdump kernel
memory and filling it in when executing kexec_load().

Then, its location will be advertised to crash dump kernel via a new
device-tree property, "linux,elfcorehdr", and crash dump kernel preserves
the region for later use with fdt_reserve_elfcorehdr() at boot time.

At the same time, it will also limit the crash kdump kernel to the
crashkernel area via a new device-tree property, "linux, usable-memory-range",
so as not to destroy the original kernel dump data.

On crash dump kernel, /proc/vmcore will access the primary kernel's memory
with copy_oldmem_page().

I tested this on  LoongArch 3A5000 machine and works as expected (Suggest
crashkernel parameter is "crashkernel=512M@2320M"), you may test it by
triggering a crash through /proc/sysrq_trigger:

 $ sudo kexec -p /boot/vmlinux-kdump --reuse-cmdline --append="nr_cpus=1"
 # echo c > /proc/sysrq_trigger

Signed-off-by: Youling Tang <tangyouling@loongson.cn>
---
 arch/loongarch/Kconfig                  |  22 ++++++
 arch/loongarch/Makefile                 |   4 +
 arch/loongarch/kernel/Makefile          |   3 +-
 arch/loongarch/kernel/crash.c           | 100 ++++++++++++++++++++++++
 arch/loongarch/kernel/crash_dump.c      |  19 +++++
 arch/loongarch/kernel/machine_kexec.c   |  12 ++-
 arch/loongarch/kernel/mem.c             |   6 ++
 arch/loongarch/kernel/relocate_kernel.S |   6 ++
 arch/loongarch/kernel/setup.c           |  49 ++++++++++++
 arch/loongarch/kernel/traps.c           |   4 +
 10 files changed, 217 insertions(+), 8 deletions(-)
 create mode 100644 arch/loongarch/kernel/crash.c
 create mode 100644 arch/loongarch/kernel/crash_dump.c

diff --git a/arch/loongarch/Kconfig b/arch/loongarch/Kconfig
index 903c82fa958d..7c1b07a5b5bd 100644
--- a/arch/loongarch/Kconfig
+++ b/arch/loongarch/Kconfig
@@ -420,6 +420,28 @@ config KEXEC
 
 	  The name comes from the similarity to the exec system call.
 
+config CRASH_DUMP
+	bool "Build kdump crash kernel"
+	help
+	  Generate crash dump after being started by kexec. This should
+	  be normally only set in special crash dump kernels which are
+	  loaded in the main kernel with kexec-tools into a specially
+	  reserved region and then later executed after a crash by
+	  kdump/kexec.
+
+	  For more details see Documentation/admin-guide/kdump/kdump.rst
+
+config PHYSICAL_START
+	hex "Physical address where the kernel is loaded"
+	default "0x9000000091000000" if 64BIT
+	depends on CRASH_DUMP
+	help
+	  This gives the XKPRANGE address where the kernel is loaded.
+	  If you plan to use kernel for capturing the crash dump change
+	  this value to start of the reserved region (the "X" value as
+	  specified in the "crashkernel=YM@XM" command line boot parameter
+	  passed to the panic-ed kernel).
+
 config SECCOMP
 	bool "Enable seccomp to safely compute untrusted bytecode"
 	depends on PROC_FS
diff --git a/arch/loongarch/Makefile b/arch/loongarch/Makefile
index 4bc47f47cfd8..7dabd580426d 100644
--- a/arch/loongarch/Makefile
+++ b/arch/loongarch/Makefile
@@ -48,7 +48,11 @@ KBUILD_CFLAGS_MODULE		+= -fplt -Wa,-mla-global-with-abs,-mla-local-with-abs
 cflags-y += -ffreestanding
 cflags-y += $(call cc-option, -mno-check-zero-division)
 
+ifdef CONFIG_PHYSICAL_START
+load-y		= $(CONFIG_PHYSICAL_START)
+else
 load-y		= 0x9000000000200000
+endif
 bootvars-y	= VMLINUX_LOAD_ADDRESS=$(load-y)
 
 drivers-$(CONFIG_PCI)		+= arch/loongarch/pci/
diff --git a/arch/loongarch/kernel/Makefile b/arch/loongarch/kernel/Makefile
index 20b64ac3f128..df5aea129364 100644
--- a/arch/loongarch/kernel/Makefile
+++ b/arch/loongarch/kernel/Makefile
@@ -17,7 +17,8 @@ obj-$(CONFIG_CPU_HAS_FPU)	+= fpu.o
 obj-$(CONFIG_MODULES)		+= module.o module-sections.o
 obj-$(CONFIG_STACKTRACE)	+= stacktrace.o
 
-obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o
+obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o crash.o
+obj-$(CONFIG_CRASH_DUMP)        += crash_dump.o
 
 obj-$(CONFIG_PROC_FS)		+= proc.o
 
diff --git a/arch/loongarch/kernel/crash.c b/arch/loongarch/kernel/crash.c
new file mode 100644
index 000000000000..b4f249ec6301
--- /dev/null
+++ b/arch/loongarch/kernel/crash.c
@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2022 Loongson Technology Corporation Limited
+ *
+ * Derived from MIPS
+ */
+#include <linux/kernel.h>
+#include <linux/smp.h>
+#include <linux/reboot.h>
+#include <linux/crash_dump.h>
+#include <linux/delay.h>
+#include <linux/irq.h>
+#include <linux/types.h>
+#include <linux/sched.h>
+#include <linux/sched/task_stack.h>
+#include <asm/cacheflush.h>
+#include <asm/kexec.h>
+
+static cpumask_t cpus_in_crash = CPU_MASK_NONE;
+
+#ifdef CONFIG_SMP
+static void crash_shutdown_secondary(void *passed_regs)
+{
+	struct pt_regs *regs = passed_regs;
+	int cpu = smp_processor_id();
+
+	/*
+	 * If we are passed registers, use those.  Otherwise get the
+	 * regs from the last interrupt, which should be correct, as
+	 * we are in an interrupt.  But if the regs are not there,
+	 * pull them from the top of the stack.  They are probably
+	 * wrong, but we need something to keep from crashing again.
+	 */
+	if (!regs)
+		regs = get_irq_regs();
+	if (!regs)
+		regs = task_pt_regs(current);
+
+	local_irq_disable();
+	if (!cpumask_test_cpu(cpu, &cpus_in_crash))
+		crash_save_cpu(regs, cpu);
+	cpumask_set_cpu(cpu, &cpus_in_crash);
+
+	while (!atomic_read(&kexec_ready_to_reboot))
+		cpu_relax();
+
+	kexec_reboot();
+}
+
+/* Override the weak function in kernel/panic.c */
+void crash_smp_send_stop(void)
+{
+	static int cpus_stopped;
+	unsigned long timeout;
+	unsigned int ncpus;
+
+	/*
+	 * This function can be called twice in panic path, but obviously
+	 * we execute this only once.
+	 */
+	if (cpus_stopped)
+		return;
+
+	cpus_stopped = 1;
+
+	 /* Excluding the panic cpu */
+	ncpus = num_online_cpus() - 1;
+
+	smp_call_function(crash_shutdown_secondary, NULL, 0);
+	smp_wmb();
+
+	/*
+	 * The crash CPU sends an IPI and wait for other CPUs to
+	 * respond. Delay of at least 10 seconds.
+	 */
+	pr_emerg("Sending IPI to other cpus...\n");
+	timeout = USEC_PER_SEC * 10;
+	while ((cpumask_weight(&cpus_in_crash) < ncpus) && timeout--) {
+		cpu_relax();
+		udelay(1);
+	}
+}
+
+#endif
+
+void machine_crash_shutdown(struct pt_regs *regs)
+{
+	int crashing_cpu;
+
+	local_irq_disable();
+
+	crashing_cpu = smp_processor_id();
+	crash_save_cpu(regs, crashing_cpu);
+
+	/* shutdown non-crashing cpus */
+	crash_smp_send_stop();
+	cpumask_set_cpu(crashing_cpu, &cpus_in_crash);
+
+	pr_info("Starting crashdump kernel...\n");
+}
diff --git a/arch/loongarch/kernel/crash_dump.c b/arch/loongarch/kernel/crash_dump.c
new file mode 100644
index 000000000000..13e5d2f7870d
--- /dev/null
+++ b/arch/loongarch/kernel/crash_dump.c
@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <linux/highmem.h>
+#include <linux/crash_dump.h>
+#include <linux/io.h>
+
+ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn,
+			 size_t csize, unsigned long offset)
+{
+	void  *vaddr;
+
+	if (!csize)
+		return 0;
+
+	vaddr = kmap_local_pfn(pfn);
+	csize = copy_to_iter(vaddr + offset, csize, iter);
+	kunmap_local(vaddr);
+
+	return csize;
+}
diff --git a/arch/loongarch/kernel/machine_kexec.c b/arch/loongarch/kernel/machine_kexec.c
index 4ffcd4cd9c8c..f793a3ff09a3 100644
--- a/arch/loongarch/kernel/machine_kexec.c
+++ b/arch/loongarch/kernel/machine_kexec.c
@@ -69,7 +69,7 @@ int machine_kexec_prepare(struct kimage *kimage)
 		continue;
 	}
 
-	/* kexec need a safe page to save reboot_code_buffer */
+	/* kexec/kdump need a safe page to save reboot_code_buffer */
 	kimage->control_code_page = virt_to_page((void *)KEXEC_CTRL_CODE);
 
 	reboot_code_buffer =
@@ -113,10 +113,6 @@ static void kexec_shutdown_secondary(void *)
 
 	kexec_reboot();
 }
-
-void machine_crash_shutdown(struct pt_regs *regs)
-{
-}
 #endif
 
 void machine_shutdown(void)
@@ -135,7 +131,8 @@ void machine_kexec(struct kimage *image)
 
 	jump_addr = (unsigned long)phys_to_virt(image->start);
 
-	first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
+	if (image->type == KEXEC_TYPE_DEFAULT)
+		first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
 
 	/*
 	 * The generic kexec code builds a page list with physical
@@ -167,7 +164,8 @@ void machine_kexec(struct kimage *image)
 
 	/*
 	 * We know we were online, and there will be no incoming IPIs at
-	 * this point.
+	 * this point. Mark online again before rebooting so that the crash
+	 * analysis tool will see us correctly.
 	 */
 	set_cpu_online(smp_processor_id(), true);
 
diff --git a/arch/loongarch/kernel/mem.c b/arch/loongarch/kernel/mem.c
index 7423361b0ebc..c6def6ff81c8 100644
--- a/arch/loongarch/kernel/mem.c
+++ b/arch/loongarch/kernel/mem.c
@@ -5,6 +5,7 @@
 #include <linux/efi.h>
 #include <linux/initrd.h>
 #include <linux/memblock.h>
+#include <linux/of_fdt.h>
 
 #include <asm/bootinfo.h>
 #include <asm/loongson.h>
@@ -61,4 +62,9 @@ void __init memblock_init(void)
 
 	/* Reserve the initrd */
 	reserve_initrd_mem();
+
+	/* Mainly reserved memory for the elf core head */
+	early_init_fdt_scan_reserved_mem();
+	/* Parse linux,usable-memory-range is for crash dump kernel */
+	early_init_dt_check_for_usable_mem_range();
 }
diff --git a/arch/loongarch/kernel/relocate_kernel.S b/arch/loongarch/kernel/relocate_kernel.S
index d1f242f74ea8..4ee5ac4ac2d7 100644
--- a/arch/loongarch/kernel/relocate_kernel.S
+++ b/arch/loongarch/kernel/relocate_kernel.S
@@ -28,6 +28,12 @@ SYM_CODE_START(relocate_new_kernel)
 	move		s2, a2
 	move		s3, a3
 
+	/*
+	 * In case of a kdump/crash kernel, the indirection page is not
+	 * populated as the kernel is directly copied to a reserved location
+	 */
+	beqz		s2, done
+
 process_entry:
 	PTR_L		s4, s2, 0
 	PTR_ADDI	s2, s2, SZREG
diff --git a/arch/loongarch/kernel/setup.c b/arch/loongarch/kernel/setup.c
index f938aae3e92c..ea34b77e402f 100644
--- a/arch/loongarch/kernel/setup.c
+++ b/arch/loongarch/kernel/setup.c
@@ -19,6 +19,8 @@
 #include <linux/memblock.h>
 #include <linux/initrd.h>
 #include <linux/ioport.h>
+#include <linux/kexec.h>
+#include <linux/crash_dump.h>
 #include <linux/root_dev.h>
 #include <linux/console.h>
 #include <linux/pfn.h>
@@ -186,6 +188,50 @@ static int __init early_parse_mem(char *p)
 }
 early_param("mem", early_parse_mem);
 
+static void __init loongarch_parse_crashkernel(void)
+{
+#ifdef CONFIG_KEXEC
+	unsigned long long start;
+	unsigned long long total_mem;
+	unsigned long long crash_size, crash_base;
+	int ret;
+
+	total_mem = memblock_phys_mem_size();
+	ret = parse_crashkernel(boot_command_line, total_mem,
+				&crash_size, &crash_base);
+	if (ret != 0 || crash_size <= 0)
+		return;
+
+
+	start = memblock_phys_alloc_range(crash_size, 1, crash_base,
+					crash_base + crash_size);
+	if (start != crash_base) {
+		pr_warn("Invalid memory region reserved for crash kernel\n");
+		return;
+	}
+
+	crashk_res.start = crash_base;
+	crashk_res.end	 = crash_base + crash_size - 1;
+#endif
+}
+
+static void __init request_crashkernel(struct resource *res)
+{
+#ifdef CONFIG_KEXEC
+	int ret;
+
+	if (crashk_res.start == crashk_res.end)
+		return;
+
+	ret = request_resource(res, &crashk_res);
+	if (!ret)
+		pr_info("Reserving %ldMB of memory at %ldMB for crashkernel\n",
+			(unsigned long)((crashk_res.end -
+					 crashk_res.start + 1) >> 20),
+			(unsigned long)(crashk_res.start  >> 20));
+#endif
+}
+
 void __init platform_init(void)
 {
 	efi_init();
@@ -229,6 +275,8 @@ static void __init arch_mem_init(char **cmdline_p)
 
 	check_kernel_sections_mem();
 
+	loongarch_parse_crashkernel();
+
 	/*
 	 * In order to reduce the possibility of kernel panic when failed to
 	 * get IO TLB memory under CONFIG_SWIOTLB, it is better to allocate
@@ -290,6 +338,7 @@ static void __init resource_init(void)
 		request_resource(res, &code_resource);
 		request_resource(res, &data_resource);
 		request_resource(res, &bss_resource);
+		request_crashkernel(res);
 	}
 }
 
diff --git a/arch/loongarch/kernel/traps.c b/arch/loongarch/kernel/traps.c
index aa1c95aaf595..0e610872f3f4 100644
--- a/arch/loongarch/kernel/traps.c
+++ b/arch/loongarch/kernel/traps.c
@@ -10,6 +10,7 @@
 #include <linux/entry-common.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
+#include <linux/kexec.h>
 #include <linux/module.h>
 #include <linux/extable.h>
 #include <linux/mm.h>
@@ -246,6 +247,9 @@ void __noreturn die(const char *str, struct pt_regs *regs)
 
 	oops_exit();
 
+	if (regs && kexec_should_crash(current))
+		crash_kexec(regs);
+
 	if (in_interrupt())
 		panic("Fatal exception in interrupt");
 
-- 
2.36.0

Re: [PATCH 2/3] LoongArch: Add kdump support

[Huacai Chen]

Hi, Youling,

I think crash.c can be merged into crash_dump.c

Huacai

On Mon, Aug 29, 2022 at 12:37 PM Youling Tang <tangyouling@loongson.cn> wrote:
>
> This patch adds support for kdump, the kernel will reserve a region
> for the crash kernel and jump there on panic.
>
> Arch-specific functions are added to allow for implementing a crash
> dump file interface, /proc/vmcore, which can be viewed as a ELF file.
>
> A user space tool, like kexec-tools, is responsible for allocating a
> separate region for the core's ELF header within crash kdump kernel
> memory and filling it in when executing kexec_load().
>
> Then, its location will be advertised to crash dump kernel via a new
> device-tree property, "linux,elfcorehdr", and crash dump kernel preserves
> the region for later use with fdt_reserve_elfcorehdr() at boot time.
>
> At the same time, it will also limit the crash kdump kernel to the
> crashkernel area via a new device-tree property, "linux, usable-memory-range",
> so as not to destroy the original kernel dump data.
>
> On crash dump kernel, /proc/vmcore will access the primary kernel's memory
> with copy_oldmem_page().
>
> I tested this on  LoongArch 3A5000 machine and works as expected (Suggest
> crashkernel parameter is "crashkernel=512M@2320M"), you may test it by
> triggering a crash through /proc/sysrq_trigger:
>
>  $ sudo kexec -p /boot/vmlinux-kdump --reuse-cmdline --append="nr_cpus=1"
>  # echo c > /proc/sysrq_trigger
>
> Signed-off-by: Youling Tang <tangyouling@loongson.cn>
> ---
>  arch/loongarch/Kconfig                  |  22 ++++++
>  arch/loongarch/Makefile                 |   4 +
>  arch/loongarch/kernel/Makefile          |   3 +-
>  arch/loongarch/kernel/crash.c           | 100 ++++++++++++++++++++++++
>  arch/loongarch/kernel/crash_dump.c      |  19 +++++
>  arch/loongarch/kernel/machine_kexec.c   |  12 ++-
>  arch/loongarch/kernel/mem.c             |   6 ++
>  arch/loongarch/kernel/relocate_kernel.S |   6 ++
>  arch/loongarch/kernel/setup.c           |  49 ++++++++++++
>  arch/loongarch/kernel/traps.c           |   4 +
>  10 files changed, 217 insertions(+), 8 deletions(-)
>  create mode 100644 arch/loongarch/kernel/crash.c
>  create mode 100644 arch/loongarch/kernel/crash_dump.c
>
> diff --git a/arch/loongarch/Kconfig b/arch/loongarch/Kconfig
> index 903c82fa958d..7c1b07a5b5bd 100644
> --- a/arch/loongarch/Kconfig
> +++ b/arch/loongarch/Kconfig
> @@ -420,6 +420,28 @@ config KEXEC
>
>           The name comes from the similarity to the exec system call.
>
> +config CRASH_DUMP
> +       bool "Build kdump crash kernel"
> +       help
> +         Generate crash dump after being started by kexec. This should
> +         be normally only set in special crash dump kernels which are
> +         loaded in the main kernel with kexec-tools into a specially
> +         reserved region and then later executed after a crash by
> +         kdump/kexec.
> +
> +         For more details see Documentation/admin-guide/kdump/kdump.rst
> +
> +config PHYSICAL_START
> +       hex "Physical address where the kernel is loaded"
> +       default "0x9000000091000000" if 64BIT
> +       depends on CRASH_DUMP
> +       help
> +         This gives the XKPRANGE address where the kernel is loaded.
> +         If you plan to use kernel for capturing the crash dump change
> +         this value to start of the reserved region (the "X" value as
> +         specified in the "crashkernel=YM@XM" command line boot parameter
> +         passed to the panic-ed kernel).
> +
>  config SECCOMP
>         bool "Enable seccomp to safely compute untrusted bytecode"
>         depends on PROC_FS
> diff --git a/arch/loongarch/Makefile b/arch/loongarch/Makefile
> index 4bc47f47cfd8..7dabd580426d 100644
> --- a/arch/loongarch/Makefile
> +++ b/arch/loongarch/Makefile
> @@ -48,7 +48,11 @@ KBUILD_CFLAGS_MODULE         += -fplt -Wa,-mla-global-with-abs,-mla-local-with-abs
>  cflags-y += -ffreestanding
>  cflags-y += $(call cc-option, -mno-check-zero-division)
>
> +ifdef CONFIG_PHYSICAL_START
> +load-y         = $(CONFIG_PHYSICAL_START)
> +else
>  load-y         = 0x9000000000200000
> +endif
>  bootvars-y     = VMLINUX_LOAD_ADDRESS=$(load-y)
>
>  drivers-$(CONFIG_PCI)          += arch/loongarch/pci/
> diff --git a/arch/loongarch/kernel/Makefile b/arch/loongarch/kernel/Makefile
> index 20b64ac3f128..df5aea129364 100644
> --- a/arch/loongarch/kernel/Makefile
> +++ b/arch/loongarch/kernel/Makefile
> @@ -17,7 +17,8 @@ obj-$(CONFIG_CPU_HAS_FPU)     += fpu.o
>  obj-$(CONFIG_MODULES)          += module.o module-sections.o
>  obj-$(CONFIG_STACKTRACE)       += stacktrace.o
>
> -obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o
> +obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o crash.o
> +obj-$(CONFIG_CRASH_DUMP)        += crash_dump.o
>
>  obj-$(CONFIG_PROC_FS)          += proc.o
>
> diff --git a/arch/loongarch/kernel/crash.c b/arch/loongarch/kernel/crash.c
> new file mode 100644
> index 000000000000..b4f249ec6301
> --- /dev/null
> +++ b/arch/loongarch/kernel/crash.c
> @@ -0,0 +1,100 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (C) 2022 Loongson Technology Corporation Limited
> + *
> + * Derived from MIPS
> + */
> +#include <linux/kernel.h>
> +#include <linux/smp.h>
> +#include <linux/reboot.h>
> +#include <linux/crash_dump.h>
> +#include <linux/delay.h>
> +#include <linux/irq.h>
> +#include <linux/types.h>
> +#include <linux/sched.h>
> +#include <linux/sched/task_stack.h>
> +#include <asm/cacheflush.h>
> +#include <asm/kexec.h>
> +
> +static cpumask_t cpus_in_crash = CPU_MASK_NONE;
> +
> +#ifdef CONFIG_SMP
> +static void crash_shutdown_secondary(void *passed_regs)
> +{
> +       struct pt_regs *regs = passed_regs;
> +       int cpu = smp_processor_id();
> +
> +       /*
> +        * If we are passed registers, use those.  Otherwise get the
> +        * regs from the last interrupt, which should be correct, as
> +        * we are in an interrupt.  But if the regs are not there,
> +        * pull them from the top of the stack.  They are probably
> +        * wrong, but we need something to keep from crashing again.
> +        */
> +       if (!regs)
> +               regs = get_irq_regs();
> +       if (!regs)
> +               regs = task_pt_regs(current);
> +
> +       local_irq_disable();
> +       if (!cpumask_test_cpu(cpu, &cpus_in_crash))
> +               crash_save_cpu(regs, cpu);
> +       cpumask_set_cpu(cpu, &cpus_in_crash);
> +
> +       while (!atomic_read(&kexec_ready_to_reboot))
> +               cpu_relax();
> +
> +       kexec_reboot();
> +}
> +
> +/* Override the weak function in kernel/panic.c */
> +void crash_smp_send_stop(void)
> +{
> +       static int cpus_stopped;
> +       unsigned long timeout;
> +       unsigned int ncpus;
> +
> +       /*
> +        * This function can be called twice in panic path, but obviously
> +        * we execute this only once.
> +        */
> +       if (cpus_stopped)
> +               return;
> +
> +       cpus_stopped = 1;
> +
> +        /* Excluding the panic cpu */
> +       ncpus = num_online_cpus() - 1;
> +
> +       smp_call_function(crash_shutdown_secondary, NULL, 0);
> +       smp_wmb();
> +
> +       /*
> +        * The crash CPU sends an IPI and wait for other CPUs to
> +        * respond. Delay of at least 10 seconds.
> +        */
> +       pr_emerg("Sending IPI to other cpus...\n");
> +       timeout = USEC_PER_SEC * 10;
> +       while ((cpumask_weight(&cpus_in_crash) < ncpus) && timeout--) {
> +               cpu_relax();
> +               udelay(1);
> +       }
> +}
> +
> +#endif
> +
> +void machine_crash_shutdown(struct pt_regs *regs)
> +{
> +       int crashing_cpu;
> +
> +       local_irq_disable();
> +
> +       crashing_cpu = smp_processor_id();
> +       crash_save_cpu(regs, crashing_cpu);
> +
> +       /* shutdown non-crashing cpus */
> +       crash_smp_send_stop();
> +       cpumask_set_cpu(crashing_cpu, &cpus_in_crash);
> +
> +       pr_info("Starting crashdump kernel...\n");
> +}
> diff --git a/arch/loongarch/kernel/crash_dump.c b/arch/loongarch/kernel/crash_dump.c
> new file mode 100644
> index 000000000000..13e5d2f7870d
> --- /dev/null
> +++ b/arch/loongarch/kernel/crash_dump.c
> @@ -0,0 +1,19 @@
> +// SPDX-License-Identifier: GPL-2.0
> +#include <linux/highmem.h>
> +#include <linux/crash_dump.h>
> +#include <linux/io.h>
> +
> +ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn,
> +                        size_t csize, unsigned long offset)
> +{
> +       void  *vaddr;
> +
> +       if (!csize)
> +               return 0;
> +
> +       vaddr = kmap_local_pfn(pfn);
> +       csize = copy_to_iter(vaddr + offset, csize, iter);
> +       kunmap_local(vaddr);
> +
> +       return csize;
> +}
> diff --git a/arch/loongarch/kernel/machine_kexec.c b/arch/loongarch/kernel/machine_kexec.c
> index 4ffcd4cd9c8c..f793a3ff09a3 100644
> --- a/arch/loongarch/kernel/machine_kexec.c
> +++ b/arch/loongarch/kernel/machine_kexec.c
> @@ -69,7 +69,7 @@ int machine_kexec_prepare(struct kimage *kimage)
>                 continue;
>         }
>
> -       /* kexec need a safe page to save reboot_code_buffer */
> +       /* kexec/kdump need a safe page to save reboot_code_buffer */
>         kimage->control_code_page = virt_to_page((void *)KEXEC_CTRL_CODE);
>
>         reboot_code_buffer =
> @@ -113,10 +113,6 @@ static void kexec_shutdown_secondary(void *)
>
>         kexec_reboot();
>  }
> -
> -void machine_crash_shutdown(struct pt_regs *regs)
> -{
> -}
>  #endif
>
>  void machine_shutdown(void)
> @@ -135,7 +131,8 @@ void machine_kexec(struct kimage *image)
>
>         jump_addr = (unsigned long)phys_to_virt(image->start);
>
> -       first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
> +       if (image->type == KEXEC_TYPE_DEFAULT)
> +               first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
>
>         /*
>          * The generic kexec code builds a page list with physical
> @@ -167,7 +164,8 @@ void machine_kexec(struct kimage *image)
>
>         /*
>          * We know we were online, and there will be no incoming IPIs at
> -        * this point.
> +        * this point. Mark online again before rebooting so that the crash
> +        * analysis tool will see us correctly.
>          */
>         set_cpu_online(smp_processor_id(), true);
>
> diff --git a/arch/loongarch/kernel/mem.c b/arch/loongarch/kernel/mem.c
> index 7423361b0ebc..c6def6ff81c8 100644
> --- a/arch/loongarch/kernel/mem.c
> +++ b/arch/loongarch/kernel/mem.c
> @@ -5,6 +5,7 @@
>  #include <linux/efi.h>
>  #include <linux/initrd.h>
>  #include <linux/memblock.h>
> +#include <linux/of_fdt.h>
>
>  #include <asm/bootinfo.h>
>  #include <asm/loongson.h>
> @@ -61,4 +62,9 @@ void __init memblock_init(void)
>
>         /* Reserve the initrd */
>         reserve_initrd_mem();
> +
> +       /* Mainly reserved memory for the elf core head */
> +       early_init_fdt_scan_reserved_mem();
> +       /* Parse linux,usable-memory-range is for crash dump kernel */
> +       early_init_dt_check_for_usable_mem_range();
>  }
> diff --git a/arch/loongarch/kernel/relocate_kernel.S b/arch/loongarch/kernel/relocate_kernel.S
> index d1f242f74ea8..4ee5ac4ac2d7 100644
> --- a/arch/loongarch/kernel/relocate_kernel.S
> +++ b/arch/loongarch/kernel/relocate_kernel.S
> @@ -28,6 +28,12 @@ SYM_CODE_START(relocate_new_kernel)
>         move            s2, a2
>         move            s3, a3
>
> +       /*
> +        * In case of a kdump/crash kernel, the indirection page is not
> +        * populated as the kernel is directly copied to a reserved location
> +        */
> +       beqz            s2, done
> +
>  process_entry:
>         PTR_L           s4, s2, 0
>         PTR_ADDI        s2, s2, SZREG
> diff --git a/arch/loongarch/kernel/setup.c b/arch/loongarch/kernel/setup.c
> index f938aae3e92c..ea34b77e402f 100644
> --- a/arch/loongarch/kernel/setup.c
> +++ b/arch/loongarch/kernel/setup.c
> @@ -19,6 +19,8 @@
>  #include <linux/memblock.h>
>  #include <linux/initrd.h>
>  #include <linux/ioport.h>
> +#include <linux/kexec.h>
> +#include <linux/crash_dump.h>
>  #include <linux/root_dev.h>
>  #include <linux/console.h>
>  #include <linux/pfn.h>
> @@ -186,6 +188,50 @@ static int __init early_parse_mem(char *p)
>  }
>  early_param("mem", early_parse_mem);
>
> +static void __init loongarch_parse_crashkernel(void)
> +{
> +#ifdef CONFIG_KEXEC
> +       unsigned long long start;
> +       unsigned long long total_mem;
> +       unsigned long long crash_size, crash_base;
> +       int ret;
> +
> +       total_mem = memblock_phys_mem_size();
> +       ret = parse_crashkernel(boot_command_line, total_mem,
> +                               &crash_size, &crash_base);
> +       if (ret != 0 || crash_size <= 0)
> +               return;
> +
> +
> +       start = memblock_phys_alloc_range(crash_size, 1, crash_base,
> +                                       crash_base + crash_size);
> +       if (start != crash_base) {
> +               pr_warn("Invalid memory region reserved for crash kernel\n");
> +               return;
> +       }
> +
> +       crashk_res.start = crash_base;
> +       crashk_res.end   = crash_base + crash_size - 1;
> +#endif
> +}
> +
> +static void __init request_crashkernel(struct resource *res)
> +{
> +#ifdef CONFIG_KEXEC
> +       int ret;
> +
> +       if (crashk_res.start == crashk_res.end)
> +               return;
> +
> +       ret = request_resource(res, &crashk_res);
> +       if (!ret)
> +               pr_info("Reserving %ldMB of memory at %ldMB for crashkernel\n",
> +                       (unsigned long)((crashk_res.end -
> +                                        crashk_res.start + 1) >> 20),
> +                       (unsigned long)(crashk_res.start  >> 20));
> +#endif
> +}
> +
>  void __init platform_init(void)
>  {
>         efi_init();
> @@ -229,6 +275,8 @@ static void __init arch_mem_init(char **cmdline_p)
>
>         check_kernel_sections_mem();
>
> +       loongarch_parse_crashkernel();
> +
>         /*
>          * In order to reduce the possibility of kernel panic when failed to
>          * get IO TLB memory under CONFIG_SWIOTLB, it is better to allocate
> @@ -290,6 +338,7 @@ static void __init resource_init(void)
>                 request_resource(res, &code_resource);
>                 request_resource(res, &data_resource);
>                 request_resource(res, &bss_resource);
> +               request_crashkernel(res);
>         }
>  }
>
> diff --git a/arch/loongarch/kernel/traps.c b/arch/loongarch/kernel/traps.c
> index aa1c95aaf595..0e610872f3f4 100644
> --- a/arch/loongarch/kernel/traps.c
> +++ b/arch/loongarch/kernel/traps.c
> @@ -10,6 +10,7 @@
>  #include <linux/entry-common.h>
>  #include <linux/init.h>
>  #include <linux/kernel.h>
> +#include <linux/kexec.h>
>  #include <linux/module.h>
>  #include <linux/extable.h>
>  #include <linux/mm.h>
> @@ -246,6 +247,9 @@ void __noreturn die(const char *str, struct pt_regs *regs)
>
>         oops_exit();
>
> +       if (regs && kexec_should_crash(current))
> +               crash_kexec(regs);
> +
>         if (in_interrupt())
>                 panic("Fatal exception in interrupt");
>
> --
> 2.36.0
>

Re: [PATCH 2/3] LoongArch: Add kdump support

[Youling Tang]

Hi, Huacai

On 09/04/2022 08:21 PM, Huacai Chen wrote:
> Hi, Youling,
>
> I think crash.c can be merged into crash_dump.c

Most architectures only implement copy_oldmem_page() in crash_dump.c, 
I'm not sure if merging crash.c into crash_dump.c will break its 
consistency?

Thanks,
Youling

>
> Huacai
>
> On Mon, Aug 29, 2022 at 12:37 PM Youling Tang <tangyouling@loongson.cn> wrote:
>>
>> This patch adds support for kdump, the kernel will reserve a region
>> for the crash kernel and jump there on panic.
>>
>> Arch-specific functions are added to allow for implementing a crash
>> dump file interface, /proc/vmcore, which can be viewed as a ELF file.
>>
>> A user space tool, like kexec-tools, is responsible for allocating a
>> separate region for the core's ELF header within crash kdump kernel
>> memory and filling it in when executing kexec_load().
>>
>> Then, its location will be advertised to crash dump kernel via a new
>> device-tree property, "linux,elfcorehdr", and crash dump kernel preserves
>> the region for later use with fdt_reserve_elfcorehdr() at boot time.
>>
>> At the same time, it will also limit the crash kdump kernel to the
>> crashkernel area via a new device-tree property, "linux, usable-memory-range",
>> so as not to destroy the original kernel dump data.
>>
>> On crash dump kernel, /proc/vmcore will access the primary kernel's memory
>> with copy_oldmem_page().
>>
>> I tested this on  LoongArch 3A5000 machine and works as expected (Suggest
>> crashkernel parameter is "crashkernel=512M@2320M"), you may test it by
>> triggering a crash through /proc/sysrq_trigger:
>>
>>  $ sudo kexec -p /boot/vmlinux-kdump --reuse-cmdline --append="nr_cpus=1"
>>  # echo c > /proc/sysrq_trigger
>>
>> Signed-off-by: Youling Tang <tangyouling@loongson.cn>
>> ---
>>  arch/loongarch/Kconfig                  |  22 ++++++
>>  arch/loongarch/Makefile                 |   4 +
>>  arch/loongarch/kernel/Makefile          |   3 +-
>>  arch/loongarch/kernel/crash.c           | 100 ++++++++++++++++++++++++
>>  arch/loongarch/kernel/crash_dump.c      |  19 +++++
>>  arch/loongarch/kernel/machine_kexec.c   |  12 ++-
>>  arch/loongarch/kernel/mem.c             |   6 ++
>>  arch/loongarch/kernel/relocate_kernel.S |   6 ++
>>  arch/loongarch/kernel/setup.c           |  49 ++++++++++++
>>  arch/loongarch/kernel/traps.c           |   4 +
>>  10 files changed, 217 insertions(+), 8 deletions(-)
>>  create mode 100644 arch/loongarch/kernel/crash.c
>>  create mode 100644 arch/loongarch/kernel/crash_dump.c
>>
>> diff --git a/arch/loongarch/Kconfig b/arch/loongarch/Kconfig
>> index 903c82fa958d..7c1b07a5b5bd 100644
>> --- a/arch/loongarch/Kconfig
>> +++ b/arch/loongarch/Kconfig
>> @@ -420,6 +420,28 @@ config KEXEC
>>
>>           The name comes from the similarity to the exec system call.
>>
>> +config CRASH_DUMP
>> +       bool "Build kdump crash kernel"
>> +       help
>> +         Generate crash dump after being started by kexec. This should
>> +         be normally only set in special crash dump kernels which are
>> +         loaded in the main kernel with kexec-tools into a specially
>> +         reserved region and then later executed after a crash by
>> +         kdump/kexec.
>> +
>> +         For more details see Documentation/admin-guide/kdump/kdump.rst
>> +
>> +config PHYSICAL_START
>> +       hex "Physical address where the kernel is loaded"
>> +       default "0x9000000091000000" if 64BIT
>> +       depends on CRASH_DUMP
>> +       help
>> +         This gives the XKPRANGE address where the kernel is loaded.
>> +         If you plan to use kernel for capturing the crash dump change
>> +         this value to start of the reserved region (the "X" value as
>> +         specified in the "crashkernel=YM@XM" command line boot parameter
>> +         passed to the panic-ed kernel).
>> +
>>  config SECCOMP
>>         bool "Enable seccomp to safely compute untrusted bytecode"
>>         depends on PROC_FS
>> diff --git a/arch/loongarch/Makefile b/arch/loongarch/Makefile
>> index 4bc47f47cfd8..7dabd580426d 100644
>> --- a/arch/loongarch/Makefile
>> +++ b/arch/loongarch/Makefile
>> @@ -48,7 +48,11 @@ KBUILD_CFLAGS_MODULE         += -fplt -Wa,-mla-global-with-abs,-mla-local-with-abs
>>  cflags-y += -ffreestanding
>>  cflags-y += $(call cc-option, -mno-check-zero-division)
>>
>> +ifdef CONFIG_PHYSICAL_START
>> +load-y         = $(CONFIG_PHYSICAL_START)
>> +else
>>  load-y         = 0x9000000000200000
>> +endif
>>  bootvars-y     = VMLINUX_LOAD_ADDRESS=$(load-y)
>>
>>  drivers-$(CONFIG_PCI)          += arch/loongarch/pci/
>> diff --git a/arch/loongarch/kernel/Makefile b/arch/loongarch/kernel/Makefile
>> index 20b64ac3f128..df5aea129364 100644
>> --- a/arch/loongarch/kernel/Makefile
>> +++ b/arch/loongarch/kernel/Makefile
>> @@ -17,7 +17,8 @@ obj-$(CONFIG_CPU_HAS_FPU)     += fpu.o
>>  obj-$(CONFIG_MODULES)          += module.o module-sections.o
>>  obj-$(CONFIG_STACKTRACE)       += stacktrace.o
>>
>> -obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o
>> +obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o crash.o
>> +obj-$(CONFIG_CRASH_DUMP)        += crash_dump.o
>>
>>  obj-$(CONFIG_PROC_FS)          += proc.o
>>
>> diff --git a/arch/loongarch/kernel/crash.c b/arch/loongarch/kernel/crash.c
>> new file mode 100644
>> index 000000000000..b4f249ec6301
>> --- /dev/null
>> +++ b/arch/loongarch/kernel/crash.c
>> @@ -0,0 +1,100 @@
>> +// SPDX-License-Identifier: GPL-2.0
>> +/*
>> + * Copyright (C) 2022 Loongson Technology Corporation Limited
>> + *
>> + * Derived from MIPS
>> + */
>> +#include <linux/kernel.h>
>> +#include <linux/smp.h>
>> +#include <linux/reboot.h>
>> +#include <linux/crash_dump.h>
>> +#include <linux/delay.h>
>> +#include <linux/irq.h>
>> +#include <linux/types.h>
>> +#include <linux/sched.h>
>> +#include <linux/sched/task_stack.h>
>> +#include <asm/cacheflush.h>
>> +#include <asm/kexec.h>
>> +
>> +static cpumask_t cpus_in_crash = CPU_MASK_NONE;
>> +
>> +#ifdef CONFIG_SMP
>> +static void crash_shutdown_secondary(void *passed_regs)
>> +{
>> +       struct pt_regs *regs = passed_regs;
>> +       int cpu = smp_processor_id();
>> +
>> +       /*
>> +        * If we are passed registers, use those.  Otherwise get the
>> +        * regs from the last interrupt, which should be correct, as
>> +        * we are in an interrupt.  But if the regs are not there,
>> +        * pull them from the top of the stack.  They are probably
>> +        * wrong, but we need something to keep from crashing again.
>> +        */
>> +       if (!regs)
>> +               regs = get_irq_regs();
>> +       if (!regs)
>> +               regs = task_pt_regs(current);
>> +
>> +       local_irq_disable();
>> +       if (!cpumask_test_cpu(cpu, &cpus_in_crash))
>> +               crash_save_cpu(regs, cpu);
>> +       cpumask_set_cpu(cpu, &cpus_in_crash);
>> +
>> +       while (!atomic_read(&kexec_ready_to_reboot))
>> +               cpu_relax();
>> +
>> +       kexec_reboot();
>> +}
>> +
>> +/* Override the weak function in kernel/panic.c */
>> +void crash_smp_send_stop(void)
>> +{
>> +       static int cpus_stopped;
>> +       unsigned long timeout;
>> +       unsigned int ncpus;
>> +
>> +       /*
>> +        * This function can be called twice in panic path, but obviously
>> +        * we execute this only once.
>> +        */
>> +       if (cpus_stopped)
>> +               return;
>> +
>> +       cpus_stopped = 1;
>> +
>> +        /* Excluding the panic cpu */
>> +       ncpus = num_online_cpus() - 1;
>> +
>> +       smp_call_function(crash_shutdown_secondary, NULL, 0);
>> +       smp_wmb();
>> +
>> +       /*
>> +        * The crash CPU sends an IPI and wait for other CPUs to
>> +        * respond. Delay of at least 10 seconds.
>> +        */
>> +       pr_emerg("Sending IPI to other cpus...\n");
>> +       timeout = USEC_PER_SEC * 10;
>> +       while ((cpumask_weight(&cpus_in_crash) < ncpus) && timeout--) {
>> +               cpu_relax();
>> +               udelay(1);
>> +       }
>> +}
>> +
>> +#endif
>> +
>> +void machine_crash_shutdown(struct pt_regs *regs)
>> +{
>> +       int crashing_cpu;
>> +
>> +       local_irq_disable();
>> +
>> +       crashing_cpu = smp_processor_id();
>> +       crash_save_cpu(regs, crashing_cpu);
>> +
>> +       /* shutdown non-crashing cpus */
>> +       crash_smp_send_stop();
>> +       cpumask_set_cpu(crashing_cpu, &cpus_in_crash);
>> +
>> +       pr_info("Starting crashdump kernel...\n");
>> +}
>> diff --git a/arch/loongarch/kernel/crash_dump.c b/arch/loongarch/kernel/crash_dump.c
>> new file mode 100644
>> index 000000000000..13e5d2f7870d
>> --- /dev/null
>> +++ b/arch/loongarch/kernel/crash_dump.c
>> @@ -0,0 +1,19 @@
>> +// SPDX-License-Identifier: GPL-2.0
>> +#include <linux/highmem.h>
>> +#include <linux/crash_dump.h>
>> +#include <linux/io.h>
>> +
>> +ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn,
>> +                        size_t csize, unsigned long offset)
>> +{
>> +       void  *vaddr;
>> +
>> +       if (!csize)
>> +               return 0;
>> +
>> +       vaddr = kmap_local_pfn(pfn);
>> +       csize = copy_to_iter(vaddr + offset, csize, iter);
>> +       kunmap_local(vaddr);
>> +
>> +       return csize;
>> +}
>> diff --git a/arch/loongarch/kernel/machine_kexec.c b/arch/loongarch/kernel/machine_kexec.c
>> index 4ffcd4cd9c8c..f793a3ff09a3 100644
>> --- a/arch/loongarch/kernel/machine_kexec.c
>> +++ b/arch/loongarch/kernel/machine_kexec.c
>> @@ -69,7 +69,7 @@ int machine_kexec_prepare(struct kimage *kimage)
>>                 continue;
>>         }
>>
>> -       /* kexec need a safe page to save reboot_code_buffer */
>> +       /* kexec/kdump need a safe page to save reboot_code_buffer */
>>         kimage->control_code_page = virt_to_page((void *)KEXEC_CTRL_CODE);
>>
>>         reboot_code_buffer =
>> @@ -113,10 +113,6 @@ static void kexec_shutdown_secondary(void *)
>>
>>         kexec_reboot();
>>  }
>> -
>> -void machine_crash_shutdown(struct pt_regs *regs)
>> -{
>> -}
>>  #endif
>>
>>  void machine_shutdown(void)
>> @@ -135,7 +131,8 @@ void machine_kexec(struct kimage *image)
>>
>>         jump_addr = (unsigned long)phys_to_virt(image->start);
>>
>> -       first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
>> +       if (image->type == KEXEC_TYPE_DEFAULT)
>> +               first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
>>
>>         /*
>>          * The generic kexec code builds a page list with physical
>> @@ -167,7 +164,8 @@ void machine_kexec(struct kimage *image)
>>
>>         /*
>>          * We know we were online, and there will be no incoming IPIs at
>> -        * this point.
>> +        * this point. Mark online again before rebooting so that the crash
>> +        * analysis tool will see us correctly.
>>          */
>>         set_cpu_online(smp_processor_id(), true);
>>
>> diff --git a/arch/loongarch/kernel/mem.c b/arch/loongarch/kernel/mem.c
>> index 7423361b0ebc..c6def6ff81c8 100644
>> --- a/arch/loongarch/kernel/mem.c
>> +++ b/arch/loongarch/kernel/mem.c
>> @@ -5,6 +5,7 @@
>>  #include <linux/efi.h>
>>  #include <linux/initrd.h>
>>  #include <linux/memblock.h>
>> +#include <linux/of_fdt.h>
>>
>>  #include <asm/bootinfo.h>
>>  #include <asm/loongson.h>
>> @@ -61,4 +62,9 @@ void __init memblock_init(void)
>>
>>         /* Reserve the initrd */
>>         reserve_initrd_mem();
>> +
>> +       /* Mainly reserved memory for the elf core head */
>> +       early_init_fdt_scan_reserved_mem();
>> +       /* Parse linux,usable-memory-range is for crash dump kernel */
>> +       early_init_dt_check_for_usable_mem_range();
>>  }
>> diff --git a/arch/loongarch/kernel/relocate_kernel.S b/arch/loongarch/kernel/relocate_kernel.S
>> index d1f242f74ea8..4ee5ac4ac2d7 100644
>> --- a/arch/loongarch/kernel/relocate_kernel.S
>> +++ b/arch/loongarch/kernel/relocate_kernel.S
>> @@ -28,6 +28,12 @@ SYM_CODE_START(relocate_new_kernel)
>>         move            s2, a2
>>         move            s3, a3
>>
>> +       /*
>> +        * In case of a kdump/crash kernel, the indirection page is not
>> +        * populated as the kernel is directly copied to a reserved location
>> +        */
>> +       beqz            s2, done
>> +
>>  process_entry:
>>         PTR_L           s4, s2, 0
>>         PTR_ADDI        s2, s2, SZREG
>> diff --git a/arch/loongarch/kernel/setup.c b/arch/loongarch/kernel/setup.c
>> index f938aae3e92c..ea34b77e402f 100644
>> --- a/arch/loongarch/kernel/setup.c
>> +++ b/arch/loongarch/kernel/setup.c
>> @@ -19,6 +19,8 @@
>>  #include <linux/memblock.h>
>>  #include <linux/initrd.h>
>>  #include <linux/ioport.h>
>> +#include <linux/kexec.h>
>> +#include <linux/crash_dump.h>
>>  #include <linux/root_dev.h>
>>  #include <linux/console.h>
>>  #include <linux/pfn.h>
>> @@ -186,6 +188,50 @@ static int __init early_parse_mem(char *p)
>>  }
>>  early_param("mem", early_parse_mem);
>>
>> +static void __init loongarch_parse_crashkernel(void)
>> +{
>> +#ifdef CONFIG_KEXEC
>> +       unsigned long long start;
>> +       unsigned long long total_mem;
>> +       unsigned long long crash_size, crash_base;
>> +       int ret;
>> +
>> +       total_mem = memblock_phys_mem_size();
>> +       ret = parse_crashkernel(boot_command_line, total_mem,
>> +                               &crash_size, &crash_base);
>> +       if (ret != 0 || crash_size <= 0)
>> +               return;
>> +
>> +
>> +       start = memblock_phys_alloc_range(crash_size, 1, crash_base,
>> +                                       crash_base + crash_size);
>> +       if (start != crash_base) {
>> +               pr_warn("Invalid memory region reserved for crash kernel\n");
>> +               return;
>> +       }
>> +
>> +       crashk_res.start = crash_base;
>> +       crashk_res.end   = crash_base + crash_size - 1;
>> +#endif
>> +}
>> +
>> +static void __init request_crashkernel(struct resource *res)
>> +{
>> +#ifdef CONFIG_KEXEC
>> +       int ret;
>> +
>> +       if (crashk_res.start == crashk_res.end)
>> +               return;
>> +
>> +       ret = request_resource(res, &crashk_res);
>> +       if (!ret)
>> +               pr_info("Reserving %ldMB of memory at %ldMB for crashkernel\n",
>> +                       (unsigned long)((crashk_res.end -
>> +                                        crashk_res.start + 1) >> 20),
>> +                       (unsigned long)(crashk_res.start  >> 20));
>> +#endif
>> +}
>> +
>>  void __init platform_init(void)
>>  {
>>         efi_init();
>> @@ -229,6 +275,8 @@ static void __init arch_mem_init(char **cmdline_p)
>>
>>         check_kernel_sections_mem();
>>
>> +       loongarch_parse_crashkernel();
>> +
>>         /*
>>          * In order to reduce the possibility of kernel panic when failed to
>>          * get IO TLB memory under CONFIG_SWIOTLB, it is better to allocate
>> @@ -290,6 +338,7 @@ static void __init resource_init(void)
>>                 request_resource(res, &code_resource);
>>                 request_resource(res, &data_resource);
>>                 request_resource(res, &bss_resource);
>> +               request_crashkernel(res);
>>         }
>>  }
>>
>> diff --git a/arch/loongarch/kernel/traps.c b/arch/loongarch/kernel/traps.c
>> index aa1c95aaf595..0e610872f3f4 100644
>> --- a/arch/loongarch/kernel/traps.c
>> +++ b/arch/loongarch/kernel/traps.c
>> @@ -10,6 +10,7 @@
>>  #include <linux/entry-common.h>
>>  #include <linux/init.h>
>>  #include <linux/kernel.h>
>> +#include <linux/kexec.h>
>>  #include <linux/module.h>
>>  #include <linux/extable.h>
>>  #include <linux/mm.h>
>> @@ -246,6 +247,9 @@ void __noreturn die(const char *str, struct pt_regs *regs)
>>
>>         oops_exit();
>>
>> +       if (regs && kexec_should_crash(current))
>> +               crash_kexec(regs);
>> +
>>         if (in_interrupt())
>>                 panic("Fatal exception in interrupt");
>>
>> --
>> 2.36.0
>>

Re: [PATCH 2/3] LoongArch: Add kdump support

[Huacai Chen]

Hi, Youling,

On Mon, Sep 5, 2022 at 8:54 AM Youling Tang <tangyouling@loongson.cn> wrote:
>
> Hi, Huacai
>
> On 09/04/2022 08:21 PM, Huacai Chen wrote:
> > Hi, Youling,
> >
> > I think crash.c can be merged into crash_dump.c
>
> Most architectures only implement copy_oldmem_page() in crash_dump.c,
> I'm not sure if merging crash.c into crash_dump.c will break its
> consistency?
>
> Thanks,
> Youling
Yes, you are right, crash.c cannot be merged into crash_dump.c, but it
can be merged into machine_kexec.c, as arm64 and riscv do.

Huacai
>
> >
> > Huacai
> >
> > On Mon, Aug 29, 2022 at 12:37 PM Youling Tang <tangyouling@loongson.cn> wrote:
> >>
> >> This patch adds support for kdump, the kernel will reserve a region
> >> for the crash kernel and jump there on panic.
> >>
> >> Arch-specific functions are added to allow for implementing a crash
> >> dump file interface, /proc/vmcore, which can be viewed as a ELF file.
> >>
> >> A user space tool, like kexec-tools, is responsible for allocating a
> >> separate region for the core's ELF header within crash kdump kernel
> >> memory and filling it in when executing kexec_load().
> >>
> >> Then, its location will be advertised to crash dump kernel via a new
> >> device-tree property, "linux,elfcorehdr", and crash dump kernel preserves
> >> the region for later use with fdt_reserve_elfcorehdr() at boot time.
> >>
> >> At the same time, it will also limit the crash kdump kernel to the
> >> crashkernel area via a new device-tree property, "linux, usable-memory-range",
> >> so as not to destroy the original kernel dump data.
> >>
> >> On crash dump kernel, /proc/vmcore will access the primary kernel's memory
> >> with copy_oldmem_page().
> >>
> >> I tested this on  LoongArch 3A5000 machine and works as expected (Suggest
> >> crashkernel parameter is "crashkernel=512M@2320M"), you may test it by
> >> triggering a crash through /proc/sysrq_trigger:
> >>
> >>  $ sudo kexec -p /boot/vmlinux-kdump --reuse-cmdline --append="nr_cpus=1"
> >>  # echo c > /proc/sysrq_trigger
> >>
> >> Signed-off-by: Youling Tang <tangyouling@loongson.cn>
> >> ---
> >>  arch/loongarch/Kconfig                  |  22 ++++++
> >>  arch/loongarch/Makefile                 |   4 +
> >>  arch/loongarch/kernel/Makefile          |   3 +-
> >>  arch/loongarch/kernel/crash.c           | 100 ++++++++++++++++++++++++
> >>  arch/loongarch/kernel/crash_dump.c      |  19 +++++
> >>  arch/loongarch/kernel/machine_kexec.c   |  12 ++-
> >>  arch/loongarch/kernel/mem.c             |   6 ++
> >>  arch/loongarch/kernel/relocate_kernel.S |   6 ++
> >>  arch/loongarch/kernel/setup.c           |  49 ++++++++++++
> >>  arch/loongarch/kernel/traps.c           |   4 +
> >>  10 files changed, 217 insertions(+), 8 deletions(-)
> >>  create mode 100644 arch/loongarch/kernel/crash.c
> >>  create mode 100644 arch/loongarch/kernel/crash_dump.c
> >>
> >> diff --git a/arch/loongarch/Kconfig b/arch/loongarch/Kconfig
> >> index 903c82fa958d..7c1b07a5b5bd 100644
> >> --- a/arch/loongarch/Kconfig
> >> +++ b/arch/loongarch/Kconfig
> >> @@ -420,6 +420,28 @@ config KEXEC
> >>
> >>           The name comes from the similarity to the exec system call.
> >>
> >> +config CRASH_DUMP
> >> +       bool "Build kdump crash kernel"
> >> +       help
> >> +         Generate crash dump after being started by kexec. This should
> >> +         be normally only set in special crash dump kernels which are
> >> +         loaded in the main kernel with kexec-tools into a specially
> >> +         reserved region and then later executed after a crash by
> >> +         kdump/kexec.
> >> +
> >> +         For more details see Documentation/admin-guide/kdump/kdump.rst
> >> +
> >> +config PHYSICAL_START
> >> +       hex "Physical address where the kernel is loaded"
> >> +       default "0x9000000091000000" if 64BIT
> >> +       depends on CRASH_DUMP
> >> +       help
> >> +         This gives the XKPRANGE address where the kernel is loaded.
> >> +         If you plan to use kernel for capturing the crash dump change
> >> +         this value to start of the reserved region (the "X" value as
> >> +         specified in the "crashkernel=YM@XM" command line boot parameter
> >> +         passed to the panic-ed kernel).
> >> +
> >>  config SECCOMP
> >>         bool "Enable seccomp to safely compute untrusted bytecode"
> >>         depends on PROC_FS
> >> diff --git a/arch/loongarch/Makefile b/arch/loongarch/Makefile
> >> index 4bc47f47cfd8..7dabd580426d 100644
> >> --- a/arch/loongarch/Makefile
> >> +++ b/arch/loongarch/Makefile
> >> @@ -48,7 +48,11 @@ KBUILD_CFLAGS_MODULE         += -fplt -Wa,-mla-global-with-abs,-mla-local-with-abs
> >>  cflags-y += -ffreestanding
> >>  cflags-y += $(call cc-option, -mno-check-zero-division)
> >>
> >> +ifdef CONFIG_PHYSICAL_START
> >> +load-y         = $(CONFIG_PHYSICAL_START)
> >> +else
> >>  load-y         = 0x9000000000200000
> >> +endif
> >>  bootvars-y     = VMLINUX_LOAD_ADDRESS=$(load-y)
> >>
> >>  drivers-$(CONFIG_PCI)          += arch/loongarch/pci/
> >> diff --git a/arch/loongarch/kernel/Makefile b/arch/loongarch/kernel/Makefile
> >> index 20b64ac3f128..df5aea129364 100644
> >> --- a/arch/loongarch/kernel/Makefile
> >> +++ b/arch/loongarch/kernel/Makefile
> >> @@ -17,7 +17,8 @@ obj-$(CONFIG_CPU_HAS_FPU)     += fpu.o
> >>  obj-$(CONFIG_MODULES)          += module.o module-sections.o
> >>  obj-$(CONFIG_STACKTRACE)       += stacktrace.o
> >>
> >> -obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o
> >> +obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o crash.o
> >> +obj-$(CONFIG_CRASH_DUMP)        += crash_dump.o
> >>
> >>  obj-$(CONFIG_PROC_FS)          += proc.o
> >>
> >> diff --git a/arch/loongarch/kernel/crash.c b/arch/loongarch/kernel/crash.c
> >> new file mode 100644
> >> index 000000000000..b4f249ec6301
> >> --- /dev/null
> >> +++ b/arch/loongarch/kernel/crash.c
> >> @@ -0,0 +1,100 @@
> >> +// SPDX-License-Identifier: GPL-2.0
> >> +/*
> >> + * Copyright (C) 2022 Loongson Technology Corporation Limited
> >> + *
> >> + * Derived from MIPS
> >> + */
> >> +#include <linux/kernel.h>
> >> +#include <linux/smp.h>
> >> +#include <linux/reboot.h>
> >> +#include <linux/crash_dump.h>
> >> +#include <linux/delay.h>
> >> +#include <linux/irq.h>
> >> +#include <linux/types.h>
> >> +#include <linux/sched.h>
> >> +#include <linux/sched/task_stack.h>
> >> +#include <asm/cacheflush.h>
> >> +#include <asm/kexec.h>
> >> +
> >> +static cpumask_t cpus_in_crash = CPU_MASK_NONE;
> >> +
> >> +#ifdef CONFIG_SMP
> >> +static void crash_shutdown_secondary(void *passed_regs)
> >> +{
> >> +       struct pt_regs *regs = passed_regs;
> >> +       int cpu = smp_processor_id();
> >> +
> >> +       /*
> >> +        * If we are passed registers, use those.  Otherwise get the
> >> +        * regs from the last interrupt, which should be correct, as
> >> +        * we are in an interrupt.  But if the regs are not there,
> >> +        * pull them from the top of the stack.  They are probably
> >> +        * wrong, but we need something to keep from crashing again.
> >> +        */
> >> +       if (!regs)
> >> +               regs = get_irq_regs();
> >> +       if (!regs)
> >> +               regs = task_pt_regs(current);
> >> +
> >> +       local_irq_disable();
> >> +       if (!cpumask_test_cpu(cpu, &cpus_in_crash))
> >> +               crash_save_cpu(regs, cpu);
> >> +       cpumask_set_cpu(cpu, &cpus_in_crash);
> >> +
> >> +       while (!atomic_read(&kexec_ready_to_reboot))
> >> +               cpu_relax();
> >> +
> >> +       kexec_reboot();
> >> +}
> >> +
> >> +/* Override the weak function in kernel/panic.c */
> >> +void crash_smp_send_stop(void)
> >> +{
> >> +       static int cpus_stopped;
> >> +       unsigned long timeout;
> >> +       unsigned int ncpus;
> >> +
> >> +       /*
> >> +        * This function can be called twice in panic path, but obviously
> >> +        * we execute this only once.
> >> +        */
> >> +       if (cpus_stopped)
> >> +               return;
> >> +
> >> +       cpus_stopped = 1;
> >> +
> >> +        /* Excluding the panic cpu */
> >> +       ncpus = num_online_cpus() - 1;
> >> +
> >> +       smp_call_function(crash_shutdown_secondary, NULL, 0);
> >> +       smp_wmb();
> >> +
> >> +       /*
> >> +        * The crash CPU sends an IPI and wait for other CPUs to
> >> +        * respond. Delay of at least 10 seconds.
> >> +        */
> >> +       pr_emerg("Sending IPI to other cpus...\n");
> >> +       timeout = USEC_PER_SEC * 10;
> >> +       while ((cpumask_weight(&cpus_in_crash) < ncpus) && timeout--) {
> >> +               cpu_relax();
> >> +               udelay(1);
> >> +       }
> >> +}
> >> +
> >> +#endif
> >> +
> >> +void machine_crash_shutdown(struct pt_regs *regs)
> >> +{
> >> +       int crashing_cpu;
> >> +
> >> +       local_irq_disable();
> >> +
> >> +       crashing_cpu = smp_processor_id();
> >> +       crash_save_cpu(regs, crashing_cpu);
> >> +
> >> +       /* shutdown non-crashing cpus */
> >> +       crash_smp_send_stop();
> >> +       cpumask_set_cpu(crashing_cpu, &cpus_in_crash);
> >> +
> >> +       pr_info("Starting crashdump kernel...\n");
> >> +}
> >> diff --git a/arch/loongarch/kernel/crash_dump.c b/arch/loongarch/kernel/crash_dump.c
> >> new file mode 100644
> >> index 000000000000..13e5d2f7870d
> >> --- /dev/null
> >> +++ b/arch/loongarch/kernel/crash_dump.c
> >> @@ -0,0 +1,19 @@
> >> +// SPDX-License-Identifier: GPL-2.0
> >> +#include <linux/highmem.h>
> >> +#include <linux/crash_dump.h>
> >> +#include <linux/io.h>
> >> +
> >> +ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn,
> >> +                        size_t csize, unsigned long offset)
> >> +{
> >> +       void  *vaddr;
> >> +
> >> +       if (!csize)
> >> +               return 0;
> >> +
> >> +       vaddr = kmap_local_pfn(pfn);
> >> +       csize = copy_to_iter(vaddr + offset, csize, iter);
> >> +       kunmap_local(vaddr);
> >> +
> >> +       return csize;
> >> +}
> >> diff --git a/arch/loongarch/kernel/machine_kexec.c b/arch/loongarch/kernel/machine_kexec.c
> >> index 4ffcd4cd9c8c..f793a3ff09a3 100644
> >> --- a/arch/loongarch/kernel/machine_kexec.c
> >> +++ b/arch/loongarch/kernel/machine_kexec.c
> >> @@ -69,7 +69,7 @@ int machine_kexec_prepare(struct kimage *kimage)
> >>                 continue;
> >>         }
> >>
> >> -       /* kexec need a safe page to save reboot_code_buffer */
> >> +       /* kexec/kdump need a safe page to save reboot_code_buffer */
> >>         kimage->control_code_page = virt_to_page((void *)KEXEC_CTRL_CODE);
> >>
> >>         reboot_code_buffer =
> >> @@ -113,10 +113,6 @@ static void kexec_shutdown_secondary(void *)
> >>
> >>         kexec_reboot();
> >>  }
> >> -
> >> -void machine_crash_shutdown(struct pt_regs *regs)
> >> -{
> >> -}
> >>  #endif
> >>
> >>  void machine_shutdown(void)
> >> @@ -135,7 +131,8 @@ void machine_kexec(struct kimage *image)
> >>
> >>         jump_addr = (unsigned long)phys_to_virt(image->start);
> >>
> >> -       first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
> >> +       if (image->type == KEXEC_TYPE_DEFAULT)
> >> +               first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
> >>
> >>         /*
> >>          * The generic kexec code builds a page list with physical
> >> @@ -167,7 +164,8 @@ void machine_kexec(struct kimage *image)
> >>
> >>         /*
> >>          * We know we were online, and there will be no incoming IPIs at
> >> -        * this point.
> >> +        * this point. Mark online again before rebooting so that the crash
> >> +        * analysis tool will see us correctly.
> >>          */
> >>         set_cpu_online(smp_processor_id(), true);
> >>
> >> diff --git a/arch/loongarch/kernel/mem.c b/arch/loongarch/kernel/mem.c
> >> index 7423361b0ebc..c6def6ff81c8 100644
> >> --- a/arch/loongarch/kernel/mem.c
> >> +++ b/arch/loongarch/kernel/mem.c
> >> @@ -5,6 +5,7 @@
> >>  #include <linux/efi.h>
> >>  #include <linux/initrd.h>
> >>  #include <linux/memblock.h>
> >> +#include <linux/of_fdt.h>
> >>
> >>  #include <asm/bootinfo.h>
> >>  #include <asm/loongson.h>
> >> @@ -61,4 +62,9 @@ void __init memblock_init(void)
> >>
> >>         /* Reserve the initrd */
> >>         reserve_initrd_mem();
> >> +
> >> +       /* Mainly reserved memory for the elf core head */
> >> +       early_init_fdt_scan_reserved_mem();
> >> +       /* Parse linux,usable-memory-range is for crash dump kernel */
> >> +       early_init_dt_check_for_usable_mem_range();
> >>  }
> >> diff --git a/arch/loongarch/kernel/relocate_kernel.S b/arch/loongarch/kernel/relocate_kernel.S
> >> index d1f242f74ea8..4ee5ac4ac2d7 100644
> >> --- a/arch/loongarch/kernel/relocate_kernel.S
> >> +++ b/arch/loongarch/kernel/relocate_kernel.S
> >> @@ -28,6 +28,12 @@ SYM_CODE_START(relocate_new_kernel)
> >>         move            s2, a2
> >>         move            s3, a3
> >>
> >> +       /*
> >> +        * In case of a kdump/crash kernel, the indirection page is not
> >> +        * populated as the kernel is directly copied to a reserved location
> >> +        */
> >> +       beqz            s2, done
> >> +
> >>  process_entry:
> >>         PTR_L           s4, s2, 0
> >>         PTR_ADDI        s2, s2, SZREG
> >> diff --git a/arch/loongarch/kernel/setup.c b/arch/loongarch/kernel/setup.c
> >> index f938aae3e92c..ea34b77e402f 100644
> >> --- a/arch/loongarch/kernel/setup.c
> >> +++ b/arch/loongarch/kernel/setup.c
> >> @@ -19,6 +19,8 @@
> >>  #include <linux/memblock.h>
> >>  #include <linux/initrd.h>
> >>  #include <linux/ioport.h>
> >> +#include <linux/kexec.h>
> >> +#include <linux/crash_dump.h>
> >>  #include <linux/root_dev.h>
> >>  #include <linux/console.h>
> >>  #include <linux/pfn.h>
> >> @@ -186,6 +188,50 @@ static int __init early_parse_mem(char *p)
> >>  }
> >>  early_param("mem", early_parse_mem);
> >>
> >> +static void __init loongarch_parse_crashkernel(void)
> >> +{
> >> +#ifdef CONFIG_KEXEC
> >> +       unsigned long long start;
> >> +       unsigned long long total_mem;
> >> +       unsigned long long crash_size, crash_base;
> >> +       int ret;
> >> +
> >> +       total_mem = memblock_phys_mem_size();
> >> +       ret = parse_crashkernel(boot_command_line, total_mem,
> >> +                               &crash_size, &crash_base);
> >> +       if (ret != 0 || crash_size <= 0)
> >> +               return;
> >> +
> >> +
> >> +       start = memblock_phys_alloc_range(crash_size, 1, crash_base,
> >> +                                       crash_base + crash_size);
> >> +       if (start != crash_base) {
> >> +               pr_warn("Invalid memory region reserved for crash kernel\n");
> >> +               return;
> >> +       }
> >> +
> >> +       crashk_res.start = crash_base;
> >> +       crashk_res.end   = crash_base + crash_size - 1;
> >> +#endif
> >> +}
> >> +
> >> +static void __init request_crashkernel(struct resource *res)
> >> +{
> >> +#ifdef CONFIG_KEXEC
> >> +       int ret;
> >> +
> >> +       if (crashk_res.start == crashk_res.end)
> >> +               return;
> >> +
> >> +       ret = request_resource(res, &crashk_res);
> >> +       if (!ret)
> >> +               pr_info("Reserving %ldMB of memory at %ldMB for crashkernel\n",
> >> +                       (unsigned long)((crashk_res.end -
> >> +                                        crashk_res.start + 1) >> 20),
> >> +                       (unsigned long)(crashk_res.start  >> 20));
> >> +#endif
> >> +}
> >> +
> >>  void __init platform_init(void)
> >>  {
> >>         efi_init();
> >> @@ -229,6 +275,8 @@ static void __init arch_mem_init(char **cmdline_p)
> >>
> >>         check_kernel_sections_mem();
> >>
> >> +       loongarch_parse_crashkernel();
> >> +
> >>         /*
> >>          * In order to reduce the possibility of kernel panic when failed to
> >>          * get IO TLB memory under CONFIG_SWIOTLB, it is better to allocate
> >> @@ -290,6 +338,7 @@ static void __init resource_init(void)
> >>                 request_resource(res, &code_resource);
> >>                 request_resource(res, &data_resource);
> >>                 request_resource(res, &bss_resource);
> >> +               request_crashkernel(res);
> >>         }
> >>  }
> >>
> >> diff --git a/arch/loongarch/kernel/traps.c b/arch/loongarch/kernel/traps.c
> >> index aa1c95aaf595..0e610872f3f4 100644
> >> --- a/arch/loongarch/kernel/traps.c
> >> +++ b/arch/loongarch/kernel/traps.c
> >> @@ -10,6 +10,7 @@
> >>  #include <linux/entry-common.h>
> >>  #include <linux/init.h>
> >>  #include <linux/kernel.h>
> >> +#include <linux/kexec.h>
> >>  #include <linux/module.h>
> >>  #include <linux/extable.h>
> >>  #include <linux/mm.h>
> >> @@ -246,6 +247,9 @@ void __noreturn die(const char *str, struct pt_regs *regs)
> >>
> >>         oops_exit();
> >>
> >> +       if (regs && kexec_should_crash(current))
> >> +               crash_kexec(regs);
> >> +
> >>         if (in_interrupt())
> >>                 panic("Fatal exception in interrupt");
> >>
> >> --
> >> 2.36.0
> >>
>

Re: [PATCH 2/3] LoongArch: Add kdump support

[Youling Tang]

Hi, Huacai

On 09/05/2022 09:38 AM, Huacai Chen wrote:
> Hi, Youling,
>
> On Mon, Sep 5, 2022 at 8:54 AM Youling Tang <tangyouling@loongson.cn> wrote:
>>
>> Hi, Huacai
>>
>> On 09/04/2022 08:21 PM, Huacai Chen wrote:
>>> Hi, Youling,
>>>
>>> I think crash.c can be merged into crash_dump.c
>>
>> Most architectures only implement copy_oldmem_page() in crash_dump.c,
>> I'm not sure if merging crash.c into crash_dump.c will break its
>> consistency?
>>
>> Thanks,
>> Youling
> Yes, you are right, crash.c cannot be merged into crash_dump.c, but it
> can be merged into machine_kexec.c, as arm64 and riscv do.

For arm64, machine_crash_shutdown() is placed in machine_kexec.c, and
crash_smp_send_stop is placed in smp.c. If crash.c needs to be merged
into machine_kexec.c, should crash_shutdown_secondary and
crash_smp_send_stop be placed in smp.c?

Youling.
>
> Huacai
>>
>>>
>>> Huacai
>>>
>>> On Mon, Aug 29, 2022 at 12:37 PM Youling Tang <tangyouling@loongson.cn> wrote:
>>>>
>>>> This patch adds support for kdump, the kernel will reserve a region
>>>> for the crash kernel and jump there on panic.
>>>>
>>>> Arch-specific functions are added to allow for implementing a crash
>>>> dump file interface, /proc/vmcore, which can be viewed as a ELF file.
>>>>
>>>> A user space tool, like kexec-tools, is responsible for allocating a
>>>> separate region for the core's ELF header within crash kdump kernel
>>>> memory and filling it in when executing kexec_load().
>>>>
>>>> Then, its location will be advertised to crash dump kernel via a new
>>>> device-tree property, "linux,elfcorehdr", and crash dump kernel preserves
>>>> the region for later use with fdt_reserve_elfcorehdr() at boot time.
>>>>
>>>> At the same time, it will also limit the crash kdump kernel to the
>>>> crashkernel area via a new device-tree property, "linux, usable-memory-range",
>>>> so as not to destroy the original kernel dump data.
>>>>
>>>> On crash dump kernel, /proc/vmcore will access the primary kernel's memory
>>>> with copy_oldmem_page().
>>>>
>>>> I tested this on  LoongArch 3A5000 machine and works as expected (Suggest
>>>> crashkernel parameter is "crashkernel=512M@2320M"), you may test it by
>>>> triggering a crash through /proc/sysrq_trigger:
>>>>
>>>>  $ sudo kexec -p /boot/vmlinux-kdump --reuse-cmdline --append="nr_cpus=1"
>>>>  # echo c > /proc/sysrq_trigger
>>>>
>>>> Signed-off-by: Youling Tang <tangyouling@loongson.cn>
>>>> ---
>>>>  arch/loongarch/Kconfig                  |  22 ++++++
>>>>  arch/loongarch/Makefile                 |   4 +
>>>>  arch/loongarch/kernel/Makefile          |   3 +-
>>>>  arch/loongarch/kernel/crash.c           | 100 ++++++++++++++++++++++++
>>>>  arch/loongarch/kernel/crash_dump.c      |  19 +++++
>>>>  arch/loongarch/kernel/machine_kexec.c   |  12 ++-
>>>>  arch/loongarch/kernel/mem.c             |   6 ++
>>>>  arch/loongarch/kernel/relocate_kernel.S |   6 ++
>>>>  arch/loongarch/kernel/setup.c           |  49 ++++++++++++
>>>>  arch/loongarch/kernel/traps.c           |   4 +
>>>>  10 files changed, 217 insertions(+), 8 deletions(-)
>>>>  create mode 100644 arch/loongarch/kernel/crash.c
>>>>  create mode 100644 arch/loongarch/kernel/crash_dump.c
>>>>
>>>> diff --git a/arch/loongarch/Kconfig b/arch/loongarch/Kconfig
>>>> index 903c82fa958d..7c1b07a5b5bd 100644
>>>> --- a/arch/loongarch/Kconfig
>>>> +++ b/arch/loongarch/Kconfig
>>>> @@ -420,6 +420,28 @@ config KEXEC
>>>>
>>>>           The name comes from the similarity to the exec system call.
>>>>
>>>> +config CRASH_DUMP
>>>> +       bool "Build kdump crash kernel"
>>>> +       help
>>>> +         Generate crash dump after being started by kexec. This should
>>>> +         be normally only set in special crash dump kernels which are
>>>> +         loaded in the main kernel with kexec-tools into a specially
>>>> +         reserved region and then later executed after a crash by
>>>> +         kdump/kexec.
>>>> +
>>>> +         For more details see Documentation/admin-guide/kdump/kdump.rst
>>>> +
>>>> +config PHYSICAL_START
>>>> +       hex "Physical address where the kernel is loaded"
>>>> +       default "0x9000000091000000" if 64BIT
>>>> +       depends on CRASH_DUMP
>>>> +       help
>>>> +         This gives the XKPRANGE address where the kernel is loaded.
>>>> +         If you plan to use kernel for capturing the crash dump change
>>>> +         this value to start of the reserved region (the "X" value as
>>>> +         specified in the "crashkernel=YM@XM" command line boot parameter
>>>> +         passed to the panic-ed kernel).
>>>> +
>>>>  config SECCOMP
>>>>         bool "Enable seccomp to safely compute untrusted bytecode"
>>>>         depends on PROC_FS
>>>> diff --git a/arch/loongarch/Makefile b/arch/loongarch/Makefile
>>>> index 4bc47f47cfd8..7dabd580426d 100644
>>>> --- a/arch/loongarch/Makefile
>>>> +++ b/arch/loongarch/Makefile
>>>> @@ -48,7 +48,11 @@ KBUILD_CFLAGS_MODULE         += -fplt -Wa,-mla-global-with-abs,-mla-local-with-abs
>>>>  cflags-y += -ffreestanding
>>>>  cflags-y += $(call cc-option, -mno-check-zero-division)
>>>>
>>>> +ifdef CONFIG_PHYSICAL_START
>>>> +load-y         = $(CONFIG_PHYSICAL_START)
>>>> +else
>>>>  load-y         = 0x9000000000200000
>>>> +endif
>>>>  bootvars-y     = VMLINUX_LOAD_ADDRESS=$(load-y)
>>>>
>>>>  drivers-$(CONFIG_PCI)          += arch/loongarch/pci/
>>>> diff --git a/arch/loongarch/kernel/Makefile b/arch/loongarch/kernel/Makefile
>>>> index 20b64ac3f128..df5aea129364 100644
>>>> --- a/arch/loongarch/kernel/Makefile
>>>> +++ b/arch/loongarch/kernel/Makefile
>>>> @@ -17,7 +17,8 @@ obj-$(CONFIG_CPU_HAS_FPU)     += fpu.o
>>>>  obj-$(CONFIG_MODULES)          += module.o module-sections.o
>>>>  obj-$(CONFIG_STACKTRACE)       += stacktrace.o
>>>>
>>>> -obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o
>>>> +obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o crash.o
>>>> +obj-$(CONFIG_CRASH_DUMP)        += crash_dump.o
>>>>
>>>>  obj-$(CONFIG_PROC_FS)          += proc.o
>>>>
>>>> diff --git a/arch/loongarch/kernel/crash.c b/arch/loongarch/kernel/crash.c
>>>> new file mode 100644
>>>> index 000000000000..b4f249ec6301
>>>> --- /dev/null
>>>> +++ b/arch/loongarch/kernel/crash.c
>>>> @@ -0,0 +1,100 @@
>>>> +// SPDX-License-Identifier: GPL-2.0
>>>> +/*
>>>> + * Copyright (C) 2022 Loongson Technology Corporation Limited
>>>> + *
>>>> + * Derived from MIPS
>>>> + */
>>>> +#include <linux/kernel.h>
>>>> +#include <linux/smp.h>
>>>> +#include <linux/reboot.h>
>>>> +#include <linux/crash_dump.h>
>>>> +#include <linux/delay.h>
>>>> +#include <linux/irq.h>
>>>> +#include <linux/types.h>
>>>> +#include <linux/sched.h>
>>>> +#include <linux/sched/task_stack.h>
>>>> +#include <asm/cacheflush.h>
>>>> +#include <asm/kexec.h>
>>>> +
>>>> +static cpumask_t cpus_in_crash = CPU_MASK_NONE;
>>>> +
>>>> +#ifdef CONFIG_SMP
>>>> +static void crash_shutdown_secondary(void *passed_regs)
>>>> +{
>>>> +       struct pt_regs *regs = passed_regs;
>>>> +       int cpu = smp_processor_id();
>>>> +
>>>> +       /*
>>>> +        * If we are passed registers, use those.  Otherwise get the
>>>> +        * regs from the last interrupt, which should be correct, as
>>>> +        * we are in an interrupt.  But if the regs are not there,
>>>> +        * pull them from the top of the stack.  They are probably
>>>> +        * wrong, but we need something to keep from crashing again.
>>>> +        */
>>>> +       if (!regs)
>>>> +               regs = get_irq_regs();
>>>> +       if (!regs)
>>>> +               regs = task_pt_regs(current);
>>>> +
>>>> +       local_irq_disable();
>>>> +       if (!cpumask_test_cpu(cpu, &cpus_in_crash))
>>>> +               crash_save_cpu(regs, cpu);
>>>> +       cpumask_set_cpu(cpu, &cpus_in_crash);
>>>> +
>>>> +       while (!atomic_read(&kexec_ready_to_reboot))
>>>> +               cpu_relax();
>>>> +
>>>> +       kexec_reboot();
>>>> +}
>>>> +
>>>> +/* Override the weak function in kernel/panic.c */
>>>> +void crash_smp_send_stop(void)
>>>> +{
>>>> +       static int cpus_stopped;
>>>> +       unsigned long timeout;
>>>> +       unsigned int ncpus;
>>>> +
>>>> +       /*
>>>> +        * This function can be called twice in panic path, but obviously
>>>> +        * we execute this only once.
>>>> +        */
>>>> +       if (cpus_stopped)
>>>> +               return;
>>>> +
>>>> +       cpus_stopped = 1;
>>>> +
>>>> +        /* Excluding the panic cpu */
>>>> +       ncpus = num_online_cpus() - 1;
>>>> +
>>>> +       smp_call_function(crash_shutdown_secondary, NULL, 0);
>>>> +       smp_wmb();
>>>> +
>>>> +       /*
>>>> +        * The crash CPU sends an IPI and wait for other CPUs to
>>>> +        * respond. Delay of at least 10 seconds.
>>>> +        */
>>>> +       pr_emerg("Sending IPI to other cpus...\n");
>>>> +       timeout = USEC_PER_SEC * 10;
>>>> +       while ((cpumask_weight(&cpus_in_crash) < ncpus) && timeout--) {
>>>> +               cpu_relax();
>>>> +               udelay(1);
>>>> +       }
>>>> +}
>>>> +
>>>> +#endif
>>>> +
>>>> +void machine_crash_shutdown(struct pt_regs *regs)
>>>> +{
>>>> +       int crashing_cpu;
>>>> +
>>>> +       local_irq_disable();
>>>> +
>>>> +       crashing_cpu = smp_processor_id();
>>>> +       crash_save_cpu(regs, crashing_cpu);
>>>> +
>>>> +       /* shutdown non-crashing cpus */
>>>> +       crash_smp_send_stop();
>>>> +       cpumask_set_cpu(crashing_cpu, &cpus_in_crash);
>>>> +
>>>> +       pr_info("Starting crashdump kernel...\n");
>>>> +}
>>>> diff --git a/arch/loongarch/kernel/crash_dump.c b/arch/loongarch/kernel/crash_dump.c
>>>> new file mode 100644
>>>> index 000000000000..13e5d2f7870d
>>>> --- /dev/null
>>>> +++ b/arch/loongarch/kernel/crash_dump.c
>>>> @@ -0,0 +1,19 @@
>>>> +// SPDX-License-Identifier: GPL-2.0
>>>> +#include <linux/highmem.h>
>>>> +#include <linux/crash_dump.h>
>>>> +#include <linux/io.h>
>>>> +
>>>> +ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn,
>>>> +                        size_t csize, unsigned long offset)
>>>> +{
>>>> +       void  *vaddr;
>>>> +
>>>> +       if (!csize)
>>>> +               return 0;
>>>> +
>>>> +       vaddr = kmap_local_pfn(pfn);
>>>> +       csize = copy_to_iter(vaddr + offset, csize, iter);
>>>> +       kunmap_local(vaddr);
>>>> +
>>>> +       return csize;
>>>> +}
>>>> diff --git a/arch/loongarch/kernel/machine_kexec.c b/arch/loongarch/kernel/machine_kexec.c
>>>> index 4ffcd4cd9c8c..f793a3ff09a3 100644
>>>> --- a/arch/loongarch/kernel/machine_kexec.c
>>>> +++ b/arch/loongarch/kernel/machine_kexec.c
>>>> @@ -69,7 +69,7 @@ int machine_kexec_prepare(struct kimage *kimage)
>>>>                 continue;
>>>>         }
>>>>
>>>> -       /* kexec need a safe page to save reboot_code_buffer */
>>>> +       /* kexec/kdump need a safe page to save reboot_code_buffer */
>>>>         kimage->control_code_page = virt_to_page((void *)KEXEC_CTRL_CODE);
>>>>
>>>>         reboot_code_buffer =
>>>> @@ -113,10 +113,6 @@ static void kexec_shutdown_secondary(void *)
>>>>
>>>>         kexec_reboot();
>>>>  }
>>>> -
>>>> -void machine_crash_shutdown(struct pt_regs *regs)
>>>> -{
>>>> -}
>>>>  #endif
>>>>
>>>>  void machine_shutdown(void)
>>>> @@ -135,7 +131,8 @@ void machine_kexec(struct kimage *image)
>>>>
>>>>         jump_addr = (unsigned long)phys_to_virt(image->start);
>>>>
>>>> -       first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
>>>> +       if (image->type == KEXEC_TYPE_DEFAULT)
>>>> +               first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
>>>>
>>>>         /*
>>>>          * The generic kexec code builds a page list with physical
>>>> @@ -167,7 +164,8 @@ void machine_kexec(struct kimage *image)
>>>>
>>>>         /*
>>>>          * We know we were online, and there will be no incoming IPIs at
>>>> -        * this point.
>>>> +        * this point. Mark online again before rebooting so that the crash
>>>> +        * analysis tool will see us correctly.
>>>>          */
>>>>         set_cpu_online(smp_processor_id(), true);
>>>>
>>>> diff --git a/arch/loongarch/kernel/mem.c b/arch/loongarch/kernel/mem.c
>>>> index 7423361b0ebc..c6def6ff81c8 100644
>>>> --- a/arch/loongarch/kernel/mem.c
>>>> +++ b/arch/loongarch/kernel/mem.c
>>>> @@ -5,6 +5,7 @@
>>>>  #include <linux/efi.h>
>>>>  #include <linux/initrd.h>
>>>>  #include <linux/memblock.h>
>>>> +#include <linux/of_fdt.h>
>>>>
>>>>  #include <asm/bootinfo.h>
>>>>  #include <asm/loongson.h>
>>>> @@ -61,4 +62,9 @@ void __init memblock_init(void)
>>>>
>>>>         /* Reserve the initrd */
>>>>         reserve_initrd_mem();
>>>> +
>>>> +       /* Mainly reserved memory for the elf core head */
>>>> +       early_init_fdt_scan_reserved_mem();
>>>> +       /* Parse linux,usable-memory-range is for crash dump kernel */
>>>> +       early_init_dt_check_for_usable_mem_range();
>>>>  }
>>>> diff --git a/arch/loongarch/kernel/relocate_kernel.S b/arch/loongarch/kernel/relocate_kernel.S
>>>> index d1f242f74ea8..4ee5ac4ac2d7 100644
>>>> --- a/arch/loongarch/kernel/relocate_kernel.S
>>>> +++ b/arch/loongarch/kernel/relocate_kernel.S
>>>> @@ -28,6 +28,12 @@ SYM_CODE_START(relocate_new_kernel)
>>>>         move            s2, a2
>>>>         move            s3, a3
>>>>
>>>> +       /*
>>>> +        * In case of a kdump/crash kernel, the indirection page is not
>>>> +        * populated as the kernel is directly copied to a reserved location
>>>> +        */
>>>> +       beqz            s2, done
>>>> +
>>>>  process_entry:
>>>>         PTR_L           s4, s2, 0
>>>>         PTR_ADDI        s2, s2, SZREG
>>>> diff --git a/arch/loongarch/kernel/setup.c b/arch/loongarch/kernel/setup.c
>>>> index f938aae3e92c..ea34b77e402f 100644
>>>> --- a/arch/loongarch/kernel/setup.c
>>>> +++ b/arch/loongarch/kernel/setup.c
>>>> @@ -19,6 +19,8 @@
>>>>  #include <linux/memblock.h>
>>>>  #include <linux/initrd.h>
>>>>  #include <linux/ioport.h>
>>>> +#include <linux/kexec.h>
>>>> +#include <linux/crash_dump.h>
>>>>  #include <linux/root_dev.h>
>>>>  #include <linux/console.h>
>>>>  #include <linux/pfn.h>
>>>> @@ -186,6 +188,50 @@ static int __init early_parse_mem(char *p)
>>>>  }
>>>>  early_param("mem", early_parse_mem);
>>>>
>>>> +static void __init loongarch_parse_crashkernel(void)
>>>> +{
>>>> +#ifdef CONFIG_KEXEC
>>>> +       unsigned long long start;
>>>> +       unsigned long long total_mem;
>>>> +       unsigned long long crash_size, crash_base;
>>>> +       int ret;
>>>> +
>>>> +       total_mem = memblock_phys_mem_size();
>>>> +       ret = parse_crashkernel(boot_command_line, total_mem,
>>>> +                               &crash_size, &crash_base);
>>>> +       if (ret != 0 || crash_size <= 0)
>>>> +               return;
>>>> +
>>>> +
>>>> +       start = memblock_phys_alloc_range(crash_size, 1, crash_base,
>>>> +                                       crash_base + crash_size);
>>>> +       if (start != crash_base) {
>>>> +               pr_warn("Invalid memory region reserved for crash kernel\n");
>>>> +               return;
>>>> +       }
>>>> +
>>>> +       crashk_res.start = crash_base;
>>>> +       crashk_res.end   = crash_base + crash_size - 1;
>>>> +#endif
>>>> +}
>>>> +
>>>> +static void __init request_crashkernel(struct resource *res)
>>>> +{
>>>> +#ifdef CONFIG_KEXEC
>>>> +       int ret;
>>>> +
>>>> +       if (crashk_res.start == crashk_res.end)
>>>> +               return;
>>>> +
>>>> +       ret = request_resource(res, &crashk_res);
>>>> +       if (!ret)
>>>> +               pr_info("Reserving %ldMB of memory at %ldMB for crashkernel\n",
>>>> +                       (unsigned long)((crashk_res.end -
>>>> +                                        crashk_res.start + 1) >> 20),
>>>> +                       (unsigned long)(crashk_res.start  >> 20));
>>>> +#endif
>>>> +}
>>>> +
>>>>  void __init platform_init(void)
>>>>  {
>>>>         efi_init();
>>>> @@ -229,6 +275,8 @@ static void __init arch_mem_init(char **cmdline_p)
>>>>
>>>>         check_kernel_sections_mem();
>>>>
>>>> +       loongarch_parse_crashkernel();
>>>> +
>>>>         /*
>>>>          * In order to reduce the possibility of kernel panic when failed to
>>>>          * get IO TLB memory under CONFIG_SWIOTLB, it is better to allocate
>>>> @@ -290,6 +338,7 @@ static void __init resource_init(void)
>>>>                 request_resource(res, &code_resource);
>>>>                 request_resource(res, &data_resource);
>>>>                 request_resource(res, &bss_resource);
>>>> +               request_crashkernel(res);
>>>>         }
>>>>  }
>>>>
>>>> diff --git a/arch/loongarch/kernel/traps.c b/arch/loongarch/kernel/traps.c
>>>> index aa1c95aaf595..0e610872f3f4 100644
>>>> --- a/arch/loongarch/kernel/traps.c
>>>> +++ b/arch/loongarch/kernel/traps.c
>>>> @@ -10,6 +10,7 @@
>>>>  #include <linux/entry-common.h>
>>>>  #include <linux/init.h>
>>>>  #include <linux/kernel.h>
>>>> +#include <linux/kexec.h>
>>>>  #include <linux/module.h>
>>>>  #include <linux/extable.h>
>>>>  #include <linux/mm.h>
>>>> @@ -246,6 +247,9 @@ void __noreturn die(const char *str, struct pt_regs *regs)
>>>>
>>>>         oops_exit();
>>>>
>>>> +       if (regs && kexec_should_crash(current))
>>>> +               crash_kexec(regs);
>>>> +
>>>>         if (in_interrupt())
>>>>                 panic("Fatal exception in interrupt");
>>>>
>>>> --
>>>> 2.36.0
>>>>
>>

Re: [PATCH 2/3] LoongArch: Add kdump support

[Huacai Chen]

On Mon, Sep 5, 2022 at 10:04 AM Youling Tang <tangyouling@loongson.cn> wrote:
>
> Hi, Huacai
>
> On 09/05/2022 09:38 AM, Huacai Chen wrote:
> > Hi, Youling,
> >
> > On Mon, Sep 5, 2022 at 8:54 AM Youling Tang <tangyouling@loongson.cn> wrote:
> >>
> >> Hi, Huacai
> >>
> >> On 09/04/2022 08:21 PM, Huacai Chen wrote:
> >>> Hi, Youling,
> >>>
> >>> I think crash.c can be merged into crash_dump.c
> >>
> >> Most architectures only implement copy_oldmem_page() in crash_dump.c,
> >> I'm not sure if merging crash.c into crash_dump.c will break its
> >> consistency?
> >>
> >> Thanks,
> >> Youling
> > Yes, you are right, crash.c cannot be merged into crash_dump.c, but it
> > can be merged into machine_kexec.c, as arm64 and riscv do.
>
> For arm64, machine_crash_shutdown() is placed in machine_kexec.c, and
> crash_smp_send_stop is placed in smp.c. If crash.c needs to be merged
> into machine_kexec.c, should crash_shutdown_secondary and
> crash_smp_send_stop be placed in smp.c?
I don't want to touch smp.c, all merged into machine_kexec.c seems reasonable.

Huacai
>
> Youling.
> >
> > Huacai
> >>
> >>>
> >>> Huacai
> >>>
> >>> On Mon, Aug 29, 2022 at 12:37 PM Youling Tang <tangyouling@loongson.cn> wrote:
> >>>>
> >>>> This patch adds support for kdump, the kernel will reserve a region
> >>>> for the crash kernel and jump there on panic.
> >>>>
> >>>> Arch-specific functions are added to allow for implementing a crash
> >>>> dump file interface, /proc/vmcore, which can be viewed as a ELF file.
> >>>>
> >>>> A user space tool, like kexec-tools, is responsible for allocating a
> >>>> separate region for the core's ELF header within crash kdump kernel
> >>>> memory and filling it in when executing kexec_load().
> >>>>
> >>>> Then, its location will be advertised to crash dump kernel via a new
> >>>> device-tree property, "linux,elfcorehdr", and crash dump kernel preserves
> >>>> the region for later use with fdt_reserve_elfcorehdr() at boot time.
> >>>>
> >>>> At the same time, it will also limit the crash kdump kernel to the
> >>>> crashkernel area via a new device-tree property, "linux, usable-memory-range",
> >>>> so as not to destroy the original kernel dump data.
> >>>>
> >>>> On crash dump kernel, /proc/vmcore will access the primary kernel's memory
> >>>> with copy_oldmem_page().
> >>>>
> >>>> I tested this on  LoongArch 3A5000 machine and works as expected (Suggest
> >>>> crashkernel parameter is "crashkernel=512M@2320M"), you may test it by
> >>>> triggering a crash through /proc/sysrq_trigger:
> >>>>
> >>>>  $ sudo kexec -p /boot/vmlinux-kdump --reuse-cmdline --append="nr_cpus=1"
> >>>>  # echo c > /proc/sysrq_trigger
> >>>>
> >>>> Signed-off-by: Youling Tang <tangyouling@loongson.cn>
> >>>> ---
> >>>>  arch/loongarch/Kconfig                  |  22 ++++++
> >>>>  arch/loongarch/Makefile                 |   4 +
> >>>>  arch/loongarch/kernel/Makefile          |   3 +-
> >>>>  arch/loongarch/kernel/crash.c           | 100 ++++++++++++++++++++++++
> >>>>  arch/loongarch/kernel/crash_dump.c      |  19 +++++
> >>>>  arch/loongarch/kernel/machine_kexec.c   |  12 ++-
> >>>>  arch/loongarch/kernel/mem.c             |   6 ++
> >>>>  arch/loongarch/kernel/relocate_kernel.S |   6 ++
> >>>>  arch/loongarch/kernel/setup.c           |  49 ++++++++++++
> >>>>  arch/loongarch/kernel/traps.c           |   4 +
> >>>>  10 files changed, 217 insertions(+), 8 deletions(-)
> >>>>  create mode 100644 arch/loongarch/kernel/crash.c
> >>>>  create mode 100644 arch/loongarch/kernel/crash_dump.c
> >>>>
> >>>> diff --git a/arch/loongarch/Kconfig b/arch/loongarch/Kconfig
> >>>> index 903c82fa958d..7c1b07a5b5bd 100644
> >>>> --- a/arch/loongarch/Kconfig
> >>>> +++ b/arch/loongarch/Kconfig
> >>>> @@ -420,6 +420,28 @@ config KEXEC
> >>>>
> >>>>           The name comes from the similarity to the exec system call.
> >>>>
> >>>> +config CRASH_DUMP
> >>>> +       bool "Build kdump crash kernel"
> >>>> +       help
> >>>> +         Generate crash dump after being started by kexec. This should
> >>>> +         be normally only set in special crash dump kernels which are
> >>>> +         loaded in the main kernel with kexec-tools into a specially
> >>>> +         reserved region and then later executed after a crash by
> >>>> +         kdump/kexec.
> >>>> +
> >>>> +         For more details see Documentation/admin-guide/kdump/kdump.rst
> >>>> +
> >>>> +config PHYSICAL_START
> >>>> +       hex "Physical address where the kernel is loaded"
> >>>> +       default "0x9000000091000000" if 64BIT
> >>>> +       depends on CRASH_DUMP
> >>>> +       help
> >>>> +         This gives the XKPRANGE address where the kernel is loaded.
> >>>> +         If you plan to use kernel for capturing the crash dump change
> >>>> +         this value to start of the reserved region (the "X" value as
> >>>> +         specified in the "crashkernel=YM@XM" command line boot parameter
> >>>> +         passed to the panic-ed kernel).
> >>>> +
> >>>>  config SECCOMP
> >>>>         bool "Enable seccomp to safely compute untrusted bytecode"
> >>>>         depends on PROC_FS
> >>>> diff --git a/arch/loongarch/Makefile b/arch/loongarch/Makefile
> >>>> index 4bc47f47cfd8..7dabd580426d 100644
> >>>> --- a/arch/loongarch/Makefile
> >>>> +++ b/arch/loongarch/Makefile
> >>>> @@ -48,7 +48,11 @@ KBUILD_CFLAGS_MODULE         += -fplt -Wa,-mla-global-with-abs,-mla-local-with-abs
> >>>>  cflags-y += -ffreestanding
> >>>>  cflags-y += $(call cc-option, -mno-check-zero-division)
> >>>>
> >>>> +ifdef CONFIG_PHYSICAL_START
> >>>> +load-y         = $(CONFIG_PHYSICAL_START)
> >>>> +else
> >>>>  load-y         = 0x9000000000200000
> >>>> +endif
> >>>>  bootvars-y     = VMLINUX_LOAD_ADDRESS=$(load-y)
> >>>>
> >>>>  drivers-$(CONFIG_PCI)          += arch/loongarch/pci/
> >>>> diff --git a/arch/loongarch/kernel/Makefile b/arch/loongarch/kernel/Makefile
> >>>> index 20b64ac3f128..df5aea129364 100644
> >>>> --- a/arch/loongarch/kernel/Makefile
> >>>> +++ b/arch/loongarch/kernel/Makefile
> >>>> @@ -17,7 +17,8 @@ obj-$(CONFIG_CPU_HAS_FPU)     += fpu.o
> >>>>  obj-$(CONFIG_MODULES)          += module.o module-sections.o
> >>>>  obj-$(CONFIG_STACKTRACE)       += stacktrace.o
> >>>>
> >>>> -obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o
> >>>> +obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o crash.o
> >>>> +obj-$(CONFIG_CRASH_DUMP)        += crash_dump.o
> >>>>
> >>>>  obj-$(CONFIG_PROC_FS)          += proc.o
> >>>>
> >>>> diff --git a/arch/loongarch/kernel/crash.c b/arch/loongarch/kernel/crash.c
> >>>> new file mode 100644
> >>>> index 000000000000..b4f249ec6301
> >>>> --- /dev/null
> >>>> +++ b/arch/loongarch/kernel/crash.c
> >>>> @@ -0,0 +1,100 @@
> >>>> +// SPDX-License-Identifier: GPL-2.0
> >>>> +/*
> >>>> + * Copyright (C) 2022 Loongson Technology Corporation Limited
> >>>> + *
> >>>> + * Derived from MIPS
> >>>> + */
> >>>> +#include <linux/kernel.h>
> >>>> +#include <linux/smp.h>
> >>>> +#include <linux/reboot.h>
> >>>> +#include <linux/crash_dump.h>
> >>>> +#include <linux/delay.h>
> >>>> +#include <linux/irq.h>
> >>>> +#include <linux/types.h>
> >>>> +#include <linux/sched.h>
> >>>> +#include <linux/sched/task_stack.h>
> >>>> +#include <asm/cacheflush.h>
> >>>> +#include <asm/kexec.h>
> >>>> +
> >>>> +static cpumask_t cpus_in_crash = CPU_MASK_NONE;
> >>>> +
> >>>> +#ifdef CONFIG_SMP
> >>>> +static void crash_shutdown_secondary(void *passed_regs)
> >>>> +{
> >>>> +       struct pt_regs *regs = passed_regs;
> >>>> +       int cpu = smp_processor_id();
> >>>> +
> >>>> +       /*
> >>>> +        * If we are passed registers, use those.  Otherwise get the
> >>>> +        * regs from the last interrupt, which should be correct, as
> >>>> +        * we are in an interrupt.  But if the regs are not there,
> >>>> +        * pull them from the top of the stack.  They are probably
> >>>> +        * wrong, but we need something to keep from crashing again.
> >>>> +        */
> >>>> +       if (!regs)
> >>>> +               regs = get_irq_regs();
> >>>> +       if (!regs)
> >>>> +               regs = task_pt_regs(current);
> >>>> +
> >>>> +       local_irq_disable();
> >>>> +       if (!cpumask_test_cpu(cpu, &cpus_in_crash))
> >>>> +               crash_save_cpu(regs, cpu);
> >>>> +       cpumask_set_cpu(cpu, &cpus_in_crash);
> >>>> +
> >>>> +       while (!atomic_read(&kexec_ready_to_reboot))
> >>>> +               cpu_relax();
> >>>> +
> >>>> +       kexec_reboot();
> >>>> +}
> >>>> +
> >>>> +/* Override the weak function in kernel/panic.c */
> >>>> +void crash_smp_send_stop(void)
> >>>> +{
> >>>> +       static int cpus_stopped;
> >>>> +       unsigned long timeout;
> >>>> +       unsigned int ncpus;
> >>>> +
> >>>> +       /*
> >>>> +        * This function can be called twice in panic path, but obviously
> >>>> +        * we execute this only once.
> >>>> +        */
> >>>> +       if (cpus_stopped)
> >>>> +               return;
> >>>> +
> >>>> +       cpus_stopped = 1;
> >>>> +
> >>>> +        /* Excluding the panic cpu */
> >>>> +       ncpus = num_online_cpus() - 1;
> >>>> +
> >>>> +       smp_call_function(crash_shutdown_secondary, NULL, 0);
> >>>> +       smp_wmb();
> >>>> +
> >>>> +       /*
> >>>> +        * The crash CPU sends an IPI and wait for other CPUs to
> >>>> +        * respond. Delay of at least 10 seconds.
> >>>> +        */
> >>>> +       pr_emerg("Sending IPI to other cpus...\n");
> >>>> +       timeout = USEC_PER_SEC * 10;
> >>>> +       while ((cpumask_weight(&cpus_in_crash) < ncpus) && timeout--) {
> >>>> +               cpu_relax();
> >>>> +               udelay(1);
> >>>> +       }
> >>>> +}
> >>>> +
> >>>> +#endif
> >>>> +
> >>>> +void machine_crash_shutdown(struct pt_regs *regs)
> >>>> +{
> >>>> +       int crashing_cpu;
> >>>> +
> >>>> +       local_irq_disable();
> >>>> +
> >>>> +       crashing_cpu = smp_processor_id();
> >>>> +       crash_save_cpu(regs, crashing_cpu);
> >>>> +
> >>>> +       /* shutdown non-crashing cpus */
> >>>> +       crash_smp_send_stop();
> >>>> +       cpumask_set_cpu(crashing_cpu, &cpus_in_crash);
> >>>> +
> >>>> +       pr_info("Starting crashdump kernel...\n");
> >>>> +}
> >>>> diff --git a/arch/loongarch/kernel/crash_dump.c b/arch/loongarch/kernel/crash_dump.c
> >>>> new file mode 100644
> >>>> index 000000000000..13e5d2f7870d
> >>>> --- /dev/null
> >>>> +++ b/arch/loongarch/kernel/crash_dump.c
> >>>> @@ -0,0 +1,19 @@
> >>>> +// SPDX-License-Identifier: GPL-2.0
> >>>> +#include <linux/highmem.h>
> >>>> +#include <linux/crash_dump.h>
> >>>> +#include <linux/io.h>
> >>>> +
> >>>> +ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn,
> >>>> +                        size_t csize, unsigned long offset)
> >>>> +{
> >>>> +       void  *vaddr;
> >>>> +
> >>>> +       if (!csize)
> >>>> +               return 0;
> >>>> +
> >>>> +       vaddr = kmap_local_pfn(pfn);
> >>>> +       csize = copy_to_iter(vaddr + offset, csize, iter);
> >>>> +       kunmap_local(vaddr);
> >>>> +
> >>>> +       return csize;
> >>>> +}
> >>>> diff --git a/arch/loongarch/kernel/machine_kexec.c b/arch/loongarch/kernel/machine_kexec.c
> >>>> index 4ffcd4cd9c8c..f793a3ff09a3 100644
> >>>> --- a/arch/loongarch/kernel/machine_kexec.c
> >>>> +++ b/arch/loongarch/kernel/machine_kexec.c
> >>>> @@ -69,7 +69,7 @@ int machine_kexec_prepare(struct kimage *kimage)
> >>>>                 continue;
> >>>>         }
> >>>>
> >>>> -       /* kexec need a safe page to save reboot_code_buffer */
> >>>> +       /* kexec/kdump need a safe page to save reboot_code_buffer */
> >>>>         kimage->control_code_page = virt_to_page((void *)KEXEC_CTRL_CODE);
> >>>>
> >>>>         reboot_code_buffer =
> >>>> @@ -113,10 +113,6 @@ static void kexec_shutdown_secondary(void *)
> >>>>
> >>>>         kexec_reboot();
> >>>>  }
> >>>> -
> >>>> -void machine_crash_shutdown(struct pt_regs *regs)
> >>>> -{
> >>>> -}
> >>>>  #endif
> >>>>
> >>>>  void machine_shutdown(void)
> >>>> @@ -135,7 +131,8 @@ void machine_kexec(struct kimage *image)
> >>>>
> >>>>         jump_addr = (unsigned long)phys_to_virt(image->start);
> >>>>
> >>>> -       first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
> >>>> +       if (image->type == KEXEC_TYPE_DEFAULT)
> >>>> +               first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
> >>>>
> >>>>         /*
> >>>>          * The generic kexec code builds a page list with physical
> >>>> @@ -167,7 +164,8 @@ void machine_kexec(struct kimage *image)
> >>>>
> >>>>         /*
> >>>>          * We know we were online, and there will be no incoming IPIs at
> >>>> -        * this point.
> >>>> +        * this point. Mark online again before rebooting so that the crash
> >>>> +        * analysis tool will see us correctly.
> >>>>          */
> >>>>         set_cpu_online(smp_processor_id(), true);
> >>>>
> >>>> diff --git a/arch/loongarch/kernel/mem.c b/arch/loongarch/kernel/mem.c
> >>>> index 7423361b0ebc..c6def6ff81c8 100644
> >>>> --- a/arch/loongarch/kernel/mem.c
> >>>> +++ b/arch/loongarch/kernel/mem.c
> >>>> @@ -5,6 +5,7 @@
> >>>>  #include <linux/efi.h>
> >>>>  #include <linux/initrd.h>
> >>>>  #include <linux/memblock.h>
> >>>> +#include <linux/of_fdt.h>
> >>>>
> >>>>  #include <asm/bootinfo.h>
> >>>>  #include <asm/loongson.h>
> >>>> @@ -61,4 +62,9 @@ void __init memblock_init(void)
> >>>>
> >>>>         /* Reserve the initrd */
> >>>>         reserve_initrd_mem();
> >>>> +
> >>>> +       /* Mainly reserved memory for the elf core head */
> >>>> +       early_init_fdt_scan_reserved_mem();
> >>>> +       /* Parse linux,usable-memory-range is for crash dump kernel */
> >>>> +       early_init_dt_check_for_usable_mem_range();
> >>>>  }
> >>>> diff --git a/arch/loongarch/kernel/relocate_kernel.S b/arch/loongarch/kernel/relocate_kernel.S
> >>>> index d1f242f74ea8..4ee5ac4ac2d7 100644
> >>>> --- a/arch/loongarch/kernel/relocate_kernel.S
> >>>> +++ b/arch/loongarch/kernel/relocate_kernel.S
> >>>> @@ -28,6 +28,12 @@ SYM_CODE_START(relocate_new_kernel)
> >>>>         move            s2, a2
> >>>>         move            s3, a3
> >>>>
> >>>> +       /*
> >>>> +        * In case of a kdump/crash kernel, the indirection page is not
> >>>> +        * populated as the kernel is directly copied to a reserved location
> >>>> +        */
> >>>> +       beqz            s2, done
> >>>> +
> >>>>  process_entry:
> >>>>         PTR_L           s4, s2, 0
> >>>>         PTR_ADDI        s2, s2, SZREG
> >>>> diff --git a/arch/loongarch/kernel/setup.c b/arch/loongarch/kernel/setup.c
> >>>> index f938aae3e92c..ea34b77e402f 100644
> >>>> --- a/arch/loongarch/kernel/setup.c
> >>>> +++ b/arch/loongarch/kernel/setup.c
> >>>> @@ -19,6 +19,8 @@
> >>>>  #include <linux/memblock.h>
> >>>>  #include <linux/initrd.h>
> >>>>  #include <linux/ioport.h>
> >>>> +#include <linux/kexec.h>
> >>>> +#include <linux/crash_dump.h>
> >>>>  #include <linux/root_dev.h>
> >>>>  #include <linux/console.h>
> >>>>  #include <linux/pfn.h>
> >>>> @@ -186,6 +188,50 @@ static int __init early_parse_mem(char *p)
> >>>>  }
> >>>>  early_param("mem", early_parse_mem);
> >>>>
> >>>> +static void __init loongarch_parse_crashkernel(void)
> >>>> +{
> >>>> +#ifdef CONFIG_KEXEC
> >>>> +       unsigned long long start;
> >>>> +       unsigned long long total_mem;
> >>>> +       unsigned long long crash_size, crash_base;
> >>>> +       int ret;
> >>>> +
> >>>> +       total_mem = memblock_phys_mem_size();
> >>>> +       ret = parse_crashkernel(boot_command_line, total_mem,
> >>>> +                               &crash_size, &crash_base);
> >>>> +       if (ret != 0 || crash_size <= 0)
> >>>> +               return;
> >>>> +
> >>>> +
> >>>> +       start = memblock_phys_alloc_range(crash_size, 1, crash_base,
> >>>> +                                       crash_base + crash_size);
> >>>> +       if (start != crash_base) {
> >>>> +               pr_warn("Invalid memory region reserved for crash kernel\n");
> >>>> +               return;
> >>>> +       }
> >>>> +
> >>>> +       crashk_res.start = crash_base;
> >>>> +       crashk_res.end   = crash_base + crash_size - 1;
> >>>> +#endif
> >>>> +}
> >>>> +
> >>>> +static void __init request_crashkernel(struct resource *res)
> >>>> +{
> >>>> +#ifdef CONFIG_KEXEC
> >>>> +       int ret;
> >>>> +
> >>>> +       if (crashk_res.start == crashk_res.end)
> >>>> +               return;
> >>>> +
> >>>> +       ret = request_resource(res, &crashk_res);
> >>>> +       if (!ret)
> >>>> +               pr_info("Reserving %ldMB of memory at %ldMB for crashkernel\n",
> >>>> +                       (unsigned long)((crashk_res.end -
> >>>> +                                        crashk_res.start + 1) >> 20),
> >>>> +                       (unsigned long)(crashk_res.start  >> 20));
> >>>> +#endif
> >>>> +}
> >>>> +
> >>>>  void __init platform_init(void)
> >>>>  {
> >>>>         efi_init();
> >>>> @@ -229,6 +275,8 @@ static void __init arch_mem_init(char **cmdline_p)
> >>>>
> >>>>         check_kernel_sections_mem();
> >>>>
> >>>> +       loongarch_parse_crashkernel();
> >>>> +
> >>>>         /*
> >>>>          * In order to reduce the possibility of kernel panic when failed to
> >>>>          * get IO TLB memory under CONFIG_SWIOTLB, it is better to allocate
> >>>> @@ -290,6 +338,7 @@ static void __init resource_init(void)
> >>>>                 request_resource(res, &code_resource);
> >>>>                 request_resource(res, &data_resource);
> >>>>                 request_resource(res, &bss_resource);
> >>>> +               request_crashkernel(res);
> >>>>         }
> >>>>  }
> >>>>
> >>>> diff --git a/arch/loongarch/kernel/traps.c b/arch/loongarch/kernel/traps.c
> >>>> index aa1c95aaf595..0e610872f3f4 100644
> >>>> --- a/arch/loongarch/kernel/traps.c
> >>>> +++ b/arch/loongarch/kernel/traps.c
> >>>> @@ -10,6 +10,7 @@
> >>>>  #include <linux/entry-common.h>
> >>>>  #include <linux/init.h>
> >>>>  #include <linux/kernel.h>
> >>>> +#include <linux/kexec.h>
> >>>>  #include <linux/module.h>
> >>>>  #include <linux/extable.h>
> >>>>  #include <linux/mm.h>
> >>>> @@ -246,6 +247,9 @@ void __noreturn die(const char *str, struct pt_regs *regs)
> >>>>
> >>>>         oops_exit();
> >>>>
> >>>> +       if (regs && kexec_should_crash(current))
> >>>> +               crash_kexec(regs);
> >>>> +
> >>>>         if (in_interrupt())
> >>>>                 panic("Fatal exception in interrupt");
> >>>>
> >>>> --
> >>>> 2.36.0
> >>>>
> >>
>

Re: [PATCH 2/3] LoongArch: Add kdump support

[Youling Tang]

On 09/05/2022 10:14 AM, Huacai Chen wrote:
> On Mon, Sep 5, 2022 at 10:04 AM Youling Tang <tangyouling@loongson.cn> wrote:
>>
>> Hi, Huacai
>>
>> On 09/05/2022 09:38 AM, Huacai Chen wrote:
>>> Hi, Youling,
>>>
>>> On Mon, Sep 5, 2022 at 8:54 AM Youling Tang <tangyouling@loongson.cn> wrote:
>>>>
>>>> Hi, Huacai
>>>>
>>>> On 09/04/2022 08:21 PM, Huacai Chen wrote:
>>>>> Hi, Youling,
>>>>>
>>>>> I think crash.c can be merged into crash_dump.c
>>>>
>>>> Most architectures only implement copy_oldmem_page() in crash_dump.c,
>>>> I'm not sure if merging crash.c into crash_dump.c will break its
>>>> consistency?
>>>>
>>>> Thanks,
>>>> Youling
>>> Yes, you are right, crash.c cannot be merged into crash_dump.c, but it
>>> can be merged into machine_kexec.c, as arm64 and riscv do.
>>
>> For arm64, machine_crash_shutdown() is placed in machine_kexec.c, and
>> crash_smp_send_stop is placed in smp.c. If crash.c needs to be merged
>> into machine_kexec.c, should crash_shutdown_secondary and
>> crash_smp_send_stop be placed in smp.c?
> I don't want to touch smp.c, all merged into machine_kexec.c seems reasonable.

Ok, I'll merge all into machine_kexec.c.

Youling.

>
> Huacai
>>
>> Youling.
>>>
>>> Huacai
>>>>
>>>>>
>>>>> Huacai
>>>>>
>>>>> On Mon, Aug 29, 2022 at 12:37 PM Youling Tang <tangyouling@loongson.cn> wrote:
>>>>>>
>>>>>> This patch adds support for kdump, the kernel will reserve a region
>>>>>> for the crash kernel and jump there on panic.
>>>>>>
>>>>>> Arch-specific functions are added to allow for implementing a crash
>>>>>> dump file interface, /proc/vmcore, which can be viewed as a ELF file.
>>>>>>
>>>>>> A user space tool, like kexec-tools, is responsible for allocating a
>>>>>> separate region for the core's ELF header within crash kdump kernel
>>>>>> memory and filling it in when executing kexec_load().
>>>>>>
>>>>>> Then, its location will be advertised to crash dump kernel via a new
>>>>>> device-tree property, "linux,elfcorehdr", and crash dump kernel preserves
>>>>>> the region for later use with fdt_reserve_elfcorehdr() at boot time.
>>>>>>
>>>>>> At the same time, it will also limit the crash kdump kernel to the
>>>>>> crashkernel area via a new device-tree property, "linux, usable-memory-range",
>>>>>> so as not to destroy the original kernel dump data.
>>>>>>
>>>>>> On crash dump kernel, /proc/vmcore will access the primary kernel's memory
>>>>>> with copy_oldmem_page().
>>>>>>
>>>>>> I tested this on  LoongArch 3A5000 machine and works as expected (Suggest
>>>>>> crashkernel parameter is "crashkernel=512M@2320M"), you may test it by
>>>>>> triggering a crash through /proc/sysrq_trigger:
>>>>>>
>>>>>>  $ sudo kexec -p /boot/vmlinux-kdump --reuse-cmdline --append="nr_cpus=1"
>>>>>>  # echo c > /proc/sysrq_trigger
>>>>>>
>>>>>> Signed-off-by: Youling Tang <tangyouling@loongson.cn>
>>>>>> ---
>>>>>>  arch/loongarch/Kconfig                  |  22 ++++++
>>>>>>  arch/loongarch/Makefile                 |   4 +
>>>>>>  arch/loongarch/kernel/Makefile          |   3 +-
>>>>>>  arch/loongarch/kernel/crash.c           | 100 ++++++++++++++++++++++++
>>>>>>  arch/loongarch/kernel/crash_dump.c      |  19 +++++
>>>>>>  arch/loongarch/kernel/machine_kexec.c   |  12 ++-
>>>>>>  arch/loongarch/kernel/mem.c             |   6 ++
>>>>>>  arch/loongarch/kernel/relocate_kernel.S |   6 ++
>>>>>>  arch/loongarch/kernel/setup.c           |  49 ++++++++++++
>>>>>>  arch/loongarch/kernel/traps.c           |   4 +
>>>>>>  10 files changed, 217 insertions(+), 8 deletions(-)
>>>>>>  create mode 100644 arch/loongarch/kernel/crash.c
>>>>>>  create mode 100644 arch/loongarch/kernel/crash_dump.c
>>>>>>
>>>>>> diff --git a/arch/loongarch/Kconfig b/arch/loongarch/Kconfig
>>>>>> index 903c82fa958d..7c1b07a5b5bd 100644
>>>>>> --- a/arch/loongarch/Kconfig
>>>>>> +++ b/arch/loongarch/Kconfig
>>>>>> @@ -420,6 +420,28 @@ config KEXEC
>>>>>>
>>>>>>           The name comes from the similarity to the exec system call.
>>>>>>
>>>>>> +config CRASH_DUMP
>>>>>> +       bool "Build kdump crash kernel"
>>>>>> +       help
>>>>>> +         Generate crash dump after being started by kexec. This should
>>>>>> +         be normally only set in special crash dump kernels which are
>>>>>> +         loaded in the main kernel with kexec-tools into a specially
>>>>>> +         reserved region and then later executed after a crash by
>>>>>> +         kdump/kexec.
>>>>>> +
>>>>>> +         For more details see Documentation/admin-guide/kdump/kdump.rst
>>>>>> +
>>>>>> +config PHYSICAL_START
>>>>>> +       hex "Physical address where the kernel is loaded"
>>>>>> +       default "0x9000000091000000" if 64BIT
>>>>>> +       depends on CRASH_DUMP
>>>>>> +       help
>>>>>> +         This gives the XKPRANGE address where the kernel is loaded.
>>>>>> +         If you plan to use kernel for capturing the crash dump change
>>>>>> +         this value to start of the reserved region (the "X" value as
>>>>>> +         specified in the "crashkernel=YM@XM" command line boot parameter
>>>>>> +         passed to the panic-ed kernel).
>>>>>> +
>>>>>>  config SECCOMP
>>>>>>         bool "Enable seccomp to safely compute untrusted bytecode"
>>>>>>         depends on PROC_FS
>>>>>> diff --git a/arch/loongarch/Makefile b/arch/loongarch/Makefile
>>>>>> index 4bc47f47cfd8..7dabd580426d 100644
>>>>>> --- a/arch/loongarch/Makefile
>>>>>> +++ b/arch/loongarch/Makefile
>>>>>> @@ -48,7 +48,11 @@ KBUILD_CFLAGS_MODULE         += -fplt -Wa,-mla-global-with-abs,-mla-local-with-abs
>>>>>>  cflags-y += -ffreestanding
>>>>>>  cflags-y += $(call cc-option, -mno-check-zero-division)
>>>>>>
>>>>>> +ifdef CONFIG_PHYSICAL_START
>>>>>> +load-y         = $(CONFIG_PHYSICAL_START)
>>>>>> +else
>>>>>>  load-y         = 0x9000000000200000
>>>>>> +endif
>>>>>>  bootvars-y     = VMLINUX_LOAD_ADDRESS=$(load-y)
>>>>>>
>>>>>>  drivers-$(CONFIG_PCI)          += arch/loongarch/pci/
>>>>>> diff --git a/arch/loongarch/kernel/Makefile b/arch/loongarch/kernel/Makefile
>>>>>> index 20b64ac3f128..df5aea129364 100644
>>>>>> --- a/arch/loongarch/kernel/Makefile
>>>>>> +++ b/arch/loongarch/kernel/Makefile
>>>>>> @@ -17,7 +17,8 @@ obj-$(CONFIG_CPU_HAS_FPU)     += fpu.o
>>>>>>  obj-$(CONFIG_MODULES)          += module.o module-sections.o
>>>>>>  obj-$(CONFIG_STACKTRACE)       += stacktrace.o
>>>>>>
>>>>>> -obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o
>>>>>> +obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o crash.o
>>>>>> +obj-$(CONFIG_CRASH_DUMP)        += crash_dump.o
>>>>>>
>>>>>>  obj-$(CONFIG_PROC_FS)          += proc.o
>>>>>>
>>>>>> diff --git a/arch/loongarch/kernel/crash.c b/arch/loongarch/kernel/crash.c
>>>>>> new file mode 100644
>>>>>> index 000000000000..b4f249ec6301
>>>>>> --- /dev/null
>>>>>> +++ b/arch/loongarch/kernel/crash.c
>>>>>> @@ -0,0 +1,100 @@
>>>>>> +// SPDX-License-Identifier: GPL-2.0
>>>>>> +/*
>>>>>> + * Copyright (C) 2022 Loongson Technology Corporation Limited
>>>>>> + *
>>>>>> + * Derived from MIPS
>>>>>> + */
>>>>>> +#include <linux/kernel.h>
>>>>>> +#include <linux/smp.h>
>>>>>> +#include <linux/reboot.h>
>>>>>> +#include <linux/crash_dump.h>
>>>>>> +#include <linux/delay.h>
>>>>>> +#include <linux/irq.h>
>>>>>> +#include <linux/types.h>
>>>>>> +#include <linux/sched.h>
>>>>>> +#include <linux/sched/task_stack.h>
>>>>>> +#include <asm/cacheflush.h>
>>>>>> +#include <asm/kexec.h>
>>>>>> +
>>>>>> +static cpumask_t cpus_in_crash = CPU_MASK_NONE;
>>>>>> +
>>>>>> +#ifdef CONFIG_SMP
>>>>>> +static void crash_shutdown_secondary(void *passed_regs)
>>>>>> +{
>>>>>> +       struct pt_regs *regs = passed_regs;
>>>>>> +       int cpu = smp_processor_id();
>>>>>> +
>>>>>> +       /*
>>>>>> +        * If we are passed registers, use those.  Otherwise get the
>>>>>> +        * regs from the last interrupt, which should be correct, as
>>>>>> +        * we are in an interrupt.  But if the regs are not there,
>>>>>> +        * pull them from the top of the stack.  They are probably
>>>>>> +        * wrong, but we need something to keep from crashing again.
>>>>>> +        */
>>>>>> +       if (!regs)
>>>>>> +               regs = get_irq_regs();
>>>>>> +       if (!regs)
>>>>>> +               regs = task_pt_regs(current);
>>>>>> +
>>>>>> +       local_irq_disable();
>>>>>> +       if (!cpumask_test_cpu(cpu, &cpus_in_crash))
>>>>>> +               crash_save_cpu(regs, cpu);
>>>>>> +       cpumask_set_cpu(cpu, &cpus_in_crash);
>>>>>> +
>>>>>> +       while (!atomic_read(&kexec_ready_to_reboot))
>>>>>> +               cpu_relax();
>>>>>> +
>>>>>> +       kexec_reboot();
>>>>>> +}
>>>>>> +
>>>>>> +/* Override the weak function in kernel/panic.c */
>>>>>> +void crash_smp_send_stop(void)
>>>>>> +{
>>>>>> +       static int cpus_stopped;
>>>>>> +       unsigned long timeout;
>>>>>> +       unsigned int ncpus;
>>>>>> +
>>>>>> +       /*
>>>>>> +        * This function can be called twice in panic path, but obviously
>>>>>> +        * we execute this only once.
>>>>>> +        */
>>>>>> +       if (cpus_stopped)
>>>>>> +               return;
>>>>>> +
>>>>>> +       cpus_stopped = 1;
>>>>>> +
>>>>>> +        /* Excluding the panic cpu */
>>>>>> +       ncpus = num_online_cpus() - 1;
>>>>>> +
>>>>>> +       smp_call_function(crash_shutdown_secondary, NULL, 0);
>>>>>> +       smp_wmb();
>>>>>> +
>>>>>> +       /*
>>>>>> +        * The crash CPU sends an IPI and wait for other CPUs to
>>>>>> +        * respond. Delay of at least 10 seconds.
>>>>>> +        */
>>>>>> +       pr_emerg("Sending IPI to other cpus...\n");
>>>>>> +       timeout = USEC_PER_SEC * 10;
>>>>>> +       while ((cpumask_weight(&cpus_in_crash) < ncpus) && timeout--) {
>>>>>> +               cpu_relax();
>>>>>> +               udelay(1);
>>>>>> +       }
>>>>>> +}
>>>>>> +
>>>>>> +#endif
>>>>>> +
>>>>>> +void machine_crash_shutdown(struct pt_regs *regs)
>>>>>> +{
>>>>>> +       int crashing_cpu;
>>>>>> +
>>>>>> +       local_irq_disable();
>>>>>> +
>>>>>> +       crashing_cpu = smp_processor_id();
>>>>>> +       crash_save_cpu(regs, crashing_cpu);
>>>>>> +
>>>>>> +       /* shutdown non-crashing cpus */
>>>>>> +       crash_smp_send_stop();
>>>>>> +       cpumask_set_cpu(crashing_cpu, &cpus_in_crash);
>>>>>> +
>>>>>> +       pr_info("Starting crashdump kernel...\n");
>>>>>> +}
>>>>>> diff --git a/arch/loongarch/kernel/crash_dump.c b/arch/loongarch/kernel/crash_dump.c
>>>>>> new file mode 100644
>>>>>> index 000000000000..13e5d2f7870d
>>>>>> --- /dev/null
>>>>>> +++ b/arch/loongarch/kernel/crash_dump.c
>>>>>> @@ -0,0 +1,19 @@
>>>>>> +// SPDX-License-Identifier: GPL-2.0
>>>>>> +#include <linux/highmem.h>
>>>>>> +#include <linux/crash_dump.h>
>>>>>> +#include <linux/io.h>
>>>>>> +
>>>>>> +ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn,
>>>>>> +                        size_t csize, unsigned long offset)
>>>>>> +{
>>>>>> +       void  *vaddr;
>>>>>> +
>>>>>> +       if (!csize)
>>>>>> +               return 0;
>>>>>> +
>>>>>> +       vaddr = kmap_local_pfn(pfn);
>>>>>> +       csize = copy_to_iter(vaddr + offset, csize, iter);
>>>>>> +       kunmap_local(vaddr);
>>>>>> +
>>>>>> +       return csize;
>>>>>> +}
>>>>>> diff --git a/arch/loongarch/kernel/machine_kexec.c b/arch/loongarch/kernel/machine_kexec.c
>>>>>> index 4ffcd4cd9c8c..f793a3ff09a3 100644
>>>>>> --- a/arch/loongarch/kernel/machine_kexec.c
>>>>>> +++ b/arch/loongarch/kernel/machine_kexec.c
>>>>>> @@ -69,7 +69,7 @@ int machine_kexec_prepare(struct kimage *kimage)
>>>>>>                 continue;
>>>>>>         }
>>>>>>
>>>>>> -       /* kexec need a safe page to save reboot_code_buffer */
>>>>>> +       /* kexec/kdump need a safe page to save reboot_code_buffer */
>>>>>>         kimage->control_code_page = virt_to_page((void *)KEXEC_CTRL_CODE);
>>>>>>
>>>>>>         reboot_code_buffer =
>>>>>> @@ -113,10 +113,6 @@ static void kexec_shutdown_secondary(void *)
>>>>>>
>>>>>>         kexec_reboot();
>>>>>>  }
>>>>>> -
>>>>>> -void machine_crash_shutdown(struct pt_regs *regs)
>>>>>> -{
>>>>>> -}
>>>>>>  #endif
>>>>>>
>>>>>>  void machine_shutdown(void)
>>>>>> @@ -135,7 +131,8 @@ void machine_kexec(struct kimage *image)
>>>>>>
>>>>>>         jump_addr = (unsigned long)phys_to_virt(image->start);
>>>>>>
>>>>>> -       first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
>>>>>> +       if (image->type == KEXEC_TYPE_DEFAULT)
>>>>>> +               first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
>>>>>>
>>>>>>         /*
>>>>>>          * The generic kexec code builds a page list with physical
>>>>>> @@ -167,7 +164,8 @@ void machine_kexec(struct kimage *image)
>>>>>>
>>>>>>         /*
>>>>>>          * We know we were online, and there will be no incoming IPIs at
>>>>>> -        * this point.
>>>>>> +        * this point. Mark online again before rebooting so that the crash
>>>>>> +        * analysis tool will see us correctly.
>>>>>>          */
>>>>>>         set_cpu_online(smp_processor_id(), true);
>>>>>>
>>>>>> diff --git a/arch/loongarch/kernel/mem.c b/arch/loongarch/kernel/mem.c
>>>>>> index 7423361b0ebc..c6def6ff81c8 100644
>>>>>> --- a/arch/loongarch/kernel/mem.c
>>>>>> +++ b/arch/loongarch/kernel/mem.c
>>>>>> @@ -5,6 +5,7 @@
>>>>>>  #include <linux/efi.h>
>>>>>>  #include <linux/initrd.h>
>>>>>>  #include <linux/memblock.h>
>>>>>> +#include <linux/of_fdt.h>
>>>>>>
>>>>>>  #include <asm/bootinfo.h>
>>>>>>  #include <asm/loongson.h>
>>>>>> @@ -61,4 +62,9 @@ void __init memblock_init(void)
>>>>>>
>>>>>>         /* Reserve the initrd */
>>>>>>         reserve_initrd_mem();
>>>>>> +
>>>>>> +       /* Mainly reserved memory for the elf core head */
>>>>>> +       early_init_fdt_scan_reserved_mem();
>>>>>> +       /* Parse linux,usable-memory-range is for crash dump kernel */
>>>>>> +       early_init_dt_check_for_usable_mem_range();
>>>>>>  }
>>>>>> diff --git a/arch/loongarch/kernel/relocate_kernel.S b/arch/loongarch/kernel/relocate_kernel.S
>>>>>> index d1f242f74ea8..4ee5ac4ac2d7 100644
>>>>>> --- a/arch/loongarch/kernel/relocate_kernel.S
>>>>>> +++ b/arch/loongarch/kernel/relocate_kernel.S
>>>>>> @@ -28,6 +28,12 @@ SYM_CODE_START(relocate_new_kernel)
>>>>>>         move            s2, a2
>>>>>>         move            s3, a3
>>>>>>
>>>>>> +       /*
>>>>>> +        * In case of a kdump/crash kernel, the indirection page is not
>>>>>> +        * populated as the kernel is directly copied to a reserved location
>>>>>> +        */
>>>>>> +       beqz            s2, done
>>>>>> +
>>>>>>  process_entry:
>>>>>>         PTR_L           s4, s2, 0
>>>>>>         PTR_ADDI        s2, s2, SZREG
>>>>>> diff --git a/arch/loongarch/kernel/setup.c b/arch/loongarch/kernel/setup.c
>>>>>> index f938aae3e92c..ea34b77e402f 100644
>>>>>> --- a/arch/loongarch/kernel/setup.c
>>>>>> +++ b/arch/loongarch/kernel/setup.c
>>>>>> @@ -19,6 +19,8 @@
>>>>>>  #include <linux/memblock.h>
>>>>>>  #include <linux/initrd.h>
>>>>>>  #include <linux/ioport.h>
>>>>>> +#include <linux/kexec.h>
>>>>>> +#include <linux/crash_dump.h>
>>>>>>  #include <linux/root_dev.h>
>>>>>>  #include <linux/console.h>
>>>>>>  #include <linux/pfn.h>
>>>>>> @@ -186,6 +188,50 @@ static int __init early_parse_mem(char *p)
>>>>>>  }
>>>>>>  early_param("mem", early_parse_mem);
>>>>>>
>>>>>> +static void __init loongarch_parse_crashkernel(void)
>>>>>> +{
>>>>>> +#ifdef CONFIG_KEXEC
>>>>>> +       unsigned long long start;
>>>>>> +       unsigned long long total_mem;
>>>>>> +       unsigned long long crash_size, crash_base;
>>>>>> +       int ret;
>>>>>> +
>>>>>> +       total_mem = memblock_phys_mem_size();
>>>>>> +       ret = parse_crashkernel(boot_command_line, total_mem,
>>>>>> +                               &crash_size, &crash_base);
>>>>>> +       if (ret != 0 || crash_size <= 0)
>>>>>> +               return;
>>>>>> +
>>>>>> +
>>>>>> +       start = memblock_phys_alloc_range(crash_size, 1, crash_base,
>>>>>> +                                       crash_base + crash_size);
>>>>>> +       if (start != crash_base) {
>>>>>> +               pr_warn("Invalid memory region reserved for crash kernel\n");
>>>>>> +               return;
>>>>>> +       }
>>>>>> +
>>>>>> +       crashk_res.start = crash_base;
>>>>>> +       crashk_res.end   = crash_base + crash_size - 1;
>>>>>> +#endif
>>>>>> +}
>>>>>> +
>>>>>> +static void __init request_crashkernel(struct resource *res)
>>>>>> +{
>>>>>> +#ifdef CONFIG_KEXEC
>>>>>> +       int ret;
>>>>>> +
>>>>>> +       if (crashk_res.start == crashk_res.end)
>>>>>> +               return;
>>>>>> +
>>>>>> +       ret = request_resource(res, &crashk_res);
>>>>>> +       if (!ret)
>>>>>> +               pr_info("Reserving %ldMB of memory at %ldMB for crashkernel\n",
>>>>>> +                       (unsigned long)((crashk_res.end -
>>>>>> +                                        crashk_res.start + 1) >> 20),
>>>>>> +                       (unsigned long)(crashk_res.start  >> 20));
>>>>>> +#endif
>>>>>> +}
>>>>>> +
>>>>>>  void __init platform_init(void)
>>>>>>  {
>>>>>>         efi_init();
>>>>>> @@ -229,6 +275,8 @@ static void __init arch_mem_init(char **cmdline_p)
>>>>>>
>>>>>>         check_kernel_sections_mem();
>>>>>>
>>>>>> +       loongarch_parse_crashkernel();
>>>>>> +
>>>>>>         /*
>>>>>>          * In order to reduce the possibility of kernel panic when failed to
>>>>>>          * get IO TLB memory under CONFIG_SWIOTLB, it is better to allocate
>>>>>> @@ -290,6 +338,7 @@ static void __init resource_init(void)
>>>>>>                 request_resource(res, &code_resource);
>>>>>>                 request_resource(res, &data_resource);
>>>>>>                 request_resource(res, &bss_resource);
>>>>>> +               request_crashkernel(res);
>>>>>>         }
>>>>>>  }
>>>>>>
>>>>>> diff --git a/arch/loongarch/kernel/traps.c b/arch/loongarch/kernel/traps.c
>>>>>> index aa1c95aaf595..0e610872f3f4 100644
>>>>>> --- a/arch/loongarch/kernel/traps.c
>>>>>> +++ b/arch/loongarch/kernel/traps.c
>>>>>> @@ -10,6 +10,7 @@
>>>>>>  #include <linux/entry-common.h>
>>>>>>  #include <linux/init.h>
>>>>>>  #include <linux/kernel.h>
>>>>>> +#include <linux/kexec.h>
>>>>>>  #include <linux/module.h>
>>>>>>  #include <linux/extable.h>
>>>>>>  #include <linux/mm.h>
>>>>>> @@ -246,6 +247,9 @@ void __noreturn die(const char *str, struct pt_regs *regs)
>>>>>>
>>>>>>         oops_exit();
>>>>>>
>>>>>> +       if (regs && kexec_should_crash(current))
>>>>>> +               crash_kexec(regs);
>>>>>> +
>>>>>>         if (in_interrupt())
>>>>>>                 panic("Fatal exception in interrupt");
>>>>>>
>>>>>> --
>>>>>> 2.36.0
>>>>>>
>>>>
>>

Re: [PATCH 2/3] LoongArch: Add kdump support

[Huacai Chen]

Hi, Youling,

On Mon, Sep 5, 2022 at 10:22 AM Youling Tang <tangyouling@loongson.cn> wrote:
>
>
>
> On 09/05/2022 10:14 AM, Huacai Chen wrote:
> > On Mon, Sep 5, 2022 at 10:04 AM Youling Tang <tangyouling@loongson.cn> wrote:
> >>
> >> Hi, Huacai
> >>
> >> On 09/05/2022 09:38 AM, Huacai Chen wrote:
> >>> Hi, Youling,
> >>>
> >>> On Mon, Sep 5, 2022 at 8:54 AM Youling Tang <tangyouling@loongson.cn> wrote:
> >>>>
> >>>> Hi, Huacai
> >>>>
> >>>> On 09/04/2022 08:21 PM, Huacai Chen wrote:
> >>>>> Hi, Youling,
> >>>>>
> >>>>> I think crash.c can be merged into crash_dump.c
> >>>>
> >>>> Most architectures only implement copy_oldmem_page() in crash_dump.c,
> >>>> I'm not sure if merging crash.c into crash_dump.c will break its
> >>>> consistency?
> >>>>
> >>>> Thanks,
> >>>> Youling
> >>> Yes, you are right, crash.c cannot be merged into crash_dump.c, but it
> >>> can be merged into machine_kexec.c, as arm64 and riscv do.
> >>
> >> For arm64, machine_crash_shutdown() is placed in machine_kexec.c, and
> >> crash_smp_send_stop is placed in smp.c. If crash.c needs to be merged
> >> into machine_kexec.c, should crash_shutdown_secondary and
> >> crash_smp_send_stop be placed in smp.c?
> > I don't want to touch smp.c, all merged into machine_kexec.c seems reasonable.
>
> Ok, I'll merge all into machine_kexec.c.
>
> Youling.
Another problem, 0x9000000091000000 for PHYSICAL_START is too tricky.
If you want to skip the "low memory", maybe we can use
0x9000000090000000 or 0x90000000a0000000?

Huacai
>
> >
> > Huacai
> >>
> >> Youling.
> >>>
> >>> Huacai
> >>>>
> >>>>>
> >>>>> Huacai
> >>>>>
> >>>>> On Mon, Aug 29, 2022 at 12:37 PM Youling Tang <tangyouling@loongson.cn> wrote:
> >>>>>>
> >>>>>> This patch adds support for kdump, the kernel will reserve a region
> >>>>>> for the crash kernel and jump there on panic.
> >>>>>>
> >>>>>> Arch-specific functions are added to allow for implementing a crash
> >>>>>> dump file interface, /proc/vmcore, which can be viewed as a ELF file.
> >>>>>>
> >>>>>> A user space tool, like kexec-tools, is responsible for allocating a
> >>>>>> separate region for the core's ELF header within crash kdump kernel
> >>>>>> memory and filling it in when executing kexec_load().
> >>>>>>
> >>>>>> Then, its location will be advertised to crash dump kernel via a new
> >>>>>> device-tree property, "linux,elfcorehdr", and crash dump kernel preserves
> >>>>>> the region for later use with fdt_reserve_elfcorehdr() at boot time.
> >>>>>>
> >>>>>> At the same time, it will also limit the crash kdump kernel to the
> >>>>>> crashkernel area via a new device-tree property, "linux, usable-memory-range",
> >>>>>> so as not to destroy the original kernel dump data.
> >>>>>>
> >>>>>> On crash dump kernel, /proc/vmcore will access the primary kernel's memory
> >>>>>> with copy_oldmem_page().
> >>>>>>
> >>>>>> I tested this on  LoongArch 3A5000 machine and works as expected (Suggest
> >>>>>> crashkernel parameter is "crashkernel=512M@2320M"), you may test it by
> >>>>>> triggering a crash through /proc/sysrq_trigger:
> >>>>>>
> >>>>>>  $ sudo kexec -p /boot/vmlinux-kdump --reuse-cmdline --append="nr_cpus=1"
> >>>>>>  # echo c > /proc/sysrq_trigger
> >>>>>>
> >>>>>> Signed-off-by: Youling Tang <tangyouling@loongson.cn>
> >>>>>> ---
> >>>>>>  arch/loongarch/Kconfig                  |  22 ++++++
> >>>>>>  arch/loongarch/Makefile                 |   4 +
> >>>>>>  arch/loongarch/kernel/Makefile          |   3 +-
> >>>>>>  arch/loongarch/kernel/crash.c           | 100 ++++++++++++++++++++++++
> >>>>>>  arch/loongarch/kernel/crash_dump.c      |  19 +++++
> >>>>>>  arch/loongarch/kernel/machine_kexec.c   |  12 ++-
> >>>>>>  arch/loongarch/kernel/mem.c             |   6 ++
> >>>>>>  arch/loongarch/kernel/relocate_kernel.S |   6 ++
> >>>>>>  arch/loongarch/kernel/setup.c           |  49 ++++++++++++
> >>>>>>  arch/loongarch/kernel/traps.c           |   4 +
> >>>>>>  10 files changed, 217 insertions(+), 8 deletions(-)
> >>>>>>  create mode 100644 arch/loongarch/kernel/crash.c
> >>>>>>  create mode 100644 arch/loongarch/kernel/crash_dump.c
> >>>>>>
> >>>>>> diff --git a/arch/loongarch/Kconfig b/arch/loongarch/Kconfig
> >>>>>> index 903c82fa958d..7c1b07a5b5bd 100644
> >>>>>> --- a/arch/loongarch/Kconfig
> >>>>>> +++ b/arch/loongarch/Kconfig
> >>>>>> @@ -420,6 +420,28 @@ config KEXEC
> >>>>>>
> >>>>>>           The name comes from the similarity to the exec system call.
> >>>>>>
> >>>>>> +config CRASH_DUMP
> >>>>>> +       bool "Build kdump crash kernel"
> >>>>>> +       help
> >>>>>> +         Generate crash dump after being started by kexec. This should
> >>>>>> +         be normally only set in special crash dump kernels which are
> >>>>>> +         loaded in the main kernel with kexec-tools into a specially
> >>>>>> +         reserved region and then later executed after a crash by
> >>>>>> +         kdump/kexec.
> >>>>>> +
> >>>>>> +         For more details see Documentation/admin-guide/kdump/kdump.rst
> >>>>>> +
> >>>>>> +config PHYSICAL_START
> >>>>>> +       hex "Physical address where the kernel is loaded"
> >>>>>> +       default "0x9000000091000000" if 64BIT
> >>>>>> +       depends on CRASH_DUMP
> >>>>>> +       help
> >>>>>> +         This gives the XKPRANGE address where the kernel is loaded.
> >>>>>> +         If you plan to use kernel for capturing the crash dump change
> >>>>>> +         this value to start of the reserved region (the "X" value as
> >>>>>> +         specified in the "crashkernel=YM@XM" command line boot parameter
> >>>>>> +         passed to the panic-ed kernel).
> >>>>>> +
> >>>>>>  config SECCOMP
> >>>>>>         bool "Enable seccomp to safely compute untrusted bytecode"
> >>>>>>         depends on PROC_FS
> >>>>>> diff --git a/arch/loongarch/Makefile b/arch/loongarch/Makefile
> >>>>>> index 4bc47f47cfd8..7dabd580426d 100644
> >>>>>> --- a/arch/loongarch/Makefile
> >>>>>> +++ b/arch/loongarch/Makefile
> >>>>>> @@ -48,7 +48,11 @@ KBUILD_CFLAGS_MODULE         += -fplt -Wa,-mla-global-with-abs,-mla-local-with-abs
> >>>>>>  cflags-y += -ffreestanding
> >>>>>>  cflags-y += $(call cc-option, -mno-check-zero-division)
> >>>>>>
> >>>>>> +ifdef CONFIG_PHYSICAL_START
> >>>>>> +load-y         = $(CONFIG_PHYSICAL_START)
> >>>>>> +else
> >>>>>>  load-y         = 0x9000000000200000
> >>>>>> +endif
> >>>>>>  bootvars-y     = VMLINUX_LOAD_ADDRESS=$(load-y)
> >>>>>>
> >>>>>>  drivers-$(CONFIG_PCI)          += arch/loongarch/pci/
> >>>>>> diff --git a/arch/loongarch/kernel/Makefile b/arch/loongarch/kernel/Makefile
> >>>>>> index 20b64ac3f128..df5aea129364 100644
> >>>>>> --- a/arch/loongarch/kernel/Makefile
> >>>>>> +++ b/arch/loongarch/kernel/Makefile
> >>>>>> @@ -17,7 +17,8 @@ obj-$(CONFIG_CPU_HAS_FPU)     += fpu.o
> >>>>>>  obj-$(CONFIG_MODULES)          += module.o module-sections.o
> >>>>>>  obj-$(CONFIG_STACKTRACE)       += stacktrace.o
> >>>>>>
> >>>>>> -obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o
> >>>>>> +obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o crash.o
> >>>>>> +obj-$(CONFIG_CRASH_DUMP)        += crash_dump.o
> >>>>>>
> >>>>>>  obj-$(CONFIG_PROC_FS)          += proc.o
> >>>>>>
> >>>>>> diff --git a/arch/loongarch/kernel/crash.c b/arch/loongarch/kernel/crash.c
> >>>>>> new file mode 100644
> >>>>>> index 000000000000..b4f249ec6301
> >>>>>> --- /dev/null
> >>>>>> +++ b/arch/loongarch/kernel/crash.c
> >>>>>> @@ -0,0 +1,100 @@
> >>>>>> +// SPDX-License-Identifier: GPL-2.0
> >>>>>> +/*
> >>>>>> + * Copyright (C) 2022 Loongson Technology Corporation Limited
> >>>>>> + *
> >>>>>> + * Derived from MIPS
> >>>>>> + */
> >>>>>> +#include <linux/kernel.h>
> >>>>>> +#include <linux/smp.h>
> >>>>>> +#include <linux/reboot.h>
> >>>>>> +#include <linux/crash_dump.h>
> >>>>>> +#include <linux/delay.h>
> >>>>>> +#include <linux/irq.h>
> >>>>>> +#include <linux/types.h>
> >>>>>> +#include <linux/sched.h>
> >>>>>> +#include <linux/sched/task_stack.h>
> >>>>>> +#include <asm/cacheflush.h>
> >>>>>> +#include <asm/kexec.h>
> >>>>>> +
> >>>>>> +static cpumask_t cpus_in_crash = CPU_MASK_NONE;
> >>>>>> +
> >>>>>> +#ifdef CONFIG_SMP
> >>>>>> +static void crash_shutdown_secondary(void *passed_regs)
> >>>>>> +{
> >>>>>> +       struct pt_regs *regs = passed_regs;
> >>>>>> +       int cpu = smp_processor_id();
> >>>>>> +
> >>>>>> +       /*
> >>>>>> +        * If we are passed registers, use those.  Otherwise get the
> >>>>>> +        * regs from the last interrupt, which should be correct, as
> >>>>>> +        * we are in an interrupt.  But if the regs are not there,
> >>>>>> +        * pull them from the top of the stack.  They are probably
> >>>>>> +        * wrong, but we need something to keep from crashing again.
> >>>>>> +        */
> >>>>>> +       if (!regs)
> >>>>>> +               regs = get_irq_regs();
> >>>>>> +       if (!regs)
> >>>>>> +               regs = task_pt_regs(current);
> >>>>>> +
> >>>>>> +       local_irq_disable();
> >>>>>> +       if (!cpumask_test_cpu(cpu, &cpus_in_crash))
> >>>>>> +               crash_save_cpu(regs, cpu);
> >>>>>> +       cpumask_set_cpu(cpu, &cpus_in_crash);
> >>>>>> +
> >>>>>> +       while (!atomic_read(&kexec_ready_to_reboot))
> >>>>>> +               cpu_relax();
> >>>>>> +
> >>>>>> +       kexec_reboot();
> >>>>>> +}
> >>>>>> +
> >>>>>> +/* Override the weak function in kernel/panic.c */
> >>>>>> +void crash_smp_send_stop(void)
> >>>>>> +{
> >>>>>> +       static int cpus_stopped;
> >>>>>> +       unsigned long timeout;
> >>>>>> +       unsigned int ncpus;
> >>>>>> +
> >>>>>> +       /*
> >>>>>> +        * This function can be called twice in panic path, but obviously
> >>>>>> +        * we execute this only once.
> >>>>>> +        */
> >>>>>> +       if (cpus_stopped)
> >>>>>> +               return;
> >>>>>> +
> >>>>>> +       cpus_stopped = 1;
> >>>>>> +
> >>>>>> +        /* Excluding the panic cpu */
> >>>>>> +       ncpus = num_online_cpus() - 1;
> >>>>>> +
> >>>>>> +       smp_call_function(crash_shutdown_secondary, NULL, 0);
> >>>>>> +       smp_wmb();
> >>>>>> +
> >>>>>> +       /*
> >>>>>> +        * The crash CPU sends an IPI and wait for other CPUs to
> >>>>>> +        * respond. Delay of at least 10 seconds.
> >>>>>> +        */
> >>>>>> +       pr_emerg("Sending IPI to other cpus...\n");
> >>>>>> +       timeout = USEC_PER_SEC * 10;
> >>>>>> +       while ((cpumask_weight(&cpus_in_crash) < ncpus) && timeout--) {
> >>>>>> +               cpu_relax();
> >>>>>> +               udelay(1);
> >>>>>> +       }
> >>>>>> +}
> >>>>>> +
> >>>>>> +#endif
> >>>>>> +
> >>>>>> +void machine_crash_shutdown(struct pt_regs *regs)
> >>>>>> +{
> >>>>>> +       int crashing_cpu;
> >>>>>> +
> >>>>>> +       local_irq_disable();
> >>>>>> +
> >>>>>> +       crashing_cpu = smp_processor_id();
> >>>>>> +       crash_save_cpu(regs, crashing_cpu);
> >>>>>> +
> >>>>>> +       /* shutdown non-crashing cpus */
> >>>>>> +       crash_smp_send_stop();
> >>>>>> +       cpumask_set_cpu(crashing_cpu, &cpus_in_crash);
> >>>>>> +
> >>>>>> +       pr_info("Starting crashdump kernel...\n");
> >>>>>> +}
> >>>>>> diff --git a/arch/loongarch/kernel/crash_dump.c b/arch/loongarch/kernel/crash_dump.c
> >>>>>> new file mode 100644
> >>>>>> index 000000000000..13e5d2f7870d
> >>>>>> --- /dev/null
> >>>>>> +++ b/arch/loongarch/kernel/crash_dump.c
> >>>>>> @@ -0,0 +1,19 @@
> >>>>>> +// SPDX-License-Identifier: GPL-2.0
> >>>>>> +#include <linux/highmem.h>
> >>>>>> +#include <linux/crash_dump.h>
> >>>>>> +#include <linux/io.h>
> >>>>>> +
> >>>>>> +ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn,
> >>>>>> +                        size_t csize, unsigned long offset)
> >>>>>> +{
> >>>>>> +       void  *vaddr;
> >>>>>> +
> >>>>>> +       if (!csize)
> >>>>>> +               return 0;
> >>>>>> +
> >>>>>> +       vaddr = kmap_local_pfn(pfn);
> >>>>>> +       csize = copy_to_iter(vaddr + offset, csize, iter);
> >>>>>> +       kunmap_local(vaddr);
> >>>>>> +
> >>>>>> +       return csize;
> >>>>>> +}
> >>>>>> diff --git a/arch/loongarch/kernel/machine_kexec.c b/arch/loongarch/kernel/machine_kexec.c
> >>>>>> index 4ffcd4cd9c8c..f793a3ff09a3 100644
> >>>>>> --- a/arch/loongarch/kernel/machine_kexec.c
> >>>>>> +++ b/arch/loongarch/kernel/machine_kexec.c
> >>>>>> @@ -69,7 +69,7 @@ int machine_kexec_prepare(struct kimage *kimage)
> >>>>>>                 continue;
> >>>>>>         }
> >>>>>>
> >>>>>> -       /* kexec need a safe page to save reboot_code_buffer */
> >>>>>> +       /* kexec/kdump need a safe page to save reboot_code_buffer */
> >>>>>>         kimage->control_code_page = virt_to_page((void *)KEXEC_CTRL_CODE);
> >>>>>>
> >>>>>>         reboot_code_buffer =
> >>>>>> @@ -113,10 +113,6 @@ static void kexec_shutdown_secondary(void *)
> >>>>>>
> >>>>>>         kexec_reboot();
> >>>>>>  }
> >>>>>> -
> >>>>>> -void machine_crash_shutdown(struct pt_regs *regs)
> >>>>>> -{
> >>>>>> -}
> >>>>>>  #endif
> >>>>>>
> >>>>>>  void machine_shutdown(void)
> >>>>>> @@ -135,7 +131,8 @@ void machine_kexec(struct kimage *image)
> >>>>>>
> >>>>>>         jump_addr = (unsigned long)phys_to_virt(image->start);
> >>>>>>
> >>>>>> -       first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
> >>>>>> +       if (image->type == KEXEC_TYPE_DEFAULT)
> >>>>>> +               first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
> >>>>>>
> >>>>>>         /*
> >>>>>>          * The generic kexec code builds a page list with physical
> >>>>>> @@ -167,7 +164,8 @@ void machine_kexec(struct kimage *image)
> >>>>>>
> >>>>>>         /*
> >>>>>>          * We know we were online, and there will be no incoming IPIs at
> >>>>>> -        * this point.
> >>>>>> +        * this point. Mark online again before rebooting so that the crash
> >>>>>> +        * analysis tool will see us correctly.
> >>>>>>          */
> >>>>>>         set_cpu_online(smp_processor_id(), true);
> >>>>>>
> >>>>>> diff --git a/arch/loongarch/kernel/mem.c b/arch/loongarch/kernel/mem.c
> >>>>>> index 7423361b0ebc..c6def6ff81c8 100644
> >>>>>> --- a/arch/loongarch/kernel/mem.c
> >>>>>> +++ b/arch/loongarch/kernel/mem.c
> >>>>>> @@ -5,6 +5,7 @@
> >>>>>>  #include <linux/efi.h>
> >>>>>>  #include <linux/initrd.h>
> >>>>>>  #include <linux/memblock.h>
> >>>>>> +#include <linux/of_fdt.h>
> >>>>>>
> >>>>>>  #include <asm/bootinfo.h>
> >>>>>>  #include <asm/loongson.h>
> >>>>>> @@ -61,4 +62,9 @@ void __init memblock_init(void)
> >>>>>>
> >>>>>>         /* Reserve the initrd */
> >>>>>>         reserve_initrd_mem();
> >>>>>> +
> >>>>>> +       /* Mainly reserved memory for the elf core head */
> >>>>>> +       early_init_fdt_scan_reserved_mem();
> >>>>>> +       /* Parse linux,usable-memory-range is for crash dump kernel */
> >>>>>> +       early_init_dt_check_for_usable_mem_range();
> >>>>>>  }
> >>>>>> diff --git a/arch/loongarch/kernel/relocate_kernel.S b/arch/loongarch/kernel/relocate_kernel.S
> >>>>>> index d1f242f74ea8..4ee5ac4ac2d7 100644
> >>>>>> --- a/arch/loongarch/kernel/relocate_kernel.S
> >>>>>> +++ b/arch/loongarch/kernel/relocate_kernel.S
> >>>>>> @@ -28,6 +28,12 @@ SYM_CODE_START(relocate_new_kernel)
> >>>>>>         move            s2, a2
> >>>>>>         move            s3, a3
> >>>>>>
> >>>>>> +       /*
> >>>>>> +        * In case of a kdump/crash kernel, the indirection page is not
> >>>>>> +        * populated as the kernel is directly copied to a reserved location
> >>>>>> +        */
> >>>>>> +       beqz            s2, done
> >>>>>> +
> >>>>>>  process_entry:
> >>>>>>         PTR_L           s4, s2, 0
> >>>>>>         PTR_ADDI        s2, s2, SZREG
> >>>>>> diff --git a/arch/loongarch/kernel/setup.c b/arch/loongarch/kernel/setup.c
> >>>>>> index f938aae3e92c..ea34b77e402f 100644
> >>>>>> --- a/arch/loongarch/kernel/setup.c
> >>>>>> +++ b/arch/loongarch/kernel/setup.c
> >>>>>> @@ -19,6 +19,8 @@
> >>>>>>  #include <linux/memblock.h>
> >>>>>>  #include <linux/initrd.h>
> >>>>>>  #include <linux/ioport.h>
> >>>>>> +#include <linux/kexec.h>
> >>>>>> +#include <linux/crash_dump.h>
> >>>>>>  #include <linux/root_dev.h>
> >>>>>>  #include <linux/console.h>
> >>>>>>  #include <linux/pfn.h>
> >>>>>> @@ -186,6 +188,50 @@ static int __init early_parse_mem(char *p)
> >>>>>>  }
> >>>>>>  early_param("mem", early_parse_mem);
> >>>>>>
> >>>>>> +static void __init loongarch_parse_crashkernel(void)
> >>>>>> +{
> >>>>>> +#ifdef CONFIG_KEXEC
> >>>>>> +       unsigned long long start;
> >>>>>> +       unsigned long long total_mem;
> >>>>>> +       unsigned long long crash_size, crash_base;
> >>>>>> +       int ret;
> >>>>>> +
> >>>>>> +       total_mem = memblock_phys_mem_size();
> >>>>>> +       ret = parse_crashkernel(boot_command_line, total_mem,
> >>>>>> +                               &crash_size, &crash_base);
> >>>>>> +       if (ret != 0 || crash_size <= 0)
> >>>>>> +               return;
> >>>>>> +
> >>>>>> +
> >>>>>> +       start = memblock_phys_alloc_range(crash_size, 1, crash_base,
> >>>>>> +                                       crash_base + crash_size);
> >>>>>> +       if (start != crash_base) {
> >>>>>> +               pr_warn("Invalid memory region reserved for crash kernel\n");
> >>>>>> +               return;
> >>>>>> +       }
> >>>>>> +
> >>>>>> +       crashk_res.start = crash_base;
> >>>>>> +       crashk_res.end   = crash_base + crash_size - 1;
> >>>>>> +#endif
> >>>>>> +}
> >>>>>> +
> >>>>>> +static void __init request_crashkernel(struct resource *res)
> >>>>>> +{
> >>>>>> +#ifdef CONFIG_KEXEC
> >>>>>> +       int ret;
> >>>>>> +
> >>>>>> +       if (crashk_res.start == crashk_res.end)
> >>>>>> +               return;
> >>>>>> +
> >>>>>> +       ret = request_resource(res, &crashk_res);
> >>>>>> +       if (!ret)
> >>>>>> +               pr_info("Reserving %ldMB of memory at %ldMB for crashkernel\n",
> >>>>>> +                       (unsigned long)((crashk_res.end -
> >>>>>> +                                        crashk_res.start + 1) >> 20),
> >>>>>> +                       (unsigned long)(crashk_res.start  >> 20));
> >>>>>> +#endif
> >>>>>> +}
> >>>>>> +
> >>>>>>  void __init platform_init(void)
> >>>>>>  {
> >>>>>>         efi_init();
> >>>>>> @@ -229,6 +275,8 @@ static void __init arch_mem_init(char **cmdline_p)
> >>>>>>
> >>>>>>         check_kernel_sections_mem();
> >>>>>>
> >>>>>> +       loongarch_parse_crashkernel();
> >>>>>> +
> >>>>>>         /*
> >>>>>>          * In order to reduce the possibility of kernel panic when failed to
> >>>>>>          * get IO TLB memory under CONFIG_SWIOTLB, it is better to allocate
> >>>>>> @@ -290,6 +338,7 @@ static void __init resource_init(void)
> >>>>>>                 request_resource(res, &code_resource);
> >>>>>>                 request_resource(res, &data_resource);
> >>>>>>                 request_resource(res, &bss_resource);
> >>>>>> +               request_crashkernel(res);
> >>>>>>         }
> >>>>>>  }
> >>>>>>
> >>>>>> diff --git a/arch/loongarch/kernel/traps.c b/arch/loongarch/kernel/traps.c
> >>>>>> index aa1c95aaf595..0e610872f3f4 100644
> >>>>>> --- a/arch/loongarch/kernel/traps.c
> >>>>>> +++ b/arch/loongarch/kernel/traps.c
> >>>>>> @@ -10,6 +10,7 @@
> >>>>>>  #include <linux/entry-common.h>
> >>>>>>  #include <linux/init.h>
> >>>>>>  #include <linux/kernel.h>
> >>>>>> +#include <linux/kexec.h>
> >>>>>>  #include <linux/module.h>
> >>>>>>  #include <linux/extable.h>
> >>>>>>  #include <linux/mm.h>
> >>>>>> @@ -246,6 +247,9 @@ void __noreturn die(const char *str, struct pt_regs *regs)
> >>>>>>
> >>>>>>         oops_exit();
> >>>>>>
> >>>>>> +       if (regs && kexec_should_crash(current))
> >>>>>> +               crash_kexec(regs);
> >>>>>> +
> >>>>>>         if (in_interrupt())
> >>>>>>                 panic("Fatal exception in interrupt");
> >>>>>>
> >>>>>> --
> >>>>>> 2.36.0
> >>>>>>
> >>>>
> >>
>

Re: [PATCH 2/3] LoongArch: Add kdump support

[Youling Tang]

Hi, Huacai

On 09/05/2022 03:32 PM, Huacai Chen wrote:
> Hi, Youling,
>
> On Mon, Sep 5, 2022 at 10:22 AM Youling Tang <tangyouling@loongson.cn> wrote:
>>
>>
>>
>> On 09/05/2022 10:14 AM, Huacai Chen wrote:
>>> On Mon, Sep 5, 2022 at 10:04 AM Youling Tang <tangyouling@loongson.cn> wrote:
>>>>
>>>> Hi, Huacai
>>>>
>>>> On 09/05/2022 09:38 AM, Huacai Chen wrote:
>>>>> Hi, Youling,
>>>>>
>>>>> On Mon, Sep 5, 2022 at 8:54 AM Youling Tang <tangyouling@loongson.cn> wrote:
>>>>>>
>>>>>> Hi, Huacai
>>>>>>
>>>>>> On 09/04/2022 08:21 PM, Huacai Chen wrote:
>>>>>>> Hi, Youling,
>>>>>>>
>>>>>>> I think crash.c can be merged into crash_dump.c
>>>>>>
>>>>>> Most architectures only implement copy_oldmem_page() in crash_dump.c,
>>>>>> I'm not sure if merging crash.c into crash_dump.c will break its
>>>>>> consistency?
>>>>>>
>>>>>> Thanks,
>>>>>> Youling
>>>>> Yes, you are right, crash.c cannot be merged into crash_dump.c, but it
>>>>> can be merged into machine_kexec.c, as arm64 and riscv do.
>>>>
>>>> For arm64, machine_crash_shutdown() is placed in machine_kexec.c, and
>>>> crash_smp_send_stop is placed in smp.c. If crash.c needs to be merged
>>>> into machine_kexec.c, should crash_shutdown_secondary and
>>>> crash_smp_send_stop be placed in smp.c?
>>> I don't want to touch smp.c, all merged into machine_kexec.c seems reasonable.
>>
>> Ok, I'll merge all into machine_kexec.c.
>>
>> Youling.
> Another problem, 0x9000000091000000 for PHYSICAL_START is too tricky.
> If you want to skip the "low memory", maybe we can use
> 0x9000000090000000 or 0x90000000a0000000?

Because there are many holes in our memory layout, if PHYSICAL_START is
set to 0x90000000a0000000, the largest reserved area of ​​the crashkernel
will be 512M, beyond which it will fail.

# cat /proc/iomem
90400000-bfffffff : System RAM
c0020000-f9efffff : System RAM
   f6810000-f6813fff : Reserved

The second System RAM starts at 0x90400000, so 0x9000000090000000 will
be too small.

Youling.

>
> Huacai
>>
>>>
>>> Huacai
>>>>
>>>> Youling.
>>>>>
>>>>> Huacai
>>>>>>
>>>>>>>
>>>>>>> Huacai
>>>>>>>
>>>>>>> On Mon, Aug 29, 2022 at 12:37 PM Youling Tang <tangyouling@loongson.cn> wrote:
>>>>>>>>
>>>>>>>> This patch adds support for kdump, the kernel will reserve a region
>>>>>>>> for the crash kernel and jump there on panic.
>>>>>>>>
>>>>>>>> Arch-specific functions are added to allow for implementing a crash
>>>>>>>> dump file interface, /proc/vmcore, which can be viewed as a ELF file.
>>>>>>>>
>>>>>>>> A user space tool, like kexec-tools, is responsible for allocating a
>>>>>>>> separate region for the core's ELF header within crash kdump kernel
>>>>>>>> memory and filling it in when executing kexec_load().
>>>>>>>>
>>>>>>>> Then, its location will be advertised to crash dump kernel via a new
>>>>>>>> device-tree property, "linux,elfcorehdr", and crash dump kernel preserves
>>>>>>>> the region for later use with fdt_reserve_elfcorehdr() at boot time.
>>>>>>>>
>>>>>>>> At the same time, it will also limit the crash kdump kernel to the
>>>>>>>> crashkernel area via a new device-tree property, "linux, usable-memory-range",
>>>>>>>> so as not to destroy the original kernel dump data.
>>>>>>>>
>>>>>>>> On crash dump kernel, /proc/vmcore will access the primary kernel's memory
>>>>>>>> with copy_oldmem_page().
>>>>>>>>
>>>>>>>> I tested this on  LoongArch 3A5000 machine and works as expected (Suggest
>>>>>>>> crashkernel parameter is "crashkernel=512M@2320M"), you may test it by
>>>>>>>> triggering a crash through /proc/sysrq_trigger:
>>>>>>>>
>>>>>>>>  $ sudo kexec -p /boot/vmlinux-kdump --reuse-cmdline --append="nr_cpus=1"
>>>>>>>>  # echo c > /proc/sysrq_trigger
>>>>>>>>
>>>>>>>> Signed-off-by: Youling Tang <tangyouling@loongson.cn>
>>>>>>>> ---
>>>>>>>>  arch/loongarch/Kconfig                  |  22 ++++++
>>>>>>>>  arch/loongarch/Makefile                 |   4 +
>>>>>>>>  arch/loongarch/kernel/Makefile          |   3 +-
>>>>>>>>  arch/loongarch/kernel/crash.c           | 100 ++++++++++++++++++++++++
>>>>>>>>  arch/loongarch/kernel/crash_dump.c      |  19 +++++
>>>>>>>>  arch/loongarch/kernel/machine_kexec.c   |  12 ++-
>>>>>>>>  arch/loongarch/kernel/mem.c             |   6 ++
>>>>>>>>  arch/loongarch/kernel/relocate_kernel.S |   6 ++
>>>>>>>>  arch/loongarch/kernel/setup.c           |  49 ++++++++++++
>>>>>>>>  arch/loongarch/kernel/traps.c           |   4 +
>>>>>>>>  10 files changed, 217 insertions(+), 8 deletions(-)
>>>>>>>>  create mode 100644 arch/loongarch/kernel/crash.c
>>>>>>>>  create mode 100644 arch/loongarch/kernel/crash_dump.c
>>>>>>>>
>>>>>>>> diff --git a/arch/loongarch/Kconfig b/arch/loongarch/Kconfig
>>>>>>>> index 903c82fa958d..7c1b07a5b5bd 100644
>>>>>>>> --- a/arch/loongarch/Kconfig
>>>>>>>> +++ b/arch/loongarch/Kconfig
>>>>>>>> @@ -420,6 +420,28 @@ config KEXEC
>>>>>>>>
>>>>>>>>           The name comes from the similarity to the exec system call.
>>>>>>>>
>>>>>>>> +config CRASH_DUMP
>>>>>>>> +       bool "Build kdump crash kernel"
>>>>>>>> +       help
>>>>>>>> +         Generate crash dump after being started by kexec. This should
>>>>>>>> +         be normally only set in special crash dump kernels which are
>>>>>>>> +         loaded in the main kernel with kexec-tools into a specially
>>>>>>>> +         reserved region and then later executed after a crash by
>>>>>>>> +         kdump/kexec.
>>>>>>>> +
>>>>>>>> +         For more details see Documentation/admin-guide/kdump/kdump.rst
>>>>>>>> +
>>>>>>>> +config PHYSICAL_START
>>>>>>>> +       hex "Physical address where the kernel is loaded"
>>>>>>>> +       default "0x9000000091000000" if 64BIT
>>>>>>>> +       depends on CRASH_DUMP
>>>>>>>> +       help
>>>>>>>> +         This gives the XKPRANGE address where the kernel is loaded.
>>>>>>>> +         If you plan to use kernel for capturing the crash dump change
>>>>>>>> +         this value to start of the reserved region (the "X" value as
>>>>>>>> +         specified in the "crashkernel=YM@XM" command line boot parameter
>>>>>>>> +         passed to the panic-ed kernel).
>>>>>>>> +
>>>>>>>>  config SECCOMP
>>>>>>>>         bool "Enable seccomp to safely compute untrusted bytecode"
>>>>>>>>         depends on PROC_FS
>>>>>>>> diff --git a/arch/loongarch/Makefile b/arch/loongarch/Makefile
>>>>>>>> index 4bc47f47cfd8..7dabd580426d 100644
>>>>>>>> --- a/arch/loongarch/Makefile
>>>>>>>> +++ b/arch/loongarch/Makefile
>>>>>>>> @@ -48,7 +48,11 @@ KBUILD_CFLAGS_MODULE         += -fplt -Wa,-mla-global-with-abs,-mla-local-with-abs
>>>>>>>>  cflags-y += -ffreestanding
>>>>>>>>  cflags-y += $(call cc-option, -mno-check-zero-division)
>>>>>>>>
>>>>>>>> +ifdef CONFIG_PHYSICAL_START
>>>>>>>> +load-y         = $(CONFIG_PHYSICAL_START)
>>>>>>>> +else
>>>>>>>>  load-y         = 0x9000000000200000
>>>>>>>> +endif
>>>>>>>>  bootvars-y     = VMLINUX_LOAD_ADDRESS=$(load-y)
>>>>>>>>
>>>>>>>>  drivers-$(CONFIG_PCI)          += arch/loongarch/pci/
>>>>>>>> diff --git a/arch/loongarch/kernel/Makefile b/arch/loongarch/kernel/Makefile
>>>>>>>> index 20b64ac3f128..df5aea129364 100644
>>>>>>>> --- a/arch/loongarch/kernel/Makefile
>>>>>>>> +++ b/arch/loongarch/kernel/Makefile
>>>>>>>> @@ -17,7 +17,8 @@ obj-$(CONFIG_CPU_HAS_FPU)     += fpu.o
>>>>>>>>  obj-$(CONFIG_MODULES)          += module.o module-sections.o
>>>>>>>>  obj-$(CONFIG_STACKTRACE)       += stacktrace.o
>>>>>>>>
>>>>>>>> -obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o
>>>>>>>> +obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o crash.o
>>>>>>>> +obj-$(CONFIG_CRASH_DUMP)        += crash_dump.o
>>>>>>>>
>>>>>>>>  obj-$(CONFIG_PROC_FS)          += proc.o
>>>>>>>>
>>>>>>>> diff --git a/arch/loongarch/kernel/crash.c b/arch/loongarch/kernel/crash.c
>>>>>>>> new file mode 100644
>>>>>>>> index 000000000000..b4f249ec6301
>>>>>>>> --- /dev/null
>>>>>>>> +++ b/arch/loongarch/kernel/crash.c
>>>>>>>> @@ -0,0 +1,100 @@
>>>>>>>> +// SPDX-License-Identifier: GPL-2.0
>>>>>>>> +/*
>>>>>>>> + * Copyright (C) 2022 Loongson Technology Corporation Limited
>>>>>>>> + *
>>>>>>>> + * Derived from MIPS
>>>>>>>> + */
>>>>>>>> +#include <linux/kernel.h>
>>>>>>>> +#include <linux/smp.h>
>>>>>>>> +#include <linux/reboot.h>
>>>>>>>> +#include <linux/crash_dump.h>
>>>>>>>> +#include <linux/delay.h>
>>>>>>>> +#include <linux/irq.h>
>>>>>>>> +#include <linux/types.h>
>>>>>>>> +#include <linux/sched.h>
>>>>>>>> +#include <linux/sched/task_stack.h>
>>>>>>>> +#include <asm/cacheflush.h>
>>>>>>>> +#include <asm/kexec.h>
>>>>>>>> +
>>>>>>>> +static cpumask_t cpus_in_crash = CPU_MASK_NONE;
>>>>>>>> +
>>>>>>>> +#ifdef CONFIG_SMP
>>>>>>>> +static void crash_shutdown_secondary(void *passed_regs)
>>>>>>>> +{
>>>>>>>> +       struct pt_regs *regs = passed_regs;
>>>>>>>> +       int cpu = smp_processor_id();
>>>>>>>> +
>>>>>>>> +       /*
>>>>>>>> +        * If we are passed registers, use those.  Otherwise get the
>>>>>>>> +        * regs from the last interrupt, which should be correct, as
>>>>>>>> +        * we are in an interrupt.  But if the regs are not there,
>>>>>>>> +        * pull them from the top of the stack.  They are probably
>>>>>>>> +        * wrong, but we need something to keep from crashing again.
>>>>>>>> +        */
>>>>>>>> +       if (!regs)
>>>>>>>> +               regs = get_irq_regs();
>>>>>>>> +       if (!regs)
>>>>>>>> +               regs = task_pt_regs(current);
>>>>>>>> +
>>>>>>>> +       local_irq_disable();
>>>>>>>> +       if (!cpumask_test_cpu(cpu, &cpus_in_crash))
>>>>>>>> +               crash_save_cpu(regs, cpu);
>>>>>>>> +       cpumask_set_cpu(cpu, &cpus_in_crash);
>>>>>>>> +
>>>>>>>> +       while (!atomic_read(&kexec_ready_to_reboot))
>>>>>>>> +               cpu_relax();
>>>>>>>> +
>>>>>>>> +       kexec_reboot();
>>>>>>>> +}
>>>>>>>> +
>>>>>>>> +/* Override the weak function in kernel/panic.c */
>>>>>>>> +void crash_smp_send_stop(void)
>>>>>>>> +{
>>>>>>>> +       static int cpus_stopped;
>>>>>>>> +       unsigned long timeout;
>>>>>>>> +       unsigned int ncpus;
>>>>>>>> +
>>>>>>>> +       /*
>>>>>>>> +        * This function can be called twice in panic path, but obviously
>>>>>>>> +        * we execute this only once.
>>>>>>>> +        */
>>>>>>>> +       if (cpus_stopped)
>>>>>>>> +               return;
>>>>>>>> +
>>>>>>>> +       cpus_stopped = 1;
>>>>>>>> +
>>>>>>>> +        /* Excluding the panic cpu */
>>>>>>>> +       ncpus = num_online_cpus() - 1;
>>>>>>>> +
>>>>>>>> +       smp_call_function(crash_shutdown_secondary, NULL, 0);
>>>>>>>> +       smp_wmb();
>>>>>>>> +
>>>>>>>> +       /*
>>>>>>>> +        * The crash CPU sends an IPI and wait for other CPUs to
>>>>>>>> +        * respond. Delay of at least 10 seconds.
>>>>>>>> +        */
>>>>>>>> +       pr_emerg("Sending IPI to other cpus...\n");
>>>>>>>> +       timeout = USEC_PER_SEC * 10;
>>>>>>>> +       while ((cpumask_weight(&cpus_in_crash) < ncpus) && timeout--) {
>>>>>>>> +               cpu_relax();
>>>>>>>> +               udelay(1);
>>>>>>>> +       }
>>>>>>>> +}
>>>>>>>> +
>>>>>>>> +#endif
>>>>>>>> +
>>>>>>>> +void machine_crash_shutdown(struct pt_regs *regs)
>>>>>>>> +{
>>>>>>>> +       int crashing_cpu;
>>>>>>>> +
>>>>>>>> +       local_irq_disable();
>>>>>>>> +
>>>>>>>> +       crashing_cpu = smp_processor_id();
>>>>>>>> +       crash_save_cpu(regs, crashing_cpu);
>>>>>>>> +
>>>>>>>> +       /* shutdown non-crashing cpus */
>>>>>>>> +       crash_smp_send_stop();
>>>>>>>> +       cpumask_set_cpu(crashing_cpu, &cpus_in_crash);
>>>>>>>> +
>>>>>>>> +       pr_info("Starting crashdump kernel...\n");
>>>>>>>> +}
>>>>>>>> diff --git a/arch/loongarch/kernel/crash_dump.c b/arch/loongarch/kernel/crash_dump.c
>>>>>>>> new file mode 100644
>>>>>>>> index 000000000000..13e5d2f7870d
>>>>>>>> --- /dev/null
>>>>>>>> +++ b/arch/loongarch/kernel/crash_dump.c
>>>>>>>> @@ -0,0 +1,19 @@
>>>>>>>> +// SPDX-License-Identifier: GPL-2.0
>>>>>>>> +#include <linux/highmem.h>
>>>>>>>> +#include <linux/crash_dump.h>
>>>>>>>> +#include <linux/io.h>
>>>>>>>> +
>>>>>>>> +ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn,
>>>>>>>> +                        size_t csize, unsigned long offset)
>>>>>>>> +{
>>>>>>>> +       void  *vaddr;
>>>>>>>> +
>>>>>>>> +       if (!csize)
>>>>>>>> +               return 0;
>>>>>>>> +
>>>>>>>> +       vaddr = kmap_local_pfn(pfn);
>>>>>>>> +       csize = copy_to_iter(vaddr + offset, csize, iter);
>>>>>>>> +       kunmap_local(vaddr);
>>>>>>>> +
>>>>>>>> +       return csize;
>>>>>>>> +}
>>>>>>>> diff --git a/arch/loongarch/kernel/machine_kexec.c b/arch/loongarch/kernel/machine_kexec.c
>>>>>>>> index 4ffcd4cd9c8c..f793a3ff09a3 100644
>>>>>>>> --- a/arch/loongarch/kernel/machine_kexec.c
>>>>>>>> +++ b/arch/loongarch/kernel/machine_kexec.c
>>>>>>>> @@ -69,7 +69,7 @@ int machine_kexec_prepare(struct kimage *kimage)
>>>>>>>>                 continue;
>>>>>>>>         }
>>>>>>>>
>>>>>>>> -       /* kexec need a safe page to save reboot_code_buffer */
>>>>>>>> +       /* kexec/kdump need a safe page to save reboot_code_buffer */
>>>>>>>>         kimage->control_code_page = virt_to_page((void *)KEXEC_CTRL_CODE);
>>>>>>>>
>>>>>>>>         reboot_code_buffer =
>>>>>>>> @@ -113,10 +113,6 @@ static void kexec_shutdown_secondary(void *)
>>>>>>>>
>>>>>>>>         kexec_reboot();
>>>>>>>>  }
>>>>>>>> -
>>>>>>>> -void machine_crash_shutdown(struct pt_regs *regs)
>>>>>>>> -{
>>>>>>>> -}
>>>>>>>>  #endif
>>>>>>>>
>>>>>>>>  void machine_shutdown(void)
>>>>>>>> @@ -135,7 +131,8 @@ void machine_kexec(struct kimage *image)
>>>>>>>>
>>>>>>>>         jump_addr = (unsigned long)phys_to_virt(image->start);
>>>>>>>>
>>>>>>>> -       first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
>>>>>>>> +       if (image->type == KEXEC_TYPE_DEFAULT)
>>>>>>>> +               first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
>>>>>>>>
>>>>>>>>         /*
>>>>>>>>          * The generic kexec code builds a page list with physical
>>>>>>>> @@ -167,7 +164,8 @@ void machine_kexec(struct kimage *image)
>>>>>>>>
>>>>>>>>         /*
>>>>>>>>          * We know we were online, and there will be no incoming IPIs at
>>>>>>>> -        * this point.
>>>>>>>> +        * this point. Mark online again before rebooting so that the crash
>>>>>>>> +        * analysis tool will see us correctly.
>>>>>>>>          */
>>>>>>>>         set_cpu_online(smp_processor_id(), true);
>>>>>>>>
>>>>>>>> diff --git a/arch/loongarch/kernel/mem.c b/arch/loongarch/kernel/mem.c
>>>>>>>> index 7423361b0ebc..c6def6ff81c8 100644
>>>>>>>> --- a/arch/loongarch/kernel/mem.c
>>>>>>>> +++ b/arch/loongarch/kernel/mem.c
>>>>>>>> @@ -5,6 +5,7 @@
>>>>>>>>  #include <linux/efi.h>
>>>>>>>>  #include <linux/initrd.h>
>>>>>>>>  #include <linux/memblock.h>
>>>>>>>> +#include <linux/of_fdt.h>
>>>>>>>>
>>>>>>>>  #include <asm/bootinfo.h>
>>>>>>>>  #include <asm/loongson.h>
>>>>>>>> @@ -61,4 +62,9 @@ void __init memblock_init(void)
>>>>>>>>
>>>>>>>>         /* Reserve the initrd */
>>>>>>>>         reserve_initrd_mem();
>>>>>>>> +
>>>>>>>> +       /* Mainly reserved memory for the elf core head */
>>>>>>>> +       early_init_fdt_scan_reserved_mem();
>>>>>>>> +       /* Parse linux,usable-memory-range is for crash dump kernel */
>>>>>>>> +       early_init_dt_check_for_usable_mem_range();
>>>>>>>>  }
>>>>>>>> diff --git a/arch/loongarch/kernel/relocate_kernel.S b/arch/loongarch/kernel/relocate_kernel.S
>>>>>>>> index d1f242f74ea8..4ee5ac4ac2d7 100644
>>>>>>>> --- a/arch/loongarch/kernel/relocate_kernel.S
>>>>>>>> +++ b/arch/loongarch/kernel/relocate_kernel.S
>>>>>>>> @@ -28,6 +28,12 @@ SYM_CODE_START(relocate_new_kernel)
>>>>>>>>         move            s2, a2
>>>>>>>>         move            s3, a3
>>>>>>>>
>>>>>>>> +       /*
>>>>>>>> +        * In case of a kdump/crash kernel, the indirection page is not
>>>>>>>> +        * populated as the kernel is directly copied to a reserved location
>>>>>>>> +        */
>>>>>>>> +       beqz            s2, done
>>>>>>>> +
>>>>>>>>  process_entry:
>>>>>>>>         PTR_L           s4, s2, 0
>>>>>>>>         PTR_ADDI        s2, s2, SZREG
>>>>>>>> diff --git a/arch/loongarch/kernel/setup.c b/arch/loongarch/kernel/setup.c
>>>>>>>> index f938aae3e92c..ea34b77e402f 100644
>>>>>>>> --- a/arch/loongarch/kernel/setup.c
>>>>>>>> +++ b/arch/loongarch/kernel/setup.c
>>>>>>>> @@ -19,6 +19,8 @@
>>>>>>>>  #include <linux/memblock.h>
>>>>>>>>  #include <linux/initrd.h>
>>>>>>>>  #include <linux/ioport.h>
>>>>>>>> +#include <linux/kexec.h>
>>>>>>>> +#include <linux/crash_dump.h>
>>>>>>>>  #include <linux/root_dev.h>
>>>>>>>>  #include <linux/console.h>
>>>>>>>>  #include <linux/pfn.h>
>>>>>>>> @@ -186,6 +188,50 @@ static int __init early_parse_mem(char *p)
>>>>>>>>  }
>>>>>>>>  early_param("mem", early_parse_mem);
>>>>>>>>
>>>>>>>> +static void __init loongarch_parse_crashkernel(void)
>>>>>>>> +{
>>>>>>>> +#ifdef CONFIG_KEXEC
>>>>>>>> +       unsigned long long start;
>>>>>>>> +       unsigned long long total_mem;
>>>>>>>> +       unsigned long long crash_size, crash_base;
>>>>>>>> +       int ret;
>>>>>>>> +
>>>>>>>> +       total_mem = memblock_phys_mem_size();
>>>>>>>> +       ret = parse_crashkernel(boot_command_line, total_mem,
>>>>>>>> +                               &crash_size, &crash_base);
>>>>>>>> +       if (ret != 0 || crash_size <= 0)
>>>>>>>> +               return;
>>>>>>>> +
>>>>>>>> +
>>>>>>>> +       start = memblock_phys_alloc_range(crash_size, 1, crash_base,
>>>>>>>> +                                       crash_base + crash_size);
>>>>>>>> +       if (start != crash_base) {
>>>>>>>> +               pr_warn("Invalid memory region reserved for crash kernel\n");
>>>>>>>> +               return;
>>>>>>>> +       }
>>>>>>>> +
>>>>>>>> +       crashk_res.start = crash_base;
>>>>>>>> +       crashk_res.end   = crash_base + crash_size - 1;
>>>>>>>> +#endif
>>>>>>>> +}
>>>>>>>> +
>>>>>>>> +static void __init request_crashkernel(struct resource *res)
>>>>>>>> +{
>>>>>>>> +#ifdef CONFIG_KEXEC
>>>>>>>> +       int ret;
>>>>>>>> +
>>>>>>>> +       if (crashk_res.start == crashk_res.end)
>>>>>>>> +               return;
>>>>>>>> +
>>>>>>>> +       ret = request_resource(res, &crashk_res);
>>>>>>>> +       if (!ret)
>>>>>>>> +               pr_info("Reserving %ldMB of memory at %ldMB for crashkernel\n",
>>>>>>>> +                       (unsigned long)((crashk_res.end -
>>>>>>>> +                                        crashk_res.start + 1) >> 20),
>>>>>>>> +                       (unsigned long)(crashk_res.start  >> 20));
>>>>>>>> +#endif
>>>>>>>> +}
>>>>>>>> +
>>>>>>>>  void __init platform_init(void)
>>>>>>>>  {
>>>>>>>>         efi_init();
>>>>>>>> @@ -229,6 +275,8 @@ static void __init arch_mem_init(char **cmdline_p)
>>>>>>>>
>>>>>>>>         check_kernel_sections_mem();
>>>>>>>>
>>>>>>>> +       loongarch_parse_crashkernel();
>>>>>>>> +
>>>>>>>>         /*
>>>>>>>>          * In order to reduce the possibility of kernel panic when failed to
>>>>>>>>          * get IO TLB memory under CONFIG_SWIOTLB, it is better to allocate
>>>>>>>> @@ -290,6 +338,7 @@ static void __init resource_init(void)
>>>>>>>>                 request_resource(res, &code_resource);
>>>>>>>>                 request_resource(res, &data_resource);
>>>>>>>>                 request_resource(res, &bss_resource);
>>>>>>>> +               request_crashkernel(res);
>>>>>>>>         }
>>>>>>>>  }
>>>>>>>>
>>>>>>>> diff --git a/arch/loongarch/kernel/traps.c b/arch/loongarch/kernel/traps.c
>>>>>>>> index aa1c95aaf595..0e610872f3f4 100644
>>>>>>>> --- a/arch/loongarch/kernel/traps.c
>>>>>>>> +++ b/arch/loongarch/kernel/traps.c
>>>>>>>> @@ -10,6 +10,7 @@
>>>>>>>>  #include <linux/entry-common.h>
>>>>>>>>  #include <linux/init.h>
>>>>>>>>  #include <linux/kernel.h>
>>>>>>>> +#include <linux/kexec.h>
>>>>>>>>  #include <linux/module.h>
>>>>>>>>  #include <linux/extable.h>
>>>>>>>>  #include <linux/mm.h>
>>>>>>>> @@ -246,6 +247,9 @@ void __noreturn die(const char *str, struct pt_regs *regs)
>>>>>>>>
>>>>>>>>         oops_exit();
>>>>>>>>
>>>>>>>> +       if (regs && kexec_should_crash(current))
>>>>>>>> +               crash_kexec(regs);
>>>>>>>> +
>>>>>>>>         if (in_interrupt())
>>>>>>>>                 panic("Fatal exception in interrupt");
>>>>>>>>
>>>>>>>> --
>>>>>>>> 2.36.0
>>>>>>>>
>>>>>>
>>>>
>>

Re: [PATCH 2/3] LoongArch: Add kdump support

[Huacai Chen]

Hi, Youling,

On Mon, Sep 5, 2022 at 3:45 PM Youling Tang <tangyouling@loongson.cn> wrote:
>
> Hi, Huacai
>
> On 09/05/2022 03:32 PM, Huacai Chen wrote:
> > Hi, Youling,
> >
> > On Mon, Sep 5, 2022 at 10:22 AM Youling Tang <tangyouling@loongson.cn> wrote:
> >>
> >>
> >>
> >> On 09/05/2022 10:14 AM, Huacai Chen wrote:
> >>> On Mon, Sep 5, 2022 at 10:04 AM Youling Tang <tangyouling@loongson.cn> wrote:
> >>>>
> >>>> Hi, Huacai
> >>>>
> >>>> On 09/05/2022 09:38 AM, Huacai Chen wrote:
> >>>>> Hi, Youling,
> >>>>>
> >>>>> On Mon, Sep 5, 2022 at 8:54 AM Youling Tang <tangyouling@loongson.cn> wrote:
> >>>>>>
> >>>>>> Hi, Huacai
> >>>>>>
> >>>>>> On 09/04/2022 08:21 PM, Huacai Chen wrote:
> >>>>>>> Hi, Youling,
> >>>>>>>
> >>>>>>> I think crash.c can be merged into crash_dump.c
> >>>>>>
> >>>>>> Most architectures only implement copy_oldmem_page() in crash_dump.c,
> >>>>>> I'm not sure if merging crash.c into crash_dump.c will break its
> >>>>>> consistency?
> >>>>>>
> >>>>>> Thanks,
> >>>>>> Youling
> >>>>> Yes, you are right, crash.c cannot be merged into crash_dump.c, but it
> >>>>> can be merged into machine_kexec.c, as arm64 and riscv do.
> >>>>
> >>>> For arm64, machine_crash_shutdown() is placed in machine_kexec.c, and
> >>>> crash_smp_send_stop is placed in smp.c. If crash.c needs to be merged
> >>>> into machine_kexec.c, should crash_shutdown_secondary and
> >>>> crash_smp_send_stop be placed in smp.c?
> >>> I don't want to touch smp.c, all merged into machine_kexec.c seems reasonable.
> >>
> >> Ok, I'll merge all into machine_kexec.c.
> >>
> >> Youling.
> > Another problem, 0x9000000091000000 for PHYSICAL_START is too tricky.
> > If you want to skip the "low memory", maybe we can use
> > 0x9000000090000000 or 0x90000000a0000000?
>
> Because there are many holes in our memory layout, if PHYSICAL_START is
> set to 0x90000000a0000000, the largest reserved area of the crashkernel
> will be 512M, beyond which it will fail.
Then 0x9000000090000000 is not suitable, but I think 512M is enough?
If so, let's use 0x90000000a0000000.

Huacai

Huacai
>
> # cat /proc/iomem
> 90400000-bfffffff : System RAM
> c0020000-f9efffff : System RAM
>    f6810000-f6813fff : Reserved
>
> The second System RAM starts at 0x90400000, so 0x9000000090000000 will
> be too small.
>
> Youling.
>
> >
> > Huacai
> >>
> >>>
> >>> Huacai
> >>>>
> >>>> Youling.
> >>>>>
> >>>>> Huacai
> >>>>>>
> >>>>>>>
> >>>>>>> Huacai
> >>>>>>>
> >>>>>>> On Mon, Aug 29, 2022 at 12:37 PM Youling Tang <tangyouling@loongson.cn> wrote:
> >>>>>>>>
> >>>>>>>> This patch adds support for kdump, the kernel will reserve a region
> >>>>>>>> for the crash kernel and jump there on panic.
> >>>>>>>>
> >>>>>>>> Arch-specific functions are added to allow for implementing a crash
> >>>>>>>> dump file interface, /proc/vmcore, which can be viewed as a ELF file.
> >>>>>>>>
> >>>>>>>> A user space tool, like kexec-tools, is responsible for allocating a
> >>>>>>>> separate region for the core's ELF header within crash kdump kernel
> >>>>>>>> memory and filling it in when executing kexec_load().
> >>>>>>>>
> >>>>>>>> Then, its location will be advertised to crash dump kernel via a new
> >>>>>>>> device-tree property, "linux,elfcorehdr", and crash dump kernel preserves
> >>>>>>>> the region for later use with fdt_reserve_elfcorehdr() at boot time.
> >>>>>>>>
> >>>>>>>> At the same time, it will also limit the crash kdump kernel to the
> >>>>>>>> crashkernel area via a new device-tree property, "linux, usable-memory-range",
> >>>>>>>> so as not to destroy the original kernel dump data.
> >>>>>>>>
> >>>>>>>> On crash dump kernel, /proc/vmcore will access the primary kernel's memory
> >>>>>>>> with copy_oldmem_page().
> >>>>>>>>
> >>>>>>>> I tested this on  LoongArch 3A5000 machine and works as expected (Suggest
> >>>>>>>> crashkernel parameter is "crashkernel=512M@2320M"), you may test it by
> >>>>>>>> triggering a crash through /proc/sysrq_trigger:
> >>>>>>>>
> >>>>>>>>  $ sudo kexec -p /boot/vmlinux-kdump --reuse-cmdline --append="nr_cpus=1"
> >>>>>>>>  # echo c > /proc/sysrq_trigger
> >>>>>>>>
> >>>>>>>> Signed-off-by: Youling Tang <tangyouling@loongson.cn>
> >>>>>>>> ---
> >>>>>>>>  arch/loongarch/Kconfig                  |  22 ++++++
> >>>>>>>>  arch/loongarch/Makefile                 |   4 +
> >>>>>>>>  arch/loongarch/kernel/Makefile          |   3 +-
> >>>>>>>>  arch/loongarch/kernel/crash.c           | 100 ++++++++++++++++++++++++
> >>>>>>>>  arch/loongarch/kernel/crash_dump.c      |  19 +++++
> >>>>>>>>  arch/loongarch/kernel/machine_kexec.c   |  12 ++-
> >>>>>>>>  arch/loongarch/kernel/mem.c             |   6 ++
> >>>>>>>>  arch/loongarch/kernel/relocate_kernel.S |   6 ++
> >>>>>>>>  arch/loongarch/kernel/setup.c           |  49 ++++++++++++
> >>>>>>>>  arch/loongarch/kernel/traps.c           |   4 +
> >>>>>>>>  10 files changed, 217 insertions(+), 8 deletions(-)
> >>>>>>>>  create mode 100644 arch/loongarch/kernel/crash.c
> >>>>>>>>  create mode 100644 arch/loongarch/kernel/crash_dump.c
> >>>>>>>>
> >>>>>>>> diff --git a/arch/loongarch/Kconfig b/arch/loongarch/Kconfig
> >>>>>>>> index 903c82fa958d..7c1b07a5b5bd 100644
> >>>>>>>> --- a/arch/loongarch/Kconfig
> >>>>>>>> +++ b/arch/loongarch/Kconfig
> >>>>>>>> @@ -420,6 +420,28 @@ config KEXEC
> >>>>>>>>
> >>>>>>>>           The name comes from the similarity to the exec system call.
> >>>>>>>>
> >>>>>>>> +config CRASH_DUMP
> >>>>>>>> +       bool "Build kdump crash kernel"
> >>>>>>>> +       help
> >>>>>>>> +         Generate crash dump after being started by kexec. This should
> >>>>>>>> +         be normally only set in special crash dump kernels which are
> >>>>>>>> +         loaded in the main kernel with kexec-tools into a specially
> >>>>>>>> +         reserved region and then later executed after a crash by
> >>>>>>>> +         kdump/kexec.
> >>>>>>>> +
> >>>>>>>> +         For more details see Documentation/admin-guide/kdump/kdump.rst
> >>>>>>>> +
> >>>>>>>> +config PHYSICAL_START
> >>>>>>>> +       hex "Physical address where the kernel is loaded"
> >>>>>>>> +       default "0x9000000091000000" if 64BIT
> >>>>>>>> +       depends on CRASH_DUMP
> >>>>>>>> +       help
> >>>>>>>> +         This gives the XKPRANGE address where the kernel is loaded.
> >>>>>>>> +         If you plan to use kernel for capturing the crash dump change
> >>>>>>>> +         this value to start of the reserved region (the "X" value as
> >>>>>>>> +         specified in the "crashkernel=YM@XM" command line boot parameter
> >>>>>>>> +         passed to the panic-ed kernel).
> >>>>>>>> +
> >>>>>>>>  config SECCOMP
> >>>>>>>>         bool "Enable seccomp to safely compute untrusted bytecode"
> >>>>>>>>         depends on PROC_FS
> >>>>>>>> diff --git a/arch/loongarch/Makefile b/arch/loongarch/Makefile
> >>>>>>>> index 4bc47f47cfd8..7dabd580426d 100644
> >>>>>>>> --- a/arch/loongarch/Makefile
> >>>>>>>> +++ b/arch/loongarch/Makefile
> >>>>>>>> @@ -48,7 +48,11 @@ KBUILD_CFLAGS_MODULE         += -fplt -Wa,-mla-global-with-abs,-mla-local-with-abs
> >>>>>>>>  cflags-y += -ffreestanding
> >>>>>>>>  cflags-y += $(call cc-option, -mno-check-zero-division)
> >>>>>>>>
> >>>>>>>> +ifdef CONFIG_PHYSICAL_START
> >>>>>>>> +load-y         = $(CONFIG_PHYSICAL_START)
> >>>>>>>> +else
> >>>>>>>>  load-y         = 0x9000000000200000
> >>>>>>>> +endif
> >>>>>>>>  bootvars-y     = VMLINUX_LOAD_ADDRESS=$(load-y)
> >>>>>>>>
> >>>>>>>>  drivers-$(CONFIG_PCI)          += arch/loongarch/pci/
> >>>>>>>> diff --git a/arch/loongarch/kernel/Makefile b/arch/loongarch/kernel/Makefile
> >>>>>>>> index 20b64ac3f128..df5aea129364 100644
> >>>>>>>> --- a/arch/loongarch/kernel/Makefile
> >>>>>>>> +++ b/arch/loongarch/kernel/Makefile
> >>>>>>>> @@ -17,7 +17,8 @@ obj-$(CONFIG_CPU_HAS_FPU)     += fpu.o
> >>>>>>>>  obj-$(CONFIG_MODULES)          += module.o module-sections.o
> >>>>>>>>  obj-$(CONFIG_STACKTRACE)       += stacktrace.o
> >>>>>>>>
> >>>>>>>> -obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o
> >>>>>>>> +obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o crash.o
> >>>>>>>> +obj-$(CONFIG_CRASH_DUMP)        += crash_dump.o
> >>>>>>>>
> >>>>>>>>  obj-$(CONFIG_PROC_FS)          += proc.o
> >>>>>>>>
> >>>>>>>> diff --git a/arch/loongarch/kernel/crash.c b/arch/loongarch/kernel/crash.c
> >>>>>>>> new file mode 100644
> >>>>>>>> index 000000000000..b4f249ec6301
> >>>>>>>> --- /dev/null
> >>>>>>>> +++ b/arch/loongarch/kernel/crash.c
> >>>>>>>> @@ -0,0 +1,100 @@
> >>>>>>>> +// SPDX-License-Identifier: GPL-2.0
> >>>>>>>> +/*
> >>>>>>>> + * Copyright (C) 2022 Loongson Technology Corporation Limited
> >>>>>>>> + *
> >>>>>>>> + * Derived from MIPS
> >>>>>>>> + */
> >>>>>>>> +#include <linux/kernel.h>
> >>>>>>>> +#include <linux/smp.h>
> >>>>>>>> +#include <linux/reboot.h>
> >>>>>>>> +#include <linux/crash_dump.h>
> >>>>>>>> +#include <linux/delay.h>
> >>>>>>>> +#include <linux/irq.h>
> >>>>>>>> +#include <linux/types.h>
> >>>>>>>> +#include <linux/sched.h>
> >>>>>>>> +#include <linux/sched/task_stack.h>
> >>>>>>>> +#include <asm/cacheflush.h>
> >>>>>>>> +#include <asm/kexec.h>
> >>>>>>>> +
> >>>>>>>> +static cpumask_t cpus_in_crash = CPU_MASK_NONE;
> >>>>>>>> +
> >>>>>>>> +#ifdef CONFIG_SMP
> >>>>>>>> +static void crash_shutdown_secondary(void *passed_regs)
> >>>>>>>> +{
> >>>>>>>> +       struct pt_regs *regs = passed_regs;
> >>>>>>>> +       int cpu = smp_processor_id();
> >>>>>>>> +
> >>>>>>>> +       /*
> >>>>>>>> +        * If we are passed registers, use those.  Otherwise get the
> >>>>>>>> +        * regs from the last interrupt, which should be correct, as
> >>>>>>>> +        * we are in an interrupt.  But if the regs are not there,
> >>>>>>>> +        * pull them from the top of the stack.  They are probably
> >>>>>>>> +        * wrong, but we need something to keep from crashing again.
> >>>>>>>> +        */
> >>>>>>>> +       if (!regs)
> >>>>>>>> +               regs = get_irq_regs();
> >>>>>>>> +       if (!regs)
> >>>>>>>> +               regs = task_pt_regs(current);
> >>>>>>>> +
> >>>>>>>> +       local_irq_disable();
> >>>>>>>> +       if (!cpumask_test_cpu(cpu, &cpus_in_crash))
> >>>>>>>> +               crash_save_cpu(regs, cpu);
> >>>>>>>> +       cpumask_set_cpu(cpu, &cpus_in_crash);
> >>>>>>>> +
> >>>>>>>> +       while (!atomic_read(&kexec_ready_to_reboot))
> >>>>>>>> +               cpu_relax();
> >>>>>>>> +
> >>>>>>>> +       kexec_reboot();
> >>>>>>>> +}
> >>>>>>>> +
> >>>>>>>> +/* Override the weak function in kernel/panic.c */
> >>>>>>>> +void crash_smp_send_stop(void)
> >>>>>>>> +{
> >>>>>>>> +       static int cpus_stopped;
> >>>>>>>> +       unsigned long timeout;
> >>>>>>>> +       unsigned int ncpus;
> >>>>>>>> +
> >>>>>>>> +       /*
> >>>>>>>> +        * This function can be called twice in panic path, but obviously
> >>>>>>>> +        * we execute this only once.
> >>>>>>>> +        */
> >>>>>>>> +       if (cpus_stopped)
> >>>>>>>> +               return;
> >>>>>>>> +
> >>>>>>>> +       cpus_stopped = 1;
> >>>>>>>> +
> >>>>>>>> +        /* Excluding the panic cpu */
> >>>>>>>> +       ncpus = num_online_cpus() - 1;
> >>>>>>>> +
> >>>>>>>> +       smp_call_function(crash_shutdown_secondary, NULL, 0);
> >>>>>>>> +       smp_wmb();
> >>>>>>>> +
> >>>>>>>> +       /*
> >>>>>>>> +        * The crash CPU sends an IPI and wait for other CPUs to
> >>>>>>>> +        * respond. Delay of at least 10 seconds.
> >>>>>>>> +        */
> >>>>>>>> +       pr_emerg("Sending IPI to other cpus...\n");
> >>>>>>>> +       timeout = USEC_PER_SEC * 10;
> >>>>>>>> +       while ((cpumask_weight(&cpus_in_crash) < ncpus) && timeout--) {
> >>>>>>>> +               cpu_relax();
> >>>>>>>> +               udelay(1);
> >>>>>>>> +       }
> >>>>>>>> +}
> >>>>>>>> +
> >>>>>>>> +#endif
> >>>>>>>> +
> >>>>>>>> +void machine_crash_shutdown(struct pt_regs *regs)
> >>>>>>>> +{
> >>>>>>>> +       int crashing_cpu;
> >>>>>>>> +
> >>>>>>>> +       local_irq_disable();
> >>>>>>>> +
> >>>>>>>> +       crashing_cpu = smp_processor_id();
> >>>>>>>> +       crash_save_cpu(regs, crashing_cpu);
> >>>>>>>> +
> >>>>>>>> +       /* shutdown non-crashing cpus */
> >>>>>>>> +       crash_smp_send_stop();
> >>>>>>>> +       cpumask_set_cpu(crashing_cpu, &cpus_in_crash);
> >>>>>>>> +
> >>>>>>>> +       pr_info("Starting crashdump kernel...\n");
> >>>>>>>> +}
> >>>>>>>> diff --git a/arch/loongarch/kernel/crash_dump.c b/arch/loongarch/kernel/crash_dump.c
> >>>>>>>> new file mode 100644
> >>>>>>>> index 000000000000..13e5d2f7870d
> >>>>>>>> --- /dev/null
> >>>>>>>> +++ b/arch/loongarch/kernel/crash_dump.c
> >>>>>>>> @@ -0,0 +1,19 @@
> >>>>>>>> +// SPDX-License-Identifier: GPL-2.0
> >>>>>>>> +#include <linux/highmem.h>
> >>>>>>>> +#include <linux/crash_dump.h>
> >>>>>>>> +#include <linux/io.h>
> >>>>>>>> +
> >>>>>>>> +ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn,
> >>>>>>>> +                        size_t csize, unsigned long offset)
> >>>>>>>> +{
> >>>>>>>> +       void  *vaddr;
> >>>>>>>> +
> >>>>>>>> +       if (!csize)
> >>>>>>>> +               return 0;
> >>>>>>>> +
> >>>>>>>> +       vaddr = kmap_local_pfn(pfn);
> >>>>>>>> +       csize = copy_to_iter(vaddr + offset, csize, iter);
> >>>>>>>> +       kunmap_local(vaddr);
> >>>>>>>> +
> >>>>>>>> +       return csize;
> >>>>>>>> +}
> >>>>>>>> diff --git a/arch/loongarch/kernel/machine_kexec.c b/arch/loongarch/kernel/machine_kexec.c
> >>>>>>>> index 4ffcd4cd9c8c..f793a3ff09a3 100644
> >>>>>>>> --- a/arch/loongarch/kernel/machine_kexec.c
> >>>>>>>> +++ b/arch/loongarch/kernel/machine_kexec.c
> >>>>>>>> @@ -69,7 +69,7 @@ int machine_kexec_prepare(struct kimage *kimage)
> >>>>>>>>                 continue;
> >>>>>>>>         }
> >>>>>>>>
> >>>>>>>> -       /* kexec need a safe page to save reboot_code_buffer */
> >>>>>>>> +       /* kexec/kdump need a safe page to save reboot_code_buffer */
> >>>>>>>>         kimage->control_code_page = virt_to_page((void *)KEXEC_CTRL_CODE);
> >>>>>>>>
> >>>>>>>>         reboot_code_buffer =
> >>>>>>>> @@ -113,10 +113,6 @@ static void kexec_shutdown_secondary(void *)
> >>>>>>>>
> >>>>>>>>         kexec_reboot();
> >>>>>>>>  }
> >>>>>>>> -
> >>>>>>>> -void machine_crash_shutdown(struct pt_regs *regs)
> >>>>>>>> -{
> >>>>>>>> -}
> >>>>>>>>  #endif
> >>>>>>>>
> >>>>>>>>  void machine_shutdown(void)
> >>>>>>>> @@ -135,7 +131,8 @@ void machine_kexec(struct kimage *image)
> >>>>>>>>
> >>>>>>>>         jump_addr = (unsigned long)phys_to_virt(image->start);
> >>>>>>>>
> >>>>>>>> -       first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
> >>>>>>>> +       if (image->type == KEXEC_TYPE_DEFAULT)
> >>>>>>>> +               first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
> >>>>>>>>
> >>>>>>>>         /*
> >>>>>>>>          * The generic kexec code builds a page list with physical
> >>>>>>>> @@ -167,7 +164,8 @@ void machine_kexec(struct kimage *image)
> >>>>>>>>
> >>>>>>>>         /*
> >>>>>>>>          * We know we were online, and there will be no incoming IPIs at
> >>>>>>>> -        * this point.
> >>>>>>>> +        * this point. Mark online again before rebooting so that the crash
> >>>>>>>> +        * analysis tool will see us correctly.
> >>>>>>>>          */
> >>>>>>>>         set_cpu_online(smp_processor_id(), true);
> >>>>>>>>
> >>>>>>>> diff --git a/arch/loongarch/kernel/mem.c b/arch/loongarch/kernel/mem.c
> >>>>>>>> index 7423361b0ebc..c6def6ff81c8 100644
> >>>>>>>> --- a/arch/loongarch/kernel/mem.c
> >>>>>>>> +++ b/arch/loongarch/kernel/mem.c
> >>>>>>>> @@ -5,6 +5,7 @@
> >>>>>>>>  #include <linux/efi.h>
> >>>>>>>>  #include <linux/initrd.h>
> >>>>>>>>  #include <linux/memblock.h>
> >>>>>>>> +#include <linux/of_fdt.h>
> >>>>>>>>
> >>>>>>>>  #include <asm/bootinfo.h>
> >>>>>>>>  #include <asm/loongson.h>
> >>>>>>>> @@ -61,4 +62,9 @@ void __init memblock_init(void)
> >>>>>>>>
> >>>>>>>>         /* Reserve the initrd */
> >>>>>>>>         reserve_initrd_mem();
> >>>>>>>> +
> >>>>>>>> +       /* Mainly reserved memory for the elf core head */
> >>>>>>>> +       early_init_fdt_scan_reserved_mem();
> >>>>>>>> +       /* Parse linux,usable-memory-range is for crash dump kernel */
> >>>>>>>> +       early_init_dt_check_for_usable_mem_range();
> >>>>>>>>  }
> >>>>>>>> diff --git a/arch/loongarch/kernel/relocate_kernel.S b/arch/loongarch/kernel/relocate_kernel.S
> >>>>>>>> index d1f242f74ea8..4ee5ac4ac2d7 100644
> >>>>>>>> --- a/arch/loongarch/kernel/relocate_kernel.S
> >>>>>>>> +++ b/arch/loongarch/kernel/relocate_kernel.S
> >>>>>>>> @@ -28,6 +28,12 @@ SYM_CODE_START(relocate_new_kernel)
> >>>>>>>>         move            s2, a2
> >>>>>>>>         move            s3, a3
> >>>>>>>>
> >>>>>>>> +       /*
> >>>>>>>> +        * In case of a kdump/crash kernel, the indirection page is not
> >>>>>>>> +        * populated as the kernel is directly copied to a reserved location
> >>>>>>>> +        */
> >>>>>>>> +       beqz            s2, done
> >>>>>>>> +
> >>>>>>>>  process_entry:
> >>>>>>>>         PTR_L           s4, s2, 0
> >>>>>>>>         PTR_ADDI        s2, s2, SZREG
> >>>>>>>> diff --git a/arch/loongarch/kernel/setup.c b/arch/loongarch/kernel/setup.c
> >>>>>>>> index f938aae3e92c..ea34b77e402f 100644
> >>>>>>>> --- a/arch/loongarch/kernel/setup.c
> >>>>>>>> +++ b/arch/loongarch/kernel/setup.c
> >>>>>>>> @@ -19,6 +19,8 @@
> >>>>>>>>  #include <linux/memblock.h>
> >>>>>>>>  #include <linux/initrd.h>
> >>>>>>>>  #include <linux/ioport.h>
> >>>>>>>> +#include <linux/kexec.h>
> >>>>>>>> +#include <linux/crash_dump.h>
> >>>>>>>>  #include <linux/root_dev.h>
> >>>>>>>>  #include <linux/console.h>
> >>>>>>>>  #include <linux/pfn.h>
> >>>>>>>> @@ -186,6 +188,50 @@ static int __init early_parse_mem(char *p)
> >>>>>>>>  }
> >>>>>>>>  early_param("mem", early_parse_mem);
> >>>>>>>>
> >>>>>>>> +static void __init loongarch_parse_crashkernel(void)
> >>>>>>>> +{
> >>>>>>>> +#ifdef CONFIG_KEXEC
> >>>>>>>> +       unsigned long long start;
> >>>>>>>> +       unsigned long long total_mem;
> >>>>>>>> +       unsigned long long crash_size, crash_base;
> >>>>>>>> +       int ret;
> >>>>>>>> +
> >>>>>>>> +       total_mem = memblock_phys_mem_size();
> >>>>>>>> +       ret = parse_crashkernel(boot_command_line, total_mem,
> >>>>>>>> +                               &crash_size, &crash_base);
> >>>>>>>> +       if (ret != 0 || crash_size <= 0)
> >>>>>>>> +               return;
> >>>>>>>> +
> >>>>>>>> +
> >>>>>>>> +       start = memblock_phys_alloc_range(crash_size, 1, crash_base,
> >>>>>>>> +                                       crash_base + crash_size);
> >>>>>>>> +       if (start != crash_base) {
> >>>>>>>> +               pr_warn("Invalid memory region reserved for crash kernel\n");
> >>>>>>>> +               return;
> >>>>>>>> +       }
> >>>>>>>> +
> >>>>>>>> +       crashk_res.start = crash_base;
> >>>>>>>> +       crashk_res.end   = crash_base + crash_size - 1;
> >>>>>>>> +#endif
> >>>>>>>> +}
> >>>>>>>> +
> >>>>>>>> +static void __init request_crashkernel(struct resource *res)
> >>>>>>>> +{
> >>>>>>>> +#ifdef CONFIG_KEXEC
> >>>>>>>> +       int ret;
> >>>>>>>> +
> >>>>>>>> +       if (crashk_res.start == crashk_res.end)
> >>>>>>>> +               return;
> >>>>>>>> +
> >>>>>>>> +       ret = request_resource(res, &crashk_res);
> >>>>>>>> +       if (!ret)
> >>>>>>>> +               pr_info("Reserving %ldMB of memory at %ldMB for crashkernel\n",
> >>>>>>>> +                       (unsigned long)((crashk_res.end -
> >>>>>>>> +                                        crashk_res.start + 1) >> 20),
> >>>>>>>> +                       (unsigned long)(crashk_res.start  >> 20));
> >>>>>>>> +#endif
> >>>>>>>> +}
> >>>>>>>> +
> >>>>>>>>  void __init platform_init(void)
> >>>>>>>>  {
> >>>>>>>>         efi_init();
> >>>>>>>> @@ -229,6 +275,8 @@ static void __init arch_mem_init(char **cmdline_p)
> >>>>>>>>
> >>>>>>>>         check_kernel_sections_mem();
> >>>>>>>>
> >>>>>>>> +       loongarch_parse_crashkernel();
> >>>>>>>> +
> >>>>>>>>         /*
> >>>>>>>>          * In order to reduce the possibility of kernel panic when failed to
> >>>>>>>>          * get IO TLB memory under CONFIG_SWIOTLB, it is better to allocate
> >>>>>>>> @@ -290,6 +338,7 @@ static void __init resource_init(void)
> >>>>>>>>                 request_resource(res, &code_resource);
> >>>>>>>>                 request_resource(res, &data_resource);
> >>>>>>>>                 request_resource(res, &bss_resource);
> >>>>>>>> +               request_crashkernel(res);
> >>>>>>>>         }
> >>>>>>>>  }
> >>>>>>>>
> >>>>>>>> diff --git a/arch/loongarch/kernel/traps.c b/arch/loongarch/kernel/traps.c
> >>>>>>>> index aa1c95aaf595..0e610872f3f4 100644
> >>>>>>>> --- a/arch/loongarch/kernel/traps.c
> >>>>>>>> +++ b/arch/loongarch/kernel/traps.c
> >>>>>>>> @@ -10,6 +10,7 @@
> >>>>>>>>  #include <linux/entry-common.h>
> >>>>>>>>  #include <linux/init.h>
> >>>>>>>>  #include <linux/kernel.h>
> >>>>>>>> +#include <linux/kexec.h>
> >>>>>>>>  #include <linux/module.h>
> >>>>>>>>  #include <linux/extable.h>
> >>>>>>>>  #include <linux/mm.h>
> >>>>>>>> @@ -246,6 +247,9 @@ void __noreturn die(const char *str, struct pt_regs *regs)
> >>>>>>>>
> >>>>>>>>         oops_exit();
> >>>>>>>>
> >>>>>>>> +       if (regs && kexec_should_crash(current))
> >>>>>>>> +               crash_kexec(regs);
> >>>>>>>> +
> >>>>>>>>         if (in_interrupt())
> >>>>>>>>                 panic("Fatal exception in interrupt");
> >>>>>>>>
> >>>>>>>> --
> >>>>>>>> 2.36.0
> >>>>>>>>
> >>>>>>
> >>>>
> >>
>

Re: [PATCH 2/3] LoongArch: Add kdump support

[Youling Tang]

Hi, Huacai

On 09/05/2022 09:01 PM, Huacai Chen wrote:
> Hi, Youling,
>
> On Mon, Sep 5, 2022 at 3:45 PM Youling Tang <tangyouling@loongson.cn> wrote:
>>
>> Hi, Huacai
>>
>> On 09/05/2022 03:32 PM, Huacai Chen wrote:
>>> Hi, Youling,
>>>
>>> On Mon, Sep 5, 2022 at 10:22 AM Youling Tang <tangyouling@loongson.cn> wrote:
>>>>
>>>>
>>>>
>>>> On 09/05/2022 10:14 AM, Huacai Chen wrote:
>>>>> On Mon, Sep 5, 2022 at 10:04 AM Youling Tang <tangyouling@loongson.cn> wrote:
>>>>>>
>>>>>> Hi, Huacai
>>>>>>
>>>>>> On 09/05/2022 09:38 AM, Huacai Chen wrote:
>>>>>>> Hi, Youling,
>>>>>>>
>>>>>>> On Mon, Sep 5, 2022 at 8:54 AM Youling Tang <tangyouling@loongson.cn> wrote:
>>>>>>>>
>>>>>>>> Hi, Huacai
>>>>>>>>
>>>>>>>> On 09/04/2022 08:21 PM, Huacai Chen wrote:
>>>>>>>>> Hi, Youling,
>>>>>>>>>
>>>>>>>>> I think crash.c can be merged into crash_dump.c
>>>>>>>>
>>>>>>>> Most architectures only implement copy_oldmem_page() in crash_dump.c,
>>>>>>>> I'm not sure if merging crash.c into crash_dump.c will break its
>>>>>>>> consistency?
>>>>>>>>
>>>>>>>> Thanks,
>>>>>>>> Youling
>>>>>>> Yes, you are right, crash.c cannot be merged into crash_dump.c, but it
>>>>>>> can be merged into machine_kexec.c, as arm64 and riscv do.
>>>>>>
>>>>>> For arm64, machine_crash_shutdown() is placed in machine_kexec.c, and
>>>>>> crash_smp_send_stop is placed in smp.c. If crash.c needs to be merged
>>>>>> into machine_kexec.c, should crash_shutdown_secondary and
>>>>>> crash_smp_send_stop be placed in smp.c?
>>>>> I don't want to touch smp.c, all merged into machine_kexec.c seems reasonable.
>>>>
>>>> Ok, I'll merge all into machine_kexec.c.
>>>>
>>>> Youling.
>>> Another problem, 0x9000000091000000 for PHYSICAL_START is too tricky.
>>> If you want to skip the "low memory", maybe we can use
>>> 0x9000000090000000 or 0x90000000a0000000?
>>
>> Because there are many holes in our memory layout, if PHYSICAL_START is
>> set to 0x90000000a0000000, the largest reserved area of the crashkernel
>> will be 512M, beyond which it will fail.
> Then 0x9000000090000000 is not suitable, but I think 512M is enough?
> If so, let's use 0x90000000a0000000.

I'm not sure if it's enough for the server machine?
I will change to 0x90000000a0000000.

Youling.
>
> Huacai
>
> Huacai
>>
>> # cat /proc/iomem
>> 90400000-bfffffff : System RAM
>> c0020000-f9efffff : System RAM
>>    f6810000-f6813fff : Reserved
>>
>> The second System RAM starts at 0x90400000, so 0x9000000090000000 will
>> be too small.
>>
>> Youling.
>>
>>>
>>> Huacai
>>>>
>>>>>
>>>>> Huacai
>>>>>>
>>>>>> Youling.
>>>>>>>
>>>>>>> Huacai
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Huacai
>>>>>>>>>
>>>>>>>>> On Mon, Aug 29, 2022 at 12:37 PM Youling Tang <tangyouling@loongson.cn> wrote:
>>>>>>>>>>
>>>>>>>>>> This patch adds support for kdump, the kernel will reserve a region
>>>>>>>>>> for the crash kernel and jump there on panic.
>>>>>>>>>>
>>>>>>>>>> Arch-specific functions are added to allow for implementing a crash
>>>>>>>>>> dump file interface, /proc/vmcore, which can be viewed as a ELF file.
>>>>>>>>>>
>>>>>>>>>> A user space tool, like kexec-tools, is responsible for allocating a
>>>>>>>>>> separate region for the core's ELF header within crash kdump kernel
>>>>>>>>>> memory and filling it in when executing kexec_load().
>>>>>>>>>>
>>>>>>>>>> Then, its location will be advertised to crash dump kernel via a new
>>>>>>>>>> device-tree property, "linux,elfcorehdr", and crash dump kernel preserves
>>>>>>>>>> the region for later use with fdt_reserve_elfcorehdr() at boot time.
>>>>>>>>>>
>>>>>>>>>> At the same time, it will also limit the crash kdump kernel to the
>>>>>>>>>> crashkernel area via a new device-tree property, "linux, usable-memory-range",
>>>>>>>>>> so as not to destroy the original kernel dump data.
>>>>>>>>>>
>>>>>>>>>> On crash dump kernel, /proc/vmcore will access the primary kernel's memory
>>>>>>>>>> with copy_oldmem_page().
>>>>>>>>>>
>>>>>>>>>> I tested this on  LoongArch 3A5000 machine and works as expected (Suggest
>>>>>>>>>> crashkernel parameter is "crashkernel=512M@2320M"), you may test it by
>>>>>>>>>> triggering a crash through /proc/sysrq_trigger:
>>>>>>>>>>
>>>>>>>>>>  $ sudo kexec -p /boot/vmlinux-kdump --reuse-cmdline --append="nr_cpus=1"
>>>>>>>>>>  # echo c > /proc/sysrq_trigger
>>>>>>>>>>
>>>>>>>>>> Signed-off-by: Youling Tang <tangyouling@loongson.cn>
>>>>>>>>>> ---
>>>>>>>>>>  arch/loongarch/Kconfig                  |  22 ++++++
>>>>>>>>>>  arch/loongarch/Makefile                 |   4 +
>>>>>>>>>>  arch/loongarch/kernel/Makefile          |   3 +-
>>>>>>>>>>  arch/loongarch/kernel/crash.c           | 100 ++++++++++++++++++++++++
>>>>>>>>>>  arch/loongarch/kernel/crash_dump.c      |  19 +++++
>>>>>>>>>>  arch/loongarch/kernel/machine_kexec.c   |  12 ++-
>>>>>>>>>>  arch/loongarch/kernel/mem.c             |   6 ++
>>>>>>>>>>  arch/loongarch/kernel/relocate_kernel.S |   6 ++
>>>>>>>>>>  arch/loongarch/kernel/setup.c           |  49 ++++++++++++
>>>>>>>>>>  arch/loongarch/kernel/traps.c           |   4 +
>>>>>>>>>>  10 files changed, 217 insertions(+), 8 deletions(-)
>>>>>>>>>>  create mode 100644 arch/loongarch/kernel/crash.c
>>>>>>>>>>  create mode 100644 arch/loongarch/kernel/crash_dump.c
>>>>>>>>>>
>>>>>>>>>> diff --git a/arch/loongarch/Kconfig b/arch/loongarch/Kconfig
>>>>>>>>>> index 903c82fa958d..7c1b07a5b5bd 100644
>>>>>>>>>> --- a/arch/loongarch/Kconfig
>>>>>>>>>> +++ b/arch/loongarch/Kconfig
>>>>>>>>>> @@ -420,6 +420,28 @@ config KEXEC
>>>>>>>>>>
>>>>>>>>>>           The name comes from the similarity to the exec system call.
>>>>>>>>>>
>>>>>>>>>> +config CRASH_DUMP
>>>>>>>>>> +       bool "Build kdump crash kernel"
>>>>>>>>>> +       help
>>>>>>>>>> +         Generate crash dump after being started by kexec. This should
>>>>>>>>>> +         be normally only set in special crash dump kernels which are
>>>>>>>>>> +         loaded in the main kernel with kexec-tools into a specially
>>>>>>>>>> +         reserved region and then later executed after a crash by
>>>>>>>>>> +         kdump/kexec.
>>>>>>>>>> +
>>>>>>>>>> +         For more details see Documentation/admin-guide/kdump/kdump.rst
>>>>>>>>>> +
>>>>>>>>>> +config PHYSICAL_START
>>>>>>>>>> +       hex "Physical address where the kernel is loaded"
>>>>>>>>>> +       default "0x9000000091000000" if 64BIT
>>>>>>>>>> +       depends on CRASH_DUMP
>>>>>>>>>> +       help
>>>>>>>>>> +         This gives the XKPRANGE address where the kernel is loaded.
>>>>>>>>>> +         If you plan to use kernel for capturing the crash dump change
>>>>>>>>>> +         this value to start of the reserved region (the "X" value as
>>>>>>>>>> +         specified in the "crashkernel=YM@XM" command line boot parameter
>>>>>>>>>> +         passed to the panic-ed kernel).
>>>>>>>>>> +
>>>>>>>>>>  config SECCOMP
>>>>>>>>>>         bool "Enable seccomp to safely compute untrusted bytecode"
>>>>>>>>>>         depends on PROC_FS
>>>>>>>>>> diff --git a/arch/loongarch/Makefile b/arch/loongarch/Makefile
>>>>>>>>>> index 4bc47f47cfd8..7dabd580426d 100644
>>>>>>>>>> --- a/arch/loongarch/Makefile
>>>>>>>>>> +++ b/arch/loongarch/Makefile
>>>>>>>>>> @@ -48,7 +48,11 @@ KBUILD_CFLAGS_MODULE         += -fplt -Wa,-mla-global-with-abs,-mla-local-with-abs
>>>>>>>>>>  cflags-y += -ffreestanding
>>>>>>>>>>  cflags-y += $(call cc-option, -mno-check-zero-division)
>>>>>>>>>>
>>>>>>>>>> +ifdef CONFIG_PHYSICAL_START
>>>>>>>>>> +load-y         = $(CONFIG_PHYSICAL_START)
>>>>>>>>>> +else
>>>>>>>>>>  load-y         = 0x9000000000200000
>>>>>>>>>> +endif
>>>>>>>>>>  bootvars-y     = VMLINUX_LOAD_ADDRESS=$(load-y)
>>>>>>>>>>
>>>>>>>>>>  drivers-$(CONFIG_PCI)          += arch/loongarch/pci/
>>>>>>>>>> diff --git a/arch/loongarch/kernel/Makefile b/arch/loongarch/kernel/Makefile
>>>>>>>>>> index 20b64ac3f128..df5aea129364 100644
>>>>>>>>>> --- a/arch/loongarch/kernel/Makefile
>>>>>>>>>> +++ b/arch/loongarch/kernel/Makefile
>>>>>>>>>> @@ -17,7 +17,8 @@ obj-$(CONFIG_CPU_HAS_FPU)     += fpu.o
>>>>>>>>>>  obj-$(CONFIG_MODULES)          += module.o module-sections.o
>>>>>>>>>>  obj-$(CONFIG_STACKTRACE)       += stacktrace.o
>>>>>>>>>>
>>>>>>>>>> -obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o
>>>>>>>>>> +obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o crash.o
>>>>>>>>>> +obj-$(CONFIG_CRASH_DUMP)        += crash_dump.o
>>>>>>>>>>
>>>>>>>>>>  obj-$(CONFIG_PROC_FS)          += proc.o
>>>>>>>>>>
>>>>>>>>>> diff --git a/arch/loongarch/kernel/crash.c b/arch/loongarch/kernel/crash.c
>>>>>>>>>> new file mode 100644
>>>>>>>>>> index 000000000000..b4f249ec6301
>>>>>>>>>> --- /dev/null
>>>>>>>>>> +++ b/arch/loongarch/kernel/crash.c
>>>>>>>>>> @@ -0,0 +1,100 @@
>>>>>>>>>> +// SPDX-License-Identifier: GPL-2.0
>>>>>>>>>> +/*
>>>>>>>>>> + * Copyright (C) 2022 Loongson Technology Corporation Limited
>>>>>>>>>> + *
>>>>>>>>>> + * Derived from MIPS
>>>>>>>>>> + */
>>>>>>>>>> +#include <linux/kernel.h>
>>>>>>>>>> +#include <linux/smp.h>
>>>>>>>>>> +#include <linux/reboot.h>
>>>>>>>>>> +#include <linux/crash_dump.h>
>>>>>>>>>> +#include <linux/delay.h>
>>>>>>>>>> +#include <linux/irq.h>
>>>>>>>>>> +#include <linux/types.h>
>>>>>>>>>> +#include <linux/sched.h>
>>>>>>>>>> +#include <linux/sched/task_stack.h>
>>>>>>>>>> +#include <asm/cacheflush.h>
>>>>>>>>>> +#include <asm/kexec.h>
>>>>>>>>>> +
>>>>>>>>>> +static cpumask_t cpus_in_crash = CPU_MASK_NONE;
>>>>>>>>>> +
>>>>>>>>>> +#ifdef CONFIG_SMP
>>>>>>>>>> +static void crash_shutdown_secondary(void *passed_regs)
>>>>>>>>>> +{
>>>>>>>>>> +       struct pt_regs *regs = passed_regs;
>>>>>>>>>> +       int cpu = smp_processor_id();
>>>>>>>>>> +
>>>>>>>>>> +       /*
>>>>>>>>>> +        * If we are passed registers, use those.  Otherwise get the
>>>>>>>>>> +        * regs from the last interrupt, which should be correct, as
>>>>>>>>>> +        * we are in an interrupt.  But if the regs are not there,
>>>>>>>>>> +        * pull them from the top of the stack.  They are probably
>>>>>>>>>> +        * wrong, but we need something to keep from crashing again.
>>>>>>>>>> +        */
>>>>>>>>>> +       if (!regs)
>>>>>>>>>> +               regs = get_irq_regs();
>>>>>>>>>> +       if (!regs)
>>>>>>>>>> +               regs = task_pt_regs(current);
>>>>>>>>>> +
>>>>>>>>>> +       local_irq_disable();
>>>>>>>>>> +       if (!cpumask_test_cpu(cpu, &cpus_in_crash))
>>>>>>>>>> +               crash_save_cpu(regs, cpu);
>>>>>>>>>> +       cpumask_set_cpu(cpu, &cpus_in_crash);
>>>>>>>>>> +
>>>>>>>>>> +       while (!atomic_read(&kexec_ready_to_reboot))
>>>>>>>>>> +               cpu_relax();
>>>>>>>>>> +
>>>>>>>>>> +       kexec_reboot();
>>>>>>>>>> +}
>>>>>>>>>> +
>>>>>>>>>> +/* Override the weak function in kernel/panic.c */
>>>>>>>>>> +void crash_smp_send_stop(void)
>>>>>>>>>> +{
>>>>>>>>>> +       static int cpus_stopped;
>>>>>>>>>> +       unsigned long timeout;
>>>>>>>>>> +       unsigned int ncpus;
>>>>>>>>>> +
>>>>>>>>>> +       /*
>>>>>>>>>> +        * This function can be called twice in panic path, but obviously
>>>>>>>>>> +        * we execute this only once.
>>>>>>>>>> +        */
>>>>>>>>>> +       if (cpus_stopped)
>>>>>>>>>> +               return;
>>>>>>>>>> +
>>>>>>>>>> +       cpus_stopped = 1;
>>>>>>>>>> +
>>>>>>>>>> +        /* Excluding the panic cpu */
>>>>>>>>>> +       ncpus = num_online_cpus() - 1;
>>>>>>>>>> +
>>>>>>>>>> +       smp_call_function(crash_shutdown_secondary, NULL, 0);
>>>>>>>>>> +       smp_wmb();
>>>>>>>>>> +
>>>>>>>>>> +       /*
>>>>>>>>>> +        * The crash CPU sends an IPI and wait for other CPUs to
>>>>>>>>>> +        * respond. Delay of at least 10 seconds.
>>>>>>>>>> +        */
>>>>>>>>>> +       pr_emerg("Sending IPI to other cpus...\n");
>>>>>>>>>> +       timeout = USEC_PER_SEC * 10;
>>>>>>>>>> +       while ((cpumask_weight(&cpus_in_crash) < ncpus) && timeout--) {
>>>>>>>>>> +               cpu_relax();
>>>>>>>>>> +               udelay(1);
>>>>>>>>>> +       }
>>>>>>>>>> +}
>>>>>>>>>> +
>>>>>>>>>> +#endif
>>>>>>>>>> +
>>>>>>>>>> +void machine_crash_shutdown(struct pt_regs *regs)
>>>>>>>>>> +{
>>>>>>>>>> +       int crashing_cpu;
>>>>>>>>>> +
>>>>>>>>>> +       local_irq_disable();
>>>>>>>>>> +
>>>>>>>>>> +       crashing_cpu = smp_processor_id();
>>>>>>>>>> +       crash_save_cpu(regs, crashing_cpu);
>>>>>>>>>> +
>>>>>>>>>> +       /* shutdown non-crashing cpus */
>>>>>>>>>> +       crash_smp_send_stop();
>>>>>>>>>> +       cpumask_set_cpu(crashing_cpu, &cpus_in_crash);
>>>>>>>>>> +
>>>>>>>>>> +       pr_info("Starting crashdump kernel...\n");
>>>>>>>>>> +}
>>>>>>>>>> diff --git a/arch/loongarch/kernel/crash_dump.c b/arch/loongarch/kernel/crash_dump.c
>>>>>>>>>> new file mode 100644
>>>>>>>>>> index 000000000000..13e5d2f7870d
>>>>>>>>>> --- /dev/null
>>>>>>>>>> +++ b/arch/loongarch/kernel/crash_dump.c
>>>>>>>>>> @@ -0,0 +1,19 @@
>>>>>>>>>> +// SPDX-License-Identifier: GPL-2.0
>>>>>>>>>> +#include <linux/highmem.h>
>>>>>>>>>> +#include <linux/crash_dump.h>
>>>>>>>>>> +#include <linux/io.h>
>>>>>>>>>> +
>>>>>>>>>> +ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn,
>>>>>>>>>> +                        size_t csize, unsigned long offset)
>>>>>>>>>> +{
>>>>>>>>>> +       void  *vaddr;
>>>>>>>>>> +
>>>>>>>>>> +       if (!csize)
>>>>>>>>>> +               return 0;
>>>>>>>>>> +
>>>>>>>>>> +       vaddr = kmap_local_pfn(pfn);
>>>>>>>>>> +       csize = copy_to_iter(vaddr + offset, csize, iter);
>>>>>>>>>> +       kunmap_local(vaddr);
>>>>>>>>>> +
>>>>>>>>>> +       return csize;
>>>>>>>>>> +}
>>>>>>>>>> diff --git a/arch/loongarch/kernel/machine_kexec.c b/arch/loongarch/kernel/machine_kexec.c
>>>>>>>>>> index 4ffcd4cd9c8c..f793a3ff09a3 100644
>>>>>>>>>> --- a/arch/loongarch/kernel/machine_kexec.c
>>>>>>>>>> +++ b/arch/loongarch/kernel/machine_kexec.c
>>>>>>>>>> @@ -69,7 +69,7 @@ int machine_kexec_prepare(struct kimage *kimage)
>>>>>>>>>>                 continue;
>>>>>>>>>>         }
>>>>>>>>>>
>>>>>>>>>> -       /* kexec need a safe page to save reboot_code_buffer */
>>>>>>>>>> +       /* kexec/kdump need a safe page to save reboot_code_buffer */
>>>>>>>>>>         kimage->control_code_page = virt_to_page((void *)KEXEC_CTRL_CODE);
>>>>>>>>>>
>>>>>>>>>>         reboot_code_buffer =
>>>>>>>>>> @@ -113,10 +113,6 @@ static void kexec_shutdown_secondary(void *)
>>>>>>>>>>
>>>>>>>>>>         kexec_reboot();
>>>>>>>>>>  }
>>>>>>>>>> -
>>>>>>>>>> -void machine_crash_shutdown(struct pt_regs *regs)
>>>>>>>>>> -{
>>>>>>>>>> -}
>>>>>>>>>>  #endif
>>>>>>>>>>
>>>>>>>>>>  void machine_shutdown(void)
>>>>>>>>>> @@ -135,7 +131,8 @@ void machine_kexec(struct kimage *image)
>>>>>>>>>>
>>>>>>>>>>         jump_addr = (unsigned long)phys_to_virt(image->start);
>>>>>>>>>>
>>>>>>>>>> -       first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
>>>>>>>>>> +       if (image->type == KEXEC_TYPE_DEFAULT)
>>>>>>>>>> +               first_ind_entry = (unsigned long)phys_to_virt(image->head & PAGE_MASK);
>>>>>>>>>>
>>>>>>>>>>         /*
>>>>>>>>>>          * The generic kexec code builds a page list with physical
>>>>>>>>>> @@ -167,7 +164,8 @@ void machine_kexec(struct kimage *image)
>>>>>>>>>>
>>>>>>>>>>         /*
>>>>>>>>>>          * We know we were online, and there will be no incoming IPIs at
>>>>>>>>>> -        * this point.
>>>>>>>>>> +        * this point. Mark online again before rebooting so that the crash
>>>>>>>>>> +        * analysis tool will see us correctly.
>>>>>>>>>>          */
>>>>>>>>>>         set_cpu_online(smp_processor_id(), true);
>>>>>>>>>>
>>>>>>>>>> diff --git a/arch/loongarch/kernel/mem.c b/arch/loongarch/kernel/mem.c
>>>>>>>>>> index 7423361b0ebc..c6def6ff81c8 100644
>>>>>>>>>> --- a/arch/loongarch/kernel/mem.c
>>>>>>>>>> +++ b/arch/loongarch/kernel/mem.c
>>>>>>>>>> @@ -5,6 +5,7 @@
>>>>>>>>>>  #include <linux/efi.h>
>>>>>>>>>>  #include <linux/initrd.h>
>>>>>>>>>>  #include <linux/memblock.h>
>>>>>>>>>> +#include <linux/of_fdt.h>
>>>>>>>>>>
>>>>>>>>>>  #include <asm/bootinfo.h>
>>>>>>>>>>  #include <asm/loongson.h>
>>>>>>>>>> @@ -61,4 +62,9 @@ void __init memblock_init(void)
>>>>>>>>>>
>>>>>>>>>>         /* Reserve the initrd */
>>>>>>>>>>         reserve_initrd_mem();
>>>>>>>>>> +
>>>>>>>>>> +       /* Mainly reserved memory for the elf core head */
>>>>>>>>>> +       early_init_fdt_scan_reserved_mem();
>>>>>>>>>> +       /* Parse linux,usable-memory-range is for crash dump kernel */
>>>>>>>>>> +       early_init_dt_check_for_usable_mem_range();
>>>>>>>>>>  }
>>>>>>>>>> diff --git a/arch/loongarch/kernel/relocate_kernel.S b/arch/loongarch/kernel/relocate_kernel.S
>>>>>>>>>> index d1f242f74ea8..4ee5ac4ac2d7 100644
>>>>>>>>>> --- a/arch/loongarch/kernel/relocate_kernel.S
>>>>>>>>>> +++ b/arch/loongarch/kernel/relocate_kernel.S
>>>>>>>>>> @@ -28,6 +28,12 @@ SYM_CODE_START(relocate_new_kernel)
>>>>>>>>>>         move            s2, a2
>>>>>>>>>>         move            s3, a3
>>>>>>>>>>
>>>>>>>>>> +       /*
>>>>>>>>>> +        * In case of a kdump/crash kernel, the indirection page is not
>>>>>>>>>> +        * populated as the kernel is directly copied to a reserved location
>>>>>>>>>> +        */
>>>>>>>>>> +       beqz            s2, done
>>>>>>>>>> +
>>>>>>>>>>  process_entry:
>>>>>>>>>>         PTR_L           s4, s2, 0
>>>>>>>>>>         PTR_ADDI        s2, s2, SZREG
>>>>>>>>>> diff --git a/arch/loongarch/kernel/setup.c b/arch/loongarch/kernel/setup.c
>>>>>>>>>> index f938aae3e92c..ea34b77e402f 100644
>>>>>>>>>> --- a/arch/loongarch/kernel/setup.c
>>>>>>>>>> +++ b/arch/loongarch/kernel/setup.c
>>>>>>>>>> @@ -19,6 +19,8 @@
>>>>>>>>>>  #include <linux/memblock.h>
>>>>>>>>>>  #include <linux/initrd.h>
>>>>>>>>>>  #include <linux/ioport.h>
>>>>>>>>>> +#include <linux/kexec.h>
>>>>>>>>>> +#include <linux/crash_dump.h>
>>>>>>>>>>  #include <linux/root_dev.h>
>>>>>>>>>>  #include <linux/console.h>
>>>>>>>>>>  #include <linux/pfn.h>
>>>>>>>>>> @@ -186,6 +188,50 @@ static int __init early_parse_mem(char *p)
>>>>>>>>>>  }
>>>>>>>>>>  early_param("mem", early_parse_mem);
>>>>>>>>>>
>>>>>>>>>> +static void __init loongarch_parse_crashkernel(void)
>>>>>>>>>> +{
>>>>>>>>>> +#ifdef CONFIG_KEXEC
>>>>>>>>>> +       unsigned long long start;
>>>>>>>>>> +       unsigned long long total_mem;
>>>>>>>>>> +       unsigned long long crash_size, crash_base;
>>>>>>>>>> +       int ret;
>>>>>>>>>> +
>>>>>>>>>> +       total_mem = memblock_phys_mem_size();
>>>>>>>>>> +       ret = parse_crashkernel(boot_command_line, total_mem,
>>>>>>>>>> +                               &crash_size, &crash_base);
>>>>>>>>>> +       if (ret != 0 || crash_size <= 0)
>>>>>>>>>> +               return;
>>>>>>>>>> +
>>>>>>>>>> +
>>>>>>>>>> +       start = memblock_phys_alloc_range(crash_size, 1, crash_base,
>>>>>>>>>> +                                       crash_base + crash_size);
>>>>>>>>>> +       if (start != crash_base) {
>>>>>>>>>> +               pr_warn("Invalid memory region reserved for crash kernel\n");
>>>>>>>>>> +               return;
>>>>>>>>>> +       }
>>>>>>>>>> +
>>>>>>>>>> +       crashk_res.start = crash_base;
>>>>>>>>>> +       crashk_res.end   = crash_base + crash_size - 1;
>>>>>>>>>> +#endif
>>>>>>>>>> +}
>>>>>>>>>> +
>>>>>>>>>> +static void __init request_crashkernel(struct resource *res)
>>>>>>>>>> +{
>>>>>>>>>> +#ifdef CONFIG_KEXEC
>>>>>>>>>> +       int ret;
>>>>>>>>>> +
>>>>>>>>>> +       if (crashk_res.start == crashk_res.end)
>>>>>>>>>> +               return;
>>>>>>>>>> +
>>>>>>>>>> +       ret = request_resource(res, &crashk_res);
>>>>>>>>>> +       if (!ret)
>>>>>>>>>> +               pr_info("Reserving %ldMB of memory at %ldMB for crashkernel\n",
>>>>>>>>>> +                       (unsigned long)((crashk_res.end -
>>>>>>>>>> +                                        crashk_res.start + 1) >> 20),
>>>>>>>>>> +                       (unsigned long)(crashk_res.start  >> 20));
>>>>>>>>>> +#endif
>>>>>>>>>> +}
>>>>>>>>>> +
>>>>>>>>>>  void __init platform_init(void)
>>>>>>>>>>  {
>>>>>>>>>>         efi_init();
>>>>>>>>>> @@ -229,6 +275,8 @@ static void __init arch_mem_init(char **cmdline_p)
>>>>>>>>>>
>>>>>>>>>>         check_kernel_sections_mem();
>>>>>>>>>>
>>>>>>>>>> +       loongarch_parse_crashkernel();
>>>>>>>>>> +
>>>>>>>>>>         /*
>>>>>>>>>>          * In order to reduce the possibility of kernel panic when failed to
>>>>>>>>>>          * get IO TLB memory under CONFIG_SWIOTLB, it is better to allocate
>>>>>>>>>> @@ -290,6 +338,7 @@ static void __init resource_init(void)
>>>>>>>>>>                 request_resource(res, &code_resource);
>>>>>>>>>>                 request_resource(res, &data_resource);
>>>>>>>>>>                 request_resource(res, &bss_resource);
>>>>>>>>>> +               request_crashkernel(res);
>>>>>>>>>>         }
>>>>>>>>>>  }
>>>>>>>>>>
>>>>>>>>>> diff --git a/arch/loongarch/kernel/traps.c b/arch/loongarch/kernel/traps.c
>>>>>>>>>> index aa1c95aaf595..0e610872f3f4 100644
>>>>>>>>>> --- a/arch/loongarch/kernel/traps.c
>>>>>>>>>> +++ b/arch/loongarch/kernel/traps.c
>>>>>>>>>> @@ -10,6 +10,7 @@
>>>>>>>>>>  #include <linux/entry-common.h>
>>>>>>>>>>  #include <linux/init.h>
>>>>>>>>>>  #include <linux/kernel.h>
>>>>>>>>>> +#include <linux/kexec.h>
>>>>>>>>>>  #include <linux/module.h>
>>>>>>>>>>  #include <linux/extable.h>
>>>>>>>>>>  #include <linux/mm.h>
>>>>>>>>>> @@ -246,6 +247,9 @@ void __noreturn die(const char *str, struct pt_regs *regs)
>>>>>>>>>>
>>>>>>>>>>         oops_exit();
>>>>>>>>>>
>>>>>>>>>> +       if (regs && kexec_should_crash(current))
>>>>>>>>>> +               crash_kexec(regs);
>>>>>>>>>> +
>>>>>>>>>>         if (in_interrupt())
>>>>>>>>>>                 panic("Fatal exception in interrupt");
>>>>>>>>>>
>>>>>>>>>> --
>>>>>>>>>> 2.36.0
>>>>>>>>>>
>>>>>>>>
>>>>>>
>>>>
>>

[PATCH 3/3] LoongArch: Enable CONFIG_KEXEC

[Youling Tang]

Defaults enable CONFIG_KEXEC to convenient kexec operations.

Signed-off-by: Youling Tang <tangyouling@loongson.cn>
---
 arch/loongarch/configs/loongson3_defconfig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/arch/loongarch/configs/loongson3_defconfig b/arch/loongarch/configs/loongson3_defconfig
index 68c9609670d4..52db7a3a79f3 100644
--- a/arch/loongarch/configs/loongson3_defconfig
+++ b/arch/loongarch/configs/loongson3_defconfig
@@ -45,6 +45,7 @@ CONFIG_SMP=y
 CONFIG_HOTPLUG_CPU=y
 CONFIG_NR_CPUS=64
 CONFIG_NUMA=y
+CONFIG_KEXEC=y
 CONFIG_PAGE_SIZE_16KB=y
 CONFIG_HZ_250=y
 CONFIG_ACPI=y
-- 
2.36.0