crash: Kernel handling of CPU and memory hot un/plug
Subsystems (12)
v13 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, 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 (eg. 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; thus no involvement with userspace needed.
To realize the benefits/test this patchset, one must make a couple of minor changes to userspace:
- Prevent udev from updating kdump crash kernel on hot un/plug changes. Add the following as the first lines to the RHEL udev rule file /usr/lib/udev/rules.d/98-kexec.rules:
# The kernel handles updates to crash elfcorehdr for cpu and memory changes SUBSYSTEM=="cpu", ATTRS{crash_hotplug}=="1", GOTO="kdump_reload_end" SUBSYSTEM=="memory", ATTRS{crash_hotplug}=="1", GOTO="kdump_reload_end"
These lines will cause cpu and memory hot un/plug events to be skipped within this rule file, with this changset applied.
- 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 kernel patchset also supports kexec_load() with a modified kexec userspace utility. A working changeset to the kexec userspace utility is posted to the kexec-tools mailing list here:
http://lists.infradead.org/pipermail/kexec/2022-October/026032.html
To use the kexec-tools patch, apply, build and install kexec-tools, then change the kdumpctl's standard_kexec_args to replace the -s with --hotplug. The removal of -s reverts to the kexec_load syscall and the addition of --hotplug invokes the changes put forth in the kexec-tools patch.
Regards,
eric
---
v13: 31oct2022
- Rebased onto 6.1.0-rc3, which means converting to use the new kexec_trylock() away from mutex_lock(kexec_mutex).
- Moved arch_un/map_crash_pages() into kexec.h and default implementation using k/unmap_local_pages().
- Changed more #ifdef's into IS_ENABLED()
- Changed CRASH_MAX_MEMORY_RANGES to 8192 from 32768, and it moved into x86 crash.c as #define rather Kconfig item, per Boris.
- Check number of Phdrs against PN_XNUM, max possible.
v12: 9sep2022
https://lkml.org/lkml/2022/9/9/1358
- Rebased onto 6.0-rc4
- Addressed some minor formatting items, per Baoquan
v11: 26aug2022
https://lkml.org/lkml/2022/8/26/963
- Rebased onto 6.0-rc2
- Redid the rework of __weak to use asm/kexec.h, per Baoquan
- Reworked some comments and minor items, per Baoquan
v10: 21jul2022
https://lkml.org/lkml/2022/7/21/1007
- Rebased to 5.19.0-rc7
- Per Sourabh, corrected build issue with arch_un/map_crash_pages() for architectures not supporting this feature.
- Per David Hildebrand, removed the WARN_ONCE() altogether.
- Per David Hansen, converted to use of kmap_local_page().
- Per Baoquan He, replaced use of __weak with the kexec technique.
v9: 13jun2022
https://lkml.org/lkml/2022/6/13/3382
- Rebased to 5.18.0
- Per Sourabh, moved crash_prepare_elf64_headers() into common crash_core.c to avoid compile issues with kexec_load only path.
- Per David Hildebrand, replaced mutex_trylock() with mutex_lock().
- Changed the __weak arch_crash_handle_hotplug_event() to utilize WARN_ONCE() instead of WARN(). Fix some formatting issues.
- Per Sourabh, introduced sysfs attribute crash_hotplug for memory and CPUs; for use by userspace (udev) to determine if the kernel performs crash hot un/plug support.
- Per Sourabh, moved the code detecting the elfcorehdr segment from arch/x86 into crash_core:handle_hotplug_event() so both kexec_load and kexec_file_load can benefit.
- Updated userspace kexec-tools kexec utility to reflect change to using CRASH_MAX_MEMORY_RANGES and get_nr_cpus().
- Updated the new proposed udev rules to reflect using the sysfs attributes crash_hotplug.
v8: 5may2022
https://lkml.org/lkml/2022/5/5/1133
- Per Borislav Petkov, eliminated CONFIG_CRASH_HOTPLUG in favor of CONFIG_HOTPLUG_CPU || CONFIG_MEMORY_HOTPLUG, ie a new define is not needed. Also use of IS_ENABLED() rather than #ifdef's. Renamed crash_hotplug_handler() to handle_hotplug_event(). And other corrections.
- Per Baoquan, minimized the parameters to the arch_crash_ handle_hotplug_event() to hp_action and cpu.
- Introduce KEXEC_CRASH_HP_INVALID_CPU definition, per Baoquan.
- Per Sourabh Jain, renamed and repurposed CRASH_HOTPLUG_ELFCOREHDR_SZ to CONFIG_CRASH_MAX_MEMORY_RANGES, mirroring kexec-tools change by David Hildebrand. Folded this patch into the x86 kexec_file_load support patch.
v7: 13apr2022
https://lkml.org/lkml/2022/4/13/850
- Resolved parameter usage to crash_hotplug_handler(), per Baoquan.
v6: 1apr2022
https://lkml.org/lkml/2022/4/1/1203
- 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 (7):
crash: move crash_prepare_elf64_headers()
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
crash: memory and cpu hotplug sysfs attributes x86/crash: add x86 crash hotplug support
.../admin-guide/mm/memory-hotplug.rst | 8 + Documentation/core-api/cpu_hotplug.rst | 18 ++ arch/arm64/kernel/machine_kexec_file.c | 6 +- arch/powerpc/kexec/file_load_64.c | 2 +- arch/riscv/kernel/elf_kexec.c | 7 +- arch/x86/include/asm/kexec.h | 14 + arch/x86/kernel/crash.c | 110 +++++++- drivers/base/cpu.c | 14 + drivers/base/memory.c | 13 + include/linux/crash_core.h | 8 + include/linux/kexec.h | 54 +++- kernel/crash_core.c | 255 ++++++++++++++++++ kernel/kexec_file.c | 105 +------- 13 files changed, 502 insertions(+), 112 deletions(-)
Signature · 7 lines
2.31.1 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
PATCH v13 1/7 crash: move crash_prepare_elf64_headers()
At the outcome of this patch set, the crash_prepare_elf64_headers() is utilized on both the kexec_file_load() and kexec_load() paths. As such, need to move this function out of kexec_file.c and into a common location crash_core.c.
No functionality change.
--- kernel/crash_core.c | 100 ++++++++++++++++++++++++++++++++++++++++++++ kernel/kexec_file.c | 99 ------------------------------------------- 2 files changed, 100 insertions(+), 99 deletions(-)
kernel/crash_core.c +100 -0
@@ -10,6 +10,7 @@#include <linux/utsname.h> #include <linux/vmalloc.h> #include <linux/sizes.h> +#include <linux/kexec.h> #include <asm/page.h> #include <asm/sections.h>
@@ -314,6 +315,105 @@ static int __init parse_crashkernel_dummy(char *arg) }early_param ("crashkernel" , parse_crashkernel_dummy); +int crash_prepare_elf64_headers (struct crash_mem *mem,int need_kernel_map, +void **addr,unsigned long *sz) +{ +Elf64_Ehdr *ehdr; +Elf64_Phdr *phdr; +unsigned long nr_cpus =num_possible_cpus (), nr_phdr, elf_sz; +unsigned char *buf; +unsigned int cpu, i; +unsigned long long notes_addr; +unsigned long mstart, mend; + +/* extra phdr for vmcoreinfo ELF note */ + nr_phdr = nr_cpus +1 ; + nr_phdr += mem->nr_ranges; + +/* +* kexec-tools creates an extra PT_LOAD phdr for kernel text mapping +* area (for example, ffffffff80000000 - ffffffffa0000000 on x86_64). +* I think this is required by tools like gdb. So same physical +* memory will be mapped in two ELF headers. One will contain kernel +* text virtual addresses and other will have __va(physical) addresses. +*/ + + nr_phdr++; + elf_sz =sizeof (Elf64_Ehdr) + nr_phdr *sizeof (Elf64_Phdr); + elf_sz =ALIGN (elf_sz,ELF_CORE_HEADER_ALIGN ); + + buf =vzalloc (elf_sz); +if (!buf) +return -ENOMEM ; + + ehdr = (Elf64_Ehdr *)buf; + phdr = (Elf64_Phdr *)(ehdr +1 ); +memcpy (ehdr->e_ident,ELFMAG ,SELFMAG ); + ehdr->e_ident[EI_CLASS ] =ELFCLASS64 ; + ehdr->e_ident[EI_DATA ] =ELFDATA2LSB ; + ehdr->e_ident[EI_VERSION ] =EV_CURRENT ; + ehdr->e_ident[EI_OSABI ] =ELF_OSABI ; +memset (ehdr->e_ident +EI_PAD ,0 ,EI_NIDENT -EI_PAD ); + ehdr->e_type =ET_CORE ; + ehdr->e_machine =ELF_ARCH ; + ehdr->e_version =EV_CURRENT ; + ehdr->e_phoff =sizeof (Elf64_Ehdr); + ehdr->e_ehsize =sizeof (Elf64_Ehdr); + ehdr->e_phentsize =sizeof (Elf64_Phdr); + +/* Prepare one phdr of type PT_NOTE for each present CPU */ +for_each_present_cpu (cpu) { + 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; + phdr->p_filesz = phdr->p_memsz =sizeof (note_buf_t); + (ehdr->e_phnum)++; + phdr++; + } + +/* Prepare one PT_NOTE header for vmcoreinfo */ + phdr->p_type =PT_NOTE ; + phdr->p_offset = phdr->p_paddr =paddr_vmcoreinfo_note (); + phdr->p_filesz = phdr->p_memsz =VMCOREINFO_NOTE_SIZE ; + (ehdr->e_phnum)++; + phdr++; + +/* Prepare PT_LOAD type program header for kernel text region */ +if (need_kernel_map) { + phdr->p_type =PT_LOAD ; + phdr->p_flags =PF_R |PF_W |PF_X ; + phdr->p_vaddr = (unsigned long ) _text; + phdr->p_filesz = phdr->p_memsz = _end - _text; + phdr->p_offset = phdr->p_paddr =__pa_symbol (_text); + ehdr->e_phnum++; + phdr++; + } + +/* Go through all the ranges in mem->ranges[] and prepare phdr */ +for (i =0 ; i < mem->nr_ranges; i++) { + mstart = mem->ranges[i].start; + mend = mem->ranges[i].end; + + phdr->p_type =PT_LOAD ; + phdr->p_flags =PF_R |PF_W |PF_X ; + phdr->p_offset = mstart; + + phdr->p_paddr = mstart; + phdr->p_vaddr = (unsigned long )__va (mstart); + phdr->p_filesz = phdr->p_memsz = mend - mstart +1 ; + phdr->p_align =0 ; + ehdr->e_phnum++; +pr_debug ("Crash PT_LOAD ELF header. phdr=%p vaddr=0x%llx, paddr=0x%llx, sz=0x%llx e_phnum=%d p_offset=0x%llx\n" , + phdr, phdr->p_vaddr, phdr->p_paddr, phdr->p_filesz, + ehdr->e_phnum, phdr->p_offset); + phdr++; + } + + *addr = buf; + *sz = elf_sz; +return 0 ; +} +Elf_Word *append_elf_note (Elf_Word *buf,char *name,unsigned int type,void *data,size_t data_len) {
kernel/kexec_file.c +0 -99
102 lines not on this page · raw message
Signature · 7 lines
2.31.1 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
PATCH v13 2/7 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(). The hotplug members are added in "crash: add generic infrastructure for crash hotplug support".
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/riscv/kernel/elf_kexec.c | 7 ++++--- arch/x86/kernel/crash.c | 2 +- include/linux/kexec.h | 7 +++++-- kernel/crash_core.c | 4 ++-- 6 files changed, 16 insertions(+), 12 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;
@@ -64,7 +64,7 @@ static int prepare_elf_headers(void **addr, unsigned long *sz) }/* Exclude crashkernel region */ - ret =crash_exclude_mem_range (cmem, crashk_res.start, crashk_res.end); + ret =crash_exclude_mem_range (image, cmem, crashk_res.start, crashk_res.end);if (ret) goto out;
@@ -74,7 +74,7 @@ static int prepare_elf_headers(void **addr, unsigned long *sz) goto out; } - ret =crash_prepare_elf64_headers (cmem, true, addr, sz); + ret =crash_prepare_elf64_headers (image, cmem, true, addr, sz); out:kfree (cmem);
arch/powerpc/kexec/file_load_64.c +1 -1
@@ -798,7 +798,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/riscv/kernel/elf_kexec.c +4 -3
@@ -118,7 +118,8 @@ static int prepare_elf64_ram_headers_callback(struct resource *res, void *arg)return 0 ; } -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;
@@ -140,7 +141,7 @@ static int prepare_elf_headers(void **addr, unsigned long *sz)/* Exclude crashkernel region */ 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); out:kfree (cmem);
@@ -212,7 +213,7 @@ static void *elf_kexec_load(struct kimage *image, char *kernel_buf,/* Add elfcorehdr */ 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;
arch/x86/kernel/crash.c +1 -1
@@ -265,7 +265,7 @@ 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 +5 -2
@@ -253,8 +253,11 @@ 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 need_kernel_map, -void **addr,unsigned long *sz); +extern int crash_prepare_elf64_headers (struct kimage *image, +struct crash_mem *mem, +int need_kernel_map, +void **addr, +unsigned long *sz);#ifndef arch_kexec_apply_relocations_add/*
kernel/crash_core.c +2 -2
@@ -315,8 +315,8 @@ static int __init parse_crashkernel_dummy(char *arg) }early_param ("crashkernel" , parse_crashkernel_dummy); -int crash_prepare_elf64_headers (struct crash_mem *mem,int need_kernel_map, -void **addr,unsigned long *sz) +int crash_prepare_elf64_headers (struct kimage *image,struct crash_mem *mem, +int need_kernel_map,void **addr,unsigned long *sz) {Elf64_Ehdr *ehdr;Elf64_Phdr *phdr;
Signature · 7 lines
2.31.1 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
PATCH v13 3/7 crash: add generic infrastructure for crash hotplug support
In reply to Eric DeVolderCPU and memory change notifications are received in order to regenerate the elfcorehdr.
To support cpu hotplug, a callback is registered to capture the CPUHP_AP_ONLINE_DYN online and offline 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 notifiers call handle_hotplug_event() which performs needed tasks and then dispatches the event to the architecture specific arch_crash_handle_hotplug_event(). During the process, the kexec_lock is held.
--- include/linux/crash_core.h | 8 +++ include/linux/kexec.h | 39 +++++++++++ kernel/crash_core.c | 139 +++++++++++++++++++++++++++++++++++++ 3 files changed, 186 insertions(+)
include/linux/crash_core.h +8 -0
@@ -84,4 +84,12 @@ int parse_crashkernel_high(char *cmdline, unsigned long long system_ram,int parse_crashkernel_low (char *cmdline,unsigned long long system_ram,unsigned long long *crash_size,unsigned long long *crash_base); +#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 +#define KEXEC_CRASH_HP_INVALID_CPU -1U + +struct kimage ; +#endif /* LINUX_CRASH_CORE_H */
include/linux/kexec.h +39 -0
@@ -32,6 +32,7 @@ extern note_buf_t __percpu *crash_notes;#include <linux/compat.h> #include <linux/ioport.h> #include <linux/module.h> +#include <linux/highmem.h> #include <asm/kexec.h> /* Verify architecture specific macros are defined */
@@ -374,6 +375,13 @@ struct kimage {struct purgatory_info purgatory_info;#endif +#if defined(CONFIG_HOTPLUG_CPU ) || defined(CONFIG_MEMORY_HOTPLUG ) +bool hotplug_event; +unsigned int offlinecpu; +bool elfcorehdr_index_valid; +int elfcorehdr_index; +#endif +#ifdef CONFIG_IMA_KEXEC /* Virtual address of IMA measurement buffer for kexec syscall */ void *ima_buffer;
@@ -503,6 +511,37 @@ static inline int arch_kexec_post_alloc_pages(void *vaddr, unsigned int pages, gstatic inline void arch_kexec_pre_free_pages (void *vaddr,unsigned int pages) { }#endif +#ifndef arch_map_crash_pages +/* +* 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. +*/ +static inline void *arch_map_crash_pages (unsigned long paddr, +unsigned long size) +{ +if (size >0 ) +return kmap_local_page (pfn_to_page (paddr >>PAGE_SHIFT )); +else +return NULL ; +} +#endif + +#ifndef arch_unmap_crash_pages +static inline void arch_unmap_crash_pages (void *ptr) +{ +if (ptr) +kunmap_local (ptr); +} +#endif + +#ifndef arch_crash_handle_hotplug_event +static inline void arch_crash_handle_hotplug_event (struct kimage *image, +unsigned int hp_action) +{ +} +#endif +#else /* !CONFIG_KEXEC_CORE */ struct pt_regs ;struct task_struct ;
kernel/crash_core.c +139 -0
154 lines not on this page · raw message
Signature · 7 lines
2.31.1 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
PATCH v13 4/7 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
@@ -723,6 +723,12 @@ static int kexec_calculate_store_digests(struct kimage *image)for (j = i =0 ; i < image->nr_segments; i++) {struct kexec_segment *ksegment; +if (IS_ENABLED (CONFIG_HOTPLUG_CPU ) ||IS_ENABLED (CONFIG_MEMORY_HOTPLUG )) { +/* Exclude elfcorehdr segment to allow future changes via hotplug */ +if (image->elfcorehdr_index_valid && (j == image->elfcorehdr_index)) +continue ; + } + ksegment = &image->segment[i];/* * Skip purgatory as it will be modified once we put digest
Signature · 7 lines
2.31.1 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
PATCH v13 5/7 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 handle_hotplug_event(). Thus the CPU must be explicitly excluded when building the new list of CPUs.
This change identifies in handle_hotplug_event() the CPU to be excluded, and the check for excluding the CPU in crash_prepare_elf64_headers().
--- kernel/crash_core.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
kernel/crash_core.c +16 -0
@@ -366,6 +366,12 @@ 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) { +if (IS_ENABLED (CONFIG_HOTPLUG_CPU )) { +/* Skip the soon-to-be offlined cpu */ +if (image->hotplug_event && (cpu == image->offlinecpu)) +continue ; + } + 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;
@@ -684,6 +690,16 @@ static void handle_hotplug_event(unsigned int hp_action, unsigned int cpu)/* Flag to differentiate between normal load and hotplug */ 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. +*/ + image->offlinecpu = + (hp_action ==KEXEC_CRASH_HP_REMOVE_CPU ) ? + cpu :KEXEC_CRASH_HP_INVALID_CPU ; +/* Now invoke arch-specific update handler */ arch_crash_handle_hotplug_event (image, hp_action);
Signature · 7 lines
2.31.1 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
PATCH v13 6/7 crash: memory and cpu hotplug sysfs attributes
In reply to Eric DeVolderThis introduces the crash_hotplug attribute for memory and CPUs for use by userspace. This change directly facilitates the udev rule for managing userspace re-loading of the crash kernel upon hot un/plug changes.
For memory, this changeset introduces the crash_hotplug attribute to the /sys/devices/system/memory directory. For example:
# udevadm info --attribute-walk /sys/devices/system/memory/memory81
looking at device '/devices/system/memory/memory81':
KERNEL=="memory81"
SUBSYSTEM=="memory"
DRIVER==""
ATTR{online}=="1"
ATTR{phys_device}=="0"
ATTR{phys_index}=="00000051"
ATTR{removable}=="1"
ATTR{state}=="online"
ATTR{valid_zones}=="Movable"looking at parent device '/devices/system/memory':
KERNELS=="memory"
SUBSYSTEMS==""
DRIVERS==""
ATTRS{auto_online_blocks}=="offline"
ATTRS{block_size_bytes}=="8000000"
ATTRS{crash_hotplug}=="1"For CPUs, this changeset introduces the crash_hotplug attribute to the /sys/devices/system/cpu directory. For example:
# udevadm info --attribute-walk /sys/devices/system/cpu/cpu0
looking at device '/devices/system/cpu/cpu0':
KERNEL=="cpu0"
SUBSYSTEM=="cpu"
DRIVER=="processor"
ATTR{crash_notes}=="277c38600"
ATTR{crash_notes_size}=="368"
ATTR{online}=="1"looking at parent device '/devices/system/cpu':
KERNELS=="cpu"
SUBSYSTEMS==""
DRIVERS==""
ATTRS{crash_hotplug}=="1"
ATTRS{isolated}==""
ATTRS{kernel_max}=="8191"
ATTRS{nohz_full}==" (null)"
ATTRS{offline}=="4-7"
ATTRS{online}=="0-3"
ATTRS{possible}=="0-7"
ATTRS{present}=="0-3"With these sysfs attributes in place, it is possible to efficiently instruct the udev rule to skip crash kernel reloading.
For example, the following is the proposed udev rule change for RHEL system 98-kexec.rules (as the first lines of the rule file):
# The kernel handles updates to crash elfcorehdr for cpu and memory changes SUBSYSTEM=="cpu", ATTRS{crash_hotplug}=="1", GOTO="kdump_reload_end" SUBSYSTEM=="memory", ATTRS{crash_hotplug}=="1", GOTO="kdump_reload_end"
When examined in the context of 98-kexec.rules, the above change tests if crash_hotplug is set, and if so, it skips the userspace initiated unload-then-reload of the crash kernel.
Cpu and memory checks are separated in accordance with CONFIG_HOTPLUG_CPU and CONFIG_MEMORY_HOTPLUG kernel config options. If an architecture supports, for example, memory hotplug but not CPU hotplug, then the /sys/devices/system/memory/crash_hotplug attribute file is present, but the /sys/devices/system/cpu/crash_hotplug attribute file will NOT be present. Thus the udev rule will skip userspace processing of memory hot un/plug events, but the udev rule will fail for CPU events, thus allowing userspace to process cpu hot un/plug events (ie the unload-then-reload of the kdump capture kernel).
--- .../admin-guide/mm/memory-hotplug.rst | 8 ++++++++ Documentation/core-api/cpu_hotplug.rst | 18 ++++++++++++++++++ drivers/base/cpu.c | 14 ++++++++++++++ drivers/base/memory.c | 13 +++++++++++++ include/linux/kexec.h | 8 ++++++++ 5 files changed, 61 insertions(+)
Documentation/admin-guide/mm/memory-hotplug.rst +8 -0
@@ -293,6 +293,14 @@ The following files are currently defined: Availability depends on the CONFIG_ARCH_MEMORY_PROBE kernel configuration option. ``uevent`` read-write: generic udev file for device subsystems. +``crash_hotplug`` read-only: when changes to the system memory map + occur due to hot un/plug of memory, this file contains + '1' if the kernel updates the kdump capture kernel memory + map itself (via elfcorehdr), or '0' if userspace must update + the kdump capture kernel memory map. + + Availability depends on the CONFIG_MEMORY_HOTPLUG kernel + configuration option. ====================== ========================================================= .. note::
Documentation/core-api/cpu_hotplug.rst +18 -0
@@ -750,6 +750,24 @@ will receive all events. A script like:: can process the event further. +When changes to the CPUs in the system occur, the sysfs file +/sys/devices/system/cpu/crash_hotplug contains '1' if the kernel +updates the kdump capture kernel list of CPUs itself (via elfcorehdr), +or '0' if userspace must update the kdump capture kernel list of CPUs. + +The availability depends on the CONFIG_HOTPLUG_CPU kernel configuration +option. + +To skip userspace processing of CPU hot un/plug events for kdump +(ie the unload-then-reload to obtain a current list of CPUs), this sysfs +file can be used in a udev rule as follows: + + SUBSYSTEM=="cpu", ATTRS{crash_hotplug}=="1", GOTO="kdump_reload_end" + +For a cpu hot un/plug event, if the architecture supports kernel updates +of the elfcorehdr (which contains the list of CPUs), then the rule skips +the unload-then-reload of the kdump capture kernel. + Kernel Inline Documentations Reference ======================================
drivers/base/cpu.c +14 -0
@@ -293,6 +293,17 @@ static ssize_t print_cpus_nohz_full(struct device *dev, static DEVICE_ATTR(nohz_full, 0444, print_cpus_nohz_full, NULL);#endif +#ifdef CONFIG_HOTPLUG_CPU +#include <linux/kexec.h> +static ssize_t crash_hotplug_show (struct device *dev, +struct device_attribute *attr, +char *buf) +{ +return sprintf (buf,"%d\n" ,crash_hotplug_cpu_support ()); +} +static DEVICE_ATTR_ADMIN_RO (crash_hotplug); +#endif +static void cpu_device_release (struct device *dev) {/*
@@ -469,6 +480,9 @@ static struct attribute *cpu_root_attrs[] = {#ifdef CONFIG_NO_HZ_FULL &dev_attr_nohz_full.attr,#endif +#ifdef CONFIG_HOTPLUG_CPU + &dev_attr_crash_hotplug.attr, +#endif #ifdef CONFIG_GENERIC_CPU_AUTOPROBE &dev_attr_modalias.attr,#endif
drivers/base/memory.c +13 -0
@@ -483,6 +483,16 @@ static ssize_t auto_online_blocks_store(struct device *dev,static DEVICE_ATTR_RW (auto_online_blocks); +#ifdef CONFIG_MEMORY_HOTPLUG +#include <linux/kexec.h> +static ssize_t crash_hotplug_show (struct device *dev, +struct device_attribute *attr,char *buf) +{ +return sprintf (buf,"%d\n" ,crash_hotplug_memory_support ()); +} +static DEVICE_ATTR_RO (crash_hotplug); +#endif +/* * Some architectures will have custom drivers to do this, and * will not need to do it from userspace. The fake hot-add code
@@ -881,6 +891,9 @@ static struct attribute *memory_root_attrs[] = { &dev_attr_block_size_bytes.attr, &dev_attr_auto_online_blocks.attr, +#ifdef CONFIG_MEMORY_HOTPLUG + &dev_attr_crash_hotplug.attr, +#endif NULL };
include/linux/kexec.h +8 -0
@@ -542,6 +542,14 @@ static inline void arch_crash_handle_hotplug_event(struct kimage *image, }#endif +#ifndef crash_hotplug_cpu_support +static inline int crash_hotplug_cpu_support (void ) {return 0 ; } +#endif + +#ifndef crash_hotplug_memory_support +static inline int crash_hotplug_memory_support (void ) {return 0 ; } +#endif +#else /* !CONFIG_KEXEC_CORE */ struct pt_regs ;struct task_struct ;
Signature · 7 lines
2.31.1 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
PATCH v13 7/7 x86/crash: add x86 crash hotplug support
In reply to Eric DeVolderWhen CPU or memory is hot un/plugged, the crash elfcorehdr, which describes the CPUs and memory in the system, must also be updated.
A new elfcorehdr is generated from the available CPUs and memory into a buffer, and then installed over the top of the existing elfcorehdr. The segment containing the elfcorehdr is identified at run time in crash_core:handle_hotplug_event(), which works for both the kexec_load() and kexec_file_load() syscalls.
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_MAX_MEMORY_RANGES description.
--- arch/x86/include/asm/kexec.h | 14 +++++ arch/x86/kernel/crash.c | 108 ++++++++++++++++++++++++++++++++++- 2 files changed, 119 insertions(+), 3 deletions(-)
arch/x86/include/asm/kexec.h +14 -0
@@ -212,6 +212,20 @@ typedef void crash_vmclear_fn(void);extern crash_vmclear_fn __rcu *crash_vmclear_loaded_vmcss;extern void kdump_nmi_shootdown_cpus (void ); +void arch_crash_handle_hotplug_event (struct kimage *image, +unsigned int hp_action); +#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 + +#ifdef CONFIG_MEMORY_HOTPLUG +static inline int crash_hotplug_memory_support (void ) {return 1 ; } +#define crash_hotplug_memory_support crash_hotplug_memory_support +#endif +#endif /* __ASSEMBLY__ */ #endif /* _ASM_X86_KEXEC_H */
arch/x86/kernel/crash.c +105 -3
124 lines not on this page · raw message
Signature · 7 lines
2.31.1 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
Borislav Petkov
maintainerRe: [PATCH v13 7/7] x86/crash: add x86 crash hotplug support
Quoted 1 line · Eric DeVolder
+#if
defined(CONFIG_HOTPLUG_CPU)||defined(CONFIG_MEMORY_HOTPLUG)
What happened to that here:
https://lore.kernel.org/r/[email protected]
?
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH v13 7/7] x86/crash: add x86 crash hotplug support
Quoted 9 lines · Borislav Petkov
Quoted 1 line · Eric DeVolder
+#if
defined(CONFIG_HOTPLUG_CPU)||defined(CONFIG_MEMORY_HOTPLUG)What happened to that here:
https://lore.kernel.org/r/[email protected]
?
When I was evaluating the suggestions, I realized that that particular ifdiffery was now used in only 3 locations, twice in kernel/crash_core.c and once in x86 crash.c.
With that realization, and the fact that we just jettisoned CONFIG_CRASH_MAX_MEMORY_RANGES for a #define, it seemed that there wasn't a compelling need to replace the HOTPLUG_CPU || MEMORY_HOTPLUG with a new CRASH_HOTPLUG Kconfig item.
As I'm re-reading that message, I suspect now the preference is to just to strike this ifdiffery line in this file and have the code always present?
If the preference is actually for CRASH_HOTPLUG, then let me know.
Thanks!
eric
Borislav Petkov
maintainerRe: [PATCH v13 7/7] x86/crash: add x86 crash hotplug support
Quoted 4 lines · Eric DeVolder
As I'm re-reading that message, I suspect now the preference is to just to strike this ifdiffery line in this file and have the code always present?
If the preference is actually for
CRASH_HOTPLUG, then let me know.
Well, it is this part:
"But on a plain simple laptop or workstation which has CPU hotplug, would it make sense for the crash ranges to get updated too when CPUs are offlined?
If so, I think you want this code present there too, without a Kconfig item."
IOW, if this thing doesn't make sense to have on the majority of machines out there - and memory hotplug machines are not the majority - then it should be behind a Kconfig item which is default off and gets enabled only when the user selects crash and memory hotplug...
I'd say.
Signature · 9 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquette
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexecRe: [PATCH v13 7/7] x86/crash: add x86 crash hotplug support
Quoted 11 lines · Borislav Petkov
Quoted 4 lines · Eric DeVolder
As I'm re-reading that message, I suspect now the preference is to just to strike this ifdiffery line in this file and have the code always present?
If the preference is actually for
CRASH_HOTPLUG, then let me know.Well, it is this part:
"But on a plain simple laptop or workstation which has CPU hotplug, would it make sense for the crash ranges to get updated too when CPUs are offlined?
Yes, it does.
Quoted 3 lines
If so, I think you want this code present there too, without a
Kconfigitem."
Ah, ok.
Quoted 8 lines
IOW, if this thing doesn't make sense to have on the majority of machines out there - and memory hotplug machines are not the majority - then it should be behind a
Kconfigitem which is default off and gets enabled only when the user selects crash and memory hotplug...I'd say.
Ok, I'll will remove the ifdef line/pair.
Thanks!
eric
Borislav Petkov
maintainerRe: [PATCH v13 7/7] x86/crash: add x86 crash hotplug support
Quoted 5 lines · Eric DeVolder
Quoted 3 lines
"But on a plain simple laptop or workstation which has CPU hotplug, would it make sense for the crash ranges to get updated too when CPUs are offlined?
Yes, it does.
Why?
Signature · 9 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquette
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexecRe: [PATCH v13 7/7] x86/crash: add x86 crash hotplug support
Quoted 9 lines · Borislav Petkov
Quoted 5 lines · Eric DeVolder
Quoted 3 lines
"But on a plain simple laptop or workstation which has CPU hotplug, would it make sense for the crash ranges to get updated too when CPUs are offlined?
Yes, it does.
Why?
Technically the answer is no; cpu hotplug events are independent of memory hotplug events, but both are written into the elfcorehdr, so in reality yes... The elfcorehdr contains a single list of Phdrs describing CPUs and crash memory ranges; the entire list is re-written on a hotplug change.
Eric
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec
Borislav Petkov
maintainerRe: [PATCH v13 7/7] x86/crash: add x86 crash hotplug support
Quoted 4 lines · Eric DeVolder
Technically the answer is no; cpu hotplug events are independent of memory hotplug events, but both are written into the elfcorehdr, so in reality yes... The elfcorehdr contains a single list of Phdrs describing CPUs and crash memory ranges; the entire list is re-written on a hotplug change.
Then technically also yes. Otherwise your crash information will contain wrong CPU numbers.
How has that not been a problem until now...?
I.e., offline a bunch of CPUs and then cause a crash dump.
Hmm.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH v13 7/7] x86/crash: add x86 crash hotplug support
Quoted 6 lines · Borislav Petkov
Quoted 4 lines · Eric DeVolder
Technically the answer is no; cpu hotplug events are independent of memory hotplug events, but both are written into the elfcorehdr, so in reality yes... The elfcorehdr contains a single list of Phdrs describing CPUs and crash memory ranges; the entire list is re-written on a hotplug change.
Quoted 9 lines
Then technically also yes. Otherwise your crash information will contain wrong CPU numbers.
How has that not been a problem until now...?
I.e., offline a bunch of CPUs and then cause a crash dump.
Hmm.
There is a solution for updating the elfcorehdr today, for when say a bunch of CPUs are offlined. It is done via userspace udev rules to do a unload-then-reload of the entire crash kernel system (kernel, initrd, purgatory, boot_params, and of course elfcorehdr). This performs extremely poorly in highly dynamic hotplug situations (such as when adding alot of memory to a vm), and thus the attempt at this solution.
But I sense I missing your point?
Thanks!
eric
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec
Borislav Petkov
maintainerRe: [PATCH v13 7/7] x86/crash: add x86 crash hotplug support
Quoted 1 line · Eric DeVolder
But I sense I missing your point?
No no, you're spot on. So moving that into the kernel and making it more robust is always a good thing.
Thx.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH v13 7/7] x86/crash: add x86 crash hotplug support
In reply to Borislav PetkovQuoted 15 lines · Borislav Petkov
Quoted 4 lines · Eric DeVolder
As I'm re-reading that message, I suspect now the preference is to just to strike this ifdiffery line in this file and have the code always present?
If the preference is actually for
CRASH_HOTPLUG, then let me know.Well, it is this part:
"But on a plain simple laptop or workstation which has CPU hotplug, would it make sense for the crash ranges to get updated too when CPUs are offlined?
If so, I think you want this code present there too, without a
Kconfigitem."
Quoted 7 lines
IOW, if this thing doesn't make sense to have on the majority of machines out there - and memory hotplug machines are not the majority - then it should be behind a
Kconfigitem which is default off and gets enabled only when the user selects crash and memory hotplug...I'd say.
Boris,
I apologize for the delay in responding, I've been away for the past week.
I'm re-reading the thread on this topic, and I apologize for backing up a bit, but as I read the last paragraph again, your contention is that the bit of code in this file *should* be behind a Kconfig item, and default to off, as "memory hotplug machines are not the majority".
Does this mean then that I need to introduce CRASH_HOTPLUG again, so it can be default off?
Examining arch/x86/configs/x86_64_defconfig, neither HOTPLUG_CPU or MEMORY_HOTPLUG are present, but CONFIG_SMP=y.
And in examining arch/x86/Kconfig, I see:
config HOTPLUG_CPU
def_bool y
depends on SMP
which then defaults HOTPLUG_CPU to on and thus this code/ifdef in question.
And as a reminder, the '#if defined(CONFIG_HOTPLUG_CPU) || defined(CONFIG_MEMORY_HOTPLUG)' shows up in only three locations: include/linux/kexec.h, kernel/crash_core.c and arch/x86/kernel/crash.c.
And we resolved in this thread last week that this patch series is useful for cpu and/or memory hotplug.
So at this point, I'm still not sure if you want the ifdef line:
- removed altogether
- transitioned to CRASH_HOTPLUG
- leave as is
If I could get clarity on that, that would be much appreciated! Thanks!
eric
Borislav Petkov
maintainerRe: [PATCH v13 7/7] x86/crash: add x86 crash hotplug support
Quoted 2 lines · Eric DeVolder
...
which then defaultsHOTPLUG_CPUto on and thus this code/ifdef in question.
defconfig can sometimes lag reality. In this case, the majority of machines have SMP=y because the majority of machines out there are, well, multicore.
Quoted 4 lines
So at this point, I'm still not sure if you want the ifdef line:
- removed altogether
- transitioned toCRASH_HOTPLUG
- leave as is
So let's think out loud:
* the majority of machines will have CONFIG_HOTPLUG_CPU=y because they're SMP machines and we want the elfcorehdr updates to happen when CPUs get offlined or onlined.
CONFIG_MEMORY_HOTPLUG is most likely going to be =n on the majority of machines out there.
(Note how the deciding factor for all this is what would make sense on the prevailing majority of machines out there.)
And memory hotplug will be off for the simple reason that not so many machines have memory hotplug hardware capability.
Which then means, IMHO, this functionality should be separate: have a CPU hotplug callback and a memory hotplug callback.
And you kinda do that in
Subject: [PATCH v13 3/7] crash: add generic infrastructure for crash hotplug support
but then this all calls into a single handle_hotplug_event() and that hp_action doesn't really matter.
It is used in the call to
arch_crash_handle_hotplug_event(image, hp_action);
but that hp_action argument is unused in the x86 version.
IOW, you can do this callback regardless whether it is a CPU or memory hotplug event.
So thinking about it, a single CONFIG_CRASH_HOTPLUG which unifies those CPU and memory hotplug callback functionality makes most sense to me. Because you don't really differentiate between the two in the callback actions.
Anyway, this is how I see it from here. I could very well be missing an aspect, of course.
Thx.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH v13 7/7] x86/crash: add x86 crash hotplug support
Quoted 51 lines · Borislav Petkov
Quoted 2 lines · Eric DeVolder
...
which then defaultsHOTPLUG_CPUto on and thus this code/ifdef in question.defconfig can sometimes lag reality. In this case, the majority of machines have SMP=y because the majority of machines out there are, well, multicore.
Quoted 4 lines
So at this point, I'm still not sure if you want the ifdef line:
- removed altogether
- transitioned toCRASH_HOTPLUG
- leave as isSo let's think out loud:
* the majority of machines will have
CONFIG_HOTPLUG_CPU=ybecause they're SMP machines and we want the elfcorehdr updates to happen when CPUs get offlined or onlined.
CONFIG_MEMORY_HOTPLUGis most likely going to be =n on the majority of machines out there.(Note how the deciding factor for all this is what would make sense on the prevailing majority of machines out there.)
And memory hotplug will be off for the simple reason that not so many machines have memory hotplug hardware capability.
Which then means, IMHO, this functionality should be separate: have a CPU hotplug callback and a memory hotplug callback.
And you kinda do that in
Subject: [PATCH v13 3/7] crash: add generic infrastructure for crash hotplug support
but then this all calls into a single
handle_hotplug_event()and thathp_actiondoesn't really matter.It is used in the call to
arch_crash_handle_hotplug_event(image, hp_action);but that
hp_actionargument is unused in the x86 version. > IOW, you can do this callback regardless whether it is a CPU or memory hotplug event.So thinking about it, a single
CONFIG_CRASH_HOTPLUGwhich unifies those CPU and memory hotplug callback functionality makes most sense to me. Because you don't really differentiate between the two in the callback actions.
Quoted 5 lines
Anyway, this is how I see it from here. I could very well be missing an aspect, of course.
Thx.
OK, I'll put in CRASH_HOTPLUG! Expect v14 soon!
Thank you!
eric