From 52efa048a2f33d96c5307770f4806fa46ae6f1a2 Mon Sep 17 00:00:00 2001 From: CentOS Sources Date: Jan 11 2022 17:53:27 +0000 Subject: import crash-8.0.0-4.el9 --- diff --git a/.crash.metadata b/.crash.metadata index 1238fca..5276fe8 100644 --- a/.crash.metadata +++ b/.crash.metadata @@ -1,2 +1,2 @@ -35a06244e58606ebf2b5612fbfcb51301bd5877a SOURCES/crash-7.3.0.tar.gz -026f4c9e1c8152a2773354551c523acd32d7f00e SOURCES/gdb-7.6.tar.gz +692a903aa3cae47cf2c5dbb7fe79ae6e774e3641 SOURCES/crash-8.0.0.tar.gz +6bf5ee7877a4740835745ed97ce525a00bb2232c SOURCES/gdb-10.2.tar.gz diff --git a/.gitignore b/.gitignore index 169176a..7a9c68b 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,2 @@ -SOURCES/crash-7.3.0.tar.gz -SOURCES/gdb-7.6.tar.gz +SOURCES/crash-8.0.0.tar.gz +SOURCES/gdb-10.2.tar.gz diff --git a/SOURCES/0001-Fix-for-kmem-s-S-option-on-Linux-5.7-and-later-kerne.patch b/SOURCES/0001-Fix-for-kmem-s-S-option-on-Linux-5.7-and-later-kerne.patch deleted file mode 100644 index fd8b759..0000000 --- a/SOURCES/0001-Fix-for-kmem-s-S-option-on-Linux-5.7-and-later-kerne.patch +++ /dev/null @@ -1,58 +0,0 @@ -From 647a5c33e1c94054d7b63168cd6c12901591cb77 Mon Sep 17 00:00:00 2001 -From: Lianbo Jiang -Date: Thu, 27 May 2021 18:02:11 +0800 -Subject: [PATCH] Fix for "kmem -s|-S" option on Linux 5.7 and later kernels - -Linux 5.7 and later kernels that contain kernel commit 1ad53d9fa3f6 -("slub: improve bit diffusion for freelist ptr obfuscation") changed -the calculation formula in the freelist_ptr(), which added a swab() -call to mix bits a little more. When kernel is configured with the -"CONFIG_SLAB_FREELIST_HARDENED=y", without the patch, the "kmem -s|-S" -options display wrong statistics and state whether slab objects are -in use or free and can print the following errors: - - crash> kmem -s - CACHE OBJSIZE ALLOCATED TOTAL SLABS SSIZE NAME - 87201e00 528 0 0 0 8k xfs_dqtrx - 87201f00 496 0 0 0 8k xfs_dquot - kmem: xfs_buf: slab: 37202e6e900 invalid freepointer: b844bab900001d70 - kmem: xfs_buf: slab: 3720250fd80 invalid freepointer: b8603f9400001370 - ... - -Signed-off-by: Lianbo Jiang ---- - memory.c | 9 +++++++-- - 1 file changed, 7 insertions(+), 2 deletions(-) - -diff --git a/memory.c b/memory.c -index 8c6bbe409922..a3cf8a86728d 100644 ---- a/memory.c -+++ b/memory.c -@@ -20,6 +20,7 @@ - #include - #include - #include -+#include - - struct meminfo { /* general purpose memory information structure */ - ulong cache; /* used by the various memory searching/dumping */ -@@ -19336,10 +19337,14 @@ count_free_objects(struct meminfo *si, ulong freelist) - static ulong - freelist_ptr(struct meminfo *si, ulong ptr, ulong ptr_addr) - { -- if (VALID_MEMBER(kmem_cache_random)) -+ if (VALID_MEMBER(kmem_cache_random)) { - /* CONFIG_SLAB_FREELIST_HARDENED */ -+ -+ if (THIS_KERNEL_VERSION >= LINUX(5,7,0)) -+ ptr_addr = (sizeof(long) == 8) ? bswap_64(ptr_addr) -+ : bswap_32(ptr_addr); - return (ptr ^ si->random ^ ptr_addr); -- else -+ } else - return ptr; - } - --- -2.30.2 - diff --git a/SOURCES/0001-Fix-pvops-Xen-detection-for-arm-machine.patch b/SOURCES/0001-Fix-pvops-Xen-detection-for-arm-machine.patch new file mode 100644 index 0000000..c085a34 --- /dev/null +++ b/SOURCES/0001-Fix-pvops-Xen-detection-for-arm-machine.patch @@ -0,0 +1,69 @@ +From 7eba220e1a7d443cad6716dd83d4953ffd62d566 Mon Sep 17 00:00:00 2001 +From: Qi Zheng +Date: Tue, 21 Dec 2021 15:40:31 +0800 +Subject: [PATCH 1/2] Fix pvops Xen detection for arm machine + +Since the xen_start_info on the arm/arm64 platform points to a static +variable '_xen_start_info'(see its definition as below), which makes +that the address of xen_start_info will never be null. + +arch/arm/xen/enlighten.c:40:static struct start_info _xen_start_info; +arch/arm/xen/enlighten.c:41:struct start_info *xen_start_info = &_xen_start_info; +arch/arm/xen/enlighten.c:42:EXPORT_SYMBOL(xen_start_info); + +As a result, the is_pvops_xen() in commit 4badc6229c69 ("Fix pvops +Xen detection for kernels >= v4.20") always returns TRUE because it +can always read out the non-null address of xen_start_info, finally +the following error will be reported on arm/arm64 platform(non-Xen +environment) because p2m_mid_missing and xen_p2m_addr are not defined: + + crash: cannot resolve "p2m_top" + +For the arm/arm64 platform, fix it by using xen_vcpu_info instead of +xen_start_info to detect Xen dumps. + +In addition, also explicitly narrow the scope of the xen_start_info +check to x86 with the machine_type(), there is no need to check it on +other architectures. + +Fixes: 4badc6229c69 ("Fix pvops Xen detection for kernels >= v4.20") +Signed-off-by: Qi Zheng +Acked-by: Kazuhito Hagio +--- + kernel.c | 20 +++++++++++++++----- + 1 file changed, 15 insertions(+), 5 deletions(-) + +diff --git a/kernel.c b/kernel.c +index f4598ea217a3..37b7af74ed2e 100644 +--- a/kernel.c ++++ b/kernel.c +@@ -10757,11 +10757,21 @@ is_pvops_xen(void) + STREQ(sym, "paravirt_patch_default"))) + return TRUE; + +- if (symbol_exists("xen_start_info") && +- readmem(symbol_value("xen_start_info"), KVADDR, &addr, +- sizeof(void *), "xen_start_info", RETURN_ON_ERROR) && +- addr != 0) +- return TRUE; ++ if (machine_type("X86") || machine_type("X86_64")) { ++ if (symbol_exists("xen_start_info") && ++ readmem(symbol_value("xen_start_info"), KVADDR, &addr, ++ sizeof(void *), "xen_start_info", RETURN_ON_ERROR) && ++ addr != 0) ++ return TRUE; ++ } ++ ++ if (machine_type("ARM") || machine_type("ARM64")) { ++ if (symbol_exists("xen_vcpu_info") && ++ readmem(symbol_value("xen_vcpu_info"), KVADDR, &addr, ++ sizeof(void *), "xen_vcpu_info", RETURN_ON_ERROR) && ++ addr != 0) ++ return TRUE; ++ } + + return FALSE; + } +-- +2.20.1 + diff --git a/SOURCES/0001-Handle-task_struct-state-member-changes-for-kernels-.patch b/SOURCES/0001-Handle-task_struct-state-member-changes-for-kernels-.patch deleted file mode 100644 index ef66c25..0000000 --- a/SOURCES/0001-Handle-task_struct-state-member-changes-for-kernels-.patch +++ /dev/null @@ -1,76 +0,0 @@ -From 8f8314dcaad34983d1d7b8f828a9dad65ae4073d Mon Sep 17 00:00:00 2001 -From: Alexander Egorenkov -Date: Tue, 29 Jun 2021 08:39:00 +0200 -Subject: [PATCH] Handle task_struct state member changes for kernels >= - 5.14-rc1 - -Kernel commit 2f064a59a11ff9bc22e52e9678bc601404c7cb34 ("sched: Change -task_struct::state") renamed the member state of task_struct to __state -and its type changed from long to unsigned int. Without the patch, -crash fails to start up with the following error: - - crash: invalid structure member offset: task_struct_state - FILE: task.c LINE: 5929 FUNCTION: task_state() - -Signed-off-by: Alexander Egorenkov ---- - defs.h | 1 + - symbols.c | 1 + - task.c | 10 +++++++++- - 3 files changed, 11 insertions(+), 1 deletion(-) - -diff --git a/defs.h b/defs.h -index 68d29bd28719..a3f6aa3a7ad5 100644 ---- a/defs.h -+++ b/defs.h -@@ -2300,6 +2300,7 @@ struct size_table { /* stash of commonly-used sizes */ - long printk_info; - long printk_ringbuffer; - long prb_desc; -+ long task_struct_state; - }; - - struct array_table { -diff --git a/symbols.c b/symbols.c -index 370d4c3e8ac0..af1741f44777 100644 ---- a/symbols.c -+++ b/symbols.c -@@ -10672,6 +10672,7 @@ dump_offset_table(char *spec, ulong makestruct) - SIZE(page_cache_bucket)); - fprintf(fp, " pt_regs: %ld\n", SIZE(pt_regs)); - fprintf(fp, " task_struct: %ld\n", SIZE(task_struct)); -+ fprintf(fp, " task_struct_state: %ld\n", SIZE(task_struct_state)); - fprintf(fp, " task_struct_flags: %ld\n", SIZE(task_struct_flags)); - fprintf(fp, " task_struct_policy: %ld\n", SIZE(task_struct_policy)); - fprintf(fp, " thread_info: %ld\n", SIZE(thread_info)); -diff --git a/task.c b/task.c -index 36cf259e5d7b..672b41697e75 100644 ---- a/task.c -+++ b/task.c -@@ -297,6 +297,11 @@ task_init(void) - } - - MEMBER_OFFSET_INIT(task_struct_state, "task_struct", "state"); -+ MEMBER_SIZE_INIT(task_struct_state, "task_struct", "state"); -+ if (INVALID_MEMBER(task_struct_state)) { -+ MEMBER_OFFSET_INIT(task_struct_state, "task_struct", "__state"); -+ MEMBER_SIZE_INIT(task_struct_state, "task_struct", "__state"); -+ } - MEMBER_OFFSET_INIT(task_struct_exit_state, "task_struct", "exit_state"); - MEMBER_OFFSET_INIT(task_struct_pid, "task_struct", "pid"); - MEMBER_OFFSET_INIT(task_struct_comm, "task_struct", "comm"); -@@ -5926,7 +5931,10 @@ task_state(ulong task) - if (!tt->last_task_read) - return 0; - -- state = ULONG(tt->task_struct + OFFSET(task_struct_state)); -+ if (SIZE(task_struct_state) == sizeof(ulong)) -+ state = ULONG(tt->task_struct + OFFSET(task_struct_state)); -+ else -+ state = UINT(tt->task_struct + OFFSET(task_struct_state)); - exit_state = VALID_MEMBER(task_struct_exit_state) ? - ULONG(tt->task_struct + OFFSET(task_struct_exit_state)) : 0; - --- -2.30.2 - diff --git a/SOURCES/0001-arm64-Support-overflow-stack-panic.patch b/SOURCES/0001-arm64-Support-overflow-stack-panic.patch new file mode 100644 index 0000000..310c55e --- /dev/null +++ b/SOURCES/0001-arm64-Support-overflow-stack-panic.patch @@ -0,0 +1,379 @@ +From 995db8ab88916b6397676b67be98c0a4f82cca49 Mon Sep 17 00:00:00 2001 +From: Hong YANG +Date: Mon, 15 Nov 2021 15:41:01 +0800 +Subject: [PATCH 1/3] arm64: Support overflow stack panic + +Kernel commit <872d8327ce89> ("arm64: add VMAP_STACK overflow detection") +has supported the overflow stack exception handling. Without the patch, the +"bt" command will make crash generate a core dump because of segmentation +fault. With the patch, the "bt" command can display the overflow stack. + +Before: +crash> bt +PID: 3607 TASK: ffffffcbf9a4da00 CPU: 2 COMMAND: "sh" +Segmentation fault (core dumped) + +After: +crash> bt +PID: 3607 TASK: ffffffcbf9a4da00 CPU: 2 COMMAND: "sh" + #0 [ffffffccbfd85f50] __delay at ffffff8008ceded8 +... + #5 [ffffffccbfd85fd0] emergency_restart at ffffff80080d49fc + #6 [ffffffccbfd86140] panic at ffffff80080af4c0 + #7 [ffffffccbfd86150] nmi_panic at ffffff80080af150 + #8 [ffffffccbfd86190] handle_bad_stack at ffffff800808b0b8 + #9 [ffffffccbfd862d0] __bad_stack at ffffff800808285c + PC: ffffff8008082e80 [el1_sync] + LR: ffffff8000d6c214 [stack_overflow_demo+84] + SP: ffffff1a79930070 PSTATE: 204003c5 + X29: ffffff8011b03d00 X28: ffffffcbf9a4da00 X27: ffffff8008e02000 + X26: 0000000000000040 X25: 0000000000000124 X24: ffffffcbf9a4da00 + X23: 0000007daec2e288 X22: ffffffcbfe03b800 X21: 0000007daec2e288 + X20: 0000000000000002 X19: 0000000000000002 X18: 0000000000000002 + X17: 00000000000003e7 X16: 0000000000000000 X15: 0000000000000000 + X14: ffffffcc17facb00 X13: ffffffccb4c25c00 X12: 0000000000000000 + X11: ffffffcc17fad660 X10: 0000000000000af0 X9: 0000000000000000 + X8: ffffff1a799334f0 X7: 0000000000000000 X6: 000000000000003f + X5: 0000000000000040 X4: 0000000000000010 X3: 00000065981d07f0 + X2: 00000065981d07f0 X1: 0000000000000000 X0: ffffff1a799334f0 + +Signed-off-by: Hong YANG +--- + arm64.c | 169 ++++++++++++++++++++++++++++++++++++++++++++++++++------ + defs.h | 6 ++ + 2 files changed, 159 insertions(+), 16 deletions(-) + +diff --git a/arm64.c b/arm64.c +index 94681d1a37db..23c3d75d85aa 100644 +--- a/arm64.c ++++ b/arm64.c +@@ -45,6 +45,7 @@ static int arm64_vtop_3level_4k(ulong, ulong, physaddr_t *, int); + static int arm64_vtop_4level_4k(ulong, ulong, physaddr_t *, int); + static ulong arm64_get_task_pgd(ulong); + static void arm64_irq_stack_init(void); ++static void arm64_overflow_stack_init(void); + static void arm64_stackframe_init(void); + static int arm64_eframe_search(struct bt_info *); + static int arm64_is_kernel_exception_frame(struct bt_info *, ulong); +@@ -63,6 +64,7 @@ static int arm64_get_dumpfile_stackframe(struct bt_info *, struct arm64_stackfra + static int arm64_in_kdump_text(struct bt_info *, struct arm64_stackframe *); + static int arm64_in_kdump_text_on_irq_stack(struct bt_info *); + static int arm64_switch_stack(struct bt_info *, struct arm64_stackframe *, FILE *); ++static int arm64_switch_stack_from_overflow(struct bt_info *, struct arm64_stackframe *, FILE *); + static int arm64_get_stackframe(struct bt_info *, struct arm64_stackframe *); + static void arm64_get_stack_frame(struct bt_info *, ulong *, ulong *); + static void arm64_gen_hidden_frame(struct bt_info *bt, ulong, struct arm64_stackframe *); +@@ -78,8 +80,11 @@ static int arm64_get_smp_cpus(void); + static void arm64_clear_machdep_cache(void); + static int arm64_on_process_stack(struct bt_info *, ulong); + static int arm64_in_alternate_stack(int, ulong); ++static int arm64_in_alternate_stackv(int cpu, ulong stkptr, ulong *stacks, ulong stack_size); + static int arm64_on_irq_stack(int, ulong); ++static int arm64_on_overflow_stack(int, ulong); + static void arm64_set_irq_stack(struct bt_info *); ++static void arm64_set_overflow_stack(struct bt_info *); + static void arm64_set_process_stack(struct bt_info *); + static int arm64_get_kvaddr_ranges(struct vaddr_range *); + static void arm64_get_crash_notes(void); +@@ -463,6 +468,7 @@ arm64_init(int when) + machdep->hz = 100; + + arm64_irq_stack_init(); ++ arm64_overflow_stack_init(); + arm64_stackframe_init(); + break; + +@@ -1715,6 +1721,49 @@ arm64_irq_stack_init(void) + } + } + ++/* ++ * Gather Overflow stack values. ++ * ++ * Overflow stack supported since 4.14, in commit 872d8327c ++ */ ++static void ++arm64_overflow_stack_init(void) ++{ ++ int i; ++ struct syment *sp; ++ struct gnu_request request, *req; ++ struct machine_specific *ms = machdep->machspec; ++ req = &request; ++ ++ if (symbol_exists("overflow_stack") && ++ (sp = per_cpu_symbol_search("overflow_stack")) && ++ get_symbol_type("overflow_stack", NULL, req)) { ++ if (CRASHDEBUG(1)) { ++ fprintf(fp, "overflow_stack: \n"); ++ fprintf(fp, " type: %x, %s\n", ++ (int)req->typecode, ++ (req->typecode == TYPE_CODE_ARRAY) ? ++ "TYPE_CODE_ARRAY" : "other"); ++ fprintf(fp, " target_typecode: %x, %s\n", ++ (int)req->target_typecode, ++ req->target_typecode == TYPE_CODE_INT ? ++ "TYPE_CODE_INT" : "other"); ++ fprintf(fp, " target_length: %ld\n", ++ req->target_length); ++ fprintf(fp, " length: %ld\n", req->length); ++ } ++ ++ if (!(ms->overflow_stacks = (ulong *)malloc((size_t)(kt->cpus * sizeof(ulong))))) ++ error(FATAL, "cannot malloc overflow_stack addresses\n"); ++ ++ ms->overflow_stack_size = ARM64_OVERFLOW_STACK_SIZE; ++ machdep->flags |= OVERFLOW_STACKS; ++ ++ for (i = 0; i < kt->cpus; i++) ++ ms->overflow_stacks[i] = kt->__per_cpu_offset[i] + sp->value; ++ } ++} ++ + /* + * Gather and verify all of the backtrace requirements. + */ +@@ -1960,6 +2009,7 @@ static char *arm64_exception_functions[] = { + "do_mem_abort", + "do_el0_irq_bp_hardening", + "do_sp_pc_abort", ++ "handle_bad_stack", + NULL + }; + +@@ -1978,7 +2028,10 @@ arm64_in_exception_text(ulong ptr) + if ((ptr >= ms->__exception_text_start) && + (ptr < ms->__exception_text_end)) + return TRUE; +- } else if ((name = closest_symbol(ptr))) { /* Linux 5.5 and later */ ++ } ++ ++ name = closest_symbol(ptr); ++ if (name != NULL) { /* Linux 5.5 and later */ + for (func = &arm64_exception_functions[0]; *func; func++) { + if (STREQ(name, *func)) + return TRUE; +@@ -2252,15 +2305,14 @@ arm64_unwind_frame(struct bt_info *bt, struct arm64_stackframe *frame) + if ((frame->fp == 0) && (frame->pc == 0)) + return FALSE; + +- if (!(machdep->flags & IRQ_STACKS)) +- return TRUE; +- +- if (!(machdep->flags & IRQ_STACKS)) ++ if (!(machdep->flags & (IRQ_STACKS | OVERFLOW_STACKS))) + return TRUE; + + if (machdep->flags & UNW_4_14) { +- if ((bt->flags & BT_IRQSTACK) && +- !arm64_on_irq_stack(bt->tc->processor, frame->fp)) { ++ if (((bt->flags & BT_IRQSTACK) && ++ !arm64_on_irq_stack(bt->tc->processor, frame->fp)) || ++ ((bt->flags & BT_OVERFLOW_STACK) && ++ !arm64_on_overflow_stack(bt->tc->processor, frame->fp))) { + if (arm64_on_process_stack(bt, frame->fp)) { + arm64_set_process_stack(bt); + +@@ -2677,6 +2729,9 @@ arm64_back_trace_cmd(struct bt_info *bt) + if (arm64_on_irq_stack(bt->tc->processor, bt->frameptr)) { + arm64_set_irq_stack(bt); + bt->flags |= BT_IRQSTACK; ++ } else if (arm64_on_overflow_stack(bt->tc->processor, bt->frameptr)) { ++ arm64_set_overflow_stack(bt); ++ bt->flags |= BT_OVERFLOW_STACK; + } + stackframe.sp = bt->stkptr; + stackframe.pc = bt->instptr; +@@ -2731,7 +2786,9 @@ arm64_back_trace_cmd(struct bt_info *bt) + break; + + if (arm64_in_exception_text(bt->instptr) && INSTACK(stackframe.fp, bt)) { +- if (!(bt->flags & BT_IRQSTACK) || ++ if (bt->flags & BT_OVERFLOW_STACK) { ++ exception_frame = stackframe.fp - KERN_EFRAME_OFFSET; ++ } else if (!(bt->flags & BT_IRQSTACK) || + ((stackframe.sp + SIZE(pt_regs)) < bt->stacktop)) { + if (arm64_is_kernel_exception_frame(bt, stackframe.fp - KERN_EFRAME_OFFSET)) + exception_frame = stackframe.fp - KERN_EFRAME_OFFSET; +@@ -2745,6 +2802,12 @@ arm64_back_trace_cmd(struct bt_info *bt) + break; + } + ++ if ((bt->flags & BT_OVERFLOW_STACK) && ++ !arm64_on_overflow_stack(bt->tc->processor, stackframe.fp)) { ++ bt->flags &= ~BT_OVERFLOW_STACK; ++ if (arm64_switch_stack_from_overflow(bt, &stackframe, ofp) == USER_MODE) ++ break; ++ } + + level++; + } +@@ -3131,6 +3194,43 @@ arm64_switch_stack(struct bt_info *bt, struct arm64_stackframe *frame, FILE *ofp + return KERNEL_MODE; + } + ++static int ++arm64_switch_stack_from_overflow(struct bt_info *bt, struct arm64_stackframe *frame, FILE *ofp) ++{ ++ int i; ++ ulong stacktop, words, addr; ++ ulong *stackbuf; ++ char buf[BUFSIZE]; ++ struct machine_specific *ms = machdep->machspec; ++ ++ if (bt->flags & BT_FULL) { ++ stacktop = ms->overflow_stacks[bt->tc->processor] + ms->overflow_stack_size; ++ words = (stacktop - bt->bptr) / sizeof(ulong); ++ stackbuf = (ulong *)GETBUF(words * sizeof(ulong)); ++ readmem(bt->bptr, KVADDR, stackbuf, words * sizeof(long), ++ "top of overflow stack", FAULT_ON_ERROR); ++ ++ addr = bt->bptr; ++ for (i = 0; i < words; i++) { ++ if (!(i & 1)) ++ fprintf(ofp, "%s %lx: ", i ? "\n" : "", addr); ++ fprintf(ofp, "%s ", format_stack_entry(bt, buf, stackbuf[i], 0)); ++ addr += sizeof(ulong); ++ } ++ fprintf(ofp, "\n"); ++ FREEBUF(stackbuf); ++ } ++ fprintf(ofp, "--- ---\n"); ++ ++ if (frame->fp == 0) ++ return USER_MODE; ++ ++ if (!(machdep->flags & UNW_4_14)) ++ arm64_print_exception_frame(bt, frame->sp, KERNEL_MODE, ofp); ++ ++ return KERNEL_MODE; ++} ++ + static int + arm64_get_dumpfile_stackframe(struct bt_info *bt, struct arm64_stackframe *frame) + { +@@ -3682,6 +3782,16 @@ arm64_display_machine_stats(void) + machdep->machspec->irq_stacks[i]); + } + } ++ if (machdep->machspec->overflow_stack_size) { ++ fprintf(fp, "OVERFLOW STACK SIZE: %ld\n", ++ machdep->machspec->overflow_stack_size); ++ fprintf(fp, " OVERFLOW STACKS:\n"); ++ for (i = 0; i < kt->cpus; i++) { ++ pad = (i < 10) ? 3 : (i < 100) ? 2 : (i < 1000) ? 1 : 0; ++ fprintf(fp, "%s CPU %d: %lx\n", space(pad), i, ++ machdep->machspec->overflow_stacks[i]); ++ } ++ } + } + + static int +@@ -3875,24 +3985,41 @@ arm64_on_process_stack(struct bt_info *bt, ulong stkptr) + } + + static int +-arm64_on_irq_stack(int cpu, ulong stkptr) ++arm64_in_alternate_stackv(int cpu, ulong stkptr, ulong *stacks, ulong stack_size) + { +- return arm64_in_alternate_stack(cpu, stkptr); ++ if ((cpu >= kt->cpus) || (stacks == NULL) || !stack_size) ++ return FALSE; ++ ++ if ((stkptr >= stacks[cpu]) && ++ (stkptr < (stacks[cpu] + stack_size))) ++ return TRUE; ++ ++ return FALSE; + } + + static int + arm64_in_alternate_stack(int cpu, ulong stkptr) ++{ ++ return (arm64_on_irq_stack(cpu, stkptr) || ++ arm64_on_overflow_stack(cpu, stkptr)); ++} ++ ++static int ++arm64_on_irq_stack(int cpu, ulong stkptr) + { + struct machine_specific *ms = machdep->machspec; + +- if (!ms->irq_stack_size || (cpu >= kt->cpus)) +- return FALSE; ++ return arm64_in_alternate_stackv(cpu, stkptr, ++ ms->irq_stacks, ms->irq_stack_size); ++} + +- if ((stkptr >= ms->irq_stacks[cpu]) && +- (stkptr < (ms->irq_stacks[cpu] + ms->irq_stack_size))) +- return TRUE; ++static int ++arm64_on_overflow_stack(int cpu, ulong stkptr) ++{ ++ struct machine_specific *ms = machdep->machspec; + +- return FALSE; ++ return arm64_in_alternate_stackv(cpu, stkptr, ++ ms->overflow_stacks, ms->overflow_stack_size); + } + + static void +@@ -3905,6 +4032,16 @@ arm64_set_irq_stack(struct bt_info *bt) + alter_stackbuf(bt); + } + ++static void ++arm64_set_overflow_stack(struct bt_info *bt) ++{ ++ struct machine_specific *ms = machdep->machspec; ++ ++ bt->stackbase = ms->overflow_stacks[bt->tc->processor]; ++ bt->stacktop = bt->stackbase + ms->overflow_stack_size; ++ alter_stackbuf(bt); ++} ++ + static void + arm64_set_process_stack(struct bt_info *bt) + { +diff --git a/defs.h b/defs.h +index a2f30853a4b1..7e2a16e34a59 100644 +--- a/defs.h ++++ b/defs.h +@@ -3218,6 +3218,7 @@ typedef signed int s32; + #define UNW_4_14 (0x200) + #define FLIPPED_VM (0x400) + #define HAS_PHYSVIRT_OFFSET (0x800) ++#define OVERFLOW_STACKS (0x1000) + + /* + * Get kimage_voffset from /dev/crash +@@ -3260,6 +3261,7 @@ typedef signed int s32; + + #define ARM64_STACK_SIZE (16384) + #define ARM64_IRQ_STACK_SIZE ARM64_STACK_SIZE ++#define ARM64_OVERFLOW_STACK_SIZE (4096) + + #define _SECTION_SIZE_BITS 30 + #define _SECTION_SIZE_BITS_5_12 27 +@@ -3332,6 +3334,9 @@ struct machine_specific { + char *irq_stackbuf; + ulong __irqentry_text_start; + ulong __irqentry_text_end; ++ ulong overflow_stack_size; ++ ulong *overflow_stacks; ++ char *overflow_stackbuf; + /* for exception vector code */ + ulong exp_entry1_start; + ulong exp_entry1_end; +@@ -5770,6 +5775,7 @@ ulong cpu_map_addr(const char *type); + #define BT_CPUMASK (0x1000000000000ULL) + #define BT_SHOW_ALL_REGS (0x2000000000000ULL) + #define BT_REGS_NOT_FOUND (0x4000000000000ULL) ++#define BT_OVERFLOW_STACK (0x8000000000000ULL) + #define BT_SYMBOL_OFFSET (BT_SYMBOLIC_ARGS) + + #define BT_REF_HEXVAL (0x1) +-- +2.30.2 + diff --git a/SOURCES/0001-arm64-rename-ARM64_PAGE_OFFSET_ACTUAL-to-ARM64_FLIP_.patch b/SOURCES/0001-arm64-rename-ARM64_PAGE_OFFSET_ACTUAL-to-ARM64_FLIP_.patch deleted file mode 100644 index 6d91794..0000000 --- a/SOURCES/0001-arm64-rename-ARM64_PAGE_OFFSET_ACTUAL-to-ARM64_FLIP_.patch +++ /dev/null @@ -1,61 +0,0 @@ -From 5719afc7a40868418405a87a2711088556e68a3b Mon Sep 17 00:00:00 2001 -From: Pingfan Liu -Date: Fri, 2 Jul 2021 10:14:21 +0800 -Subject: [PATCH 1/4] arm64: rename ARM64_PAGE_OFFSET_ACTUAL to - ARM64_FLIP_PAGE_OFFSET_ACTUAL - -Reflect the flipped layout of kernel VA, which is introduced by -kernel commit 14c127c957c1 ("arm64: mm: Flip kernel VA space"). - -Signed-off-by: Pingfan Liu ---- - arm64.c | 10 ++++++---- - defs.h | 3 ++- - 2 files changed, 8 insertions(+), 5 deletions(-) - -diff --git a/arm64.c b/arm64.c -index 8934961..9fe1a4a 100644 ---- a/arm64.c -+++ b/arm64.c -@@ -217,10 +217,12 @@ arm64_init(int when) - arm64_calc_VA_BITS(); - arm64_calc_KERNELPACMASK(); - ms = machdep->machspec; -+ -+ /* vabits_actual introduced after mm flip, so it should be flipped layout */ - if (ms->VA_BITS_ACTUAL) { -- ms->page_offset = ARM64_PAGE_OFFSET_ACTUAL; -- machdep->identity_map_base = ARM64_PAGE_OFFSET_ACTUAL; -- machdep->kvbase = ARM64_PAGE_OFFSET_ACTUAL; -+ ms->page_offset = ARM64_FLIP_PAGE_OFFSET_ACTUAL; -+ machdep->identity_map_base = ARM64_FLIP_PAGE_OFFSET_ACTUAL; -+ machdep->kvbase = ARM64_FLIP_PAGE_OFFSET_ACTUAL; - ms->userspace_top = ARM64_USERSPACE_TOP_ACTUAL; - } else { - ms->page_offset = ARM64_PAGE_OFFSET; -@@ -401,7 +403,7 @@ arm64_init(int when) - fprintf(fp, "CONFIG_ARM64_VA_BITS: %ld\n", ms->CONFIG_ARM64_VA_BITS); - fprintf(fp, " VA_BITS_ACTUAL: %ld\n", ms->VA_BITS_ACTUAL); - fprintf(fp, "(calculated) VA_BITS: %ld\n", ms->VA_BITS); -- fprintf(fp, " PAGE_OFFSET: %lx\n", ARM64_PAGE_OFFSET_ACTUAL); -+ fprintf(fp, " PAGE_OFFSET: %lx\n", ARM64_FLIP_PAGE_OFFSET_ACTUAL); - fprintf(fp, " VA_START: %lx\n", ms->VA_START); - fprintf(fp, " modules: %lx - %lx\n", ms->modules_vaddr, ms->modules_end); - fprintf(fp, " vmalloc: %lx - %lx\n", ms->vmalloc_start_addr, ms->vmalloc_end); -diff --git a/defs.h b/defs.h -index 5d32954..eb7ce6a 100644 ---- a/defs.h -+++ b/defs.h -@@ -3233,7 +3233,8 @@ typedef signed int s32; - - #define ARM64_PAGE_OFFSET ((0xffffffffffffffffUL) \ - << (machdep->machspec->VA_BITS - 1)) --#define ARM64_PAGE_OFFSET_ACTUAL ((0xffffffffffffffffUL) \ -+/* kernels >= v5.4 the kernel VA space is flipped */ -+#define ARM64_FLIP_PAGE_OFFSET_ACTUAL ((0xffffffffffffffffUL) \ - - ((1UL) << machdep->machspec->VA_BITS_ACTUAL) + 1) - - #define ARM64_USERSPACE_TOP ((1UL) << machdep->machspec->VA_BITS) --- -2.29.2 - diff --git a/SOURCES/0001-memory-Add-support-for-SECTION_TAINT_ZONE_DEVICE-fla.patch b/SOURCES/0001-memory-Add-support-for-SECTION_TAINT_ZONE_DEVICE-fla.patch deleted file mode 100644 index fe76553..0000000 --- a/SOURCES/0001-memory-Add-support-for-SECTION_TAINT_ZONE_DEVICE-fla.patch +++ /dev/null @@ -1,101 +0,0 @@ -From 0b5435e10161345cf713ed447a155a611a1b408b Mon Sep 17 00:00:00 2001 -From: Kazuhito Hagio -Date: Wed, 26 May 2021 17:33:13 +0900 -Subject: [PATCH 1/2] memory: Add support for SECTION_TAINT_ZONE_DEVICE flag - -Fix for "kmem -n|-p" options on Linux 5.12-rc1 and later kernels -that contain commit 1f90a3477df3f ("mm: teach pfn_to_online_page() -about ZONE_DEVICE section collisions"). Without the patch, the -"kmem -n" option incorrectly shows mem_map addresses containing the -flag in bit 5 as part of the virtual address, and also the "kmem -p" -option shows page structures at wrong position. With the patch, -the "kmem -n" option displays the new "D" state flag. - -Without the patch: - crash> kmem -n - ... - NR SECTION CODED_MEM_MAP MEM_MAP STATE PFN - 1040 ffff9edf3ffd4100 ffffe2bcc0000010 ffffe2bd42000010 PMOE 34078720 - ^ ^ - crash> kmem -p - PAGE PHYSICAL MAPPING INDEX CNT FLAGS - ffffe2bd42000010 2080000000 400040 1ffffffff 9961471 dead000000000122 referenced,active,error - ffffe2bd42000050 2080001000 800080 1ffffffff 9961471 dead000000000122 referenced,active,error - ffffe2bd42000090 2080002000 0 1ffffffff 9961471 dead000000000122 referenced,active,error - ^^ -With the patch: - crash> kmem -n - ... - NR SECTION CODED_MEM_MAP MEM_MAP STATE PFN - 1040 ffff9edf3ffd4100 ffffe2bcc0000000 ffffe2bd42000000 PMOED 34078720 - - crash> kmem -p - PAGE PHYSICAL MAPPING INDEX CNT FLAGS - ffffe2bd42000000 2080000000 ffff9ebfc0044100 0 1 97ffffc0000200 slab - ffffe2bd42000040 2080001000 ffff9ebfc0044400 0 1 97ffffc0000200 slab - ffffe2bd42000080 2080002000 0 0 1 97ffffc0000000 - -Signed-off-by: Kazuhito Hagio ---- - help.c | 11 +++++++---- - memory.c | 15 +++++++++------ - 2 files changed, 16 insertions(+), 10 deletions(-) - -diff --git a/help.c b/help.c -index e0c84087add3..9649cc81fa36 100644 ---- a/help.c -+++ b/help.c -@@ -6584,10 +6584,13 @@ char *help_kmem[] = { - " kernels, the vm_zone_stat, vm_node_stat and vm_numa_stat tables,", - " the cumulative page_states counter values if they exist, and/or ", - " the cumulative, vm_event_states counter values if they exist.", --" -n display memory node, memory section, and memory block data", --" and state; the state of each memory section state is encoded", --" as \"P\", \"M\", \"O\" and/or \"E\", meaning SECTION_MARKED_PRESENT,", --" SECTION_HAS_MEM_MAP, SECTION_IS_ONLINE and SECTION_IS_EARLY.", -+" -n display memory node, memory section, memory block data and state;", -+" the state of each memory section is shown as the following flags:", -+" \"P\": SECTION_MARKED_PRESENT", -+" \"M\": SECTION_HAS_MEM_MAP", -+" \"O\": SECTION_IS_ONLINE", -+" \"E\": SECTION_IS_EARLY", -+" \"D\": SECTION_TAINT_ZONE_DEVICE", - " -z displays per-zone memory statistics.", - " -o displays each cpu's offset value that is added to per-cpu symbol", - " values to translate them into kernel virtual addresses.", -diff --git a/memory.c b/memory.c -index a3cf8a86728d..2c4f9790f498 100644 ---- a/memory.c -+++ b/memory.c -@@ -17270,12 +17270,13 @@ nr_to_section(ulong nr) - * which results in PFN_SECTION_SHIFT equal 6. - * To sum it up, at least 6 bits are available. - */ --#define SECTION_MARKED_PRESENT (1UL<<0) --#define SECTION_HAS_MEM_MAP (1UL<<1) --#define SECTION_IS_ONLINE (1UL<<2) --#define SECTION_IS_EARLY (1UL<<3) --#define SECTION_MAP_LAST_BIT (1UL<<4) --#define SECTION_MAP_MASK (~(SECTION_MAP_LAST_BIT-1)) -+#define SECTION_MARKED_PRESENT (1UL<<0) -+#define SECTION_HAS_MEM_MAP (1UL<<1) -+#define SECTION_IS_ONLINE (1UL<<2) -+#define SECTION_IS_EARLY (1UL<<3) -+#define SECTION_TAINT_ZONE_DEVICE (1UL<<4) -+#define SECTION_MAP_LAST_BIT (1UL<<5) -+#define SECTION_MAP_MASK (~(SECTION_MAP_LAST_BIT-1)) - - - int -@@ -17373,6 +17374,8 @@ fill_mem_section_state(ulong state, char *buf) - bufidx += sprintf(buf + bufidx, "%s", "O"); - if (state & SECTION_IS_EARLY) - bufidx += sprintf(buf + bufidx, "%s", "E"); -+ if (state & SECTION_TAINT_ZONE_DEVICE) -+ bufidx += sprintf(buf + bufidx, "%s", "D"); - } - - void --- -2.30.2 - diff --git a/SOURCES/0002-Handle-blk_mq_ctx-member-changes-for-kernels-5.16-rc.patch b/SOURCES/0002-Handle-blk_mq_ctx-member-changes-for-kernels-5.16-rc.patch new file mode 100644 index 0000000..fb8a27b --- /dev/null +++ b/SOURCES/0002-Handle-blk_mq_ctx-member-changes-for-kernels-5.16-rc.patch @@ -0,0 +1,101 @@ +From 98b417fc63467339b919ef6d322c1893d6d55f86 Mon Sep 17 00:00:00 2001 +From: Lianbo Jiang +Date: Fri, 24 Dec 2021 18:56:35 +0800 +Subject: [PATCH 2/2] Handle blk_mq_ctx member changes for kernels 5.16-rc1 and + later + +Kernel commit 9a14d6ce4135 ("block: remove debugfs blk_mq_ctx +dispatched/merged/completed attributes") removed the member +rq_dispatched and rq_completed from struct blk_mq_ctx. Without +the patch, "dev -d|-D" options will fail with the following error: + +crash> dev -d +MAJOR GENDISK NAME REQUEST_QUEUE TOTAL ASYNC SYNC + +dev: invalid structure member offset: blk_mq_ctx_rq_dispatched + FILE: dev.c LINE: 4229 FUNCTION: get_one_mctx_diskio() + +Signed-off-by: Lianbo Jiang +Signed-off-by: Kazuhito Hagio +--- + dev.c | 57 +++++++++++++++++++++++++++++++++++++++------------------ + 1 file changed, 39 insertions(+), 18 deletions(-) + +diff --git a/dev.c b/dev.c +index effe789f38d8..a493e51ac95c 100644 +--- a/dev.c ++++ b/dev.c +@@ -4246,6 +4246,10 @@ get_mq_diskio(unsigned long q, unsigned long *mq_count) + unsigned long mctx_addr; + struct diskio tmp; + ++ if (INVALID_MEMBER(blk_mq_ctx_rq_dispatched) || ++ INVALID_MEMBER(blk_mq_ctx_rq_completed)) ++ return; ++ + memset(&tmp, 0x00, sizeof(struct diskio)); + + readmem(q + OFFSET(request_queue_queue_ctx), KVADDR, &queue_ctx, +@@ -4475,24 +4479,41 @@ display_one_diskio(struct iter *i, unsigned long gendisk, ulong flags) + && (io.read + io.write == 0)) + return; + +- fprintf(fp, "%s%s%s %s%s%s%s %s%5d%s%s%s%s%s", +- mkstring(buf0, 5, RJUST|INT_DEC, (char *)(unsigned long)major), +- space(MINSPACE), +- mkstring(buf1, VADDR_PRLEN, LJUST|LONG_HEX, (char *)gendisk), +- space(MINSPACE), +- mkstring(buf2, 10, LJUST, disk_name), +- space(MINSPACE), +- mkstring(buf3, VADDR_PRLEN <= 11 ? 11 : VADDR_PRLEN, +- LJUST|LONG_HEX, (char *)queue_addr), +- space(MINSPACE), +- io.read + io.write, +- space(MINSPACE), +- mkstring(buf4, 5, RJUST|INT_DEC, +- (char *)(unsigned long)io.read), +- space(MINSPACE), +- mkstring(buf5, 5, RJUST|INT_DEC, +- (char *)(unsigned long)io.write), +- space(MINSPACE)); ++ if (use_mq_interface(queue_addr) && ++ (INVALID_MEMBER(blk_mq_ctx_rq_dispatched) || ++ INVALID_MEMBER(blk_mq_ctx_rq_completed))) ++ fprintf(fp, "%s%s%s %s%s%s%s %s%s%s", ++ mkstring(buf0, 5, RJUST|INT_DEC, (char *)(unsigned long)major), ++ space(MINSPACE), ++ mkstring(buf1, VADDR_PRLEN, LJUST|LONG_HEX, (char *)gendisk), ++ space(MINSPACE), ++ mkstring(buf2, 10, LJUST, disk_name), ++ space(MINSPACE), ++ mkstring(buf3, VADDR_PRLEN <= 11 ? 11 : VADDR_PRLEN, ++ LJUST|LONG_HEX, (char *)queue_addr), ++ space(MINSPACE), ++ mkstring(buf4, 17, RJUST, "(not supported)"), ++ space(MINSPACE)); ++ ++ else ++ fprintf(fp, "%s%s%s %s%s%s%s %s%5d%s%s%s%s%s", ++ mkstring(buf0, 5, RJUST|INT_DEC, (char *)(unsigned long)major), ++ space(MINSPACE), ++ mkstring(buf1, VADDR_PRLEN, LJUST|LONG_HEX, (char *)gendisk), ++ space(MINSPACE), ++ mkstring(buf2, 10, LJUST, disk_name), ++ space(MINSPACE), ++ mkstring(buf3, VADDR_PRLEN <= 11 ? 11 : VADDR_PRLEN, ++ LJUST|LONG_HEX, (char *)queue_addr), ++ space(MINSPACE), ++ io.read + io.write, ++ space(MINSPACE), ++ mkstring(buf4, 5, RJUST|INT_DEC, ++ (char *)(unsigned long)io.read), ++ space(MINSPACE), ++ mkstring(buf5, 5, RJUST|INT_DEC, ++ (char *)(unsigned long)io.write), ++ space(MINSPACE)); + + if (VALID_MEMBER(request_queue_in_flight)) { + if (!use_mq_interface(queue_addr)) { +-- +2.20.1 + diff --git a/SOURCES/0002-arm64-assign-page_offset-with-VA_BITS-kernel-configu.patch b/SOURCES/0002-arm64-assign-page_offset-with-VA_BITS-kernel-configu.patch deleted file mode 100644 index 70af173..0000000 --- a/SOURCES/0002-arm64-assign-page_offset-with-VA_BITS-kernel-configu.patch +++ /dev/null @@ -1,56 +0,0 @@ -From 167d37e347fe35c6f7db826e8539e192c4375564 Mon Sep 17 00:00:00 2001 -From: Pingfan Liu -Date: Fri, 2 Jul 2021 10:14:22 +0800 -Subject: [PATCH 2/4] arm64: assign page_offset with VA_BITS kernel - configuration value - -On RHEL9, crash hits a bug when executing "crash /proc/kcore": -seek error: kernel virtual address: ffff6a0f3fff0000 type: "pmd page" - -The kernel virtual address does not vary with vabits_actual, instead, -is determined by configuration value. But crash does not observe this -fact. - -Since vabits_actual related kernel commit is introduced after arm64 -mm layout flip commit, so changes are safe under the condition if -(ms->VA_BITS_ACTUAL), and keep the else branch untouched. - -Signed-off-by: Pingfan Liu ---- - arm64.c | 7 ++++--- - defs.h | 1 + - 2 files changed, 5 insertions(+), 3 deletions(-) - -diff --git a/arm64.c b/arm64.c -index 9fe1a4a..149db36 100644 ---- a/arm64.c -+++ b/arm64.c -@@ -220,9 +220,10 @@ arm64_init(int when) - - /* vabits_actual introduced after mm flip, so it should be flipped layout */ - if (ms->VA_BITS_ACTUAL) { -- ms->page_offset = ARM64_FLIP_PAGE_OFFSET_ACTUAL; -- machdep->identity_map_base = ARM64_FLIP_PAGE_OFFSET_ACTUAL; -- machdep->kvbase = ARM64_FLIP_PAGE_OFFSET_ACTUAL; -+ ms->page_offset = ARM64_FLIP_PAGE_OFFSET; -+ /* useless on arm64 */ -+ machdep->identity_map_base = ARM64_FLIP_PAGE_OFFSET; -+ machdep->kvbase = ARM64_FLIP_PAGE_OFFSET; - ms->userspace_top = ARM64_USERSPACE_TOP_ACTUAL; - } else { - ms->page_offset = ARM64_PAGE_OFFSET; -diff --git a/defs.h b/defs.h -index eb7ce6a..b7b20af 100644 ---- a/defs.h -+++ b/defs.h -@@ -3234,6 +3234,7 @@ typedef signed int s32; - #define ARM64_PAGE_OFFSET ((0xffffffffffffffffUL) \ - << (machdep->machspec->VA_BITS - 1)) - /* kernels >= v5.4 the kernel VA space is flipped */ -+#define ARM64_FLIP_PAGE_OFFSET (-(1UL) << machdep->machspec->CONFIG_ARM64_VA_BITS) - #define ARM64_FLIP_PAGE_OFFSET_ACTUAL ((0xffffffffffffffffUL) \ - - ((1UL) << machdep->machspec->VA_BITS_ACTUAL) + 1) - --- -2.29.2 - diff --git a/SOURCES/0002-defs.h-fix-breakage-of-compatibility-of-struct-machd.patch b/SOURCES/0002-defs.h-fix-breakage-of-compatibility-of-struct-machd.patch new file mode 100644 index 0000000..fdb0cc3 --- /dev/null +++ b/SOURCES/0002-defs.h-fix-breakage-of-compatibility-of-struct-machd.patch @@ -0,0 +1,41 @@ +From c477b04aee34d4f4784c326ed715e91b2c43eb3e Mon Sep 17 00:00:00 2001 +From: HATAYAMA Daisuke +Date: Thu, 9 Dec 2021 01:05:07 +0000 +Subject: [PATCH 2/3] defs.h: fix breakage of compatibility of struct + machdep_table for extension modules + +Commit <2f967fb5ebd7> ("crash_taget: fetch_registers support") added new +member get_cpu_reg in the middle of struct machdep_table, which breaks +compatibility of struct machdep_table for extension modules. As the result, +crash gcore command results in unexpected behavior, furthermore may cause +segmentation fault. + +Fixes: 2f967fb5ebd7 ("crash_taget: fetch_registers support") +Signed-off-by: HATAYAMA Daisuke +--- + defs.h | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/defs.h b/defs.h +index 7e2a16e34a59..7d3ed78fcd23 100644 +--- a/defs.h ++++ b/defs.h +@@ -1013,7 +1013,6 @@ struct machdep_table { + ulong (*processor_speed)(void); + int (*uvtop)(struct task_context *, ulong, physaddr_t *, int); + int (*kvtop)(struct task_context *, ulong, physaddr_t *, int); +- int (*get_cpu_reg)(int, int, const char *, int, void *); + ulong (*get_task_pgd)(ulong); + void (*dump_irq)(int); + void (*get_stack_frame)(struct bt_info *, ulong *, ulong *); +@@ -1063,6 +1062,7 @@ struct machdep_table { + void (*get_irq_affinity)(int); + void (*show_interrupts)(int, ulong *); + int (*is_page_ptr)(ulong, physaddr_t *); ++ int (*get_cpu_reg)(int, int, const char *, int, void *); + }; + + /* +-- +2.30.2 + diff --git a/SOURCES/0002-memory-Fix-for-kmem-n-option-to-display-NID-correctl.patch b/SOURCES/0002-memory-Fix-for-kmem-n-option-to-display-NID-correctl.patch deleted file mode 100644 index 6ac3c71..0000000 --- a/SOURCES/0002-memory-Fix-for-kmem-n-option-to-display-NID-correctl.patch +++ /dev/null @@ -1,48 +0,0 @@ -From ec44b902d3467e7b86ee39e2d7d472b9cb202148 Mon Sep 17 00:00:00 2001 -From: Kazuhito Hagio -Date: Mon, 31 May 2021 14:08:28 +0900 -Subject: [PATCH 2/2] memory: Fix for "kmem -n" option to display NID correctly - -The nid member of struct memory_block is a 4-byte integer, but read -and printed as a 8-byte integer on 64-bit machines. Without the -patch, the option displays wrong NIDs. - - crash> kmem -n - ... - MEM_BLOCK NAME PHYSICAL RANGE NODE STATE START_SECTION_NO - ffff9edeff2b9400 memory0 0 - 7fffffff 14195095130662240256 ONLINE 0 - ffff9edeff2bb400 memory2 100000000 - 17fffffff 14195094718345379840 ONLINE 32 - -The issue seems to appear on Linux 5.12 and later kernels that contain -commit e9a2e48e8704c ("drivers/base/memory: don't store phys_device -in memory blocks"), which changed the arrangement of the members of -struct memory_block. - -Signed-off-by: Kazuhito Hagio ---- - memory.c | 4 ++-- - 1 file changed, 2 insertions(+), 2 deletions(-) - -diff --git a/memory.c b/memory.c -index 2c4f9790f498..cbe90eebe748 100644 ---- a/memory.c -+++ b/memory.c -@@ -17568,13 +17568,13 @@ print_memory_block(ulong memory_block) - - if (MEMBER_EXISTS("memory_block", "nid")) { - readmem(memory_block + OFFSET(memory_block_nid), KVADDR, &nid, -- sizeof(void *), "memory_block nid", FAULT_ON_ERROR); -+ sizeof(int), "memory_block nid", FAULT_ON_ERROR); - fprintf(fp, " %s %s %s %s %s %s\n", - mkstring(buf1, VADDR_PRLEN, LJUST|LONG_HEX, - MKSTR(memory_block)), - mkstring(buf2, 12, CENTER, name), - parangebuf, -- mkstring(buf5, strlen("NODE"), CENTER|LONG_DEC, -+ mkstring(buf5, strlen("NODE"), CENTER|INT_DEC, - MKSTR(nid)), - mkstring(buf6, strlen("OFFLINE"), LJUST, - statebuf), --- -2.30.2 - diff --git a/SOURCES/0003-arm64-use-dedicated-bits-to-record-the-VA-space-layo.patch b/SOURCES/0003-arm64-use-dedicated-bits-to-record-the-VA-space-layo.patch deleted file mode 100644 index dfb3067..0000000 --- a/SOURCES/0003-arm64-use-dedicated-bits-to-record-the-VA-space-layo.patch +++ /dev/null @@ -1,83 +0,0 @@ -From bf1379a8b6ff8d6a8fa12978f7194f15f85c4380 Mon Sep 17 00:00:00 2001 -From: Pingfan Liu -Date: Fri, 2 Jul 2021 10:14:23 +0800 -Subject: [PATCH 3/4] arm64: use dedicated bits to record the VA space layout - changes - -arm64 memory layout experiences big changes due to the following kernel -commits in date descending order: - 5. 7bc1a0f9e176 arm64: mm: use single quantity to represent the PA to VA translation - 4. b6d00d47e81a arm64: mm: Introduce 52-bit Kernel VAs - 3. 5383cc6efed1 arm64: mm: Introduce vabits_actual - 2. 14c127c957c1 arm64: mm: Flip kernel VA space - 1. f80fb3a3d508 arm64: add support for kernel ASLR - -For 1, crash has already used NEW_VMEMMAP to trace it. -For 2, crash lacks a flag to tag it and handle it differently. -For 3, two important kernel variables vabits_actual and physvirt_offset -are introduced. -For 4, since it comes immediately after 3, crash-utility does not need -to distinguish it. -For 5, kernel variable phyvirt_offset is removed - -These changes have effects on PTOV()/VTOP() formula. So introducing -two bits HAS_PHYSVIRT_OFFSET and FLIPPED_VM as hint to apply different -formula. - -Signed-off-by: Pingfan Liu ---- - arm64.c | 10 ++++++++++ - defs.h | 2 ++ - 2 files changed, 12 insertions(+) - -diff --git a/arm64.c b/arm64.c -index 149db36..b04369f 100644 ---- a/arm64.c -+++ b/arm64.c -@@ -563,6 +563,10 @@ arm64_dump_machdep_table(ulong arg) - fprintf(fp, "%sMACHDEP_BT_TEXT", others++ ? "|" : ""); - if (machdep->flags & NEW_VMEMMAP) - fprintf(fp, "%sNEW_VMEMMAP", others++ ? "|" : ""); -+ if (machdep->flags & FLIPPED_VM) -+ fprintf(fp, "%sFLIPPED_VM", others++ ? "|" : ""); -+ if (machdep->flags & HAS_PHYSVIRT_OFFSET) -+ fprintf(fp, "%sHAS_PHYSVIRT_OFFSET", others++ ? "|" : ""); - fprintf(fp, ")\n"); - - fprintf(fp, " kvbase: %lx\n", machdep->kvbase); -@@ -997,6 +1001,7 @@ arm64_calc_physvirt_offset(void) - if (READMEM(pc->mfd, &physvirt_offset, sizeof(physvirt_offset), - sp->value, sp->value - - machdep->machspec->kimage_voffset) > 0) { -+ machdep->flags |= HAS_PHYSVIRT_OFFSET; - ms->physvirt_offset = physvirt_offset; - } - } -@@ -3963,6 +3968,11 @@ arm64_calc_VA_BITS(void) - error(FATAL, "cannot determine VA_BITS_ACTUAL\n"); - } - -+ /* -+ * The mm flip commit is introduced before 52-bits VA, which is before the -+ * commit to export NUMBER(TCR_EL1_T1SZ) -+ */ -+ machdep->flags |= FLIPPED_VM; - return; - } - -diff --git a/defs.h b/defs.h -index b7b20af..eca145c 100644 ---- a/defs.h -+++ b/defs.h -@@ -3214,6 +3214,8 @@ typedef signed int s32; - #define NEW_VMEMMAP (0x80) - #define VM_L4_4K (0x100) - #define UNW_4_14 (0x200) -+#define FLIPPED_VM (0x400) -+#define HAS_PHYSVIRT_OFFSET (0x800) - - /* - * Get kimage_voffset from /dev/crash --- -2.29.2 - diff --git a/SOURCES/0003-defs.h-fix-breakage-of-compatibility-of-struct-symbo.patch b/SOURCES/0003-defs.h-fix-breakage-of-compatibility-of-struct-symbo.patch new file mode 100644 index 0000000..91fe99b --- /dev/null +++ b/SOURCES/0003-defs.h-fix-breakage-of-compatibility-of-struct-symbo.patch @@ -0,0 +1,41 @@ +From 6968345893178d2750b8872055498d2a6010a861 Mon Sep 17 00:00:00 2001 +From: HATAYAMA Daisuke +Date: Wed, 8 Dec 2021 12:07:34 +0000 +Subject: [PATCH 3/3] defs.h: fix breakage of compatibility of struct + symbol_table_data for extension modules + +Commit <2fab8fbc0c4f> ("symbols: Implement install and remove operations +for mod_symname_hash") added new member variable mod_symname_hash in the +middle of struct symbol_table_date, which breaks compatibility of struct +symbol_table_data for extension modules. As the result, crash trace command +results in segmentation fault. + +Fixes: 2fab8fbc0c4f ("symbols: Implement install and remove operations for mod_symname_hash") +Signed-off-by: HATAYAMA Daisuke +--- + defs.h | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/defs.h b/defs.h +index 7d3ed78fcd23..b63741c7d78b 100644 +--- a/defs.h ++++ b/defs.h +@@ -2753,7 +2753,6 @@ struct symbol_table_data { + double val_hash_searches; + double val_hash_iterations; + struct syment *symname_hash[SYMNAME_HASH]; +- struct syment *mod_symname_hash[SYMNAME_HASH]; + struct symbol_namespace kernel_namespace; + struct syment *ext_module_symtable; + struct syment *ext_module_symend; +@@ -2780,6 +2779,7 @@ struct symbol_table_data { + ulong kaiser_init_vmlinux; + int kernel_symbol_type; + ulong linux_banner_vmlinux; ++ struct syment *mod_symname_hash[SYMNAME_HASH]; + }; + + /* flags for st */ +-- +2.30.2 + diff --git a/SOURCES/0004-arm64-implement-switchable-PTOV-VTOP-for-kernels-5.1.patch b/SOURCES/0004-arm64-implement-switchable-PTOV-VTOP-for-kernels-5.1.patch deleted file mode 100644 index 8370c09..0000000 --- a/SOURCES/0004-arm64-implement-switchable-PTOV-VTOP-for-kernels-5.1.patch +++ /dev/null @@ -1,165 +0,0 @@ -From f53b73e8380bca054cebd2b61ff118c46609429b Mon Sep 17 00:00:00 2001 -From: Pingfan Liu -Date: Fri, 2 Jul 2021 10:14:24 +0800 -Subject: [PATCH 4/4] arm64: implement switchable PTOV()/VTOP() for kernels >= - 5.10 - -Crash encounters a bug like the following: - ... - SECTION_SIZE_BITS: 30 - CONFIG_ARM64_VA_BITS: 52 - VA_BITS_ACTUAL: 48 - (calculated) VA_BITS: 48 - PAGE_OFFSET: ffff000000000000 - VA_START: ffff800000000000 - modules: ffff800008000000 - ffff80000fffffff - vmalloc: ffff800010000000 - ffffffdfdffeffff - kernel image: ffff800010000000 - ffff800012750000 - vmemmap: ffffffdfffe00000 - ffffffffffffffff - - - - read_netdump: addr: ffff800011c53bc8 paddr: eb453bc8 cnt: 4 offset: 1c73bc8 - irq_stack_ptr: - type: 1, TYPE_CODE_PTR - target_typecode: 8, TYPE_CODE_INT - target_length: 8 - length: 8 - GNU_GET_DATATYPE[thread_union]: returned via gdb_error_hook - - - read_netdump: READ_ERROR: offset not found for paddr: fff1000bf79c0050 - crash: read error: kernel virtual address: ffff000b779c0050 type: "IRQ stack pointer" - ... - -Apparently, for a normal system, the 'paddr: fff1000bf79c0050' is -unreasonable. - -This bug connects with kernel commit 7bc1a0f9e176 ("arm64: mm: use -single quantity to represent the PA to VA translation"), which removed -physvirt_offset kernel variable and changed the PTOV()/VTOP() formulas. - -Implement switchable PTOV()/VTOP() to cope with different kernel -version. - -Signed-off-by: Pingfan Liu ---- - arm64.c | 37 +++++++++++++++++++++++++++++++++---- - defs.h | 9 ++++----- - 2 files changed, 37 insertions(+), 9 deletions(-) - -diff --git a/arm64.c b/arm64.c -index b04369f..d73d5c5 100644 ---- a/arm64.c -+++ b/arm64.c -@@ -994,8 +994,6 @@ arm64_calc_physvirt_offset(void) - ulong physvirt_offset; - struct syment *sp; - -- ms->physvirt_offset = ms->phys_offset - ms->page_offset; -- - if ((sp = kernel_symbol_search("physvirt_offset")) && - machdep->machspec->kimage_voffset) { - if (READMEM(pc->mfd, &physvirt_offset, sizeof(physvirt_offset), -@@ -1003,8 +1001,13 @@ arm64_calc_physvirt_offset(void) - machdep->machspec->kimage_voffset) > 0) { - machdep->flags |= HAS_PHYSVIRT_OFFSET; - ms->physvirt_offset = physvirt_offset; -+ return; - } - } -+ -+ /* Useless if no symbol 'physvirt_offset', just keep semantics */ -+ ms->physvirt_offset = ms->phys_offset - ms->page_offset; -+ - } - - static void -@@ -1051,6 +1054,7 @@ arm64_calc_phys_offset(void) - if (READMEM(pc->mfd, &phys_offset, sizeof(phys_offset), - vaddr, paddr) > 0) { - ms->phys_offset = phys_offset; -+ - return; - } - } -@@ -1178,6 +1182,21 @@ arm64_init_kernel_pgd(void) - vt->kernel_pgd[i] = value; - } - -+ulong arm64_PTOV(ulong paddr) -+{ -+ struct machine_specific *ms = machdep->machspec; -+ -+ /* -+ * Either older kernel before kernel has 'physvirt_offset' or newer -+ * kernel which removes 'physvirt_offset' has the same formula: -+ * #define __phys_to_virt(x) ((unsigned long)((x) - PHYS_OFFSET) | PAGE_OFFSET) -+ */ -+ if (!(machdep->flags & HAS_PHYSVIRT_OFFSET)) -+ return (paddr - ms->phys_offset) | PAGE_OFFSET; -+ else -+ return paddr - ms->physvirt_offset; -+} -+ - ulong - arm64_VTOP(ulong addr) - { -@@ -1188,8 +1207,18 @@ arm64_VTOP(ulong addr) - return addr - machdep->machspec->kimage_voffset; - } - -- if (addr >= machdep->machspec->page_offset) -- return addr + machdep->machspec->physvirt_offset; -+ if (addr >= machdep->machspec->page_offset) { -+ if (machdep->flags & HAS_PHYSVIRT_OFFSET) { -+ return addr + machdep->machspec->physvirt_offset; -+ } else { -+ /* -+ * Either older kernel before kernel has 'physvirt_offset' or newer -+ * kernel which removes 'physvirt_offset' has the same formula: -+ * #define __lm_to_phys(addr) (((addr) & ~PAGE_OFFSET) + PHYS_OFFSET) -+ */ -+ return (addr & ~PAGE_OFFSET) + machdep->machspec->phys_offset; -+ } -+ } - else if (machdep->machspec->kimage_voffset) - return addr - machdep->machspec->kimage_voffset; - else /* no randomness */ -diff --git a/defs.h b/defs.h -index eca145c..c91177a 100644 ---- a/defs.h -+++ b/defs.h -@@ -3092,11 +3092,6 @@ typedef u64 pte_t; - #define _64BIT_ - #define MACHINE_TYPE "ARM64" - --#define PTOV(X) \ -- ((unsigned long)(X) - (machdep->machspec->physvirt_offset)) -- --#define VTOP(X) arm64_VTOP((ulong)(X)) -- - #define USERSPACE_TOP (machdep->machspec->userspace_top) - #define PAGE_OFFSET (machdep->machspec->page_offset) - #define VMALLOC_START (machdep->machspec->vmalloc_start_addr) -@@ -3106,6 +3101,9 @@ typedef u64 pte_t; - #define MODULES_VADDR (machdep->machspec->modules_vaddr) - #define MODULES_END (machdep->machspec->modules_end) - -+#define PTOV(X) arm64_PTOV((ulong)(X)) -+#define VTOP(X) arm64_VTOP((ulong)(X)) -+ - #define IS_VMALLOC_ADDR(X) arm64_IS_VMALLOC_ADDR((ulong)(X)) - - #define PAGEBASE(X) (((ulong)(X)) & (ulong)machdep->pagemask) -@@ -5910,6 +5908,7 @@ void unwind_backtrace(struct bt_info *); - void arm64_init(int); - void arm64_dump_machdep_table(ulong); - ulong arm64_VTOP(ulong); -+ulong arm64_PTOV(ulong); - int arm64_IS_VMALLOC_ADDR(ulong); - ulong arm64_swp_type(ulong); - ulong arm64_swp_offset(ulong); --- -2.29.2 - diff --git a/SOURCES/crash-8.0.0_build.patch b/SOURCES/crash-8.0.0_build.patch new file mode 100644 index 0000000..d857d7f --- /dev/null +++ b/SOURCES/crash-8.0.0_build.patch @@ -0,0 +1,33 @@ +--- crash-8.0.0/Makefile.orig ++++ crash-8.0.0/Makefile +@@ -203,7 +203,7 @@ GDB_FLAGS= + # TARGET_CFLAGS will be configured automatically by configure + TARGET_CFLAGS= + +-CRASH_CFLAGS=-g -D${TARGET} ${TARGET_CFLAGS} ${GDB_FLAGS} ${CFLAGS} ++CRASH_CFLAGS=-g -D${TARGET} ${TARGET_CFLAGS} ${GDB_FLAGS} ${CFLAGS} ${CPPFLAGS} -fPIE + + GPL_FILES= + TAR_FILES=${SOURCE_FILES} Makefile ${GPL_FILES} README .rh_rpm_package crash.8 \ +@@ -233,7 +233,7 @@ all: make_configure + gdb_merge: force + @if [ ! -f ${GDB}/README ]; then \ + make --no-print-directory gdb_unzip; fi +- @echo "${LDFLAGS} -lz -llzo2 -lsnappy -lzstd -ldl -rdynamic" > ${GDB}/gdb/mergelibs ++ @echo "${LDFLAGS} -lz -llzo2 -lsnappy -lzstd -ldl -rdynamic -Wl,-z,now -fPIE" > ${GDB}/gdb/mergelibs + @echo "../../${PROGRAM} ../../${PROGRAM}lib.a" > ${GDB}/gdb/mergeobj + @rm -f ${PROGRAM} + @if [ ! -f ${GDB}/config.status ]; then \ +--- crash-8.0.0/configure.c.orig ++++ crash-8.0.0/configure.c +@@ -810,7 +810,8 @@ build_configure(struct supported_gdb_version *sp) + fprintf(fp2, "%s\n", sp->GDB); + sprintf(target_data.gdb_version, "%s", &sp->GDB[4]); + } else if (strncmp(buf, "LDFLAGS=", strlen("LDFLAGS=")) == 0) { +- fprintf(fp2, "LDFLAGS=%s\n", ldflags ? ldflags : ""); ++ if (ldflags) ++ fprintf(fp2, "LDFLAGS=%s\n", ldflags ? ldflags : ""); + } else + fprintf(fp2, "%s", buf); + + diff --git a/SOURCES/lzo_snappy.patch b/SOURCES/lzo_snappy.patch deleted file mode 100644 index 4075b06..0000000 --- a/SOURCES/lzo_snappy.patch +++ /dev/null @@ -1,22 +0,0 @@ ---- crash-7.3.0/diskdump.c.orig -+++ crash-7.3.0/diskdump.c -@@ -23,6 +23,8 @@ - * GNU General Public License for more details. - */ - -+#define LZO -+#define SNAPPY - #include "defs.h" - #include "diskdump.h" - #include "xen_dom0.h" ---- crash-7.3.0/Makefile.orig -+++ crash-7.3.0/Makefile -@@ -228,7 +228,7 @@ all: make_configure - gdb_merge: force - @if [ ! -f ${GDB}/README ]; then \ - make --no-print-directory gdb_unzip; fi -- @echo "${LDFLAGS} -lz -ldl -rdynamic" > ${GDB}/gdb/mergelibs -+ @echo "${LDFLAGS} -lz -llzo2 -lsnappy -ldl -rdynamic" > ${GDB}/gdb/mergelibs - @echo "../../${PROGRAM} ../../${PROGRAM}lib.a" > ${GDB}/gdb/mergeobj - @rm -f ${PROGRAM} - @if [ ! -f ${GDB}/config.status ]; then \ diff --git a/SOURCES/lzo_snappy_zstd.patch b/SOURCES/lzo_snappy_zstd.patch new file mode 100644 index 0000000..87b51fe --- /dev/null +++ b/SOURCES/lzo_snappy_zstd.patch @@ -0,0 +1,23 @@ +--- crash-8.0.0/Makefile.orig ++++ crash-8.0.0/Makefile +@@ -233,7 +233,7 @@ all: make_configure + gdb_merge: force + @if [ ! -f ${GDB}/README ]; then \ + make --no-print-directory gdb_unzip; fi +- @echo "${LDFLAGS} -lz -ldl -rdynamic" > ${GDB}/gdb/mergelibs ++ @echo "${LDFLAGS} -lz -llzo2 -lsnappy -lzstd -ldl -rdynamic" > ${GDB}/gdb/mergelibs + @echo "../../${PROGRAM} ../../${PROGRAM}lib.a" > ${GDB}/gdb/mergeobj + @rm -f ${PROGRAM} + @if [ ! -f ${GDB}/config.status ]; then \ +--- crash-8.0.0/diskdump.c.orig ++++ crash-8.0.0/diskdump.c +@@ -23,6 +23,9 @@ + * GNU General Public License for more details. + */ + ++#define LZO ++#define SNAPPY ++#define ZSTD + #include "defs.h" + #include "diskdump.h" + #include "xen_dom0.h" diff --git a/SPECS/crash.spec b/SPECS/crash.spec index f7dec71..73967c0 100644 --- a/SPECS/crash.spec +++ b/SPECS/crash.spec @@ -3,29 +3,27 @@ # Summary: Kernel analysis utility for live systems, netdump, diskdump, kdump, LKCD or mcore dumpfiles Name: crash -Version: 7.3.0 -Release: 6%{?dist} +Version: 8.0.0 +Release: 4%{?dist} License: GPLv3 Source0: https://github.com/crash-utility/crash/archive/crash-%{version}.tar.gz -Source1: http://ftp.gnu.org/gnu/gdb/gdb-7.6.tar.gz +Source1: http://ftp.gnu.org/gnu/gdb/gdb-10.2.tar.gz URL: https://crash-utility.github.io ExclusiveOS: Linux ExclusiveArch: %{ix86} ia64 x86_64 ppc ppc64 s390 s390x %{arm} aarch64 ppc64le -BuildRequires: ncurses-devel zlib-devel lzo-devel snappy-devel bison +BuildRequires: ncurses-devel zlib-devel lzo-devel snappy-devel bison texinfo libzstd-devel BuildRequires: gcc gcc-c++ BuildRequires: make Requires: binutils Provides: bundled(libiberty) -Provides: bundled(gdb) = 7.6 -Patch0: lzo_snappy.patch -Patch1: 0001-Fix-for-kmem-s-S-option-on-Linux-5.7-and-later-kerne.patch -Patch2: 0001-memory-Add-support-for-SECTION_TAINT_ZONE_DEVICE-fla.patch -Patch3: 0002-memory-Fix-for-kmem-n-option-to-display-NID-correctl.patch -Patch4: 0001-arm64-rename-ARM64_PAGE_OFFSET_ACTUAL-to-ARM64_FLIP_.patch -Patch5: 0002-arm64-assign-page_offset-with-VA_BITS-kernel-configu.patch -Patch6: 0003-arm64-use-dedicated-bits-to-record-the-VA-space-layo.patch -Patch7: 0004-arm64-implement-switchable-PTOV-VTOP-for-kernels-5.1.patch -Patch8: 0001-Handle-task_struct-state-member-changes-for-kernels-.patch +Provides: bundled(gdb) = 10.2 +Patch0: lzo_snappy_zstd.patch +Patch1: crash-8.0.0_build.patch +Patch2: 0001-arm64-Support-overflow-stack-panic.patch +Patch3: 0002-defs.h-fix-breakage-of-compatibility-of-struct-machd.patch +Patch4: 0003-defs.h-fix-breakage-of-compatibility-of-struct-symbo.patch +Patch5: 0001-Fix-pvops-Xen-detection-for-arm-machine.patch +Patch6: 0002-Handle-blk_mq_ctx-member-changes-for-kernels-5.16-rc.patch %description The core analysis suite is a self-contained tool that can be used to @@ -45,26 +43,18 @@ offered by Mission Critical Linux, or the LKCD kernel patch. %prep %setup -n %{name}-%{version} -q -%patch0 -p1 -b lzo_snappy.patch -%patch1 -p1 +%patch0 -p1 -b lzo_snappy_zstd.patch +%patch1 -p1 -b crash-8.0.0_build.patch %patch2 -p1 %patch3 -p1 %patch4 -p1 %patch5 -p1 %patch6 -p1 -%patch7 -p1 -%patch8 -p1 %build -# This package has an internal copy of GDB which has broken configure code for -# INTDIV0_RAISES_SIGFPE and MUST_REINSTALL_SIGHANDLERS -# Updating that code properly seems nontrivial and best left to the package -# maintainer. -# Disable LTO -%define _lto_cflags %{nil} cp %{SOURCE1} . -make RPMPKG="%{version}-%{release}" CFLAGS="%{optflags}" LDFLAGS="%{build_ldflags}" +make RPMPKG="%{version}-%{release}" CFLAGS="%{optflags}" CXXFLAGS="%{optflags}" LDFLAGS="%{build_ldflags}" %install rm -rf %{buildroot} @@ -85,6 +75,19 @@ cp -p defs.h %{buildroot}%{_includedir}/crash %{_includedir}/* %changelog +* Wed Dec 29 2021 Lianbo Jiang - 8.0.0-4 +- Handle blk_mq_ctx member changes for kernels 5.16-rc1 and later + +* Mon Dec 13 2021 Lianbo Jiang - 8.0.0-3 +- Fix segmentation fault caused by crash extension modules +- Support the overflow stack exception handling on aarch64 + +* Mon Dec 06 2021 Lianbo Jiang - 8.0.0-2 +- Enable ZSTD feature support + +* Thu Nov 25 2021 Lianbo Jiang - 8.0.0-1 +- Rebase to upstream 8.0.0 + * Mon Aug 09 2021 Mohan Boddu - 7.3.0-6 - Rebuilt for IMA sigs, glibc 2.34, aarch64 flags Related: rhbz#1991688