!169 Fix for 'sys' to properly display the PANIC message

From: @lliuzhi 
Reviewed-by: @dillon_chen 
Signed-off-by: @dillon_chen

0000-lzo_snappy.patch

@@ -0,0 +1,23 @@
+--- crash-8.0.4/diskdump.c.orig
++++ crash-8.0.4/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"
+--- crash-8.0.4/Makefile.orig
++++ crash-8.0.4/Makefile
+@@ -256,7 +256,7 @@ all: make_configure
+ gdb_merge: force
+ 	@if [ ! -f ${GDB}/README ]; then \
+ 	  $(MAKE) 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 \

0001-add-SDEI-stack-resolution.patch

@@ -0,0 +1,369 @@
+From e43071b6ceaa4fe20c65befe1b5685b68dc9f33f Mon Sep 17 00:00:00 2001
+From: Jialong Chen <chenjialong@huawei.com>
+Date: Wed, 5 Jun 2019 21:25:34 +0800
+Subject: [PATCH] crash: add SDEI stack resolution
+reason: The kernel adds NMI dog detection, and the NMI interrupt stack uses a separate SDEI stack.
+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
+--- <IRQ stack> ---
+ #8 [ffff0000ccad3b70] __delay at ffff000008973658
+ #9 [ffff0000ccad3ba0] __const_udelay at ffff0000089735e8
+#10 [ffff0000ccad3bb0] init_module at ffff0000009c6038 [test]
+#11 [ffff0000ccad3bd0] do_one_initcall at ffff000008084ae0
+#12 [ffff0000ccad3c60] do_init_module at ffff0000081b1418
+#13 [ffff0000ccad3c90] load_module at ffff0000081afc54
+#14 [ffff0000ccad3d80] __se_sys_finit_module at ffff0000081b0134
+#15 [ffff0000ccad3e40] __arm64_sys_finit_module at ffff0000081b01a0
+#16 [ffff0000ccad3e60] el0_svc_common at ffff000008097b44
+#17 [ffff0000ccad3ea0] el0_svc_handler at ffff000008097c34
+#18 [ffff0000ccad3ff0] el0_svc at ffff000008084144
+
+Signed-off-by: Jialong Chen <chenjialong@huawei.com>
+---
+ arm64.c | 213 ++++++++++++++++++++++++++++++++++++++++++++++++++++++--
+ defs.h  |   3 +
+ 2 files changed, 212 insertions(+), 4 deletions(-)
+
+diff --git a/arm64.c b/arm64.c
+index c3e26a3..d293e6c 100644
+--- a/arm64.c
++++ b/arm64.c
+@@ -93,6 +93,11 @@ static void arm64_calc_VA_BITS(void);
+ static void arm64_calc_KERNELPACMASK(void);
+ static int arm64_get_vmcoreinfo(unsigned long *vaddr, const char *label, int base);
+
++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;
+@@ -520,6 +525,7 @@ arm64_init(int when)
+ 		arm64_irq_stack_init();
+ 		arm64_overflow_stack_init();
+ 		arm64_stackframe_init();
++		arm64_sdei_stack_init();
+ 		break;
+ 
+ 	case POST_INIT:
+@@ -2174,6 +2180,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.
+  *
+@@ -2736,7 +2806,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;
+ 
+@@ -2765,7 +2835,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);
+ 
+@@ -2805,6 +2876,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);
+@@ -2825,6 +2897,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;
+@@ -3164,6 +3255,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;
+@@ -3173,6 +3268,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);
+@@ -3186,6 +3285,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;
+@@ -3249,7 +3352,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;
+@@ -3537,6 +3641,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)
+ {
+@@ -3727,7 +3906,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;
+@@ -4488,6 +4668,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 afdcf6c..4885d55 100644
+--- a/defs.h
++++ b/defs.h
+@@ -3376,6 +3376,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.27.0
+

0004-arm64-fix-a-potential-segfault-when-unwind-frame.patch

@@ -0,0 +1,72 @@
+From af895b219876b293d551e6dec825aba3905c0588 Mon Sep 17 00:00:00 2001
+From: "qiwu.chen" <qiwu.chen@transsion.com>
+Date: Wed, 24 Jul 2024 01:36:09 +0000
+Subject: [PATCH] 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 <qiwu.chen@transsion.com>
+
+Conflict: NA
+Reference: https://github.com/crash-utility/crash/commit/af895b219876b293d551e6dec825aba3905c0588
+
+---
+ arm64.c | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/arm64.c b/arm64.c
+index b3040d7..624dba2 100644
+--- a/arm64.c
++++ b/arm64.c
+@@ -2814,7 +2814,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;
+@@ -3024,7 +3024,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
+

0005-arm64-fix-SDEI-stack-frame-unwind-while-UNW_4_14-is-.patch

@@ -0,0 +1,46 @@
+From 45685956da58b15d4542d59b95888b1968980c68 Mon Sep 17 00:00:00 2001
+From: Xiaoguang Wang <lege.wang@jaguarmicro.com>
+Date: Thu, 7 Nov 2024 14:40:07 +0800
+Subject: [PATCH] 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 <lege.wang@jaguarmicro.com>
+---
+ arm64.c | 8 ++++----
+ 1 file changed, 4 insertions(+), 4 deletions(-)
+
+diff --git a/arm64.c b/arm64.c
+index b99baa3..34c3b08 100644
+--- a/arm64.c
++++ b/arm64.c
+@@ -3244,10 +3244,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);
+ 
+@@ -3696,7 +3696,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.34.1
+

