riscv: kexec: Fixup crash_smp_send_stop without multi cores (9b932aad) · Commits · EulixOS / Software / Kernel

arch/riscv/include/asm/smp.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -50,6 +50,9 @@ void riscv_set_ipi_ops(const struct riscv_ipi_ops *ops);
		/* Clear IPI for current CPU */
		void riscv_clear_ipi(void);

		/* Check other CPUs stop or not */
		bool smp_crash_stop_failed(void);

		/* Secondary hart entry */
		asmlinkage void smp_callin(void);

arch/riscv/kernel/machine_kexec.c

+5 −16

Original line number	Diff line number	Diff line
		@@ -140,22 +140,6 @@ void machine_shutdown(void)
		#endif
		}

		/* Override the weak function in kernel/panic.c */
		void crash_smp_send_stop(void)
		{
		static int cpus_stopped;

		/*
		* This function can be called twice in panic path, but obviously
		* we execute this only once.
		*/
		if (cpus_stopped)
		return;

		smp_send_stop();
		cpus_stopped = 1;
		}

		static void machine_kexec_mask_interrupts(void)
		{
		unsigned int i;
		@@ -230,6 +214,11 @@ machine_kexec(struct kimage *image)
		void *control_code_buffer = page_address(image->control_code_page);
		riscv_kexec_method kexec_method = NULL;

		#ifdef CONFIG_SMP
		WARN(smp_crash_stop_failed(),
		"Some CPUs may be stale, kdump will be unreliable.\n");
		#endif

		if (image->type != KEXEC_TYPE_CRASH)
		kexec_method = control_code_buffer;
		else

arch/riscv/kernel/smp.c

+95 −2

Original line number	Diff line number	Diff line
		@@ -12,6 +12,7 @@
		#include <linux/clockchips.h>
		#include <linux/interrupt.h>
		#include <linux/module.h>
		#include <linux/kexec.h>
		#include <linux/profile.h>
		#include <linux/smp.h>
		#include <linux/sched.h>
		@@ -22,11 +23,13 @@
		#include <asm/sbi.h>
		#include <asm/tlbflush.h>
		#include <asm/cacheflush.h>
		#include <asm/cpu_ops.h>

		enum ipi_message_type {
		IPI_RESCHEDULE,
		IPI_CALL_FUNC,
		IPI_CPU_STOP,
		IPI_CPU_CRASH_STOP,
		IPI_IRQ_WORK,
		IPI_TIMER,
		IPI_MAX
		@@ -71,6 +74,32 @@ static void ipi_stop(void)
		wait_for_interrupt();
		}

		#ifdef CONFIG_KEXEC_CORE
		static atomic_t waiting_for_crash_ipi = ATOMIC_INIT(0);

		static inline void ipi_cpu_crash_stop(unsigned int cpu, struct pt_regs *regs)
		{
		crash_save_cpu(regs, cpu);

		atomic_dec(&waiting_for_crash_ipi);

		local_irq_disable();

		#ifdef CONFIG_HOTPLUG_CPU
		if (cpu_has_hotplug(cpu))
		cpu_ops[cpu]->cpu_stop();
		#endif

		for(;;)
		wait_for_interrupt();
		}
		#else
		static inline void ipi_cpu_crash_stop(unsigned int cpu, struct pt_regs *regs)
		{
		unreachable();
		}
		#endif

		static const struct riscv_ipi_ops *ipi_ops __ro_after_init;

		void riscv_set_ipi_ops(const struct riscv_ipi_ops *ops)
		@@ -124,8 +153,9 @@ void arch_irq_work_raise(void)

		void handle_IPI(struct pt_regs *regs)
		{
		unsigned long *pending_ipis = &ipi_data[smp_processor_id()].bits;
		unsigned long *stats = ipi_data[smp_processor_id()].stats;
		unsigned int cpu = smp_processor_id();
		unsigned long *pending_ipis = &ipi_data[cpu].bits;
		unsigned long *stats = ipi_data[cpu].stats;

		riscv_clear_ipi();

		@@ -154,6 +184,10 @@ void handle_IPI(struct pt_regs *regs)
		ipi_stop();
		}

		if (ops & (1 << IPI_CPU_CRASH_STOP)) {
		ipi_cpu_crash_stop(cpu, get_irq_regs());
		}

		if (ops & (1 << IPI_IRQ_WORK)) {
		stats[IPI_IRQ_WORK]++;
		irq_work_run();
		@@ -176,6 +210,7 @@ static const char * const ipi_names[] = {
		[IPI_RESCHEDULE] = "Rescheduling interrupts",
		[IPI_CALL_FUNC] = "Function call interrupts",
		[IPI_CPU_STOP] = "CPU stop interrupts",
		[IPI_CPU_CRASH_STOP] = "CPU stop (for crash dump) interrupts",
		[IPI_IRQ_WORK] = "IRQ work interrupts",
		[IPI_TIMER] = "Timer broadcast interrupts",
		};
		@@ -235,6 +270,64 @@ void smp_send_stop(void)
		cpumask_pr_args(cpu_online_mask));
		}

		#ifdef CONFIG_KEXEC_CORE
		/*
		* The number of CPUs online, not counting this CPU (which may not be
		* fully online and so not counted in num_online_cpus()).
		*/
		static inline unsigned int num_other_online_cpus(void)
		{
		unsigned int this_cpu_online = cpu_online(smp_processor_id());

		return num_online_cpus() - this_cpu_online;
		}

		void crash_smp_send_stop(void)
		{
		static int cpus_stopped;
		cpumask_t mask;
		unsigned long timeout;

		/*
		* This function can be called twice in panic path, but obviously
		* we execute this only once.
		*/
		if (cpus_stopped)
		return;

		cpus_stopped = 1;

		/*
		* If this cpu is the only one alive at this point in time, online or
		* not, there are no stop messages to be sent around, so just back out.
		*/
		if (num_other_online_cpus() == 0)
		return;

		cpumask_copy(&mask, cpu_online_mask);
		cpumask_clear_cpu(smp_processor_id(), &mask);

		atomic_set(&waiting_for_crash_ipi, num_other_online_cpus());

		pr_crit("SMP: stopping secondary CPUs\n");
		send_ipi_mask(&mask, IPI_CPU_CRASH_STOP);

		/* Wait up to one second for other CPUs to stop */
		timeout = USEC_PER_SEC;
		while ((atomic_read(&waiting_for_crash_ipi) > 0) && timeout--)
		udelay(1);

		if (atomic_read(&waiting_for_crash_ipi) > 0)
		pr_warn("SMP: failed to stop secondary CPUs %*pbl\n",
		cpumask_pr_args(&mask));
		}

		bool smp_crash_stop_failed(void)
		{
		return (atomic_read(&waiting_for_crash_ipi) > 0);
		}
		#endif

		void smp_send_reschedule(int cpu)
		{
		send_ipi_single(cpu, IPI_RESCHEDULE);