crash: Kernel handling of CPU and memory hot un/plug
Subsystems (7)
v6 cover crash: Kernel handling of CPU and memory hot un/plug
When the kdump service is loaded, if a CPU or memory is hot un/plugged, the crash elfcorehdr (for x86), which describes the CPUs and memory in the system, must also be updated, else the resulting vmcore is inaccurate (eg. missing either CPU context or memory regions).
The current solution utilizes udev to initiate an unload-then-reload of the kdump image (e. kernel, initrd, boot_params, puratory and elfcorehdr) by the userspace kexec utility. In previous posts I have outlined the significant performance problems related to offloading this activity to userspace.
This patchset introduces a generic crash hot un/plug handler that registers with the CPU and memory notifiers. Upon CPU or memory changes, this generic handler is invoked and performs important housekeeping, for example obtaining the appropriate lock, and then invokes an architecture specific handler to do the appropriate updates.
In the case of x86_64, the arch specific handler generates a new elfcorehdr, and overwrites the old one in memory. No involvement with userspace needed.
To realize the benefits/test this patchset, one must make a couple of minor changes to userspace:
- Disable the udev rule for updating kdump on hot un/plug changes. Add the following as the first two lines to the udev rule file /usr/lib/udev/rules.d/98-kexec.rules:
# For x86_64, the kernel handles updates to crash elfcorehdr CONST{arch}=="x86-64", GOTO="kdump_reload_end"
These two lines will cause cpu and memory hot un/plug events to be skipped within this rule file.
- Change to the kexec_file_load for loading the kdump kernel:
Eg. on RHEL: in /usr/bin/kdumpctl, change to:
standard_kexec_args="-p -d -s"
which adds the -s to select kexec_file_load syscall.
This patchset supports kexec_load with a modified kexec userspace utility, and a working changeset to the kexec userspace utility is provided here (and to use, the above change to standard_kexec_args would be, for example, to append --hotplug-size=131072 instead of -s).
diff --git a/kexec/arch/i386/crashdump-x86.c b/kexec/arch/i386/crashdump-x86.c index 9826f6d..06adb7e 100644
--- a/kexec/arch/i386/crashdump-x86.c
+++ b/kexec/arch/i386/crashdump-x86.c
@@ -48,6 +48,7 @@
#include <x86/x86-linux.h>
extern struct arch_options_t arch_options;
+extern unsigned long long hotplug_size;
static int get_kernel_page_offset(struct kexec_info *UNUSED(info),
struct crash_elf_info *elf_info)
@@ -975,6 +976,13 @@ int load_crashdump_segments(struct kexec_info *info, char* mod_cmdline,
} else {
memsz = bufsz;
}
+
+ /* If hotplug support enabled, use that size */
+ if (hotplug_size) {
+ memsz = hotplug_size;
+ }
+
+ info->elfcorehdr =
elfcorehdr = add_buffer(info, tmp, bufsz, memsz, align, min_base,
max_addr, -1);
dbgprintf("Created elf header segment at 0x%lx\n", elfcorehdr);
diff --git a/kexec/kexec.c b/kexec/kexec.c
index f63b36b..9569d9a 100644
--- a/kexec/kexec.c
+++ b/kexec/kexec.c
@@ -58,6 +58,7 @@
unsigned long long mem_min = 0;
unsigned long long mem_max = ULONG_MAX;
+unsigned long long hotplug_size = 0;
static unsigned long kexec_flags = 0;
/* Flags for kexec file (fd) based syscall */
static unsigned long kexec_file_flags = 0;
@@ -672,6 +673,12 @@ static void update_purgatory(struct kexec_info *info)
if (info->segment[i].mem == (void *)info->rhdr.rel_addr) {
continue;
}
+ /* Don't include elfcorehdr in the checksum, if hotplug
+ * support enabled.
+ */
+ if (hotplug_size && (info->segment[i].mem == (void *)info->elfcorehdr)) {
+ continue;
+ }
sha256_update(&ctx, info->segment[i].buf,
info->segment[i].bufsz);
nullsz = info->segment[i].memsz - info->segment[i].bufsz;
@@ -1504,6 +1511,17 @@ int main(int argc, char *argv[])
case OPT_PRINT_CKR_SIZE:
print_crashkernel_region_size();
return 0;
+ case OPT_HOTPLUG_SIZE:
+ /* Reserved the specified size for hotplug growth */
+ hotplug_size = strtoul(optarg, &endptr, 0);
+ if (*endptr) {
+ fprintf(stderr,
+ "Bad option value in --hotplug-size=%s\n",
+ optarg);
+ usage();
+ return 1;
+ }
+ break;
default:
break;
}
diff --git a/kexec/kexec.h b/kexec/kexec.h
index 595dd68..b30dda4 100644
--- a/kexec/kexec.h
+++ b/kexec/kexec.h
@@ -169,6 +169,7 @@ struct kexec_info {
int command_line_len;
int skip_checks;
+ unsigned long elfcorehdr;
};
struct arch_map_entry {
@@ -231,7 +232,8 @@ extern int file_types;
#define OPT_PRINT_CKR_SIZE 262
#define OPT_LOAD_LIVE_UPDATE 263
#define OPT_EXEC_LIVE_UPDATE 264
-#define OPT_MAX 265
+#define OPT_HOTPLUG_SIZE 265
+#define OPT_MAX 266
#define KEXEC_OPTIONS \
{ "help", 0, 0, OPT_HELP }, \
{ "version", 0, 0, OPT_VERSION }, \
@@ -258,6 +260,7 @@ extern int file_types;
{ "debug", 0, 0, OPT_DEBUG }, \
{ "status", 0, 0, OPT_STATUS }, \
{ "print-ckr-size", 0, 0, OPT_PRINT_CKR_SIZE }, \
+ { "hotplug-size", 2, 0, OPT_HOTPLUG_SIZE }, \
#define KEXEC_OPT_STR "h?vdfixyluet:pscaS"
Regards,
eric
---
v6: 1apr202
- Reword commit messages and some comment cleanup per Baoquan.
- Changed elf_index to elfcorehdr_index for clarity.
- Minor code changes per Baoquan.
v5: 3mar2022
https://lkml.org/lkml/2022/3/3/674
- Reworded description of CRASH_HOTPLUG_ELFCOREHDR_SZ, per David Hildenbrand.
- Refactored slightly a few patches per Baoquan recommendation.
v4: 9feb2022
https://lkml.org/lkml/2022/2/9/1406
- Refactored patches per Baoquan suggestsions.
- A few corrections, per Baoquan.
v3: 10jan2022
https://lkml.org/lkml/2022/1/10/1212
- Rebasing per Baoquan He request.
- Changed memory notifier per David Hildenbrand.
- Providing example kexec userspace change in cover letter.
RFC v2: 7dec2021
https://lkml.org/lkml/2021/12/7/1088
- Acting upon Baoquan He suggestion of removing elfcorehdr from the purgatory list of segments, removed purgatory code from patchset, and it is signficiantly simpler now.
RFC v1: 18nov2021
https://lkml.org/lkml/2021/11/18/845
- working patchset demonstrating kernel handling of hotplug updates to x86 elfcorehdr for kexec_file_load
RFC: 14dec2020
https://lkml.org/lkml/2020/12/14/532
- proposed concept of allowing kernel to handle hotplug update of elfcorehdr
---
Eric DeVolder (8):
x86/crash: fix minor typo/bug in debug message x86/crash: Introduce new options to support cpu and memory hotplug
crash: prototype change for crash_prepare_elf64_headers
crash: add generic infrastructure for crash hotplug support
kexec: exclude elfcorehdr from the segment digest
kexec: exclude hot remove cpu from elfcorehdr notes x86/crash: Add x86 crash hotplug support for kexec_file_load x86/crash: Add x86 crash hotplug support for kexec_load
arch/arm64/kernel/machine_kexec_file.c | 6 +- arch/powerpc/kexec/file_load_64.c | 2 +- arch/x86/Kconfig | 26 +++++ arch/x86/kernel/crash.c | 147 ++++++++++++++++++++++++- include/linux/kexec.h | 21 +++- kernel/crash_core.c | 118 ++++++++++++++++++++ kernel/kexec_file.c | 15 ++- 7 files changed, 325 insertions(+), 10 deletions(-)
Signature · 1 line
2.27.0
PATCH v6 1/8 x86/crash: fix minor typo/bug in debug message
The pr_debug() intends to display the memsz member, but the parameter is actually the bufsz member (which is already displayed). Correct this to display memsz value.
--- arch/x86/kernel/crash.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/x86/kernel/crash.c +1 -1
@@ -407,7 +407,7 @@ int crash_load_segments(struct kimage *image) } image->elf_load_addr = kbuf.mem;pr_debug ("Loaded ELF headers at 0x%lx bufsz=0x%lx memsz=0x%lx\n" , - image->elf_load_addr, kbuf.bufsz, kbuf.bufsz); + image->elf_load_addr, kbuf.bufsz, kbuf.memsz);return ret; }
Signature · 1 line
2.27.0
PATCH v6 2/8 x86/crash: Introduce new options to support cpu and memory hotplug
In reply to Eric DeVolderCRASH_HOTPLUG is to enable cpu and memory hotplug support of crash.
CRASH_HOTPLUG_ELFCOREHDR_SZ is used to specify the maximum size of the elfcorehdr buffer/segment.
This is a preparation for later usage.
--- arch/x86/Kconfig | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+)
arch/x86/Kconfig +26 -0
@@ -2072,6 +2072,32 @@ config CRASH_DUMP (CONFIG_RELOCATABLE=y). For more details see Documentation/admin-guide/kdump/kdump.rst +config CRASH_HOTPLUG + bool "kernel updates of crash elfcorehdr" + depends on CRASH_DUMP && (HOTPLUG_CPU || MEMORY_HOTPLUG) && KEXEC_FILE + help + Enable the kernel to update the crash elfcorehdr (which contains + the list of CPUs and memory regions) directly when hot plug/unplug + of CPUs or memory. Otherwise userspace must monitor these hot + plug/unplug change notifications via udev in order to + unload-then-reload the crash kernel so that the list of CPUs and + memory regions is kept up-to-date. Note that the udev CPU and + memory change notifications still occur (however, userspace is not + required to monitor for crash dump purposes). + +config CRASH_HOTPLUG_ELFCOREHDR_SZ + depends on CRASH_HOTPLUG + int + default 131072 + help + Specify the maximum size of the elfcorehdr buffer/segment. + The 128KiB default is sized so that it can accommodate 2048 + Elf64_Phdr, where each Phdr represents either a CPU or a + region of memory. + For example, this size can accommodate a machine with up to 1024 + CPUs and up to 1024 memory regions, eg. as represented by the + 'System RAM' entries in /proc/iomem. + config KEXEC_JUMP bool "kexec jump" depends on KEXEC && HIBERNATION
Signature · 1 line
2.27.0
Re: [PATCH v6 2/8] x86/crash: Introduce new options to support cpu and memory hotplug
Quoted 8 lines · Eric DeVolder
CRASH_HOTPLUGis to enable cpu and memory hotplug support of crash.
CRASH_HOTPLUG_ELFCOREHDR_SZis used to specify the maximum size of the elfcorehdr buffer/segment.This is a preparation for later usage.
Signed-off-by Eric DeVolder <[email protected]>
LGTM,
Quoted 44 lines
--- arch/x86/Kconfig | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+)arch/x86/Kconfig +26
-0@@ -2072,6 +2072,32 @@ config CRASH_DUMP (CONFIG_RELOCATABLE=y). For more details see Documentation/admin-guide/kdump/kdump.rst +config CRASH_HOTPLUG + bool "kernel updates of crash elfcorehdr" + depends on CRASH_DUMP && (HOTPLUG_CPU || MEMORY_HOTPLUG) && KEXEC_FILE + help + Enable the kernel to update the crash elfcorehdr (which contains + the list of CPUs and memory regions) directly when hot plug/unplug + of CPUs or memory. Otherwise userspace must monitor these hot + plug/unplug change notifications via udev in order to + unload-then-reload the crash kernel so that the list of CPUs and + memory regions is kept up-to-date. Note that the udev CPU and + memory change notifications still occur (however, userspace is not + required to monitor for crash dump purposes). + +config CRASH_HOTPLUG_ELFCOREHDR_SZ + depends on CRASH_HOTPLUG + int + default 131072 + help + Specify the maximum size of the elfcorehdr buffer/segment. + The 128KiB default is sized so that it can accommodate 2048 + Elf64_Phdr, where each Phdr represents either a CPU or a + region of memory. + For example, this size can accommodate a machine with up to 1024 + CPUs and up to 1024 memory regions, eg. as represented by the + 'System RAM' entries in /proc/iomem. + config KEXEC_JUMP bool "kexec jump" depends on KEXEC && HIBERNATIONSignature · 1 line
2.27.0
Re: [PATCH v6 2/8] x86/crash: Introduce new options to support cpu and memory hotplug
Quoted 6 lines · Baoquan He
Quoted 5 lines · Eric DeVolder
CRASH_HOTPLUGis to enable cpu and memory hotplug support of crash.
CRASH_HOTPLUG_ELFCOREHDR_SZis used to specify the maximum size of the elfcorehdr buffer/segment.
Quoted 7 lines
Quoted 3 lines
This is a preparation for later usage.
Signed-off-by Eric DeVolder <[email protected]>LGTM,
Acked-by Baoquan He <[email protected]>
Excellent, thanks!
eric
Quoted 46 lines
Quoted 45 lines
--- arch/x86/Kconfig | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+)arch/x86/Kconfig +26
-0@@ -2072,6 +2072,32 @@ config CRASH_DUMP (CONFIG_RELOCATABLE=y). For more details see Documentation/admin-guide/kdump/kdump.rst +config CRASH_HOTPLUG + bool "kernel updates of crash elfcorehdr" + depends on CRASH_DUMP && (HOTPLUG_CPU || MEMORY_HOTPLUG) && KEXEC_FILE + help + Enable the kernel to update the crash elfcorehdr (which contains + the list of CPUs and memory regions) directly when hot plug/unplug + of CPUs or memory. Otherwise userspace must monitor these hot + plug/unplug change notifications via udev in order to + unload-then-reload the crash kernel so that the list of CPUs and + memory regions is kept up-to-date. Note that the udev CPU and + memory change notifications still occur (however, userspace is not + required to monitor for crash dump purposes). + +config CRASH_HOTPLUG_ELFCOREHDR_SZ + depends on CRASH_HOTPLUG + int + default 131072 + help + Specify the maximum size of the elfcorehdr buffer/segment. + The 128KiB default is sized so that it can accommodate 2048 + Elf64_Phdr, where each Phdr represents either a CPU or a + region of memory. + For example, this size can accommodate a machine with up to 1024 + CPUs and up to 1024 memory regions, eg. as represented by the + 'System RAM' entries in /proc/iomem. + config KEXEC_JUMP bool "kexec jump" depends on KEXEC && HIBERNATIONSignature · 1 line
2.27.0
PATCH v6 3/8 crash: prototype change for crash_prepare_elf64_headers
In reply to Eric DeVolderFrom within crash_prepare_elf64_headers() there is a need to reference the struct kimage hotplug members. As such, this change passes the struct kimage as a parameter to the crash_prepare_elf64_headers().
This is preparation for later patch, no functionality change.
--- arch/arm64/kernel/machine_kexec_file.c | 6 +++--- arch/powerpc/kexec/file_load_64.c | 2 +- arch/x86/kernel/crash.c | 3 ++- include/linux/kexec.h | 5 +++-- kernel/kexec_file.c | 4 ++-- 5 files changed, 11 insertions(+), 9 deletions(-)
arch/arm64/kernel/machine_kexec_file.c +3 -3
@@ -39,7 +39,7 @@ int arch_kimage_file_post_load_cleanup(struct kimage *image)return kexec_image_post_load_cleanup_default (image); } -static int prepare_elf_headers (void **addr,unsigned long *sz) +static int prepare_elf_headers (struct kimage *image,void **addr,unsigned long *sz) {struct crash_mem *cmem;unsigned int nr_ranges;
@@ -67,7 +67,7 @@ static int prepare_elf_headers(void **addr, unsigned long *sz) ret =crash_exclude_mem_range (cmem, crashk_res.start, crashk_res.end);if (!ret) - ret =crash_prepare_elf64_headers (cmem, true, addr, sz); + ret =crash_prepare_elf64_headers (image, cmem, true, addr, sz);kfree (cmem);return ret;
@@ -96,7 +96,7 @@ int load_other_segments(struct kimage *image,/* load elf core header */ if (image->type ==KEXEC_TYPE_CRASH ) { - ret =prepare_elf_headers (&headers, &headers_sz); + ret =prepare_elf_headers (image, &headers, &headers_sz);if (ret) {pr_err ("Preparing elf core header failed\n" ); goto out_err;
arch/powerpc/kexec/file_load_64.c +1 -1
@@ -797,7 +797,7 @@ static int load_elfcorehdr_segment(struct kimage *image, struct kexec_buf *kbuf) goto out;/* Setup elfcorehdr segment */ - ret =crash_prepare_elf64_headers (cmem, false, &headers, &headers_sz); + ret =crash_prepare_elf64_headers (image, cmem, false, &headers, &headers_sz);if (ret) {pr_err ("Failed to prepare elf headers for the core\n" ); goto out;
arch/x86/kernel/crash.c +2 -1
@@ -265,7 +265,8 @@ static int prepare_elf_headers(struct kimage *image, void **addr, goto out;/* By default prepare 64bit headers */ - ret =crash_prepare_elf64_headers (cmem,IS_ENABLED (CONFIG_X86_64 ), addr, sz); + ret =crash_prepare_elf64_headers (image, cmem, +IS_ENABLED (CONFIG_X86_64 ), addr, sz); out:vfree (cmem);
include/linux/kexec.h +3 -2
@@ -227,8 +227,9 @@ struct crash_mem {extern int crash_exclude_mem_range (struct crash_mem *mem,unsigned long long mstart,unsigned long long mend); -extern int crash_prepare_elf64_headers (struct crash_mem *mem,int kernel_map, -void **addr,unsigned long *sz); +extern int crash_prepare_elf64_headers (struct kimage *image, +struct crash_mem *mem,int kernel_map, +void **addr,unsigned long *sz);#endif /* CONFIG_KEXEC_FILE */ #ifdef CONFIG_KEXEC_ELF
kernel/kexec_file.c +2 -2
@@ -1260,8 +1260,8 @@ int crash_exclude_mem_range(struct crash_mem *mem,return 0 ; } -int crash_prepare_elf64_headers (struct crash_mem *mem,int kernel_map, -void **addr,unsigned long *sz) +int crash_prepare_elf64_headers (struct kimage *image,struct crash_mem *mem, +int kernel_map,void **addr,unsigned long *sz) {Elf64_Ehdr *ehdr;Elf64_Phdr *phdr;
Signature · 1 line
2.27.0
PATCH v6 4/8 crash: add generic infrastructure for crash hotplug support
In reply to Eric DeVolderUpon CPU and memory changes, a generic crash_hotplug_handler() dispatches the hot plug/unplug event to the architecture specific arch_crash_hotplug_handler(). During the process, the kexec_mutex is held.
To support cpu hotplug, a callback is registered to capture the CPUHP_AP_ONLINE_DYN online and ofline events via cpuhp_setup_state_nocalls().
To support memory hotplug, a notifier is registered to capture the MEM_ONLINE and MEM_OFFLINE events via register_memory_notifier().
The cpu callback and memory notifier then call crash_hotplug_handler() to handle the hot plug/unplug event.
--- include/linux/kexec.h | 16 +++++++ kernel/crash_core.c | 108 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 124 insertions(+)
include/linux/kexec.h +16 -0
@@ -306,6 +306,13 @@ struct kimage {/* Information for loading purgatory */ struct purgatory_info purgatory_info; + +#ifdef CONFIG_CRASH_HOTPLUG +bool hotplug_event; +int offlinecpu; +bool elfcorehdr_index_valid; +int elfcorehdr_index; +#endif #endif #ifdef CONFIG_IMA_KEXEC
@@ -322,6 +329,15 @@ struct kimage {unsigned long elf_load_addr; }; +#ifdef CONFIG_CRASH_HOTPLUG +void arch_crash_hotplug_handler (struct kimage *image, +unsigned int hp_action,unsigned long a,unsigned long b); +#define KEXEC_CRASH_HP_REMOVE_CPU 0 +#define KEXEC_CRASH_HP_ADD_CPU 1 +#define KEXEC_CRASH_HP_REMOVE_MEMORY 2 +#define KEXEC_CRASH_HP_ADD_MEMORY 3 +#endif /* CONFIG_CRASH_HOTPLUG */ +/* kexec interface functions */ extern void machine_kexec (struct kimage *image);extern int machine_kexec_prepare (struct kimage *image);
kernel/crash_core.c +108 -0
123 lines not on this page · raw message
Signature · 1 line
2.27.0
Re: [PATCH v6 4/8] crash: add generic infrastructure for crash hotplug support
Hi Eric,
On 04/01/22 at 02:30pm, Eric DeVolder wrote:
... ...
kernel/crash_core.c static int __init crash_save_vmcoreinfo_init(void) · line 508
Quoted 2 lines
kernel/crash_core.c +2
-0+static void crash_hotplug_handler (unsigned int hp_action, +unsigned long a,unsigned long b)
I am still struggling to consider if these unused parameters should be kept or removed. Do you foresee or feel on which ARCH they could be used?
Considering our elfcorehdr updating method, once memory or cpu changed, we will update elfcorehdr and cpu notes to reflect all existing memory regions and cpu in the current system. We could end up with having them but never being used. Then we may finally need to clean them up.
If you have investigated and foresee or feel they could be used on a certain architecture, we can keep them for the time being.
Quoted 96 lines
kernel/crash_core.c +93
-0+{ +/* Obtain lock while changing crash information */ +if (!mutex_trylock (&kexec_mutex)) +return ; + +/* Check kdump is loaded */ +if (kexec_crash_image) { +pr_debug ("crash hp: hp_action %u, a %lu, b %lu" , hp_action, + a, b); + +/* Needed in order for the segments to be updated */ +arch_kexec_unprotect_crashkres (); + +/* Flag to differentiate between normal load and hotplug */ + kexec_crash_image->hotplug_event = true; + +/* Now invoke arch-specific update handler */ +arch_crash_hotplug_handler (kexec_crash_image, hp_action, a, b); + +/* No longer handling a hotplug event */ + kexec_crash_image->hotplug_event = false; + +/* Change back to read-only */ +arch_kexec_protect_crashkres (); + } + +/* Release lock now that update complete */ +mutex_unlock (&kexec_mutex); +} + +#if defined(CONFIG_MEMORY_HOTPLUG ) +static int crash_memhp_notifier (struct notifier_block *nb, +unsigned long val,void *v) +{ +struct memory_notify *mhp = v; +unsigned long start, end; + + start = mhp->start_pfn <<PAGE_SHIFT ; + end = ((mhp->start_pfn + mhp->nr_pages) <<PAGE_SHIFT ) -1 ; + +switch (val) { +case MEM_ONLINE : +crash_hotplug_handler (KEXEC_CRASH_HP_ADD_MEMORY , + start, end-start); +break ; + +case MEM_OFFLINE : +crash_hotplug_handler (KEXEC_CRASH_HP_REMOVE_MEMORY , + start, end-start); +break ; + } +return NOTIFY_OK ; +} + +static struct notifier_block crash_memhp_nb = { + .notifier_call = crash_memhp_notifier, + .priority =0 +}; +#endif + +#if defined(CONFIG_HOTPLUG_CPU ) +static int crash_cpuhp_online (unsigned int cpu) +{ +crash_hotplug_handler (KEXEC_CRASH_HP_ADD_CPU , cpu,0 ); +return 0 ; +} + +static int crash_cpuhp_offline (unsigned int cpu) +{ +crash_hotplug_handler (KEXEC_CRASH_HP_REMOVE_CPU , cpu,0 ); +return 0 ; +} +#endif + +static int __init crash_hotplug_init (void ) +{ +int result =0 ; + +#if defined(CONFIG_MEMORY_HOTPLUG ) +register_memory_notifier (&crash_memhp_nb); +#endif + +#if defined(CONFIG_HOTPLUG_CPU ) + result =cpuhp_setup_state_nocalls (CPUHP_AP_ONLINE_DYN , +"crash/cpuhp" , + crash_cpuhp_online, crash_cpuhp_offline); +#endif + +return result; +} + +subsys_initcall (crash_hotplug_init); +#endif /* CONFIG_CRASH_HOTPLUG */ Signature · 1 line
2.27.0
Re: [PATCH v6 4/8] crash: add generic infrastructure for crash hotplug support
Quoted 11 lines · Baoquan He
Hi Eric,
On 04/01/22 at 02:30pm, Eric DeVolder wrote:
... ...kernel/crash_core.c static int __init crash_save_vmcoreinfo_init(void) · line 508
Quoted 2 lines
kernel/crash_core.c +2
-0+static void crash_hotplug_handler (unsigned int hp_action, +unsigned long a,unsigned long b)I am still struggling to consider if these unused parameters should be kept or removed. Do you foresee or feel on which ARCH they could be used?
Quoted 7 lines
Considering our elfcorehdr updating method, once memory or cpu changed, we will update elfcorehdr and cpu notes to reflect all existing memory regions and cpu in the current system. We could end up with having them but never being used. Then we may finally need to clean them up.
If you have investigated and foresee or feel they could be used on a certain architecture, we can keep them for the time being.
So 'hp_action' and 'a' are used within the existing patch series. In crash_core.c, there is this bit of code:
+ kexec_crash_image->offlinecpu =
+ (hp_action == KEXEC_CRASH_HP_REMOVE_CPU) ?
+ (unsigned int)a : ~0U;
which is referencing both 'hp_action' and using 'a' from the cpu notifier handler. I looked into removing 'a' and setting offlinecpu directly, but I thought it better that offlinecpu be set within the safety of the kexec_mutex. Also, Sourabh Jain's work with PowerPC utilizing this framework directly references hp_action in the arch-specific handler.
The cpu and memory notifier handlers set hp_action accordingly. For cpu handler, the 'a' is set with the impacted cpu. For memory handler, 'a' and 'b' form the impacted memory range. I agree it looks like the memory range is currently not useful.
Let me know what you think.
eric
Quoted 98 lines
Quoted 97 lines
kernel/crash_core.c +93
-0+{ +/* Obtain lock while changing crash information */ +if (!mutex_trylock (&kexec_mutex)) +return ; + +/* Check kdump is loaded */ +if (kexec_crash_image) { +pr_debug ("crash hp: hp_action %u, a %lu, b %lu" , hp_action, + a, b); + +/* Needed in order for the segments to be updated */ +arch_kexec_unprotect_crashkres (); + +/* Flag to differentiate between normal load and hotplug */ + kexec_crash_image->hotplug_event = true; + +/* Now invoke arch-specific update handler */ +arch_crash_hotplug_handler (kexec_crash_image, hp_action, a, b); + +/* No longer handling a hotplug event */ + kexec_crash_image->hotplug_event = false; + +/* Change back to read-only */ +arch_kexec_protect_crashkres (); + } + +/* Release lock now that update complete */ +mutex_unlock (&kexec_mutex); +} + +#if defined(CONFIG_MEMORY_HOTPLUG ) +static int crash_memhp_notifier (struct notifier_block *nb, +unsigned long val,void *v) +{ +struct memory_notify *mhp = v; +unsigned long start, end; + + start = mhp->start_pfn <<PAGE_SHIFT ; + end = ((mhp->start_pfn + mhp->nr_pages) <<PAGE_SHIFT ) -1 ; + +switch (val) { +case MEM_ONLINE : +crash_hotplug_handler (KEXEC_CRASH_HP_ADD_MEMORY , + start, end-start); +break ; + +case MEM_OFFLINE : +crash_hotplug_handler (KEXEC_CRASH_HP_REMOVE_MEMORY , + start, end-start); +break ; + } +return NOTIFY_OK ; +} + +static struct notifier_block crash_memhp_nb = { + .notifier_call = crash_memhp_notifier, + .priority =0 +}; +#endif + +#if defined(CONFIG_HOTPLUG_CPU ) +static int crash_cpuhp_online (unsigned int cpu) +{ +crash_hotplug_handler (KEXEC_CRASH_HP_ADD_CPU , cpu,0 ); +return 0 ; +} + +static int crash_cpuhp_offline (unsigned int cpu) +{ +crash_hotplug_handler (KEXEC_CRASH_HP_REMOVE_CPU , cpu,0 ); +return 0 ; +} +#endif + +static int __init crash_hotplug_init (void ) +{ +int result =0 ; + +#if defined(CONFIG_MEMORY_HOTPLUG ) +register_memory_notifier (&crash_memhp_nb); +#endif + +#if defined(CONFIG_HOTPLUG_CPU ) + result =cpuhp_setup_state_nocalls (CPUHP_AP_ONLINE_DYN , +"crash/cpuhp" , + crash_cpuhp_online, crash_cpuhp_offline); +#endif + +return result; +} + +subsys_initcall (crash_hotplug_init); +#endif /* CONFIG_CRASH_HOTPLUG */ Signature · 1 line
2.27.0
Re: [PATCH v6 4/8] crash: add generic infrastructure for crash hotplug support
Quoted 35 lines · Eric DeVolder
Quoted 11 lines · Baoquan He
Hi Eric,
On 04/01/22 at 02:30pm, Eric DeVolder wrote:
... ...kernel/crash_core.c static int __init crash_save_vmcoreinfo_init(void) · line 508
Quoted 2 lines
kernel/crash_core.c +2
-0+static void crash_hotplug_handler (unsigned int hp_action, +unsigned long a,unsigned long b)I am still struggling to consider if these unused parameters should be kept or removed. Do you foresee or feel on which ARCH they could be used?
Quoted 7 lines
Considering our elfcorehdr updating method, once memory or cpu changed, we will update elfcorehdr and cpu notes to reflect all existing memory regions and cpu in the current system. We could end up with having them but never being used. Then we may finally need to clean them up.
If you have investigated and foresee or feel they could be used on a certain architecture, we can keep them for the time being.
So '
hp_action' and 'a' are used within the existing patch series. Incrash_core.c, there is this bit of code:(quoted diff) +3
-0+ kexec_crash_image->offlinecpu = + (hp_action == KEXEC_CRASH_HP_REMOVE_CPU) ? + (unsigned int)a : ~0U;which is referencing both '
hp_action' and using 'a' from the cpu notifier handler. I looked into removing 'a' and setting offlinecpu directly, but I thought it better that offlinecpu be set within the safety of thekexec_mutex. Also, Sourabh Jain's work with PowerPC utilizing this framework directly referenceshp_actionin the arch-specific handler.
Quoted 4 lines
The cpu and memory notifier handlers set
hp_actionaccordingly. For cpu handler, the 'a' is set with the impacted cpu. For memory handler, 'a' and 'b' form the impacted memory range. I agree it looks like the memory range is currently not useful.
OK, memory handler doesn't need the action, memory regions. While cpu handler needs it to exclude the hot plugged cpu.
We could have two ways to acheive this as below. How do you think about them?
static void crash_hotplug_handler(unsigned int hp_action,
unsigned long cpu)
static int crash_memhp_notifier(struct notifier_block *nb,
unsigned long val, void *v)
{
......
switch (val) {
case MEM_ONLINE:
crash_hotplug_handler(KEXEC_CRASH_HP_ADD_MEMORY,
-1UL);
break;
case MEM_OFFLINE:
crash_hotplug_handler(KEXEC_CRASH_HP_REMOVE_MEMORY,
-1UL);
break;
}
return NOTIFY_OK;
}static int crash_cpuhp_online(unsigned int cpu)
{
crash_hotplug_handler(KEXEC_CRASH_HP_ADD_CPU, cpu);
return 0;
}static int crash_cpuhp_offline(unsigned int cpu)
{
crash_hotplug_handler(KEXEC_CRASH_HP_REMOVE_CPU, cpu);
return 0;
}OR,
static void crash_hotplug_handler(unsigned int hp_action,
int* cpu)
static int crash_cpuhp_online(unsigned int cpu)
{
crash_hotplug_handler(KEXEC_CRASH_HP_ADD_CPU, NULL);
return 0;
}static int crash_cpuhp_offline(unsigned int cpu)
{
int dead_cpu = cpu;
crash_hotplug_handler(KEXEC_CRASH_HP_REMOVE_CPU, &cpu);
return 0;
}Re: [PATCH v6 4/8] crash: add generic infrastructure for crash hotplug support
Quoted 74 lines · Baoquan He
Quoted 35 lines · Eric DeVolder
Quoted 11 lines · Baoquan He
Hi Eric,
On 04/01/22 at 02:30pm, Eric DeVolder wrote:
... ...kernel/crash_core.c static int __init crash_save_vmcoreinfo_init(void) · line 508
Quoted 2 lines
kernel/crash_core.c +2
-0+static void crash_hotplug_handler (unsigned int hp_action, +unsigned long a,unsigned long b)I am still struggling to consider if these unused parameters should be kept or removed. Do you foresee or feel on which ARCH they could be used?
Quoted 7 lines
Considering our elfcorehdr updating method, once memory or cpu changed, we will update elfcorehdr and cpu notes to reflect all existing memory regions and cpu in the current system. We could end up with having them but never being used. Then we may finally need to clean them up.
If you have investigated and foresee or feel they could be used on a certain architecture, we can keep them for the time being.
So '
hp_action' and 'a' are used within the existing patch series. Incrash_core.c, there is this bit of code:(quoted diff) +3
-0+ kexec_crash_image->offlinecpu = + (hp_action == KEXEC_CRASH_HP_REMOVE_CPU) ? + (unsigned int)a : ~0U;which is referencing both '
hp_action' and using 'a' from the cpu notifier handler. I looked into removing 'a' and setting offlinecpu directly, but I thought it better that offlinecpu be set within the safety of thekexec_mutex. Also, Sourabh Jain's work with PowerPC utilizing this framework directly referenceshp_actionin the arch-specific handler.Quoted 4 lines
The cpu and memory notifier handlers set
hp_actionaccordingly. For cpu handler, the 'a' is set with the impacted cpu. For memory handler, 'a' and 'b' form the impacted memory range. I agree it looks like the memory range is currently not useful.OK, memory handler doesn't need the action, memory regions. While cpu handler needs it to exclude the hot plugged cpu.
We could have two ways to acheive this as below. How do you think about them?
static void crash_hotplug_handler(unsigned int
hp_action,
unsigned long cpu)static int crash_memhp_notifier(struct
notifier_block*nb,
unsigned long val, void *v)
{
......switch (val) { case MEM_ONLINE: crash_hotplug_handler(KEXEC_CRASH_HP_ADD_MEMORY, -1UL); break; case MEM_OFFLINE: crash_hotplug_handler(KEXEC_CRASH_HP_REMOVE_MEMORY, -1UL); break; } return NOTIFY_OK; }static int
crash_cpuhp_online(unsigned int cpu){ crash_hotplug_handler(KEXEC_CRASH_HP_ADD_CPU, cpu); return 0; }
Quoted 5 lines
static int
crash_cpuhp_offline(unsigned int cpu){ crash_hotplug_handler(KEXEC_CRASH_HP_REMOVE_CPU, cpu); return 0; }
I'm OK with the above. Shall I post v7 or are you still looking at patches 7 and 8? Thanks!
Eric
Quoted 19 lines
OR,
static void crash_hotplug_handler(unsigned int
hp_action,
int* cpu)static int
crash_cpuhp_online(unsigned int cpu){ crash_hotplug_handler(KEXEC_CRASH_HP_ADD_CPU, NULL); return 0; }static int
crash_cpuhp_offline(unsigned int cpu){ int dead_cpu = cpu; crash_hotplug_handler(KEXEC_CRASH_HP_REMOVE_CPU, &cpu); return 0; }
Re: [PATCH v6 4/8] crash: add generic infrastructure for crash hotplug support
Quoted 77 lines · Eric DeVolder
Quoted 74 lines · Baoquan He
Quoted 35 lines · Eric DeVolder
Quoted 11 lines · Baoquan He
Hi Eric,
On 04/01/22 at 02:30pm, Eric DeVolder wrote:
... ...kernel/crash_core.c static int __init crash_save_vmcoreinfo_init(void) · line 508
Quoted 2 lines
kernel/crash_core.c +2
-0+static void crash_hotplug_handler (unsigned int hp_action, +unsigned long a,unsigned long b)I am still struggling to consider if these unused parameters should be kept or removed. Do you foresee or feel on which ARCH they could be used?
Quoted 7 lines
Considering our elfcorehdr updating method, once memory or cpu changed, we will update elfcorehdr and cpu notes to reflect all existing memory regions and cpu in the current system. We could end up with having them but never being used. Then we may finally need to clean them up.
If you have investigated and foresee or feel they could be used on a certain architecture, we can keep them for the time being.
So '
hp_action' and 'a' are used within the existing patch series. Incrash_core.c, there is this bit of code:(quoted diff) +3
-0+ kexec_crash_image->offlinecpu = + (hp_action == KEXEC_CRASH_HP_REMOVE_CPU) ? + (unsigned int)a : ~0U;which is referencing both '
hp_action' and using 'a' from the cpu notifier handler. I looked into removing 'a' and setting offlinecpu directly, but I thought it better that offlinecpu be set within the safety of thekexec_mutex. Also, Sourabh Jain's work with PowerPC utilizing this framework directly referenceshp_actionin the arch-specific handler.Quoted 4 lines
The cpu and memory notifier handlers set
hp_actionaccordingly. For cpu handler, the 'a' is set with the impacted cpu. For memory handler, 'a' and 'b' form the impacted memory range. I agree it looks like the memory range is currently not useful.OK, memory handler doesn't need the action, memory regions. While cpu handler needs it to exclude the hot plugged cpu.
We could have two ways to acheive this as below. How do you think about them?
static void crash_hotplug_handler(unsigned int
hp_action,
unsigned long cpu)static int crash_memhp_notifier(struct
notifier_block*nb,
unsigned long val, void *v)
{
......switch (val) { case MEM_ONLINE: crash_hotplug_handler(KEXEC_CRASH_HP_ADD_MEMORY, -1UL); break; case MEM_OFFLINE: crash_hotplug_handler(KEXEC_CRASH_HP_REMOVE_MEMORY, -1UL); break; } return NOTIFY_OK; }static int
crash_cpuhp_online(unsigned int cpu){ crash_hotplug_handler(KEXEC_CRASH_HP_ADD_CPU, cpu); return 0; }
Quoted 8 lines
Quoted 5 lines
static int
crash_cpuhp_offline(unsigned int cpu){ crash_hotplug_handler(KEXEC_CRASH_HP_REMOVE_CPU, cpu); return 0; }I'm OK with the above. Shall I post v7 or are you still looking at patches 7 and 8? Thanks!
Just acked patch 8. Patch 7 need be updated too, so will check in v7.
Quoted 20 lines
Quoted 19 lines
OR,
static void crash_hotplug_handler(unsigned int
hp_action,
int* cpu)static int
crash_cpuhp_online(unsigned int cpu){ crash_hotplug_handler(KEXEC_CRASH_HP_ADD_CPU, NULL); return 0; }static int
crash_cpuhp_offline(unsigned int cpu){ int dead_cpu = cpu; crash_hotplug_handler(KEXEC_CRASH_HP_REMOVE_CPU, &cpu); return 0; }
PATCH v6 5/8 kexec: exclude elfcorehdr from the segment digest
In reply to Eric DeVolderWhen a crash kernel is loaded via the kexec_file_load syscall, the kernel places the various segments (ie crash kernel, crash initrd, boot_params, elfcorehdr, purgatory, etc) in memory. For those architectures that utilize purgatory, a hash digest of the segments is calculated for integrity checking. This digest is embedded into the purgatory image prior to placing purgatory in memory.
Since hotplug events cause changes to the elfcorehdr, purgatory integrity checking fails (at crash time, and no kdump created). As a result, this change explicitly excludes the elfcorehdr segment from the list of segments used to create the digest. By doing so, this permits changes to the elfcorehdr in response to hotplug events, without having to also reload purgatory due to the change to the digest.
--- kernel/kexec_file.c | 6 ++++++ 1 file changed, 6 insertions(+)
kernel/kexec_file.c +6 -0
@@ -765,6 +765,12 @@ static int kexec_calculate_store_digests(struct kimage *image)for (j = i =0 ; i < image->nr_segments; i++) {struct kexec_segment *ksegment; +#ifdef CONFIG_CRASH_HOTPLUG +/* This segment excluded to allow future changes via hotplug */ +if (image->elfcorehdr_index_valid && (j == image->elfcorehdr_index)) +continue ; +#endif + ksegment = &image->segment[i];/* * Skip purgatory as it will be modified once we put digest
Signature · 1 line
2.27.0
PATCH v6 6/8 kexec: exclude hot remove cpu from elfcorehdr notes
In reply to Eric DeVolderDue to use of CPUHP_AP_ONLINE_DYN, upon CPU unplug, the CPU is still in the for_each_present_cpu() list when within the crash_hotplug_handler(). Thus the CPU must be explicitly excluded when building the new list of CPUs.
This change identifies in crash_hotplug_handler() the CPU to be excluded, and the check for excluding the CPU in crash_prepare_elf64_headers().
--- kernel/crash_core.c | 10 ++++++++++ kernel/kexec_file.c | 5 +++++ 2 files changed, 15 insertions(+)
kernel/crash_core.c +10 -0
@@ -522,6 +522,16 @@ static void crash_hotplug_handler(unsigned int hp_action,/* Flag to differentiate between normal load and hotplug */ kexec_crash_image->hotplug_event = true; +/* +* Due to use of CPUHP_AP_ONLINE_DYN, upon unplug and during +* this callback, the CPU is still in the for_each_present_cpu() +* list. Must explicitly look to exclude this CPU when building +* new list. +*/ + kexec_crash_image->offlinecpu = + (hp_action ==KEXEC_CRASH_HP_REMOVE_CPU ) ? + (unsigned int )a : ~0U ; +/* Now invoke arch-specific update handler */ arch_crash_hotplug_handler (kexec_crash_image, hp_action, a, b);
kernel/kexec_file.c +5 -0
@@ -1314,6 +1314,11 @@ int crash_prepare_elf64_headers(struct kimage *image, struct crash_mem *mem,/* Prepare one phdr of type PT_NOTE for each present CPU */ for_each_present_cpu (cpu) { +#ifdef CONFIG_CRASH_HOTPLUG +/* Skip the soon-to-be offlined cpu */ +if (image->hotplug_event && (cpu == image->offlinecpu)) +continue ; +#endif phdr->p_type =PT_NOTE ; notes_addr =per_cpu_ptr_to_phys (per_cpu_ptr (crash_notes, cpu)); phdr->p_offset = phdr->p_paddr = notes_addr;
Signature · 1 line
2.27.0
PATCH v6 7/8 x86/crash: Add x86 crash hotplug support for kexec_file_load
In reply to Eric DeVolderFor x86_64, when CPU or memory is hot un/plugged, the crash elfcorehdr, which describes the CPUs and memory in the system, must also be updated.
To update the elfcorehdr for x86_64, a new elfcorehdr must be generated from the available CPUs and memory. The new elfcorehdr is prepared into a buffer, and then installed over the top of the existing elfcorehdr.
In the patch 'kexec: exclude elfcorehdr from the segment digest' the need to update purgatory due to the change in elfcorehdr was eliminated. As a result, no changes to purgatory or boot_params (as the elfcorehdr= kernel command line parameter pointer remains unchanged and correct) are needed, just elfcorehdr.
To accommodate a growing number of resources via hotplug, the elfcorehdr segment must be sufficiently large enough to accommodate changes, see the CRASH_HOTPLUG_ELFCOREHDR_SZ configure item.
With this change, crash hotplug for kexec_file_load syscall is supported. When loading the crash kernel via kexec_file_load, the elfcorehdr is identified at load time in crash_load_segments().
--- arch/x86/kernel/crash.c | 118 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 118 insertions(+)
arch/x86/kernel/crash.c +118 -0
@@ -25,6 +25,7 @@#include <linux/slab.h> #include <linux/vmalloc.h> #include <linux/memblock.h> +#include <linux/highmem.h> #include <asm/processor.h> #include <asm/hardirq.h>
@@ -398,7 +399,17 @@ int crash_load_segments(struct kimage *image) image->elf_headers = kbuf.buffer; image->elf_headers_sz = kbuf.bufsz; +#ifdef CONFIG_CRASH_HOTPLUG +/* Ensure elfcorehdr segment large enough for hotplug changes */ + kbuf.memsz =CONFIG_CRASH_HOTPLUG_ELFCOREHDR_SZ ; +/* For marking as usable to crash kernel */ + image->elf_headers_sz = kbuf.memsz; +/* Record the index of the elfcorehdr segment */ + image->elfcorehdr_index = image->nr_segments; + image->elfcorehdr_index_valid = true; +#else kbuf.memsz = kbuf.bufsz; +#endif kbuf.buf_align =ELF_CORE_HEADER_ALIGN ; kbuf.mem =KEXEC_BUF_MEM_UNKNOWN ; ret =kexec_add_buffer (&kbuf);
@@ -413,3 +424,110 @@ int crash_load_segments(struct kimage *image)return ret; }#endif /* CONFIG_KEXEC_FILE */ + +#ifdef CONFIG_CRASH_HOTPLUG +static void *map_crash_pages (unsigned long paddr,unsigned long size) +{ +/* +* NOTE: The addresses and sizes passed to this routine have +* already been fully aligned on page boundaries. There is no +* need for massaging the address or size. +*/ +void *ptr =NULL ; + +/* NOTE: requires arch_kexec_[un]protect_crashkres() for write access */ +if (size >0 ) { +struct page *page =pfn_to_page (paddr >>PAGE_SHIFT ); + + ptr =kmap (page); + } + +return ptr; +} + +static void unmap_crash_pages (void **ptr) +{ +if (ptr) { +if (*ptr) +kunmap (*ptr); + *ptr =NULL ; + } +} + +/** +* arch_crash_hotplug_handler() - Handle hotplug elfcorehdr changes +* @image: the active struct kimage +* @hp_action: the hot un/plug action being handled +* @a: first parameter dependent upon hp_action +* @b: first parameter dependent upon hp_action +* +* To accurately reflect hot un/plug changes, the elfcorehdr (which +* is passed to the crash kernel via the elfcorehdr= parameter) +* must be updated with the new list of CPUs and memories. The new +* elfcorehdr is prepared in a kernel buffer, and then it is +* written on top of the existing/old elfcorehdr. +* +* For hotplug changes to elfcorehdr to work, two conditions are +* needed: +* First, the segment containing the elfcorehdr must be large enough +* to permit a growing number of resources. See +* CONFIG_CRASH_HOTPLUG_ELFCOREHDR_SZ. +* Second, purgatory must explicitly exclude the elfcorehdr from the +* list of segments it checks (since the elfcorehdr changes and thus +* would require an update to purgatory itself to update the digest). +* +*/ +void arch_crash_hotplug_handler (struct kimage *image, +unsigned int hp_action,unsigned long a,unsigned long b) +{ +struct kexec_segment *ksegment; +unsigned char *ptr =NULL ; +unsigned long elfsz =0 ; +void *elfbuf =NULL ; +unsigned long mem, memsz; + +if (!image->elfcorehdr_index_valid) { +pr_err ("crash hp: unable to locate elfcorehdr segment" ); + goto out; + } + + ksegment = &image->segment[image->elfcorehdr_index]; + mem = ksegment->mem; + memsz = ksegment->memsz; + +/* +* Create the new elfcorehdr reflecting the changes to CPU and/or +* memory resources. +*/ +if (prepare_elf_headers (image, &elfbuf, &elfsz)) { +pr_err ("crash hp: unable to prepare elfcore headers" ); + goto out; + } +if (elfsz > memsz) { +pr_err ("crash hp: update elfcorehdr elfsz %lu > memsz %lu" , + elfsz, memsz); + goto out; + } + +/* +* At this point, we are all but assured of success. +* Copy new elfcorehdr into destination. +*/ + ptr =map_crash_pages (mem, memsz); +if (ptr) { +/* +* Temporarily invalidate the crash image while the +* elfcorehdr is updated. +*/ +xchg (&kexec_crash_image,NULL ); +memcpy_flushcache ((void *)ptr, elfbuf, elfsz); +xchg (&kexec_crash_image, image); + } +unmap_crash_pages ((void **)&ptr); +pr_debug ("crash hp: re-loaded elfcorehdr at 0x%lx\n" , mem); + +out: +if (elfbuf) +vfree (elfbuf); +} +#endif /* CONFIG_CRASH_HOTPLUG */
Signature · 1 line
2.27.0
PATCH v6 8/8 x86/crash: Add x86 crash hotplug support for kexec_load
In reply to Eric DeVolderFor kexec_file_load support, the loading of the crash kernel occurs entirely within the kernel, and as such the elfcorehdr is readily identified (so that it can be modified upon hotplug events).
This change enables support for kexec_load by identifying the elfcorehdr segment in the arch_crash_hotplug_handler(), if it has not already been identified.
--- arch/x86/kernel/crash.c | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)
arch/x86/kernel/crash.c +24 -0
@@ -486,6 +486,30 @@ void arch_crash_hotplug_handler(struct kimage *image,void *elfbuf =NULL ;unsigned long mem, memsz; +/* +* When the struct kimage is alloced, it is wiped to zero, so +* the elfcorehdr_index_valid defaults to false. It is set on the +* kexec_file_load path, or here for kexec_load, if not already +* identified. +*/ +if (!image->elfcorehdr_index_valid) { +unsigned int n; + +for (n =0 ; n < image->nr_segments; n++) { + mem = image->segment[n].mem; + memsz = image->segment[n].memsz; + ptr =map_crash_pages (mem, memsz); +if (ptr) { +/* The segment containing elfcorehdr */ +if (memcmp (ptr,ELFMAG ,SELFMAG ) ==0 ) { + image->elfcorehdr_index = (int )n; + image->elfcorehdr_index_valid = true; + } + } +unmap_crash_pages ((void **)&ptr); + } + } +if (!image->elfcorehdr_index_valid) {pr_err ("crash hp: unable to locate elfcorehdr segment" ); goto out;
Signature · 1 line
2.27.0
Re: [PATCH v6 8/8] x86/crash: Add x86 crash hotplug support for kexec_load
Quoted 9 lines · Eric DeVolder
For
kexec_file_loadsupport, the loading of the crash kernel occurs entirely within the kernel, and as such the elfcorehdr is readily identified (so that it can be modified upon hotplug events).This change enables support for
kexec_loadby identifying the elfcorehdr segment in thearch_crash_hotplug_handler(), if it has not already been identified.Signed-off-by Eric DeVolder <[email protected]>
LGTM,
Quoted 42 lines
--- arch/x86/kernel/crash.c | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)arch/x86/kernel/crash.c +24
-0@@ -486,6 +486,30 @@ void arch_crash_hotplug_handler(struct kimage *image,void *elfbuf =NULL ;unsigned long mem, memsz; +/* +* When the struct kimage is alloced, it is wiped to zero, so +* the elfcorehdr_index_valid defaults to false. It is set on the +* kexec_file_load path, or here for kexec_load, if not already +* identified. +*/ +if (!image->elfcorehdr_index_valid) { +unsigned int n; + +for (n =0 ; n < image->nr_segments; n++) { + mem = image->segment[n].mem; + memsz = image->segment[n].memsz; + ptr =map_crash_pages (mem, memsz); +if (ptr) { +/* The segment containing elfcorehdr */ +if (memcmp (ptr,ELFMAG ,SELFMAG ) ==0 ) { + image->elfcorehdr_index = (int )n; + image->elfcorehdr_index_valid = true; + } + } +unmap_crash_pages ((void **)&ptr); + } + } +if (!image->elfcorehdr_index_valid) {pr_err ("crash hp: unable to locate elfcorehdr segment" ); goto out;Signature · 1 line
2.27.0