backport-fix-for-sys-to-properly-display-the-PANIC-m.patch

@@ -0,0 +1,66 @@
+From db0077614aaeda6d0ed557f2b91d3349d5fe430f Mon Sep 17 00:00:00 2001
+From: Austin Kim <austindh.kim@gmail.com>
+Date: Tue, 29 Oct 2024 17:32:07 +0900
+Subject: [PATCH] Fix for 'sys' to properly display the PANIC message
+
+Using 'sys' command, we can view the panic message with general system
+information. If we run RISCV64-based vmcore, PANIC message is not properly
+displayed.
+
+The reason is that the string "Unable to handle kernel" is not
+completely matched with the panic_msg[]. The corresponding kernel commit
+is 21733cb518471.
+
+Without the patch:
+  crash> sys
+        KERNEL: vmlinux  [TAINTED]
+      DUMPFILE: vmcore
+          CPUS: 4
+          DATE: Thu Aug 22 16:13:08 KST 2024
+        UPTIME: 00:33:25
+  LOAD AVERAGE: 0.07, 0.07, 0.02
+         TASKS: 385
+      NODENAME: starfive
+       RELEASE: 6.6.20+
+       VERSION: #13 SMP Mon Aug 19 12:58:52 KST 2024
+       MACHINE: riscv64  (unknown Mhz)
+        MEMORY: 4 GB
+         PANIC: ""
+
+With the patch:
+  crash> sys
+        KERNEL: vmlinux  [TAINTED]
+      DUMPFILE: vmcore
+          CPUS: 4
+          DATE: Thu Aug 22 16:13:08 KST 2024
+        UPTIME: 00:33:25
+  LOAD AVERAGE: 0.07, 0.07, 0.02
+         TASKS: 385
+      NODENAME: starfive
+       RELEASE: 6.6.20+
+       VERSION: #13 SMP Mon Aug 19 12:58:52 KST 2024
+       MACHINE: riscv64  (unknown Mhz)
+        MEMORY: 4 GB
+         PANIC: "Unable to handle kernel access to user memory without uaccess routines at virtual address 0000000000000000"
+
+Signed-off-by: Austin Kim <austindh.kim@gmail.com>
+---
+ task.c | 5 +++++
+ 1 file changed, 5 insertions(+)
+
+diff --git a/task.c b/task.c
+index c131cc32..33de7da2 100644
+--- a/task.c
++++ b/task.c
+@@ -6392,6 +6392,11 @@ get_panicmsg(char *buf)
+ 			get_symbol_data("sysrq_pressed", sizeof(int), &msg_found);
+ 			break;
+ 		}
++
++		/*
++		 *  Try to search panic string in panic keywords
++		 */
++		search_panic_task_by_keywords(buf, &msg_found);
+ 	}
+ 
+ found:

crash.spec

@@ -1,23 +1,28 @@
 Name: crash
-Version: 7.2.9
-Release: 1
+Version: 8.0.5
+Release: 9
 Summary: Linux kernel crash utility.
 License: GPLv3
 URL: https://crash-utility.github.io
-Source0: https://github.com/crash-utility/crash/archive/%{version}.tar.gz
-Source1: http://ftp.gnu.org/gnu/gdb/gdb-7.6.tar.gz
+Source0: https://github.com/crash-utility/crash/archive/refs/tags/%{version}.tar.gz
+Source1: http://ftp.gnu.org/gnu/gdb/gdb-10.2.tar.gz
 
-#Patch0: lzo_snappy.patch
-#Patch1: use_system_readline_v3.patch
+Patch0: 0000-lzo_snappy.patch
+Patch1: 0001-add-SDEI-stack-resolution.patch
+Patch2: 0002-crash-8.0.2-sw.patch
+Patch3: 0003-crash-8.0.4-add-support-for-loongarch64.patch
+Patch4: 0004-arm64-fix-a-potential-segfault-when-unwind-frame.patch
+Patch5: 0005-arm64-fix-SDEI-stack-frame-unwind-while-UNW_4_14-is-.patch
+Patch9001: huawei-fix-ps-error-when-mm_struct.rss_stat-is-lazy-initial.patch
+%ifarch riscv64
+Patch6: backport-fix-for-sys-to-properly-display-the-PANIC-m.patch
+%endif
 
-#Patch9000: add-SDEI-stack-resolution.patch
-#Patch9001: fix-bitmap_len-calculation-overflow-problem-in-large.patch
-
-BuildRequires: ncurses-devel zlib-devel lzo-devel snappy-devel
-BuildRequires: gcc gcc-c++ bison readline-devel
+BuildRequires: ncurses-devel zlib-devel lzo-devel snappy-devel texinfo libzstd-devel 
+BuildRequires: gcc gcc-c++ bison m4
 Requires: binutils
 
-Provides: bundled(libiberty) bundled(gdb) = 7.6
+Provides: bundled(libiberty) bundled(gdb) = 10.2
 
 %description
 The core analysis suite is a self-contained tool that can be used to
@@ -42,11 +47,28 @@ created by manufacturer-specific firmware.
 %package_help
 
 %prep
-%autosetup -n %{name}-%{version} -p1
+%setup -n %{name}-%{version}
+
+%patch 0 -p1 
+%patch 1 -p1 
+
+%ifarch sw_64
+%patch 2 -p1
+%endif
+%ifarch loongarch64
+%patch 3 -p1
+%endif
+
+%patch 4 -p1
+%patch 5 -p1
+%patch 9001 -p1
+%ifarch riscv64
+%patch 6 -p1
+%endif
 
 %build
 cp %{SOURCE1} .
-make RPMPKG="%{version}-%{release}" CFLAGS="%{optflags}" LDFLAGS="%{build_ldflags}"
+make -j`nproc` RPMPKG="%{version}-%{release}" CFLAGS="%{optflags}" CXXFLAGS="%{optflags}" LDFLAGS="%{build_ldflags}"
 
 %install
 rm -rf %{buildroot}
@@ -77,6 +99,105 @@ install -D -m 0644 defs.h %{buildroot}%{_includedir}/%{name}/defs.h
 %{_mandir}/man8/crash.8*
 
 %changelog
+* Mon Jul 14 2025 liuzhilin <liuzhilin@kylinos.cn> - 8.0.5-9
+- backport Fix for 'sys' to properly display the PANIC message patch.
+
+* Wed Jun 04 2025 wangxiao <wangxiao184@h-partners.com> - 8.0.5-8
+- use patch command to apply patches for consistency in context
+
+* Wed May 21 2025 zhangjian <zhangjian496@huawei.com> - 8.0.5-7
+- fix ps error when mm_struct.rss_stat is lazy initialized
+
+* Wed Dec 04 2024 yangzhenyu <dev11101@linx-info.com> - 8.0.5-6
+- remove the architecture judgment in the patches section;
+- include all patches in the source package.
+
+* Wed Nov 20 2024 Xiaoguang Wang <lege.wang@jaguarmicro.com> - 8.0.5-5
+- arm64: fix SDEI stack frame unwind while UNW_4_14 is set
+
+* Wed Nov 13 2024 wangxiao <wangxiao184@h-partners.com> - 8.0.5-4
+- use autosetup instead of setup in prep stage
+
+* Tue Nov 12 2024 wangxiao <wangxiao184@h-partners.com> - 8.0.5-3
+- arm64: fix a potential segfault when unwind frame
+
+* Tue Nov 05 2024 xuguangmin <xuguangmin@kylinos.cn> - 8.0.5-2
+- Fix build warning:%patchN is deprecated (3 usages found), use %patch N
+
+* Thu Jul 25 2024 dillon chen<dillon.chen@gmail.com> - 8.0.5-1
+- Upgrade to crash-8.0.5
+
+* Tue May 28 2024 shaojiansong <shaojiansong@kylinos.cn> - 8.0.4-3
+- Fix lack of loongarch64 and sw_64 patch files in src.rpm package which is build from any platform.
+
+* Tue Apr 16 2024 Pengda Dou <doupengda@loongson.cn> - 8.0.4-2
+- Resolve loongarch64 patch add error
+- add support for loongarch64
+
+* Thu Jan 25 2024 chenhaixiang<chenhaixiang3@huawei.com> - 8.0.4-1
+- Upgrade to crash-8.0.4
+
+* Tue Aug 1 2023 chenhaixiang<chenhaixiang3@huawei.com> - 8.0.2-4
+- Fix compilation error due to new strlcpy function that glibc added
+
+* Mon Jul 10 2023 wangming <wangming01@loongson.cn> - 8.0.2-3
+- add LoongArch64 support.
+
+* Fri Jul 7 2023 EastDong <xudong23@iscas.ac.cn> - 8.0.2-2
+- add riscv64 support
+
+* Sun Jan 29 2023 chenhaixiang<chenhaixiang3@huawei.com> - 8.0.2-1
+- update to crash-8.0.2
+
+* Wed Jan 4 2023 lijianglin<lijianglin2@huawei.com> - 7.3.0-12
+- fix segfault by "bt" command with offline cpus
+
+* Thu Dec 29 2022 huskartang <tanly6@chinatelecom.cn> - 7.3.0-11
+- Fix the value of TIF_SIGPENDING macro
+
+* Thu Dec 29 2022 huskartang <tanly6@chinatelecom.cn> - 7.3.0-10
+- Fix "kmem -s|-S" option on Linux 5.7 and later kernels
+
+* Thu Dec 29 2022 huskartang <tanly6@chinatelecom.cn> - 7.3.0-9
+- Add lowercase tcr_el1_t1sz
+
+* Wed Dec 28 2022 huskartang <tanly6@chinatelecom.cn> - 7.3.0-8
+- rename pathes to keep in order
+
+* Thu Dec 1 2022 Ding Hui <dinghui@sangfor.com.cn> - 7.3.0-7
+- fix backtraces of arm64 KASAN kernel dumpfile truncated
+
+* Wed Oct 19 2022 wuzx<wuzx1226@qq.com> - 7.3.0-6
+- add sw64 patch
+
+* Wed Feb 23 2022 wangbin <wangbin224@huawei.com> - 7.3.0-5
+- Handle task_struct cpu member changes for kernels >= 5.16-rc1
+  and delete use_system_readline_v3.patch
+
+* Tue Feb 8 2022 zhouwenpei <zhouwenpei1@h-partners.com> - 7.3.0-4
+- revert to fix null pointer reference when CONFIG_KASAN is open
+
+* Fri Dec 31 2021 zhouwenpei <zhouwenpei1@huawei.com> - 7.3.0-3
+- add SDEI stack resolution
+
+* Thu Dec 30 2021 zhouwenpei <zhouwenpei1@huawei.com> - 7.3.0-2
+- fix seek error "IRQ stack pointer"
+
+* Tue Nov 30 2021 zhouwenpei <zhouwenpei1@huawei.com> - 7.3.0-1
+- Upgrade version to 7.3.0
+
+* Fri Sep 03 2021 wangbin <wangbin224@huawei.com> - 7.2.9-5
+- fix null pointer reference when CONFIG_KASAN is open
+
+* Tue Jun 29 2021 zhouwenpei <zhouwenpei1@huawei.com> - 7.2.9-4
+- add buildrequires m4
+
+* Mon May 10 2021 shixuantong <shixuantong@huawei.com> - 7.2.9-3
+- add -j option for building efficiency optimization
+
+* Thu Apr 08 2021 shixuantong <shixuantong@huawei.com> - 7.2.9-2
+- fix patch issue in upgrade version commit
+
 * Mon Feb 1 2021 liudabo <liudabo1@huawei.com> - 7.2.9-1
 - Upgrade version to 7.2.9
 

huawei-fix-ps-error-when-mm_struct.rss_stat-is-lazy-initial.patch

@@ -0,0 +1,28 @@
+From 45052609f61d5d4ee8286d0d6098e53ea6b199a9 Mon Sep 17 00:00:00 2001
+From: zhangjian <zhangjian496@huawei.com>
+Date: Wed, 21 May 2025 02:08:12 +0000
+Subject: [PATCH] tmp
+
+---
+ tools.c | 5 +++++
+ 1 file changed, 5 insertions(+)
+
+diff --git a/tools.c b/tools.c
+index 0f2db10..727a12c 100644
+--- a/tools.c
++++ b/tools.c
+@@ -6955,6 +6955,11 @@ percpu_counter_sum_positive(ulong fbc)
+ 	readmem(fbc + OFFSET(percpu_counter_counters), KVADDR, &addr,
+ 		sizeof(void *), "percpu_counter.counters", FAULT_ON_ERROR);
+ 
++	/* maybe mm_struct.rss_stat is lazy initialized */
++	if (!addr) {
++		return ret;
++	}
++
+ 	for (i = 0; i < kt->cpus; i++) {
+ 		readmem(addr + kt->__per_cpu_offset[i], KVADDR, &count,
+ 			sizeof(int), "percpu_counter.counters count", FAULT_ON_ERROR);
+-- 
+2.33.0
+