From ef4e24754e9f0d902ed3a51e84667827edb6ff52 Mon Sep 17 00:00:00 2001 From: YangYunYi Date: Sat, 8 Mar 2025 19:02:09 +0800 Subject: [PATCH] fix a potential segfault when unwind frame --- ...0002-crash-add-SDEI-stack-resolution.patch | 357 ++++++++++++++++++ ...potential-segfault-when-unwind-frame.patch | 72 ++++ ...tack-frame-unwind-while-UNW_4_14-is-.patch | 47 +++ SPECS/crash.spec | 10 +- 4 files changed, 485 insertions(+), 1 deletion(-) create mode 100644 SOURCES/0002-crash-add-SDEI-stack-resolution.patch create mode 100644 SOURCES/0003-arm64-fix-a-potential-segfault-when-unwind-frame.patch create mode 100644 SOURCES/0004-arm64-fix-SDEI-stack-frame-unwind-while-UNW_4_14-is-.patch diff --git a/SOURCES/0002-crash-add-SDEI-stack-resolution.patch b/SOURCES/0002-crash-add-SDEI-stack-resolution.patch new file mode 100644 index 0000000..1141a74 --- /dev/null +++ b/SOURCES/0002-crash-add-SDEI-stack-resolution.patch @@ -0,0 +1,357 @@ +From d6722c9009b4fcf4ac61d8982d9618f389a679a3 Mon Sep 17 00:00:00 2001 +From: Jialong Chen +Date: Wed, 5 Jun 2019 21:25:34 +0800 +Subject: [PATCH 1/3] crash: add SDEI stack resolution + +When the NMI dog is called, the kernel stack will switch to the sdei stack. +If the crash reads the stack data, the stack data cannot be parsed normally. + +normal call trace as follows: +PID: 55429 TASK: ffff802772e3ae80 CPU: 19 COMMAND: "insmod" + #0 [ffff00000d4e3c70] __crash_kexec at ffff0000081b4ac0 + #1 [ffff00000d4e3e00] panic at ffff0000080ebd0c + #2 [ffff00000d4e3ee0] nmi_panic at ffff0000080eb864 + #3 [ffff00000d4e3f00] watchdog_hardlockup_check at ffff0000081ecd6c + #4 [ffff00000d4e3f40] sdei_watchdog_callback at ffff0000080a411c + #5 [ffff00000d4e3f60] sdei_event_handler at ffff0000087971ec + #6 [ffff00000d4e3f90] __sdei_handler at ffff000008995964 + #7 [ffff00000d4e3ff0] __sdei_asm_handler at ffff0000080862dc + +Signed-off-by: huwentao +--- + arm64.c | 213 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-- + defs.h | 3 + + 2 files changed, 212 insertions(+), 4 deletions(-) + +diff --git a/arm64.c b/arm64.c +index 2b6b0e5..1aa432b 100644 +--- a/arm64.c ++++ b/arm64.c +@@ -93,6 +93,11 @@ static void arm64_calc_VA_BITS(void); + static int arm64_is_uvaddr(ulong, struct task_context *); + static void arm64_calc_KERNELPACMASK(void); + ++static int arm64_in_sdei_normal_stack(int cpu, ulong stkptr); ++static void arm64_set_sdei_normal_stack(struct bt_info *bt); ++static void arm64_sdei_stack_init(void); ++static int arm64_in_kdump_text_on_sdei_stack(struct bt_info *bt); ++ + struct kernel_range { + unsigned long modules_vaddr, modules_end; + unsigned long vmalloc_start_addr, vmalloc_end; +@@ -528,6 +533,7 @@ arm64_init(int when) + arm64_irq_stack_init(); + arm64_overflow_stack_init(); + arm64_stackframe_init(); ++ arm64_sdei_stack_init(); + break; + + case POST_INIT: +@@ -2169,6 +2175,70 @@ arm64_irq_stack_init(void) + } + } + ++/* ++ * Gather IRQ stack values. ++ */ ++static void ++arm64_sdei_stack_init(void) ++{ ++ int i; ++ struct syment *sp; ++ struct gnu_request request, *req; ++ struct machine_specific *ms = machdep->machspec; ++ ulong p, sz; ++ req = &request; ++ ++ if (symbol_exists("sdei_stack_normal_ptr") && ++ (sp = per_cpu_symbol_search("sdei_stack_normal_ptr")) && ++ get_symbol_type("sdei_stack_normal_ptr", NULL, req)) { ++ /* v4.14 and later with CONFIG_VMAP_STACK enabled */ ++ if (CRASHDEBUG(1)) { ++ fprintf(fp, "sdei_stack_normal_ptr: \n"); ++ fprintf(fp, " type: %x, %s\n", ++ (int)req->typecode, ++ (req->typecode == TYPE_CODE_PTR) ? ++ "TYPE_CODE_PTR" : "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->sdei_stacks = (ulong *)malloc((size_t)(kt->cpus * sizeof(ulong))))) ++ error(FATAL, "cannot malloc irq_stack addresses\n"); ++ ++ /* ++ * Determining the IRQ_STACK_SIZE is tricky, but for now ++ * 4.14 kernel has: ++ * ++ * #define IRQ_STACK_SIZE THREAD_SIZE ++ * ++ * and finding a solid usage of THREAD_SIZE is hard, but: ++ * ++ * union thread_union { ++ * ... ++ * unsigned long stack[THREAD_SIZE/sizeof(long)]; ++ * }; ++ */ ++ if (MEMBER_EXISTS("thread_union", "stack")) { ++ if ((sz = MEMBER_SIZE("thread_union", "stack")) > 0) ++ ms->sdei_stack_size = sz; ++ } else ++ ms->sdei_stack_size = ARM64_IRQ_STACK_SIZE; ++ ++ machdep->flags |= IRQ_STACKS; ++ ++ for (i = 0; i < kt->cpus; i++) { ++ p = kt->__per_cpu_offset[i] + sp->value; ++ readmem(p, KVADDR, &(ms->sdei_stacks[i]), sizeof(ulong), ++ "SDEI stack pointer", RETURN_ON_ERROR); ++ } ++ } ++} ++ + /* + * Gather Overflow stack values. + * +@@ -2737,7 +2807,7 @@ arm64_unwind_frame(struct bt_info *bt, struct arm64_stackframe *frame) + { + unsigned long high, low, fp; + unsigned long stack_mask; +- unsigned long irq_stack_ptr, orig_sp; ++ unsigned long irq_stack_ptr, orig_sp, sdei_stack_ptr; + struct arm64_pt_regs *ptregs; + struct machine_specific *ms = machdep->machspec; + +@@ -2766,7 +2836,8 @@ arm64_unwind_frame(struct bt_info *bt, struct arm64_stackframe *frame) + 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))) { ++ !arm64_on_overflow_stack(bt->tc->processor, frame->fp)) && ++ !arm64_in_sdei_normal_stack(bt->tc->processor, frame->fp)) { + if (arm64_on_process_stack(bt, frame->fp)) { + arm64_set_process_stack(bt); + +@@ -2806,6 +2877,7 @@ arm64_unwind_frame(struct bt_info *bt, struct arm64_stackframe *frame) + * orig_sp = IRQ_STACK_TO_TASK_STACK(irq_stack_ptr); (pt_regs pointer on process stack) + */ + irq_stack_ptr = ms->irq_stacks[bt->tc->processor] + ms->irq_stack_size - 16; ++ sdei_stack_ptr = ms->sdei_stacks[bt->tc->processor] + ms->sdei_stack_size - 16; + + if (frame->sp == irq_stack_ptr) { + orig_sp = GET_STACK_ULONG(irq_stack_ptr - 8); +@@ -2826,6 +2898,25 @@ arm64_unwind_frame(struct bt_info *bt, struct arm64_stackframe *frame) + frame->fp, INSTACK(frame->fp, bt) ? "" : " (?)"); + return FALSE; + } ++ } else if (frame->sp == sdei_stack_ptr) { ++ orig_sp = GET_STACK_ULONG(sdei_stack_ptr - 8); ++ arm64_set_process_stack(bt); ++ if (INSTACK(orig_sp, bt) && (INSTACK(frame->fp, bt) || (frame->fp == 0))) { ++ ptregs = (struct arm64_pt_regs *)&bt->stackbuf[(ulong)(STACK_OFFSET_TYPE(orig_sp))]; ++ frame->sp = orig_sp; ++ frame->pc = ptregs->pc; ++ bt->bptr = fp; ++ if (CRASHDEBUG(1)) ++ error(INFO, ++ "arm64_unwind_frame: switch stacks: fp: %lx sp: %lx pc: %lx\n", ++ frame->fp, frame->sp, frame->pc); ++ } else { ++ error(WARNING, ++ "arm64_unwind_frame: on IRQ stack: oriq_sp: %lx%s fp: %lx%s\n", ++ orig_sp, INSTACK(orig_sp, bt) ? "" : " (?)", ++ frame->fp, INSTACK(frame->fp, bt) ? "" : " (?)"); ++ return FALSE; ++ } + } + + return TRUE; +@@ -3165,6 +3256,10 @@ arm64_back_trace_cmd(struct bt_info *bt) + arm64_set_irq_stack(bt); + bt->flags |= BT_IRQSTACK; + } ++ if (arm64_in_sdei_normal_stack(bt->tc->processor, bt->bptr)) { ++ arm64_set_sdei_normal_stack(bt); ++ bt->flags |= BT_IRQSTACK; ++ } + stackframe.fp = GET_STACK_ULONG(bt->bptr - 8); + stackframe.pc = GET_STACK_ULONG(bt->bptr); + stackframe.sp = bt->bptr + 8; +@@ -3174,6 +3269,10 @@ arm64_back_trace_cmd(struct bt_info *bt) + arm64_set_irq_stack(bt); + bt->flags |= BT_IRQSTACK; + } ++ if (arm64_in_sdei_normal_stack(bt->tc->processor, bt->bptr)) { ++ arm64_set_sdei_normal_stack(bt); ++ bt->flags |= BT_IRQSTACK; ++ } + stackframe.fp = GET_STACK_ULONG(bt->hp->esp - 8); + stackframe.pc = bt->hp->eip ? + bt->hp->eip : GET_STACK_ULONG(bt->hp->esp); +@@ -3187,6 +3286,10 @@ arm64_back_trace_cmd(struct bt_info *bt) + arm64_set_overflow_stack(bt); + bt->flags |= BT_OVERFLOW_STACK; + } ++ if (arm64_in_sdei_normal_stack(bt->tc->processor, bt->bptr)) { ++ arm64_set_sdei_normal_stack(bt); ++ bt->flags |= BT_IRQSTACK; ++ } + stackframe.sp = bt->stkptr; + stackframe.pc = bt->instptr; + stackframe.fp = bt->frameptr; +@@ -3250,7 +3353,8 @@ arm64_back_trace_cmd(struct bt_info *bt) + } + + if ((bt->flags & BT_IRQSTACK) && +- !arm64_on_irq_stack(bt->tc->processor, stackframe.fp)) { ++ !arm64_on_irq_stack(bt->tc->processor, stackframe.fp) && ++ !arm64_in_sdei_normal_stack(bt->tc->processor, stackframe.fp)) { + bt->flags &= ~BT_IRQSTACK; + if (arm64_switch_stack(bt, &stackframe, ofp) == USER_MODE) + break; +@@ -3538,6 +3642,81 @@ arm64_in_kdump_text(struct bt_info *bt, struct arm64_stackframe *frame) + return FALSE; + } + ++static int ++arm64_in_kdump_text_on_sdei_stack(struct bt_info *bt) ++{ ++ int cpu; ++ ulong stackbase; ++ char *stackbuf; ++ ulong *ptr, *start, *base; ++ struct machine_specific *ms; ++ ++ if ((machdep->flags & (IRQ_STACKS|KDUMP_ENABLED)) != (IRQ_STACKS|KDUMP_ENABLED)) ++ return FALSE; ++ ++ ms = machdep->machspec; ++ if (!ms->sdei_stacks) ++ return FALSE; ++ cpu = bt->tc->processor; ++ stackbase = ms->sdei_stacks[cpu]; ++ stackbuf = GETBUF(ms->sdei_stack_size); ++ ++ if (!readmem(stackbase, KVADDR, stackbuf, ++ ms->sdei_stack_size, "IRQ stack contents", RETURN_ON_ERROR)) { ++ error(INFO, "read of IRQ stack at %lx failed\n", stackbase); ++ FREEBUF(stackbuf); ++ return FALSE; ++ } ++ ++ base = (ulong *)stackbuf; ++ start = (ulong *)(stackbuf + ms->sdei_stack_size); ++ ++ for (ptr = start - 8; ptr >= base; ptr--) { ++ if (bt->flags & BT_OPT_BACK_TRACE) { ++ if ((*ptr > ms->crash_kexec_start) && ++ (*ptr < ms->crash_kexec_end) && ++ INSTACK(*(ptr - 1), bt)) { ++ bt->bptr = ((ulong)(ptr - 1) - (ulong)base) + stackbase; ++ if (CRASHDEBUG(1)) ++ fprintf(fp, "%lx: %lx (crash_kexec on IRQ stack)\n", ++ bt->bptr, *ptr); ++ FREEBUF(stackbuf); ++ return TRUE; ++ } ++ if ((*ptr > ms->crash_save_cpu_start) && ++ (*ptr < ms->crash_save_cpu_end) && ++ INSTACK(*(ptr - 1), bt)) { ++ bt->bptr = ((ulong)(ptr - 1) - (ulong)base) + stackbase; ++ if (CRASHDEBUG(1)) ++ fprintf(fp, "%lx: %lx (crash_save_cpu on IRQ stack)\n", ++ bt->bptr, *ptr); ++ FREEBUF(stackbuf); ++ return TRUE; ++ } ++ } else { ++ if ((*ptr > ms->crash_kexec_start) && (*ptr < ms->crash_kexec_end)) { ++ bt->bptr = ((ulong)ptr - (ulong)base) + stackbase; ++ if (CRASHDEBUG(1)) ++ fprintf(fp, "%lx: %lx (crash_kexec on IRQ stack)\n", ++ bt->bptr, *ptr); ++ FREEBUF(stackbuf); ++ return TRUE; ++ } ++ if ((*ptr > ms->crash_save_cpu_start) && (*ptr < ms->crash_save_cpu_end)) { ++ bt->bptr = ((ulong)ptr - (ulong)base) + stackbase; ++ if (CRASHDEBUG(1)) ++ fprintf(fp, "%lx: %lx (crash_save_cpu on IRQ stack)\n", ++ bt->bptr, *ptr); ++ FREEBUF(stackbuf); ++ return TRUE; ++ } ++ } ++ } ++ ++ FREEBUF(stackbuf); ++ return FALSE; ++} ++ + static int + arm64_in_kdump_text_on_irq_stack(struct bt_info *bt) + { +@@ -3728,7 +3907,8 @@ try_kernel: + } + + if (arm64_in_kdump_text(bt, frame) || +- arm64_in_kdump_text_on_irq_stack(bt)) { ++ arm64_in_kdump_text_on_irq_stack(bt) || ++ arm64_in_kdump_text_on_sdei_stack(bt)) { + bt->flags |= BT_KDUMP_ADJUST; + if (skip && is_idle_thread(bt->task)) + bt->flags |= BT_SKIP_IDLE; +@@ -4489,6 +4669,31 @@ arm64_on_overflow_stack(int cpu, ulong stkptr) + ms->overflow_stacks, ms->overflow_stack_size); + } + ++static int ++arm64_in_sdei_normal_stack(int cpu, ulong stkptr) ++{ ++ struct machine_specific *ms = machdep->machspec; ++ ++ if (!ms->sdei_stack_size || (cpu >= kt->cpus)) ++ return FALSE; ++ ++ if ((stkptr > ms->sdei_stacks[cpu]) && ++ (stkptr < (ms->sdei_stacks[cpu] + ms->sdei_stack_size))) ++ return TRUE; ++ ++ return FALSE; ++} ++ ++static void ++arm64_set_sdei_normal_stack(struct bt_info *bt) ++{ ++ struct machine_specific *ms = machdep->machspec; ++ ++ bt->stackbase = ms->sdei_stacks[bt->tc->processor]; ++ bt->stacktop = bt->stackbase + ms->sdei_stack_size; ++ alter_stackbuf(bt); ++} ++ + static void + arm64_set_irq_stack(struct bt_info *bt) + { +diff --git a/defs.h b/defs.h +index 10116f1..2d1ef9a 100644 +--- a/defs.h ++++ b/defs.h +@@ -3468,6 +3468,9 @@ struct machine_specific { + ulong irq_stack_size; + ulong *irq_stacks; + char *irq_stackbuf; ++ ulong sdei_stack_size; ++ ulong *sdei_stacks; ++ char *sdei_stackbuf; + ulong __irqentry_text_start; + ulong __irqentry_text_end; + ulong overflow_stack_size; +-- +2.33.0 + diff --git a/SOURCES/0003-arm64-fix-a-potential-segfault-when-unwind-frame.patch b/SOURCES/0003-arm64-fix-a-potential-segfault-when-unwind-frame.patch new file mode 100644 index 0000000..cc2b350 --- /dev/null +++ b/SOURCES/0003-arm64-fix-a-potential-segfault-when-unwind-frame.patch @@ -0,0 +1,72 @@ +From 1d47af39ee7d789b73a863342c95e5208058eb56 Mon Sep 17 00:00:00 2001 +From: "qiwu.chen" +Date: Wed, 24 Jul 2024 01:36:09 +0000 +Subject: [PATCH 2/3] arm64: fix a potential segfault when unwind frame + +The range of frame->fp is checked insufficiently, which may lead to a wrong +next fp. As a result, bt->stackbuf will be accessed out of range, and segfault. + + crash> bt + [Detaching after fork from child process 11409] + PID: 7661 TASK: ffffff81858aa500 CPU: 4 COMMAND: "sh" + #0 [ffffffc008003f50] local_cpu_stop at ffffffdd7669444c + + Thread 1 "crash" received signal SIGSEGV, Segmentation fault. + 0x00005555558266cc in arm64_unwind_frame (bt=0x7fffffffd8f0, frame=0x7fffffffd080) at + arm64.c:2821 + 2821 frame->fp = GET_STACK_ULONG(fp); + (gdb) bt + arm64.c:2821 + out>) at main.c:1338 + gdb_interface.c:81 + (gdb) p /x *(struct bt_info*) 0x7fffffffd8f0 + $3 = {task = 0xffffff81858aa500, flags = 0x0, instptr = 0xffffffdd76694450, stkptr = + 0xffffffc008003f40, bptr = 0x0, stackbase = 0xffffffc027288000, + stacktop = 0xffffffc02728c000, stackbuf = 0x555556115a40, tc = 0x55559d16fdc0, hp = 0x0, + textlist = 0x0, ref = 0x0, frameptr = 0xffffffc008003f50, + call_target = 0x0, machdep = 0x0, debug = 0x0, eframe_ip = 0x0, radix = 0x0, cpumask = + 0x0} + (gdb) p /x *(struct arm64_stackframe*) 0x7fffffffd080 + $4 = {fp = 0xffffffc008003f50, sp = 0xffffffc008003f60, pc = 0xffffffdd76694450} + crash> bt -S 0xffffffc008003f50 + PID: 7661 TASK: ffffff81858aa500 CPU: 4 COMMAND: "sh" + bt: non-process stack address for this task: ffffffc008003f50 + (valid range: ffffffc027288000 - ffffffc02728c000) + +Check frame->fp value sufficiently before access it. Only frame->fp within +the range of bt->stackbase and bt->stacktop will be regarded as valid. + +Signed-off-by: qiwu.chen + +Conflict: NA +Reference: https://github.com/crash-utility/crash/commit/af895b219876b293d551e6dec825aba3905c0588 +Signed-off-by: huwentao +--- + arm64.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/arm64.c b/arm64.c +index 1aa432b..cea65e4 100644 +--- a/arm64.c ++++ b/arm64.c +@@ -2817,7 +2817,7 @@ arm64_unwind_frame(struct bt_info *bt, struct arm64_stackframe *frame) + low = frame->sp; + high = (low + stack_mask) & ~(stack_mask); + +- if (fp < low || fp > high || fp & 0xf) ++ if (fp < low || fp > high || fp & 0xf || !INSTACK(fp, bt)) + return FALSE; + + frame->sp = fp + 0x10; +@@ -3048,7 +3048,7 @@ arm64_unwind_frame_v2(struct bt_info *bt, struct arm64_stackframe *frame, + low = frame->sp; + high = (low + stack_mask) & ~(stack_mask); + +- if (fp < low || fp > high || fp & 0xf) ++ if (fp < low || fp > high || fp & 0xf || !INSTACK(fp, bt)) + return FALSE; + + if (CRASHDEBUG(1)) +-- +2.33.0 + diff --git a/SOURCES/0004-arm64-fix-SDEI-stack-frame-unwind-while-UNW_4_14-is-.patch b/SOURCES/0004-arm64-fix-SDEI-stack-frame-unwind-while-UNW_4_14-is-.patch new file mode 100644 index 0000000..06f22d3 --- /dev/null +++ b/SOURCES/0004-arm64-fix-SDEI-stack-frame-unwind-while-UNW_4_14-is-.patch @@ -0,0 +1,47 @@ +From 0f95903fe96de4e8599b11c6b2cb73b7dd5a751e Mon Sep 17 00:00:00 2001 +From: Xiaoguang Wang +Date: Thu, 7 Nov 2024 14:40:07 +0800 +Subject: [PATCH 3/3] arm64: fix SDEI stack frame unwind while UNW_4_14 is set + +Fix two bugs: + 1) If BT_IRQSTACK is set, both irq_stack and sdei_normal_stack need + to be checked while switching to process stack. + 2) Use bt->frameptr in arm64_unwind_frame() just like irq stack. + +Fixes: 442da89f4898 ("crash: add SDEI stack resolution") +Signed-off-by: Xiaoguang Wang +Signed-off-by: huwentao +--- + arm64.c | 8 ++++---- + 1 file changed, 4 insertions(+), 4 deletions(-) + +diff --git a/arm64.c b/arm64.c +index cea65e4..b79505a 100644 +--- a/arm64.c ++++ b/arm64.c +@@ -2834,10 +2834,10 @@ arm64_unwind_frame(struct bt_info *bt, struct arm64_stackframe *frame) + + if (machdep->flags & UNW_4_14) { + if (((bt->flags & BT_IRQSTACK) && +- !arm64_on_irq_stack(bt->tc->processor, frame->fp)) || ++ !arm64_on_irq_stack(bt->tc->processor, frame->fp) && ++ !arm64_in_sdei_normal_stack(bt->tc->processor, frame->fp)) || + ((bt->flags & BT_OVERFLOW_STACK) && +- !arm64_on_overflow_stack(bt->tc->processor, frame->fp)) && +- !arm64_in_sdei_normal_stack(bt->tc->processor, frame->fp)) { ++ !arm64_on_overflow_stack(bt->tc->processor, frame->fp))) { + if (arm64_on_process_stack(bt, frame->fp)) { + arm64_set_process_stack(bt); + +@@ -3286,7 +3286,7 @@ arm64_back_trace_cmd(struct bt_info *bt) + arm64_set_overflow_stack(bt); + bt->flags |= BT_OVERFLOW_STACK; + } +- if (arm64_in_sdei_normal_stack(bt->tc->processor, bt->bptr)) { ++ if (arm64_in_sdei_normal_stack(bt->tc->processor, bt->frameptr)) { + arm64_set_sdei_normal_stack(bt); + bt->flags |= BT_IRQSTACK; + } +-- +2.33.0 + diff --git a/SPECS/crash.spec b/SPECS/crash.spec index e670747..762a32b 100644 --- a/SPECS/crash.spec +++ b/SPECS/crash.spec @@ -1,7 +1,7 @@ Summary: Kernel analysis utility for live systems, netdump, diskdump, kdump, LKCD or mcore dumpfiles Name: crash Version: 8.0.4 -Release: 4%{?dist} +Release: 5%{?dist} License: GPLv3 URL: https://crash-utility.github.io Source0: https://github.com/crash-utility/crash/archive/refs/tags/%{version}.tar.gz @@ -10,6 +10,11 @@ Source1: http://ftp.gnu.org/gnu/gdb/gdb-10.2.tar.gz Patch3001: lzo_snappy_zstd.patch Patch3002: crash-8.0.3_build.patch Patch3003: 0001-crash-8.0.4-add-support-for-loongarch64.patch +Patch3004: 0002-crash-add-SDEI-stack-resolution.patch +Patch3005: 0003-arm64-fix-a-potential-segfault-when-unwind-frame.patch +Patch3006: 0004-arm64-fix-SDEI-stack-frame-unwind-while-UNW_4_14-is-.patch + + ExclusiveArch: x86_64 aarch64 ppc64le loongarch64 BuildRequires: gcc gcc-c++ make bison @@ -65,6 +70,9 @@ cp -p defs.h %{buildroot}%{_includedir}/crash/defs.h %changelog +* Sat Mar 08 2025 huwentao - 8.0.4-5 +- fix a potential segfault when unwind frame + * Thu Sep 26 2024 OpenCloudOS Release Engineering - 8.0.4-4 - Rebuilt for clarifying the packages requirement in BaseOS and AppStream -- Gitee