powerpc/crash: Kernel handling of CPU and memory hotplug
Subsystems (7)
v13 cover powerpc/crash: Kernel handling of CPU and memory hotplug
Commit 247262756121 ("crash: add generic infrastructure for crash hotplug support") added a generic infrastructure that allows architectures to selectively update the kdump image component during CPU or memory add/remove events within the kernel itself.
This patch series adds crash hotplug handler for PowerPC and enable support to update the kdump image on CPU/Memory add/remove events.
Among the 6 patches in this series, the first three patches make changes to the generic crash hotplug handler to assist PowerPC in adding support for this feature. The last three patches add support for this feature.
The following section outlines the problem addressed by this patch series, along with the current solution, its shortcomings, and the proposed resolution.
Problem:
========
Due to CPU/Memory hotplug or online/offline events the elfcorehdr (which describes the CPUs and memory of the crashed kernel) and FDT (Flattened Device Tree) of kdump image becomes outdated. Consequently, attempting dump collection with an outdated elfcorehdr or FDT can lead to failed or inaccurate dump collection.
Going forward CPU hotplug or online/offline events are referred as CPU/Memory add/remove events.
Existing solution and its shortcoming:
======================================
The current solution to address the above issue involves monitoring the CPU/memory add/remove events in userspace using udev rules and whenever there are changes in CPU and memory resources, the entire kdump image is loaded again. The kdump image includes kernel, initrd, elfcorehdr, FDT, purgatory. Given that only elfcorehdr and FDT get outdated due to CPU/Memory add/remove events, reloading the entire kdump image is inefficient. More importantly, kdump remains inactive for a substantial amount of time until the kdump reload completes.
Proposed solution:
==================
Instead of initiating a full kdump image reload from userspace on CPU/Memory hotplug and online/offline events, the proposed solution aims to update only the necessary kdump image component within the kernel itself.
Git tree for testing:
=====================
Git tree rebased on top of v6.7-rc4:
https://github.com/sourabhjains/linux/tree/kdump-in-kernel-crash-update
To realize this feature, the kdump udev rule must be updated. On RHEL, add the following two lines at the top of the "/usr/lib/udev/rules.d/98-kexec.rules" file.
SUBSYSTEM=="cpu", ATTRS{crash_hotplug}=="1", GOTO="kdump_reload_end" SUBSYSTEM=="memory", ATTRS{crash_hotplug}=="1", GOTO="kdump_reload_end"
With the above change to the kdump udev rule, kdump reload is avoided during CPU/Memory add/remove events if this feature is enabled in the kernel.
Note: only kexec_file_load syscall will work. For kexec_load minor changes are required in kexec tool.
Changelog:
----------
v13:
- Fix a build warning, take ranges.c out of CONFIG_KEXEC_FILE
- Rebase to v6.7-rc4
v12:
- A patch to add new kexec flags to support this feature on kexec_load system call
- Change in the way this feature is advertise to userspace for both kexec_load syscall
- Rebase to v6.6-rc7
v11:
- Rebase to v6.4-rc6
- The patch that introduced CONFIG_CRASH_HOTPLUG for PowerPC has been removed. The config is now part of common configuration:
https://lore.kernel.org/all/[email protected]/
v10:
- Drop the patch that adds fdt_index attribute to struct kimage_arch Find the fdt segment index when needed.
- Added more details into commits messages.
- Rebased onto 6.3.0-rc5
v9:
- Removed patch to prepare elfcorehdr crash notes for possible CPUs. The patch is moved to generic patch series that introduces generic infrastructure for in kernel crash update.
- Removed patch to pass the hotplug action type to the arch crash hotplug handler function. The generic patch series has introduced the hotplug action type in kimage struct.
- Add detail commit message for better understanding.
v8:
- Restrict fdt_index initialization to machine_kexec_post_load it work for both kexec_load and kexec_file_load.[3/8] Laurent Dufour
- Updated the logic to find the number of offline core. [6/8]
- Changed the logic to find the elfcore program header to accommodate future memory ranges due memory hotplug events. [8/8]
v7
- added a new config to configure this feature
- pass hotplug action type to arch specific handler
v6
- Added crash memory hotplug support
v5:
- Replace COFNIG_CRASH_HOTPLUG with CONFIG_HOTPLUG_CPU.
- Move fdt segment identification for kexec_load case to load path instead of crash hotplug handler
- Keep new attribute defined under kimage_arch to track FDT segment under CONFIG_HOTPLUG_CPU config.
v4:
- Update the logic to find the additional space needed for hotadd CPUs post kexec load. Refer "[RFC v4 PATCH 4/5] powerpc/crash hp: add crash hotplug support for kexec_file_load" patch to know more about the change.
- Fix a couple of typo.
- Replace pr_err to pr_info_once to warn user about memory hotplug support.
- In crash hotplug handle exit the for loop if FDT segment is found.
v3
- Move fdt_index and fdt_index_vaild variables to kimage_arch struct.
- Rebase patche on top of
https://lore.kernel.org/lkml/[email protected]/
- Fixed warning reported by checpatch script
v2:
- Use generic hotplug handler introduced by
https://lore.kernel.org/lkml/[email protected]/
a significant change from v1.
Sourabh Jain (6):
crash: forward memory_notify arg to arch crash hotplug handler
crash: make CPU and Memory hotplug support reporting flexible
crash: add a new kexec flag for FDT update powerpc/kexec: turn some static helper functions public
powerpc: add crash CPU hotplug support
powerpc: add crash memory hotplug support
arch/powerpc/Kconfig | 4 + arch/powerpc/include/asm/kexec.h | 25 ++ arch/powerpc/include/asm/kexec_ranges.h | 1 + arch/powerpc/kexec/Makefile | 4 +- arch/powerpc/kexec/core_64.c | 368 ++++++++++++++++++++++++ arch/powerpc/kexec/elf_64.c | 12 +- arch/powerpc/kexec/file_load_64.c | 210 +++----------- arch/powerpc/kexec/ranges.c | 85 ++++++ arch/x86/include/asm/kexec.h | 10 +- arch/x86/kernel/crash.c | 23 +- include/linux/kexec.h | 21 +- include/uapi/linux/kexec.h | 1 + kernel/crash_core.c | 37 ++- kernel/kexec.c | 2 + 14 files changed, 603 insertions(+), 200 deletions(-)
Signature · 7 lines
2.41.0 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
PATCH v13 1/6 crash: forward memory_notify arg to arch crash hotplug handler
In the event of memory hotplug or online/offline events, the crash memory hotplug notifier crash_memhp_notifier() receives a memory_notify object but doesn't forward that object to the generic and architecture-specific crash hotplug handler.
The memory_notify object contains the starting PFN (Page Frame Number) and the number of pages in the hot-removed memory. This information is necessary for architectures like PowerPC to update/recreate the kdump image, specifically elfcorehdr.
So update the function signature of crash_handle_hotplug_event() and arch_crash_handle_hotplug_event() to accept the memory_notify object as an argument from crash memory hotplug notifier.
Since no such object is available in the case of CPU hotplug event, the crash CPU hotplug notifier crash_cpuhp_online() passes NULL to the crash hotplug handler.
--- arch/x86/include/asm/kexec.h | 2 +- arch/x86/kernel/crash.c | 3 ++- include/linux/kexec.h | 2 +- kernel/crash_core.c | 14 +++++++------- 4 files changed, 11 insertions(+), 10 deletions(-)
arch/x86/include/asm/kexec.h +1 -1
@@ -208,7 +208,7 @@ int arch_kimage_file_post_load_cleanup(struct kimage *image);extern void kdump_nmi_shootdown_cpus (void );#ifdef CONFIG_CRASH_HOTPLUG -void arch_crash_handle_hotplug_event (struct kimage *image); +void arch_crash_handle_hotplug_event (struct kimage *image,void *arg);#define arch_crash_handle_hotplug_event arch_crash_handle_hotplug_event#ifdef CONFIG_HOTPLUG_CPU
arch/x86/kernel/crash.c +2 -1
@@ -428,10 +428,11 @@ unsigned int arch_crash_get_elfcorehdr_size(void)/** * arch_crash_handle_hotplug_event() - Handle hotplug elfcorehdr changes * @image: a pointer to kexec_crash_image +* @arg: struct memory_notify handler for memory hotplug case and NULL for CPU hotplug case. * * Prepare the new elfcorehdr and replace the existing elfcorehdr. */ -void arch_crash_handle_hotplug_event (struct kimage *image) +void arch_crash_handle_hotplug_event (struct kimage *image,void *arg) {void *elfbuf =NULL , *old_elfcorehdr;unsigned long nr_mem_ranges;
include/linux/kexec.h +1 -1
@@ -483,7 +483,7 @@ static inline void arch_kexec_pre_free_pages(void *vaddr, unsigned int pages) {#endif #ifndef arch_crash_handle_hotplug_event -static inline void arch_crash_handle_hotplug_event (struct kimage *image) { } +static inline void arch_crash_handle_hotplug_event (struct kimage *image,void *arg) { }#endif int crash_check_update_elfcorehdr (void );
kernel/crash_core.c +7 -7
@@ -935,7 +935,7 @@ int crash_check_update_elfcorehdr(void)* list of segments it checks (since the elfcorehdr changes and thus * would require an update to purgatory itself to update the digest). */ -static void crash_handle_hotplug_event (unsigned int hp_action,unsigned int cpu) +static void crash_handle_hotplug_event (unsigned int hp_action,unsigned int cpu,void *arg) {struct kimage *image;
@@ -997,7 +997,7 @@ static void crash_handle_hotplug_event(unsigned int hp_action, unsigned int cpu) image->hp_action = hp_action;/* Now invoke arch-specific update handler */ -arch_crash_handle_hotplug_event (image); +arch_crash_handle_hotplug_event (image, arg);/* No longer handling a hotplug event */ image->hp_action =KEXEC_CRASH_HP_NONE ;
@@ -1013,17 +1013,17 @@ static void crash_handle_hotplug_event(unsigned int hp_action, unsigned int cpu)crash_hotplug_unlock (); } -static int crash_memhp_notifier (struct notifier_block *nb,unsigned long val,void *v) +static int crash_memhp_notifier (struct notifier_block *nb,unsigned long val,void *arg) {switch (val) {case MEM_ONLINE :crash_handle_hotplug_event (KEXEC_CRASH_HP_ADD_MEMORY , -KEXEC_CRASH_HP_INVALID_CPU ); +KEXEC_CRASH_HP_INVALID_CPU , arg);break ;case MEM_OFFLINE :crash_handle_hotplug_event (KEXEC_CRASH_HP_REMOVE_MEMORY , -KEXEC_CRASH_HP_INVALID_CPU ); +KEXEC_CRASH_HP_INVALID_CPU , arg);break ; }return NOTIFY_OK ;
@@ -1036,13 +1036,13 @@ static struct notifier_block crash_memhp_nb = {static int crash_cpuhp_online (unsigned int cpu) { -crash_handle_hotplug_event (KEXEC_CRASH_HP_ADD_CPU , cpu); +crash_handle_hotplug_event (KEXEC_CRASH_HP_ADD_CPU , cpu,NULL );return 0 ; }static int crash_cpuhp_offline (unsigned int cpu) { -crash_handle_hotplug_event (KEXEC_CRASH_HP_REMOVE_CPU , cpu); +crash_handle_hotplug_event (KEXEC_CRASH_HP_REMOVE_CPU , cpu,NULL );return 0 ; }
Signature · 7 lines
2.41.0 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
PATCH v13 2/6 crash: make CPU and Memory hotplug support reporting flexible
In reply to Sourabh JainArchitectures' specific functions arch_crash_hotplug_cpu_support() and arch_crash_hotplug_memory_support() advertise the kernel's capability to update the kdump image on CPU and Memory hotplug events to userspace via the sysfs interface. These architecture-specific functions need to access various attributes of the kexec_crash_image object to determine whether the kernel can update the kdump image and advertise this information to userspace accordingly.
As the architecture-specific code is not exposed to the APIs required to acquire the lock for accessing the kexec_crash_image object, it calls a generic function, crash_check_update_elfcorehdr(), to determine whether the kernel can update the kdump image or not.
The lack of access to the kexec_crash_image object in architecture-specific code restricts architectures from performing additional architecture-specific checks required to determine if the kdump image is updatable or not. For instance, on PowerPC, the kernel can update the kdump image only if both the elfcorehdr and FDT are marked as updatable for the kexec_load system call.
So define two generic functions, crash_hotplug_cpu_support() and crash_hotplug_memory_support(), which are called when userspace attempts to read the crash CPU and Memory hotplug support via the sysfs interface. These functions take the necessary locks needed to access the kexec_crash_image object and then forward it to the architecture-specific handler to do the rest.
--- arch/x86/include/asm/kexec.h | 8 ++++---- arch/x86/kernel/crash.c | 20 +++++++++++++++----- include/linux/kexec.h | 13 +++++++------ kernel/crash_core.c | 23 +++++++++++++++++------ 4 files changed, 43 insertions(+), 21 deletions(-)
arch/x86/include/asm/kexec.h +4 -4
@@ -212,13 +212,13 @@ void arch_crash_handle_hotplug_event(struct kimage *image, void *arg);#define arch_crash_handle_hotplug_event arch_crash_handle_hotplug_event#ifdef CONFIG_HOTPLUG_CPU -int arch_crash_hotplug_cpu_support (void ); -#define crash_hotplug_cpu_support arch_crash_hotplug_cpu_support +int arch_crash_hotplug_cpu_support (struct kimage *image); +#define arch_crash_hotplug_cpu_support arch_crash_hotplug_cpu_support#endif #ifdef CONFIG_MEMORY_HOTPLUG -int arch_crash_hotplug_memory_support (void ); -#define crash_hotplug_memory_support arch_crash_hotplug_memory_support +int arch_crash_hotplug_memory_support (struct kimage *image); +#define arch_crash_hotplug_memory_support arch_crash_hotplug_memory_support#endif unsigned int arch_crash_get_elfcorehdr_size (void );
arch/x86/kernel/crash.c +15 -5
@@ -398,18 +398,28 @@ int crash_load_segments(struct kimage *image)#undef pr_fmt#define pr_fmt (fmt) "crash hp: " fmt -/* These functions provide the value for the sysfs crash_hotplug nodes */ +#if defined(CONFIG_HOTPLUG_CPU ) || defined(CONFIG_MEMORY_HOTPLUG ) +static int crash_hotplug_support (struct kimage *image) +{ +if (image->file_mode) +return 1 ; + +return image->update_elfcorehdr; +} +#endif +#ifdef CONFIG_HOTPLUG_CPU -int arch_crash_hotplug_cpu_support (void ) +/* These functions provide the value for the sysfs crash_hotplug nodes */ +int arch_crash_hotplug_cpu_support (struct kimage *image) { -return crash_check_update_elfcorehdr (); +return crash_hotplug_support (image); }#endif #ifdef CONFIG_MEMORY_HOTPLUG -int arch_crash_hotplug_memory_support (void ) +int arch_crash_hotplug_memory_support (struct kimage *image) { -return crash_check_update_elfcorehdr (); +return crash_hotplug_support (image); }#endif
include/linux/kexec.h +7 -6
@@ -486,16 +486,17 @@ static inline void arch_kexec_pre_free_pages(void *vaddr, unsigned int pages) {static inline void arch_crash_handle_hotplug_event (struct kimage *image,void *arg) { }#endif -int crash_check_update_elfcorehdr (void ); - -#ifndef crash_hotplug_cpu_support -static inline int crash_hotplug_cpu_support (void ) {return 0 ; } +#ifndef arch_crash_hotplug_cpu_support +static inline int arch_crash_hotplug_cpu_support (struct kimage *image) {return 0 ; }#endif -#ifndef crash_hotplug_memory_support -static inline int crash_hotplug_memory_support (void ) {return 0 ; } +#ifndef arch_crash_hotplug_memory_support +static inline int arch_crash_hotplug_memory_support (struct kimage *image) {return 0 ; }#endif +extern int crash_hotplug_cpu_support (void ); +extern int crash_hotplug_memory_support (void ); +#ifndef crash_get_elfcorehdr_sizestatic inline unsigned int crash_get_elfcorehdr_size (void ) {return 0 ; }#endif
kernel/crash_core.c +17 -6
@@ -892,12 +892,14 @@ DEFINE_MUTEX(__crash_hotplug_lock);#define crash_hotplug_lock () mutex_lock(&__crash_hotplug_lock)#define crash_hotplug_unlock () mutex_unlock(&__crash_hotplug_lock) +#define CPU_HOTPLUG 0 +#define MEM_HOTPLUG 1/* * This routine utilized when the crash_hotplug sysfs node is read. * It reflects the kernel's ability/permission to update the crash * elfcorehdr directly. */ -int crash_check_update_elfcorehdr (void ) +static int crash_hotplug_support (int hotplug) {int rc =0 ;
@@ -909,18 +911,27 @@ int crash_check_update_elfcorehdr(void)return 0 ; }if (kexec_crash_image) { -if (kexec_crash_image->file_mode) - rc =1 ; -else - rc = kexec_crash_image->update_elfcorehdr; +if (hotplug ==CPU_HOTPLUG ) + rc =arch_crash_hotplug_cpu_support (kexec_crash_image); +else if (hotplug ==MEM_HOTPLUG ) + rc =arch_crash_hotplug_memory_support (kexec_crash_image); }/* Release lock now that update complete */ kexec_unlock ();crash_hotplug_unlock (); -return rc; } +int crash_hotplug_cpu_support (void ) +{ +return crash_hotplug_support (CPU_HOTPLUG ); +} + +int crash_hotplug_memory_support (void ) +{ +return crash_hotplug_support (MEM_HOTPLUG ); +} +/* * To accurately reflect hot un/plug changes of cpu and memory resources * (including onling and offlining of those resources), the elfcorehdr
Signature · 7 lines
2.41.0 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
PATCH v13 3/6 crash: add a new kexec flag for FDT update
In reply to Sourabh JainThe commit a72bbec70da2 ("crash: hotplug support for kexec_load()") introduced a new kexec flag, KEXEC_UPDATE_ELFCOREHDR. Kexec tool uses this flag to indicate kernel that it is safe to modify the elfcorehdr of kdump image loaded using kexec_load system call.
Similarly, add a new kexec flag, KEXEC_UPDATE_FDT, for another kdump component named FDT (Flatten Device Tree). Architectures like PowerPC need to update FDT kdump image component on CPU hotplug events. Kexec tool passing KEXEC_UPDATE_FDT will be an indication to kernel that FDT segment is not part of SHA calculation hence it is safe to update it.
With the KEXEC_UPDATE_ELFCOREHDR and KEXEC_UPDATE_FDT kexec flags, crash hotplug support can be added to PowerPC for the kexec_load syscall while maintaining the backward compatibility with older kexec tools that do not have these newly introduced flags.
--- include/linux/kexec.h | 6 ++++-- include/uapi/linux/kexec.h | 1 + kernel/kexec.c | 2 ++ 3 files changed, 7 insertions(+), 2 deletions(-)
include/linux/kexec.h +4 -2
@@ -319,6 +319,7 @@ struct kimage {#ifdef CONFIG_CRASH_HOTPLUG /* If set, allow changes to elfcorehdr of kexec_load'd image */ unsigned int update_elfcorehdr:1; + unsigned int update_fdt:1;#endif #ifdef ARCH_HAS_KIMAGE_ARCH
@@ -396,9 +397,10 @@ bool kexec_load_permitted(int kexec_image_type);/* List of defined/legal kexec flags */ #ifndef CONFIG_KEXEC_JUMP -#define KEXEC_FLAGS (KEXEC_ON_CRASH | KEXEC_UPDATE_ELFCOREHDR) +#define KEXEC_FLAGS (KEXEC_ON_CRASH | KEXEC_UPDATE_ELFCOREHDR | KEXEC_UPDATE_FDT)#else -#define KEXEC_FLAGS (KEXEC_ON_CRASH | KEXEC_PRESERVE_CONTEXT | KEXEC_UPDATE_ELFCOREHDR) +#define KEXEC_FLAGS (KEXEC_ON_CRASH | KEXEC_PRESERVE_CONTEXT | KEXEC_UPDATE_ELFCOREHDR | \ + KEXEC_UPDATE_FDT)#endif /* List of defined/legal kexec file flags */
include/uapi/linux/kexec.h +1 -0
@@ -13,6 +13,7 @@#define KEXEC_ON_CRASH 0x00000001#define KEXEC_PRESERVE_CONTEXT 0x00000002#define KEXEC_UPDATE_ELFCOREHDR 0x00000004 +#define KEXEC_UPDATE_FDT 0x00000008#define KEXEC_ARCH_MASK 0xffff0000/*
kernel/kexec.c +2 -0
@@ -132,6 +132,8 @@ static int do_kexec_load(unsigned long entry, unsigned long nr_segments,#ifdef CONFIG_CRASH_HOTPLUG if (flags &KEXEC_UPDATE_ELFCOREHDR ) image->update_elfcorehdr =1 ; +if (flags &KEXEC_UPDATE_FDT ) + image->update_fdt =1 ;#endif ret =machine_kexec_prepare (image);
Signature · 7 lines
2.41.0 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
PATCH v13 4/6 powerpc/kexec: turn some static helper functions public
In reply to Sourabh JainMove the functions update_cpus_node and get_crash_memory_ranges from kexec/file_load_64.c to kexec/core_64.c to make these functions usable by other kexec components.
get_crash_memory_ranges uses functions defined in ranges.c, so take ranges.c out of CONFIG_KEXEC_FILE.
Later in the series, these functions are utilized for in-kernel updates to kdump image during CPU/Memory hotplug or online/offline events for both kexec_load and kexec_file_load syscalls.
There is no intended functional change.
--- arch/powerpc/include/asm/kexec.h | 6 ++ arch/powerpc/kexec/Makefile | 4 +- arch/powerpc/kexec/core_64.c | 166 ++++++++++++++++++++++++++++++ arch/powerpc/kexec/file_load_64.c | 162 ----------------------------- 4 files changed, 174 insertions(+), 164 deletions(-)
arch/powerpc/include/asm/kexec.h +6 -0
@@ -108,6 +108,12 @@ void crash_free_reserved_phys_range(unsigned long begin, unsigned long end);#endif /* CONFIG_PPC_RTAS */ #endif /* CONFIG_CRASH_DUMP */ +#ifdef CONFIG_PPC64 +struct crash_mem ; +int update_cpus_node (void *fdt); +int get_crash_memory_ranges (struct crash_mem **mem_ranges); +#endif /* CONFIG_PPC64 */ +#ifdef CONFIG_KEXEC_FILE extern const struct kexec_file_ops kexec_elf64_ops;
arch/powerpc/kexec/Makefile +2 -2
@@ -3,11 +3,11 @@ # Makefile for the linux kernel. # -obj-y += core.o crash.o core_$(BITS).o +obj-y += core.o crash.o ranges.o core_$(BITS).o obj-$(CONFIG_PPC32) += relocate_32.o -obj-$(CONFIG_KEXEC_FILE) += file_load.o ranges.o file_load_$(BITS).o elf_$(BITS).o +obj-$(CONFIG_KEXEC_FILE) += file_load.o file_load_$(BITS).o elf_$(BITS).o # Disable GCOV, KCOV & sanitizers in odd or sensitive code GCOV_PROFILE_core_$(BITS).o := n
arch/powerpc/kexec/core_64.c +166 -0
184 lines not on this page · raw message
arch/powerpc/kexec/file_load_64.c +0 -162
174 lines not on this page · raw message
Signature · 7 lines
2.41.0 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
PATCH v13 5/6 powerpc: add crash CPU hotplug support
In reply to Sourabh JainDue to CPU/Memory hotplug or online/offline events the elfcorehdr (which describes the CPUs and memory of the crashed kernel) and FDT (Flattened Device Tree) of kdump image becomes outdated. Consequently, attempting dump collection with an outdated elfcorehdr or FDT can lead to failed or inaccurate dump collection.
Going forward CPU hotplug or online/offlice events are referred as CPU/Memory add/remvoe events.
The current solution to address the above issue involves monitoring the CPU/memory add/remove events in userspace using udev rules and whenever there are changes in CPU and memory resources, the entire kdump image is loaded again. The kdump image includes kernel, initrd, elfcorehdr, FDT, purgatory. Given that only elfcorehdr and FDT get outdated due to CPU/Memory add/remove events, reloading the entire kdump image is inefficient. More importantly, kdump remains inactive for a substantial amount of time until the kdump reload completes.
To address the aforementioned issue, commit 247262756121 ("crash: add generic infrastructure for crash hotplug support") added a generic infrastructure that allows architectures to selectively update the kdump image component during CPU or memory add/remove events within the kernel itself.
In the event of a CPU or memory add/remove event, the generic crash hotplug event handler, crash_handle_hotplug_event(), is triggered. It then acquires the necessary locks to update the kdump image and invokes the architecture-specific crash hotplug handler, arch_crash_handle_hotplug_event(), to update the required kdump image components.
This patch adds crash hotplug handler for PowerPC and enable support to update the kdump image on CPU add/remove events. Support for memory add/remove events is added in a subsequent patch with the title "powerpc: add crash memory hotplug support."
As mentioned earlier, only the elfcorehdr and FDT kdump image components need to be updated in the event of CPU or memory add/remove events. However, the PowerPC architecture crash hotplug handler only updates the FDT to enable crash hotplug support for CPU add/remove events. Here's why.
The Elfcorehdr on PowerPC is built with possible CPUs, and thus, it does not need an update on CPU add/remove events. On the other hand, the FDT needs to be updated on CPU add events to include the newly added CPU. If the FDT is not updated and the kernel crashes on a newly added CPU, the kdump kernel will fail to boot due to the unavailability of the crashing CPU in the FDT. During the early boot, it is expected that the boot CPU must be a part of the FDT; otherwise, the kernel will raise a BUG and fail to boot. For more information, refer to commit 36ae37e3436b0 ("powerpc: Make boot_cpuid common between 32 and 64-bit"). Since it is okay to have an offline CPU in the kdump FDT, no action is taken in case of CPU removal.
There are two system calls, kexec_file_load and kexec_load, used to load the kdump image. Few changes have been made to ensure kernel can safely update the kdump FDT for both system calls.
For kexec_file_load syscall the kdump image is prepared in kernel. So to support an increasing number of CPUs, the FDT is constructed with extra buffer space to ensure it can accommodate a possible number of CPU nodes. Additionally, a call to fdt_pack (which trims the unused space once the FDT is prepared) is avoided for kdump image loading if this feature is enabled.
For the kexec_load syscall, the FDT is updated only if both the KEXEC_UPDATE_FDT and KEXEC_UPDATE_ELFCOREHDR kexec flags are passed to the kernel by the kexec tool. Passing these flags to the kernel indicates that the FDT is built to accommodate possible CPUs, and the FDT segment is not considered for SHA calculation, making it safe to update the FDT.
Commit 88a6f8994421 ("crash: memory and CPU hotplug sysfs attributes") added a sysfs interface to indicate userspace (kdump udev rule) that kernel will update the kdump image on CPU hotplug events, so kdump reload can be avoided. Implement arch specific function arch_crash_hotplug_cpu_support() to correctly advertise kernel capability to update kdump image.
This feature is advertised to userspace when the following conditions are met:
1. Kdump image is loaded using kexec_file_load system call.
2. Kdump image is loaded using kexec_load system and both KEXEC_UPATE_ELFCOREHDR and KEXEC_UPDATE_FDT kexec flags are passed to kernel.
The changes related to this feature are kept under the CRASH_HOTPLUG config, and it is enabled by default.
--- arch/powerpc/Kconfig | 4 ++ arch/powerpc/include/asm/kexec.h | 11 ++++ arch/powerpc/kexec/core_64.c | 91 +++++++++++++++++++++++++++++++ arch/powerpc/kexec/elf_64.c | 12 +++- arch/powerpc/kexec/file_load_64.c | 14 +++++ 5 files changed, 131 insertions(+), 1 deletion(-)
arch/powerpc/Kconfig +4 -0
@@ -681,6 +681,10 @@ config RELOCATABLE_TEST config ARCH_SUPPORTS_CRASH_DUMP def_bool PPC64 || PPC_BOOK3S_32 || PPC_85xx || (44x && !SMP) +config ARCH_SUPPORTS_CRASH_HOTPLUG + def_bool y + depends on PPC64 + config ARCH_SELECTS_CRASH_DUMP def_bool y depends on CRASH_DUMP
arch/powerpc/include/asm/kexec.h +11 -0
@@ -112,6 +112,17 @@ void crash_free_reserved_phys_range(unsigned long begin, unsigned long end);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,void *arg); +#define arch_crash_handle_hotplug_event arch_crash_handle_hotplug_event + +#ifdef CONFIG_HOTPLUG_CPU +int arch_crash_hotplug_cpu_support (struct kimage *image); +#define arch_crash_hotplug_cpu_support arch_crash_hotplug_cpu_support +#endif + +#endif /*CONFIG_CRASH_HOTPLUG */ #endif /* CONFIG_PPC64 */ #ifdef CONFIG_KEXEC_FILE
arch/powerpc/kexec/core_64.c +91 -0
97 lines not on this page · raw message
arch/powerpc/kexec/elf_64.c +11 -1
@@ -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 yet. +*/ +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);
arch/powerpc/kexec/file_load_64.c +14 -0
@@ -909,6 +909,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
@@ -941,6 +944,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; }
Signature · 7 lines
2.41.0 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
kernel test robot
build botRe: [PATCH v13 5/6] powerpc: add crash CPU hotplug support
kernel test robot noticed the following build errors:
Hi Sourabh,
kernel test robot noticed the following build errors:
[auto build test ERROR on powerpc/next]
[also build test ERROR on powerpc/fixes tip/x86/core akpm-mm/mm-everything linus/master v6.7-rc4 next-20231205] [If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Sourabh-Jain/crash-make-CPU-and-Memory-hotplug-support-reporting-flexible/20231204-143305 base: https://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux.git next patch link: https://lore.kernel.org/r/20231204053253.25305-6-sourabhjain%40linux.ibm.com patch subject: [PATCH v13 5/6] powerpc: add crash CPU hotplug support config: powerpc64-randconfig-001-20231205 (https://download.01.org/0day-ci/archive/20231205/[email protected]/config) compiler: powerpc64-linux-gcc (GCC) 13.2.0 reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20231205/[email protected]/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/
All errors (new ones prefixed by >>):
arch/powerpc/kexec/file_load_64.c: In function 'kexec_extra_fdt_size_ppc64':
>> arch/powerpc/kexec/file_load_64.c:953:52: error: 'threads_per_core' undeclared (first use in this function)
953 | possible_cpu_nodes = num_possible_cpus() / threads_per_core;
| ^~~~~~~~~~~~~~~~ arch/powerpc/kexec/file_load_64.c:953:52: note: each undeclared identifier is reported only once for each function it appears in
vim +/threads_per_core +953 arch/powerpc/kexec/file_load_64.c
915
916 // Budget some space for the password blob. There's already extra space
917 // for the key name
918 if (plpks_is_available())
919 extra_size += (unsigned int)plpks_get_passwordlen();
920
921 if (image->type != KEXEC_TYPE_CRASH)
922 return extra_size;
923
924 /*
925 * For kdump kernel, account for linux,usable-memory and
926 * linux,drconf-usable-memory properties. Get an approximate on the
927 * number of usable memory entries and use for FDT size estimation.
928 */
929 if (drmem_lmb_size()) {
930 usm_entries = ((memory_hotplug_max() / drmem_lmb_size()) +
931 (2 * (resource_size(&crashk_res) / drmem_lmb_size())));
932 extra_size += (unsigned int)(usm_entries * sizeof(u64));
933 }
934
935 /*
936 * Get the number of CPU nodes in the current DT. This allows to
937 * reserve places for CPU nodes added since the boot time.
938 */
939 cpu_nodes = 0;
940 for_each_node_by_type(dn, "cpu") {
941 cpu_nodes++;
942 }
943
944 if (cpu_nodes > boot_cpu_node_count)
945 extra_size += (cpu_nodes - boot_cpu_node_count) * cpu_node_size();
946
947 #ifdef CONFIG_CRASH_HOTPLUG
948 /*
949 * Make sure enough space is reserved to accommodate possible CPU nodes
950 * in the crash FDT. This allows packing possible CPU nodes which are
951 * not yet present in the system without regenerating the entire FDT.
952 */
> 953 possible_cpu_nodes = num_possible_cpus() / threads_per_core;
954 if (image->type == KEXEC_TYPE_CRASH && possible_cpu_nodes > cpu_nodes)
955 extra_size += (possible_cpu_nodes - cpu_nodes) * cpu_node_size();
956 #endif
957
958 return extra_size;
959 }
960
Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki
PATCH v13 6/6 powerpc: add crash memory hotplug support
In reply to Sourabh JainExtend the arch crash hotplug handler, as introduced by the patch title ("powerpc: add crash CPU hotplug support"), to also support memory add/remove events.
Elfcorehdr describes the memory of the crash kernel to capture the kernel; hence, it needs to be updated if memory resources change due to memory add/remove events. Therefore, arch_crash_handle_hotplug_event() is updated to recreate the elfcorehdr and replace it with the previous one on memory add/remove events.
The memblock list is used to prepare the elfcorehdr. In the case of memory hot removal, the memblock list is updated after the arch crash hotplug handler is triggered, as depicted in Figure 1. Thus, the hot-removed memory is explicitly removed from the crash memory ranges to ensure that the memory ranges added to elfcorehdr do not include the hot-removed memory.
Memory remove
|
v
Offline pages
|
v
Initiate memory notify call <----> crash hotplug handler
chain for MEM_OFFLINE event
|
vUpdate memblock list
Figure 1
There are two system calls, kexec_file_load and kexec_load, used to load the kdump image. A few changes have been made to ensure that the kernel can safely update the elfcorehdr component of the kdump image for both system calls.
For the kexec_file_load syscall, kdump image is prepared in the kernel. To support an increasing number of memory regions, the elfcorehdr is built with extra buffer space to ensure that it can accommodate additional memory ranges in future.
For the kexec_load syscall, the elfcorehdr is updated only if both the KEXEC_UPDATE_FDT and KEXEC_UPDATE_ELFCOREHDR kexec flags are passed to the kernel by the kexec tool. Passing these flags to the kernel indicates that the elfcorehdr is built to accommodate additional memory ranges and the elfcorehdr segment is not considered for SHA calculation, making it safe to update it.
Commit 88a6f8994421 ("crash: memory and CPU hotplug sysfs attributes") added a sysfs interface to indicate userspace (kdump udev rule) that kernel will update the kdump image on memory hotplug events, so kdump reload can be avoided. Implement arch specific function arch_crash_hotplug_memory_support() to correctly advertise kernel capability to update kdump image.
This feature is advertised to usersapce when following conditions are met:
1. Kdump image is loaded using kexec_file_load system call.
2. Kdump image is loaded using kexec_load system and both KEXEC_UPATE_ELFCOREHDR and KEXEC_UPDATE_FDT kexec flags are passed to kernel.
The changes related to this feature are kept under the CRASH_HOTPLUG config, and it is enabled by default.
--- arch/powerpc/include/asm/kexec.h | 8 ++ arch/powerpc/include/asm/kexec_ranges.h | 1 + arch/powerpc/kexec/core_64.c | 125 ++++++++++++++++++++++-- arch/powerpc/kexec/file_load_64.c | 34 ++++++- arch/powerpc/kexec/ranges.c | 85 ++++++++++++++++ 5 files changed, 244 insertions(+), 9 deletions(-)
arch/powerpc/include/asm/kexec.h +8 -0
@@ -122,6 +122,14 @@ int arch_crash_hotplug_cpu_support(struct kimage *image);#define arch_crash_hotplug_cpu_support arch_crash_hotplug_cpu_support#endif +#ifdef CONFIG_MEMORY_HOTPLUG +int arch_crash_hotplug_memory_support (struct kimage *image); +#define arch_crash_hotplug_memory_support arch_crash_hotplug_memory_support +#endif + +unsigned int arch_crash_get_elfcorehdr_size (void ); +#define crash_get_elfcorehdr_size arch_crash_get_elfcorehdr_size +#endif /*CONFIG_CRASH_HOTPLUG */ #endif /* CONFIG_PPC64 */
arch/powerpc/include/asm/kexec_ranges.h +1 -0
@@ -7,6 +7,7 @@void sort_memory_ranges (struct crash_mem *mrngs,bool merge);struct crash_mem *realloc_mem_ranges (struct crash_mem **mem_ranges);int add_mem_range (struct crash_mem **mem_ranges,u64 base,u64 size); +int remove_mem_range (struct crash_mem **mem_ranges,u64 base,u64 size);int add_tce_mem_ranges (struct crash_mem **mem_ranges);int add_initrd_mem_range (struct crash_mem **mem_ranges);#ifdef CONFIG_PPC_64S_HASH_MMU
arch/powerpc/kexec/core_64.c +118 -7
165 lines not on this page · raw message
arch/powerpc/kexec/file_load_64.c +32 -2
@@ -21,6 +21,8 @@#include <linux/memblock.h> #include <linux/slab.h> #include <linux/vmalloc.h> +#include <linux/elf.h> +#include <asm/setup.h> #include <asm/drmem.h> #include <asm/firmware.h>
@@ -739,7 +741,35 @@ static int load_elfcorehdr_segment(struct kimage *image, struct kexec_buf *kbuf) kbuf->buffer = headers; kbuf->mem =KEXEC_BUF_MEM_UNKNOWN ; - kbuf->bufsz = kbuf->memsz = headers_sz; + kbuf->bufsz = headers_sz; +#if defined(CONFIG_CRASH_HOTPLUG ) && defined(CONFIG_MEMORY_HOTPLUG ) +/* Adjust the elfcorehdr segment size to accommodate +* future crash memory ranges. +*/ +int max_lmb; +unsigned long pnum; + +/* In the worst case, a Phdr is needed for every other LMB to be +* represented as an individual crash range. +*/ + max_lmb =memory_hotplug_max () / (2 *drmem_lmb_size ()); + +/* Do not cross the Phdr max limit of the elf header. +* Avoid counting Phdr for crash ranges (cmem->nr_ranges) +* which are already part of elfcorehdr. +*/ +if (max_lmb >PN_XNUM ) + pnum =PN_XNUM - cmem->nr_ranges; +else + pnum = max_lmb - cmem->nr_ranges; + +/* Additional buffer space for elfcorehdr to accommodate +* future memory ranges. +*/ + kbuf->memsz = headers_sz + pnum *sizeof (Elf64_Phdr); +#else + kbuf->memsz = headers_sz; +#endif kbuf->top_down = false; ret =kexec_add_buffer (kbuf);
@@ -749,7 +779,7 @@ static int load_elfcorehdr_segment(struct kimage *image, struct kexec_buf *kbuf) } image->elf_load_addr = kbuf->mem; - image->elf_headers_sz = headers_sz; + image->elf_headers_sz = kbuf->memsz; image->elf_headers = headers; out:kfree (cmem);
arch/powerpc/kexec/ranges.c +85 -0
91 lines not on this page · raw message
Signature · 7 lines
2.41.0 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
kernel test robot
build botRe: [PATCH v13 6/6] powerpc: add crash memory hotplug support
kernel test robot noticed the following build errors:
Hi Sourabh,
kernel test robot noticed the following build errors:
[auto build test ERROR on powerpc/next]
[also build test ERROR on powerpc/fixes tip/x86/core akpm-mm/mm-everything linus/master v6.7-rc4 next-20231205] [If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Sourabh-Jain/crash-make-CPU-and-Memory-hotplug-support-reporting-flexible/20231204-143305 base: https://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux.git next patch link: https://lore.kernel.org/r/20231204053253.25305-7-sourabhjain%40linux.ibm.com patch subject: [PATCH v13 6/6] powerpc: add crash memory hotplug support config: powerpc64-randconfig-001-20231205 (https://download.01.org/0day-ci/archive/20231206/[email protected]/config) compiler: powerpc64-linux-gcc (GCC) 13.2.0 reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20231206/[email protected]/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/
All errors (new ones prefixed by >>):
arch/powerpc/kexec/core_64.c: In function 'arch_crash_get_elfcorehdr_size':
>> arch/powerpc/kexec/core_64.c:595:33: error: implicit declaration of function 'memory_hotplug_max' [-Werror=implicit-function-declaration]
595 | elf_phdr_cnt += memory_hotplug_max() / (2 * drmem_lmb_size());
| ^~~~~~~~~~~~~~~~~~cc1: some warnings being treated as errors
vim +/memory_hotplug_max +595 arch/powerpc/kexec/core_64.c
579
580 /*
581 * Advertise preferred elfcorehdr size to userspace via
582 * /sys/kernel/crash_elfcorehdr_size sysfs interface.
583 */
584 unsigned int arch_crash_get_elfcorehdr_size(void)
585 {
586 unsigned int sz;
587 unsigned long elf_phdr_cnt;
588
589 /* Program header for CPU notes and vmcoreinfo */
590 elf_phdr_cnt = 2;
591 if (IS_ENABLED(CONFIG_MEMORY_HOTPLUG))
592 /* In the worst case, a Phdr is needed for every other LMB to be
593 * represented as an individual crash range.
594 */
> 595 elf_phdr_cnt += memory_hotplug_max() / (2 * drmem_lmb_size());
596
597 /* Do not cross the max limit */
598 if (elf_phdr_cnt > PN_XNUM)
599 elf_phdr_cnt = PN_XNUM;
600
601 sz = sizeof(struct elfhdr) + (elf_phdr_cnt * sizeof(Elf64_Phdr));
602 return sz;
603 }
604
Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki