@@ -665,6 +665,9 @@ config RELOCATABLE_TEST
config ARCH_HAS_CRASH_DUMP
def_bool PPC64 || PPC_BOOK3S_32 || PPC_85xx || (44x && !SMP)
+config ARCH_HAS_CRASH_HOTPLUG
+ def_bool y
+
config ARCH_SUPPORTS_CRASH_DUMP
def_bool y
depends on CRASH_DUMP
@@ -103,6 +103,16 @@ void kexec_copy_flush(struct kimage *image);
struct crash_mem;
int update_cpus_node(void *fdt);
int get_crash_memory_ranges(struct crash_mem **mem_ranges);
+
+#ifdef CONFIG_CRASH_HOTPLUG
+void arch_crash_handle_hotplug_event(struct kimage *image);
+#define arch_crash_handle_hotplug_event arch_crash_handle_hotplug_event
+
+#ifdef CONFIG_HOTPLUG_CPU
+static inline int crash_hotplug_cpu_support(void) { return 1; }
+#define crash_hotplug_cpu_support crash_hotplug_cpu_support
+#endif
+#endif
#endif
#if defined(CONFIG_CRASH_DUMP) && defined(CONFIG_PPC_RTAS)
@@ -543,6 +543,67 @@ int update_cpus_node(void *fdt)
return ret;
}
+#ifdef CONFIG_CRASH_HOTPLUG
+#undef pr_fmt
+#define pr_fmt(fmt) "crash hp: " fmt
+
+/**
+ * arch_crash_handle_hotplug_event - Handle crash CPU/Memory hotplug events to update the
+ * necessary kexec segments based on the hotplug event.
+ * @image: the active struct kimage
+ *
+ * Update FDT segment to include newly added CPU. No action for CPU remove case.
+ */
+void arch_crash_handle_hotplug_event(struct kimage *image)
+{
+ void *fdt, *ptr;
+ unsigned long mem;
+ int i, fdt_index = -1;
+ unsigned int hp_action = image->hp_action;
+
+ /*
+ * Since the hot-unplugged CPU is already part of crash FDT,
+ * no action is needed for CPU remove case.
+ */
+ if (hp_action == KEXEC_CRASH_HP_REMOVE_CPU)
+ return;
+
+ /* crash update on memory hotplug events is not supported yet */
+ if (hp_action == KEXEC_CRASH_HP_REMOVE_MEMORY || hp_action == KEXEC_CRASH_HP_ADD_MEMORY) {
+ pr_info_once("Crash update is not supported for memory hotplug\n");
+ return;
+ }
+
+ /* Find the FDT segment index in kexec segment array. */
+ for (i = 0; i < image->nr_segments; i++) {
+ mem = image->segment[i].mem;
+ ptr = __va(mem);
+
+ if (ptr && fdt_magic(ptr) == FDT_MAGIC) {
+ fdt_index = i;
+ break;
+ }
+ }
+
+ if (fdt_index < 0) {
+ pr_err("Unable to locate FDT segment.\n");
+ return;
+ }
+
+ fdt = __va((void *)image->segment[fdt_index].mem);
+
+ /* Temporarily invalidate the crash image while it is replaced */
+ xchg(&kexec_crash_image, NULL);
+
+ /* update FDT to refelect changes in CPU resrouces */
+ if (update_cpus_node(fdt))
+ pr_err("Failed to update crash FDT");
+
+ /* The crash image is now valid once again */
+ xchg(&kexec_crash_image, image);
+}
+#endif
+
#ifdef CONFIG_PPC_64S_HASH_MMU
/* Values we need to export to the second kernel via the device tree. */
static unsigned long htab_base;
@@ -30,6 +30,7 @@ static void *elf64_load(struct kimage *image, char *kernel_buf,
unsigned long cmdline_len)
{
int ret;
+ bool do_pack_fdt = true;
unsigned long kernel_load_addr;
unsigned long initrd_load_addr = 0, fdt_load_addr;
void *fdt;
@@ -116,7 +117,16 @@ static void *elf64_load(struct kimage *image, char *kernel_buf,
if (ret)
goto out_free_fdt;
- fdt_pack(fdt);
+#ifdef CONFIG_CRASH_HOTPLG
+ /*
+ * Do not pack FDT, additional space is reserved to accommodate
+ * possible CPU nodes which are not yet present in the system.
+ */
+ if (image->type == KEXEC_TYPE_CRASH)
+ do_pack_fdt = false;
+#endif
+ if (do_pack_fdt)
+ fdt_pack(fdt);
kbuf.buffer = fdt;
kbuf.bufsz = kbuf.memsz = fdt_totalsize(fdt);
@@ -908,6 +908,9 @@ unsigned int kexec_extra_fdt_size_ppc64(struct kimage *image)
unsigned int cpu_nodes, extra_size = 0;
struct device_node *dn;
u64 usm_entries;
+#ifdef CONFIG_CRASH_HOTPLUG
+ unsigned int possible_cpu_nodes;
+#endif
// Budget some space for the password blob. There's already extra space
// for the key name
@@ -940,6 +943,17 @@ unsigned int kexec_extra_fdt_size_ppc64(struct kimage *image)
if (cpu_nodes > boot_cpu_node_count)
extra_size += (cpu_nodes - boot_cpu_node_count) * cpu_node_size();
+#ifdef CONFIG_CRASH_HOTPLUG
+ /*
+ * Make sure enough space is reserved to accommodate possible CPU nodes
+ * in the crash FDT. This allows packing possible CPU nodes which are
+ * not yet present in the system without regenerating the entire FDT.
+ */
+ possible_cpu_nodes = num_possible_cpus() / threads_per_core;
+ if (image->type == KEXEC_TYPE_CRASH && possible_cpu_nodes > cpu_nodes)
+ extra_size += (possible_cpu_nodes - cpu_nodes) * cpu_node_size();
+#endif
+
return extra_size;
}
Introduce powerpc crash hotplug handler to update the necessary kexec segments in the kernel on CPU/Memory hotplug events. Currently, these updates are done by monitoring CPU/Memory hotplug events in userspace. In the generic infrastructure, a shared crash hotplug handler is triggered for both CPU and Memory hotplug events. However, in this particular patch, only CPU hotplug events are handled for crash updates. Support for crash updates during memory hotplug events will be introduced in subsequent patches. The elfcorehdr segment facilitates the exchange of CPU and other relevant dump information between kernels. Ideally, this segment should be regenerated during CPU hotplug events to reflect any changes. However, on powerpc systems, the elfcorehdr is initially constructed with all possible CPUs, rendering it unnecessary to update or recreate it when CPU hotplug events occur. Additionally, on powerpc, there is another segment called the FDT (Flattened Device Tree) that holds CPU data. During the boot of the kdump kernel, it is crucial for the crashing CPU to be present in the FDT. Failure to have the crashing CPU in the FDT would result in a boot failure of the kdump kernel. Therefore, the only action required on powerpc to handle a crash CPU hotplug event is to add the hot-added CPUs to the kdump FDT segment, ensuring that the kdump kernel boots successfully. However, there is no need to remove the hot-unplugged CPUs from the FDT segment, so no action is taken for a CPU hot removal event. In order to support an increasing number of CPUs, the FDT is constructed with extra buffer space to ensure it can accommodate possible number of CPUs nodes. Also do not pack the FDT and shrik its size once prepared. The changes introduced here will also work for the kexec_load system call, considering that the kexec tool constructs the FDT segment with extra space to accommodate possible number CPUs nodes. Since memory crash hotplug support is not there yet the crash hotplug the handler simply warns the user and returns. The changes realted to in-kernel update to kdump kernel kexec segments on CPU/Memory hotplug and online/offline events are kept under CRASH_HOTPLUG config and it is enabled by default on PowerPC platform. Signed-off-by: Sourabh Jain <sourabhjain@linux.ibm.com> --- arch/powerpc/Kconfig | 3 ++ arch/powerpc/include/asm/kexec.h | 10 +++++ arch/powerpc/kexec/core_64.c | 61 +++++++++++++++++++++++++++++++ arch/powerpc/kexec/elf_64.c | 12 +++++- arch/powerpc/kexec/file_load_64.c | 14 +++++++ 5 files changed, 99 insertions(+), 1 deletion(-)