开源软件构建与测试

We truncated the diff of some files because they were too big. If you want to see the full diff for every file, click here.

Changes of Revision 2

_service:tar_scm:crash.spec Changed

@@ -1,25 +1,24 @@
 Name: crash
-Version: 7.3.0
-Release: 5
+Version: 8.0.2
+Release: 1
 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
+Source1: http://ftp.gnu.org/gnu/gdb/gdb-10.2.tar.gz
 
-Patch1: lzo_snappy.patch
-Patch2: 0001-arm64-rename-ARM64_PAGE_OFFSET_ACTUAL-to-ARM64_FLIP_.patch
-Patch3: 0002-arm64-assign-page_offset-with-VA_BITS-kernel-configu.patch
-Patch4: 0003-arm64-use-dedicated-bits-to-record-the-VA-space-layo.patch
-Patch5: 0004-arm64-implement-switchable-PTOV-VTOP-for-kernels-5.1.patch
-Patch6:	add-SDEI-stack-resolution.patch
-Patch7: Handle-task_struct-cpu-member-changes-for-kernels-5..patch
+Patch1: 0000-lzo_snappy.patch
+Patch2: 0001-add-SDEI-stack-resolution.patch
+%ifarch sw_64
+Patch3: 0002-crash-8.0.2-sw.patch
+%endif
+Patch4: 0003-arm64-fix-backtraces-of-KASAN-kernel-dumpfile-truncated.patch
 
-BuildRequires: ncurses-devel zlib-devel lzo-devel snappy-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
@@ -48,7 +47,7 @@
 
 %build
 cp %{SOURCE1} .
-make -j 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}
@@ -79,6 +78,30 @@
 %{_mandir}/man8/crash.8*
 
 %changelog
+* 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

_service:tar_scm:0000-lzo_snappy.patch Added

_service:tar_scm:0001-add-SDEI-stack-resolution.patch Added

@@ -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 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;
+@@ -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 stackTHREAD_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_offseti + sp->value;
++			readmem(p, KVADDR, &(ms->sdei_stacksi), 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_stacksbt->tc->processor + ms->irq_stack_size - 16;
++	sdei_stack_ptr = ms->sdei_stacksbt->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;

_service:tar_scm:0001-arm64-rename-ARM64_PAGE_OFFSET_ACTUAL-to-ARM64_FLIP_.patch Deleted

@@ -1,61 +0,0 @@
-From 5719afc7a40868418405a87a2711088556e68a3b Mon Sep 17 00:00:00 2001
-From: Pingfan Liu <piliu@redhat.com>
-Date: Fri, 2 Jul 2021 10:14:21 +0800
-Subject: PATCH 13/16 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 <piliu@redhat.com>
-Signed-off-by: Lianbo Jiang <lijiang@redhat.com>
----
- arm64.c | 10 ++++++----
- defs.h  |  3 ++-
- 2 files changed, 8 insertions(+), 5 deletions(-)
-
-diff --git a/arm64.c b/arm64.c
-index 8934961b109d..9fe1a4a3bddb 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 5d32954905c2..eb7ce6aea331 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.30.2

_service:tar_scm:0002-arm64-assign-page_offset-with-VA_BITS-kernel-configu.patch Deleted

@@ -1,56 +0,0 @@
-From 167d37e347fe35c6f7db826e8539e192c4375564 Mon Sep 17 00:00:00 2001
-From: Pingfan Liu <piliu@redhat.com>
-Date: Fri, 2 Jul 2021 10:14:22 +0800
-Subject: PATCH 14/16 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 <piliu@redhat.com>
-Signed-off-by: Lianbo Jiang <lijiang@redhat.com>
----
- arm64.c | 7 ++++---
- defs.h  | 1 +
- 2 files changed, 5 insertions(+), 3 deletions(-)
-
-diff --git a/arm64.c b/arm64.c
-index 9fe1a4a3bddb..149db36cd119 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 eb7ce6aea331..b7b20af4bcf9 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.30.2

_service:tar_scm:0002-crash-8.0.2-sw.patch Added

@@ -0,0 +1,3105 @@
+diff -Nuar crash-8.0.2.org/Makefile crash-8.0.2.sw/Makefile
+--- crash-8.0.2.org/Makefile	2022-03-14 07:58:52.278814120 +0000
++++ crash-8.0.2.sw/Makefile	2022-03-15 06:11:27.978814120 +0000
+@@ -20,7 +20,7 @@
+ PROGRAM=crash
+ 
+ #
+-# Supported targets: X86 ALPHA PPC IA64 PPC64 SPARC64
++# Supported targets: X86 SW_64 ALPHA PPC IA64 PPC64 SPARC64
+ # TARGET and GDB_CONF_FLAGS will be configured automatically by configure
+ #
+ TARGET=
+@@ -62,7 +62,7 @@
+ CFILES=main.c tools.c global_data.c memory.c filesys.c help.c task.c \
+ 	kernel.c test.c gdb_interface.c configure.c net.c dev.c bpf.c \
+ 	printk.c \
+-	alpha.c x86.c ppc.c ia64.c s390.c s390x.c s390dbf.c ppc64.c x86_64.c \
++	sw_64.c alpha.c x86.c ppc.c ia64.c s390.c s390x.c s390dbf.c ppc64.c x86_64.c \
+ 	arm.c arm64.c mips.c mips64.c sparc64.c \
+ 	extensions.c remote.c va_server.c va_server_v1.c symbols.c cmdline.c \
+ 	lkcd_common.c lkcd_v1.c lkcd_v2_v3.c lkcd_v5.c lkcd_v7.c lkcd_v8.c\
+@@ -82,7 +82,7 @@
+ OBJECT_FILES=main.o tools.o global_data.o memory.o filesys.o help.o task.o \
+ 	build_data.o kernel.o test.o gdb_interface.o net.o dev.o bpf.o \
+ 	printk.o \
+-	alpha.o x86.o ppc.o ia64.o s390.o s390x.o s390dbf.o ppc64.o x86_64.o \
++	sw_64.o alpha.o x86.o ppc.o ia64.o s390.o s390x.o s390dbf.o ppc64.o x86_64.o \
+ 	arm.o arm64.o mips.o mips64.o sparc64.o \
+ 	extensions.o remote.o va_server.o va_server_v1.o symbols.o cmdline.o \
+ 	lkcd_common.o lkcd_v1.o lkcd_v2_v3.o lkcd_v5.o lkcd_v7.o lkcd_v8.o \
+@@ -415,6 +415,9 @@
+ x86.o: ${GENERIC_HFILES} ${REDHAT_HFILES} x86.c
+ 	${CC} -c ${CRASH_CFLAGS} x86.c -DMCLX ${WARNING_OPTIONS} ${WARNING_ERROR}
+ 
++sw_64.o: ${GENERIC_HFILES} sw_64.c
++	${CC} -c ${CRASH_CFLAGS} sw_64.c ${WARNING_OPTIONS} ${WARNING_ERROR}
++
+ alpha.o: ${GENERIC_HFILES} alpha.c
+ 	${CC} -c ${CRASH_CFLAGS} alpha.c ${WARNING_OPTIONS} ${WARNING_ERROR}
+ 
+diff -Nuar crash-8.0.2.org/configure.c crash-8.0.2.sw/configure.c
+--- crash-8.0.2.org/configure.c	2022-03-14 07:58:52.278814120 +0000
++++ crash-8.0.2.sw/configure.c	2022-03-24 06:48:16.423873440 +0000
+@@ -107,6 +107,7 @@
+ #undef MIPS
+ #undef SPARC64
+ #undef MIPS64
++#undef SW_64
+ 
+ #define UNKNOWN 0
+ #define X86     1
+@@ -122,6 +123,7 @@
+ #define MIPS    11
+ #define SPARC64 12
+ #define MIPS64  13
++#define SW_64   14
+ 
+ #define TARGET_X86    "TARGET=X86"
+ #define TARGET_ALPHA  "TARGET=ALPHA"
+@@ -136,6 +138,7 @@
+ #define TARGET_MIPS   "TARGET=MIPS"
+ #define TARGET_MIPS64 "TARGET=MIPS64"
+ #define TARGET_SPARC64 "TARGET=SPARC64"
++#define TARGET_SW_64  "TARGET=SW_64"
+ 
+ #define TARGET_CFLAGS_X86    "TARGET_CFLAGS=-D_FILE_OFFSET_BITS=64"
+ #define TARGET_CFLAGS_ALPHA  "TARGET_CFLAGS="
+@@ -158,6 +161,7 @@
+ #define TARGET_CFLAGS_MIPS_ON_X86_64  "TARGET_CFLAGS=-m32 -D_FILE_OFFSET_BITS=64"
+ #define TARGET_CFLAGS_MIPS64          "TARGET_CFLAGS="
+ #define TARGET_CFLAGS_SPARC64         "TARGET_CFLAGS="
++#define TARGET_CFLAGS_SW_64  "TARGET_CFLAGS="
+ 
+ #define GDB_TARGET_DEFAULT        "GDB_CONF_FLAGS="
+ #define GDB_TARGET_ARM_ON_X86     "GDB_CONF_FLAGS=--target=arm-elf-linux"
+@@ -354,6 +358,9 @@
+ 	static char buf512;
+ 	char *p;
+ 
++#ifdef __sw_64__
++        target_data.target = SW_64;
++#endif
+ #ifdef __alpha__
+         target_data.target = ALPHA;
+ #endif
+@@ -614,6 +621,9 @@
+ 	case X86:    
+ 		printf("TARGET: X86\n");
+ 		break;
++	case SW_64: 
++		printf("TARGET: SW_64\n");
++		break;
+ 	case ALPHA: 
+ 		printf("TARGET: ALPHA\n");
+ 		break;
+@@ -693,6 +703,10 @@
+ 		} else
+ 			target_CFLAGS = TARGET_CFLAGS_X86;
+ 		break;
++	case SW_64:
++		target = TARGET_SW_64;
++		target_CFLAGS = TARGET_CFLAGS_SW_64;
++		break;
+ 	case ALPHA:
+ 		target = TARGET_ALPHA;
+ 		target_CFLAGS = TARGET_CFLAGS_ALPHA;
+@@ -1364,7 +1378,7 @@
+ 	printf("Vendor: Red Hat, Inc.\n");
+ 	printf("Packager: Dave Anderson <anderson@redhat.com>\n");
+ 	printf("ExclusiveOS: Linux\n");
+-	printf("ExclusiveArch: %%{ix86} alpha ia64 ppc ppc64 ppc64pseries ppc64iseries x86_64 s390 s390x arm aarch64 ppc64le mips mipsel mips64el sparc64\n");
++	printf("ExclusiveArch: %%{ix86} sw_64 alpha ia64 ppc ppc64 ppc64pseries ppc64iseries x86_64 s390 s390x arm aarch64 ppc64le mips mipsel mips64el sparc64\n");
+ 	printf("Buildroot: %%{_tmppath}/%%{name}-root\n");
+ 	printf("BuildRequires: ncurses-devel zlib-devel bison\n");
+ 	printf("Requires: binutils\n");
+@@ -1575,6 +1589,8 @@
+ 		target_data.initial_gdb_target = X86_64;
+ 	else if (strncmp(buf, "X86", strlen("X86")) == 0) 
+ 		target_data.initial_gdb_target = X86;
++	else if (strncmp(buf, "SW_64", strlen("SW_64")) == 0)
++		target_data.initial_gdb_target = SW_64;
+ 	else if (strncmp(buf, "ALPHA", strlen("ALPHA")) == 0)
+ 		target_data.initial_gdb_target = ALPHA;
+ 	else if (strncmp(buf, "PPC64", strlen("PPC64")) == 0)
+@@ -1606,6 +1622,7 @@
+ 	{
+ 	case X86:    return("X86");
+ 	case ALPHA:  return("ALPHA");
++	case SW_64:  return("SW_64");
+ 	case PPC:    return("PPC");
+ 	case IA64:   return("IA64");
+ 	case S390:   return("S390");
+@@ -1633,6 +1650,10 @@
+                 return X86;
+         else if (strncmp(name, "x86", strlen("x86")) == 0)
+                 return X86;
++        else if (strncmp(name, "SW_64", strlen("SW_64")) == 0)
++                return SW_64;
++        else if (strncmp(name, "sw_64", strlen("sw_64")) == 0)
++                return SW_64;
+         else if (strncmp(name, "ALPHA", strlen("ALPHA")) == 0)
+                 return ALPHA;
+         else if (strncmp(name, "alpha", strlen("alpha")) == 0)
+diff -Nuar crash-8.0.2.org/defs.h crash-8.0.2.sw/defs.h
+--- crash-8.0.2.org/defs.h	2022-03-14 07:58:52.278814120 +0000
++++ crash-8.0.2.sw/defs.h	2022-03-24 06:45:53.683873440 +0000
+@@ -69,13 +69,16 @@
+ #  define offsetof(TYPE, MEMBER) ((ulong)&((TYPE *)0)->MEMBER)
+ #endif
+ 
+-#if !defined(X86) && !defined(X86_64) && !defined(ALPHA) && !defined(PPC) && \
++#if !defined(X86) && !defined(X86_64) && !defined(ALPHA) && !defined(SW_64) && !defined(PPC) && \
+     !defined(IA64) && !defined(PPC64) && !defined(S390) && !defined(S390X) && \
+     !defined(ARM) && !defined(ARM64) && !defined(MIPS) && !defined(MIPS64) && \
+     !defined(SPARC64)
+ #ifdef __alpha__
+ #define ALPHA
+ #endif
++#ifdef __sw_64__
++#define SW_64
++#endif
+ #ifdef __i386__
+ #define X86
+ #endif
+@@ -122,6 +125,9 @@
+ #ifdef X86_64
+ #define NR_CPUS  (8192)
+ #endif
++#ifdef SW_64
++#define NR_CPUS  (64)
++#endif
+ #ifdef ALPHA
+ #define NR_CPUS  (64)
+ #endif
+@@ -3753,6 +3759,53 @@
+ 
+ #endif  /* ALPHA */
+ 
++#ifdef SW_64
++#define _64BIT_
++#define MACHINE_TYPE       "SW_64"
++
++#define PAGEBASE(X)  (((unsigned long)(X)) & (unsigned long)machdep->pagemask)
++
++#define PTOV(X)            ((unsigned long)(X)+(machdep->kvbase))
++#define VTOP(X)            ((unsigned long)(X)-(machdep->kvbase))
++#define IS_VMALLOC_ADDR(X) (vt->vmalloc_start && (ulong)(X) >= vt->vmalloc_start)
++#define KSEG_BASE_48_BIT   (0xffff800000000000)
++#define KSEG_BASE          (0xfffffc0000000000)
++#define _PFN_MASK          (0xFFFFFFFF00000000)
++#define VMALLOC_START      (0xFFFFFE0000000000)
++#define MIN_SYMBOL_VALUE   (KSEG_BASE_48_BIT)
++
++#define PGDIR_SHIFT     (PAGESHIFT() + 2*(PAGESHIFT()-3))
++#define PMD_SHIFT       (PAGESHIFT() + (PAGESHIFT()-3))
++#define PTRS_PER_PAGE   (1024)
++
++#define PTRS_PER_PGD    (1UL << (PAGESHIFT()-3))
++

_service:tar_scm:0003-arm64-fix-backtraces-of-KASAN-kernel-dumpfile-truncated.patch Added

@@ -0,0 +1,148 @@
+From 5f27639196c3240810fbf30d367da0063a6612ff Mon Sep 17 00:00:00 2001
+From: Ding Hui <dinghui@sangfor.com.cn>
+Date: Thu, 1 Dec 2022 15:01:45 +0800
+Subject: PATCH arm64: fix backtraces of KASAN kernel dumpfile truncated
+
+We met "bt" command on KASAN kernel vmcore display truncated backtraces
+like this:
+
+  crash> bt
+  PID: 4131   TASK: ffff8001521df000  CPU: 3   COMMAND: "bash"
+   #0 ffff2000224b0cb0 machine_kexec_prepare at ffff2000200bff4c
+
+After digging the root cause, it turns out that arm64_in_kdump_text()
+found wrong bt->bptr at "machine_kexec" branch.
+
+Disassemble machine_kexec() of KASAN vmlinux (gcc 7.3.0):
+
+  crash> dis -x machine_kexec
+  0xffff2000200bff50 <machine_kexec>:     stp     x29, x30, sp,#-208!
+  0xffff2000200bff54 <machine_kexec+0x4>: mov     x29, sp
+  0xffff2000200bff58 <machine_kexec+0x8>: stp     x19, x20, sp,#16
+  0xffff2000200bff5c <machine_kexec+0xc>: str     x24, sp,#56
+  0xffff2000200bff60 <machine_kexec+0x10>:        str     x26, sp,#72
+  0xffff2000200bff64 <machine_kexec+0x14>:        mov     x2, #0x8ab3
+  0xffff2000200bff68 <machine_kexec+0x18>:        add     x1, x29, #0x70
+  0xffff2000200bff6c <machine_kexec+0x1c>:        lsr     x1, x1, #3
+  0xffff2000200bff70 <machine_kexec+0x20>:        movk    x2, #0x41b5, lsl #16
+  0xffff2000200bff74 <machine_kexec+0x24>:        mov     x19, #0x200000000000
+  0xffff2000200bff78 <machine_kexec+0x28>:        adrp    x3, 0xffff2000224b0000
+  0xffff2000200bff7c <machine_kexec+0x2c>:        movk    x19, #0xdfff, lsl #48
+  0xffff2000200bff80 <machine_kexec+0x30>:        add     x3, x3, #0xcb0
+  0xffff2000200bff84 <machine_kexec+0x34>:        add     x4, x1, x19
+  0xffff2000200bff88 <machine_kexec+0x38>:        stp     x2, x3, x29,#112
+  0xffff2000200bff8c <machine_kexec+0x3c>:        adrp    x2, 0xffff2000200bf000 <swsusp_arch_resume+0x1e8>
+  0xffff2000200bff90 <machine_kexec+0x40>:        add     x2, x2, #0xf50
+  0xffff2000200bff94 <machine_kexec+0x44>:        str     x2, x29,#128
+  0xffff2000200bff98 <machine_kexec+0x48>:        mov     w2, #0xf1f1f1f1
+  0xffff2000200bff9c <machine_kexec+0x4c>:        str     w2, x1,x19
+  0xffff2000200bffa0 <machine_kexec+0x50>:        mov     w2, #0xf200
+  0xffff2000200bffa4 <machine_kexec+0x54>:        mov     w1, #0xf3f3f3f3
+  0xffff2000200bffa8 <machine_kexec+0x58>:        movk    w2, #0xf2f2, lsl #16
+  0xffff2000200bffac <machine_kexec+0x5c>:        stp     w2, w1, x4,#4
+
+We notice that:
+1. machine_kexec() start address is 0xffff2000200bff50
+2. the instruction at machine_kexec+0x44 stores the same value
+   0xffff2000200bff50 (comes from 0xffff2000200bf000 + 0xf50)
+   into stack postion x29,#128.
+
+When arm64_in_kdump_text() searches for LR from stack, it met
+0xffff2000200bff50 firstly, so got wrong bt->bptr.
+
+We know that the real LR is always greater than the start address
+of a function, so let's fix it by changing the search conditon to
+(*ptr > xxx_start) && (*ptr < xxx_end).
+
+Signed-off-by: Ding Hui <dinghui@sangfor.com.cn>
+---
+ arm64.c | 18 +++++++++---------
+ 1 file changed, 9 insertions(+), 9 deletions(-)
+
+diff --git a/arm64.c b/arm64.c
+index c3e26a3..7e8a7db 100644
+--- a/arm64.c
++++ b/arm64.c
+@@ -3479,7 +3479,7 @@ arm64_in_kdump_text(struct bt_info *bt, struct arm64_stackframe *frame)
+ 	ms = machdep->machspec;
+ 	for (ptr = start - 8; ptr >= base; ptr--) {
+ 		if (bt->flags & BT_OPT_BACK_TRACE) {
+-			if ((*ptr >= ms->crash_kexec_start) &&
++			if ((*ptr > ms->crash_kexec_start) &&
+ 			    (*ptr < ms->crash_kexec_end) &&
+ 			    INSTACK(*(ptr - 1), bt)) {
+ 				bt->bptr = ((ulong)(ptr - 1) - (ulong)base)
+@@ -3488,7 +3488,7 @@ arm64_in_kdump_text(struct bt_info *bt, struct arm64_stackframe *frame)
+ 					fprintf(fp, "%lx: %lx (crash_kexec)\n", bt->bptr, *ptr);
+ 				return TRUE;
+ 			}
+-			if ((*ptr >= ms->crash_save_cpu_start) &&
++			if ((*ptr > ms->crash_save_cpu_start) &&
+ 			    (*ptr < ms->crash_save_cpu_end) &&
+ 			    INSTACK(*(ptr - 1), bt)) {
+ 				bt->bptr = ((ulong)(ptr - 1) - (ulong)base)
+@@ -3498,14 +3498,14 @@ arm64_in_kdump_text(struct bt_info *bt, struct arm64_stackframe *frame)
+ 				return TRUE;
+ 			}
+ 		} else {
+-			if ((*ptr >= ms->machine_kexec_start) && (*ptr < ms->machine_kexec_end)) {
++			if ((*ptr > ms->machine_kexec_start) && (*ptr < ms->machine_kexec_end)) {
+ 				bt->bptr = ((ulong)ptr - (ulong)base)
+ 					   + task_to_stackbase(bt->tc->task);
+ 				if (CRASHDEBUG(1))
+ 					fprintf(fp, "%lx: %lx (machine_kexec)\n", bt->bptr, *ptr);
+ 				return TRUE;
+ 			}
+-			if ((*ptr >= ms->crash_kexec_start) && (*ptr < ms->crash_kexec_end)) {
++			if ((*ptr > ms->crash_kexec_start) && (*ptr < ms->crash_kexec_end)) {
+ 				/*
+ 				 *  Stash the first crash_kexec frame in case the machine_kexec
+ 				 *  frame is not found.
+@@ -3519,7 +3519,7 @@ arm64_in_kdump_text(struct bt_info *bt, struct arm64_stackframe *frame)
+ 				}
+ 				continue;
+ 			}
+-			if ((*ptr >= ms->crash_save_cpu_start) && (*ptr < ms->crash_save_cpu_end)) {
++			if ((*ptr > ms->crash_save_cpu_start) && (*ptr < ms->crash_save_cpu_end)) {
+ 				bt->bptr = ((ulong)ptr - (ulong)base)
+ 					   + task_to_stackbase(bt->tc->task);
+ 				if (CRASHDEBUG(1))
+@@ -3566,7 +3566,7 @@ arm64_in_kdump_text_on_irq_stack(struct bt_info *bt)
+ 
+ 	for (ptr = start - 8; ptr >= base; ptr--) {
+ 		if (bt->flags & BT_OPT_BACK_TRACE) {
+-			if ((*ptr >= ms->crash_kexec_start) &&
++			if ((*ptr > ms->crash_kexec_start) &&
+ 			    (*ptr < ms->crash_kexec_end) &&
+ 			    INSTACK(*(ptr - 1), bt)) {
+ 				bt->bptr = ((ulong)(ptr - 1) - (ulong)base) + stackbase;
+@@ -3576,7 +3576,7 @@ arm64_in_kdump_text_on_irq_stack(struct bt_info *bt)
+ 				FREEBUF(stackbuf);
+ 				return TRUE;
+ 			}
+-			if ((*ptr >= ms->crash_save_cpu_start) &&
++			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;
+@@ -3587,7 +3587,7 @@ arm64_in_kdump_text_on_irq_stack(struct bt_info *bt)
+ 				return TRUE;
+ 			}
+ 		} else {
+-			if ((*ptr >= ms->crash_kexec_start) && (*ptr < ms->crash_kexec_end)) {
++			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", 
+@@ -3595,7 +3595,7 @@ arm64_in_kdump_text_on_irq_stack(struct bt_info *bt)
+ 				FREEBUF(stackbuf);
+ 				return TRUE;
+ 			}
+-			if ((*ptr >= ms->crash_save_cpu_start) && (*ptr < ms->crash_save_cpu_end)) {
++			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", 
+-- 
+2.33.0
+

_service:tar_scm:0003-arm64-use-dedicated-bits-to-record-the-VA-space-layo.patch Deleted

@@ -1,83 +0,0 @@
-From bf1379a8b6ff8d6a8fa12978f7194f15f85c4380 Mon Sep 17 00:00:00 2001
-From: Pingfan Liu <piliu@redhat.com>
-Date: Fri, 2 Jul 2021 10:14:23 +0800
-Subject: PATCH 15/16 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 <piliu@redhat.com>
-Signed-off-by: Lianbo Jiang <lijiang@redhat.com>
----
- arm64.c | 10 ++++++++++
- defs.h  |  2 ++
- 2 files changed, 12 insertions(+)
-
-diff --git a/arm64.c b/arm64.c
-index 149db36cd119..b04369f6d4d8 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 b7b20af4bcf9..eca145cb881c 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.30.2

_service:tar_scm:0004-arm64-implement-switchable-PTOV-VTOP-for-kernels-5.1.patch Deleted

@@ -1,165 +0,0 @@
-From f53b73e8380bca054cebd2b61ff118c46609429b Mon Sep 17 00:00:00 2001
-From: Pingfan Liu <piliu@redhat.com>
-Date: Fri, 2 Jul 2021 10:14:24 +0800
-Subject: PATCH 16/16 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
-
-    <readmem: ffff800011c53bc8, KVADDR, "nr_irqs", 4, (FOE), b47bdc>
-    <read_kdump: addr: ffff800011c53bc8 paddr: eb453bc8 cnt: 4>
-    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_DATATYPEthread_union: returned via gdb_error_hook
-    <readmem: ffff000b779c0050, KVADDR, "IRQ stack pointer", 8, (ROE), 3a37bea0>
-    <read_kdump: addr: ffff000b779c0050 paddr: fff1000bf79c0050 cnt: 8>
-    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 <piliu@redhat.com>
-Signed-off-by: Lianbo Jiang <lijiang@redhat.com>
----
- arm64.c | 37 +++++++++++++++++++++++++++++++++----
- defs.h  |  9 ++++-----
- 2 files changed, 37 insertions(+), 9 deletions(-)
-
-diff --git a/arm64.c b/arm64.c
-index b04369f6d4d8..d73d5c5a4fed 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_pgdi = 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 eca145cb881c..c91177a245fd 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.30.2

_service:tar_scm:Handle-task_struct-cpu-member-changes-for-kernels-5..patch Deleted

@@ -1,56 +0,0 @@
-From 68870c83d299603c07785e3530e33c13045c87ef Mon Sep 17 00:00:00 2001
-From: Alexander Egorenkov <egorenar@linux.ibm.com>
-Date: Wed, 13 Oct 2021 10:56:39 +0200
-Subject: PATCH Handle task_struct cpu member changes for kernels >= 5.16-rc1
-
-Kernel commit bcf9033e5449bdcaa9bed46467a7141a8049dadb
-("sched: move CPU field back into thread_info if THREAD_INFO_IN_TASK=y")
-moved the member cpu of task_struct back into thread_info.
-Without the patch, crash fails with the following error message
-during session initialization:
-
-  crash: invalid structure member offset: task_struct_cpu
-         FILE: task.c  LINE: 2904  FUNCTION: add_context()
-
-Signed-off-by: Alexander Egorenkov <egorenar@linux.ibm.com>
-Signed-off-by: Kazuhito Hagio <k-hagio-ab@nec.com>
----
- task.c | 7 ++++---
- 1 file changed, 4 insertions(+), 3 deletions(-)
-
-diff --git a/task.c b/task.c
-index 672b416..bb6a5da 100644
---- a/task.c
-+++ b/task.c
-@@ -278,8 +278,10 @@ task_init(void)
- 	} else if (VALID_MEMBER(task_struct_stack))
- 		MEMBER_OFFSET_INIT(task_struct_thread_info, "task_struct", "stack");
- 
-+	MEMBER_OFFSET_INIT(task_struct_cpu, "task_struct", "cpu");
-+
- 	if (VALID_MEMBER(task_struct_thread_info)) {
--		if (tt->flags & THREAD_INFO_IN_TASK) {
-+		if (tt->flags & THREAD_INFO_IN_TASK && VALID_MEMBER(task_struct_cpu)) {
- 			MEMBER_OFFSET_INIT(thread_info_flags, "thread_info", "flags");
- 			/* (unnecessary) reminders */
- 			ASSIGN_OFFSET(thread_info_task) = INVALID_OFFSET;
-@@ -315,7 +317,6 @@ task_init(void)
-         MEMBER_OFFSET_INIT(task_struct_has_cpu, "task_struct", "has_cpu");
-         MEMBER_OFFSET_INIT(task_struct_cpus_runnable,  
- 		"task_struct", "cpus_runnable");
--	MEMBER_OFFSET_INIT(task_struct_cpu, "task_struct", "cpu");
- 	MEMBER_OFFSET_INIT(task_struct_active_mm, "task_struct", "active_mm");
- 	MEMBER_OFFSET_INIT(task_struct_next_run, "task_struct", "next_run");
- 	MEMBER_OFFSET_INIT(task_struct_flags, "task_struct", "flags");
-@@ -2900,7 +2901,7 @@ add_context(ulong task, char *tp)
- 		else
- 			tc->thread_info = ULONG(tp + OFFSET(task_struct_thread_info));
- 		fill_thread_info(tc->thread_info);
--		if (tt->flags & THREAD_INFO_IN_TASK)
-+		if (tt->flags & THREAD_INFO_IN_TASK && VALID_MEMBER(task_struct_cpu))
-                 	processor_addr = (int *) (tp + OFFSET(task_struct_cpu));
- 		else
- 			processor_addr = (int *) (tt->thread_info + 
--- 
-2.23.0
-

_service:tar_scm:add-SDEI-stack-resolution.patch Deleted

@@ -1,368 +0,0 @@
-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 | 210 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
- defs.h  |   3 +
- 2 files changed, 209 insertions(+), 4 deletions(-)
-
-diff --git a/arm64.c b/arm64.c
-index fdf77bd..cc32d9d 100644
---- a/arm64.c
-+++ b/arm64.c
-@@ -87,6 +87,10 @@ 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);
- 
- /*
-  * Do all necessary machine-specific setup here. This is called several times
-@@ -461,6 +465,7 @@ arm64_init(int when)
- 
- 		arm64_irq_stack_init();
- 		arm64_stackframe_init();
-+		arm64_sdei_stack_init();
- 		break;
- 
- 	case POST_VM:
-@@ -1655,6 +1660,70 @@ arm64_irq_stack_init(void)
- 			readmem(p, KVADDR, &(ms->irq_stacksi), sizeof(ulong),
- 			    "IRQ stack pointer", RETURN_ON_ERROR);
- 		}
-+	}
-+}
-+
-+/*
-+ *  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 stackTHREAD_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_offseti + sp->value;
-+			readmem(p, KVADDR, &(ms->sdei_stacksi), sizeof(ulong),
-+			    "SDEI stack pointer", RETURN_ON_ERROR);
-+		}
- 	} 
- }
- 
-@@ -2173,7 +2242,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;
- 
-@@ -2203,7 +2272,8 @@ 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)) {
- 			if (arm64_on_process_stack(bt, frame->fp)) {
- 				arm64_set_process_stack(bt);
- 
-@@ -2243,6 +2313,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_stacksbt->tc->processor + ms->irq_stack_size - 16;
-+	sdei_stack_ptr = ms->sdei_stacksbt->tc->processor + ms->sdei_stack_size - 16;
- 
- 	if (frame->sp == irq_stack_ptr) {
- 		orig_sp = GET_STACK_ULONG(irq_stack_ptr - 8);
-@@ -2263,6 +2334,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;
-@@ -2602,6 +2692,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;
-@@ -2611,6 +2705,10 @@ arm64_back_trace_cmd(struct bt_info *bt)
- 			arm64_set_irq_stack(bt);
- 			bt->flags |= BT_IRQSTACK;
- 		}

_service:tar_scm:lzo_snappy.patch Deleted

_service Changed

_service:tar_scm:7.3.0.tar.gz/gdb-7.6-ppc64le-support.patch Deleted

@@ -1,4950 +0,0 @@
-
-#
-#  gdb-7.6-ppc64_sysv_abi_push_float.patch  
-#
-
-From: Tiago Daitx <tdaitx@sourceware.org>
-Date: Mon Apr 1 04:05:35 2013 +0000
-Git-commit: d81e75c0756f21d2c3d45ce86d8b45c65f01ef67
-References: ppc64le enablement
-
-gdb/ChangeLog
-2013-03-01  Tiago Stürmer Daitx  <tdaitx@linux.vnet.ibm.com>
-
-	* ppc-sysv-tdep.c (ppc64_sysv_abi_push_float): New function.
-	(ppc64_sysv_abi_push_dummy_call): Handle complex arguments.
-
-Acked-by: Petr Tesarik <ptesarik@suse.cz>
-
----
- gdb/ChangeLog       |    5 +
- gdb/ppc-sysv-tdep.c |  196 +++++++++++++++++++++++++++++++++-------------------
- 2 files changed, 131 insertions(+), 70 deletions(-)
-
---- a/gdb/ChangeLog
-+++ b/gdb/ChangeLog
-@@ -1,3 +1,8 @@
-+2013-03-31  Tiago Stürmer Daitx  <tdaitx@linux.vnet.ibm.com>
-+
-+	* ppc-sysv-tdep.c (ppc64_sysv_abi_push_float): New function.
-+	(ppc64_sysv_abi_push_dummy_call): Handle complex arguments.
-+
- 2013-04-26  Joel Brobecker  <brobecker@adacore.com>
- 
- 	* NEWS: Change "since GDB 7.5" into "in GDB 7.6".
---- a/gdb/ppc-sysv-tdep.c
-+++ b/gdb/ppc-sysv-tdep.c
-@@ -1101,6 +1101,83 @@ convert_code_addr_to_desc_addr (CORE_ADD
-   return 1;
- }
- 
-+/* Push a float in either registers, or in the stack.  Using the ppc 64 bit
-+   SysV ABI.
-+
-+   This implements a dumbed down version of the ABI.  It always writes
-+   values to memory, GPR and FPR, even when not necessary.  Doing this
-+   greatly simplifies the logic.  */
-+
-+static void
-+ppc64_sysv_abi_push_float (struct gdbarch *gdbarch, struct regcache *regcache,
-+			   struct gdbarch_tdep *tdep, struct type *type, 
-+			   const bfd_byte *val, int freg, int greg,
-+			   CORE_ADDR gparam)
-+{
-+  gdb_byte regvalMAX_REGISTER_SIZE;
-+  const gdb_byte *p;
-+
-+  if (TYPE_LENGTH (type) <= 8)
-+    {
-+      /* Version 1.7 of the 64-bit PowerPC ELF ABI says:
-+
-+	 "Single precision floating point values are mapped to
-+	 the first word in a single doubleword."
-+
-+	 And version 1.9 says:
-+
-+	 "Single precision floating point values are mapped to
-+	 the second word in a single doubleword."
-+
-+	 GDB then writes single precision floating point values
-+	 at both words in a doubleword, to support both ABIs.  */
-+      if (TYPE_LENGTH (type) == 4)
-+	{
-+	  memcpy (regval, val, 4);
-+	  memcpy (regval + 4, val, 4);
-+	  p = regval;
-+	}
-+      else
-+	p = val;
-+
-+      /* Write value in the stack's parameter save area.  */
-+      write_memory (gparam, p, 8);
-+
-+      /* Floats and Doubles go in f1 .. f13.  They also consume a left aligned
-+	 GREG, and can end up in memory.  */
-+      if (freg <= 13)
-+	{
-+	  struct type *regtype;
-+
-+	  regtype = register_type (gdbarch, tdep->ppc_fp0_regnum + freg);
-+	  convert_typed_floating (val, type, regval, regtype);
-+	  regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + freg, regval);
-+	}
-+      if (greg <= 10)
-+	regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + greg, regval);
-+    }
-+  else
-+    {
-+      /* IBM long double stored in two doublewords of the
-+	 parameter save area and corresponding registers.  */
-+      if (!tdep->soft_float && freg <= 13)
-+	{
-+	  regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + freg, val);
-+	  if (freg <= 12)
-+	    regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + freg + 1,
-+				   val + 8);
-+	}
-+      if (greg <= 10)
-+	{
-+	  regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + greg, val);
-+	  if (greg <= 9)
-+	    regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + greg + 1,
-+				   val + 8);
-+	}
-+      write_memory (gparam, val, TYPE_LENGTH (type));
-+    }
-+}
-+
- /* Pass the arguments in either registers, or in the stack.  Using the
-    ppc 64 bit SysV ABI.
- 
-@@ -1218,53 +1295,9 @@ ppc64_sysv_abi_push_dummy_call (struct g
- 
- 	  if (TYPE_CODE (type) == TYPE_CODE_FLT && TYPE_LENGTH (type) <= 8)
- 	    {
--	      /* Floats and Doubles go in f1 .. f13.  They also
--	         consume a left aligned GREG,, and can end up in
--	         memory.  */
- 	      if (write_pass)
--		{
--		  gdb_byte regvalMAX_REGISTER_SIZE;
--		  const gdb_byte *p;
--
--		  /* Version 1.7 of the 64-bit PowerPC ELF ABI says:
--
--		     "Single precision floating point values are mapped to
--		     the first word in a single doubleword."
--
--		     And version 1.9 says:
--
--		     "Single precision floating point values are mapped to
--		     the second word in a single doubleword."
--
--		     GDB then writes single precision floating point values
--		     at both words in a doubleword, to support both ABIs.  */
--		  if (TYPE_LENGTH (type) == 4)
--		    {
--		      memcpy (regval, val, 4);
--		      memcpy (regval + 4, val, 4);
--		      p = regval;
--		    }
--		  else
--		    p = val;
--
--		  /* Write value in the stack's parameter save area.  */
--		  write_memory (gparam, p, 8);
--
--		  if (freg <= 13)
--		    {
--		      struct type *regtype
--                        = register_type (gdbarch, tdep->ppc_fp0_regnum);
--
--		      convert_typed_floating (val, type, regval, regtype);
--		      regcache_cooked_write (regcache,
--                                             tdep->ppc_fp0_regnum + freg,
--					     regval);
--		    }
--		  if (greg <= 10)
--		    regcache_cooked_write (regcache,
--					   tdep->ppc_gp0_regnum + greg,
--					   regval);
--		}
-+		  ppc64_sysv_abi_push_float (gdbarch, regcache, tdep, type,
-+					     val, freg, greg, gparam);
- 
- 	      freg++;
- 	      greg++;
-@@ -1276,35 +1309,58 @@ ppc64_sysv_abi_push_dummy_call (struct g
- 		   && (gdbarch_long_double_format (gdbarch)
- 		       == floatformats_ibm_long_double))
- 	    {
--	      /* IBM long double stored in two doublewords of the
--		 parameter save area and corresponding registers.  */
- 	      if (write_pass)
-+		ppc64_sysv_abi_push_float (gdbarch, regcache, tdep, type,
-+					   val, freg, greg, gparam);
-+	      freg += 2;
-+	      greg += 2;
-+	      gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize);
-+	    }
-+	  else if (TYPE_CODE (type) == TYPE_CODE_COMPLEX
-+	      && (TYPE_LENGTH (type) == 8 || TYPE_LENGTH (type) == 16))
-+	    {
-+	      int i;
-+
-+	      for (i = 0; i < 2; i++)
- 		{
--		  if (!tdep->soft_float && freg <= 13)
--		    {
--		      regcache_cooked_write (regcache,

_service:tar_scm:7.3.0.tar.gz/gdb-7.6-proc_service.h.patch Deleted

@@ -1,67 +0,0 @@
---- gdb-7.6/gdb/gdb_proc_service.h.orig
-+++ gdb-7.6/gdb/gdb_proc_service.h
-@@ -115,7 +115,7 @@ extern pid_t ps_getpid (struct ps_procha
- /* Fetch the special per-thread address associated with the given LWP.
-    This call is only used on a few platforms (most use a normal register).
-    The meaning of the `int' parameter is machine-dependent.  */
--extern ps_err_e ps_get_thread_area (const struct ps_prochandle *,
-+extern ps_err_e ps_get_thread_area (struct ps_prochandle *,
- 				    lwpid_t, int, psaddr_t *);
- 
- 
---- gdb-7.6/gdb/amd64-linux-nat.c.orig
-+++ gdb-7.6/gdb/amd64-linux-nat.c
-@@ -493,7 +493,7 @@ amd64_linux_new_fork (struct lwp_info *p
-    a request for a thread's local storage address.  */
- 
- ps_err_e
--ps_get_thread_area (const struct ps_prochandle *ph,
-+ps_get_thread_area (struct ps_prochandle *ph,
-                     lwpid_t lwpid, int idx, void **base)
- {
-   if (gdbarch_bfd_arch_info (target_gdbarch ())->bits_per_word == 32)
---- gdb-7.6/gdb/aarch64-linux-nat.c.orig
-+++ gdb-7.6/gdb/aarch64-linux-nat.c
-@@ -750,7 +750,7 @@ aarch64_linux_new_fork (struct lwp_info
-    storage (or its descriptor).  */
- 
- ps_err_e
--ps_get_thread_area (const struct ps_prochandle *ph,
-+ps_get_thread_area (struct ps_prochandle *ph,
- 		    lwpid_t lwpid, int idx, void **base)
- {
-   struct iovec iovec;
---- gdb-7.6/gdb/arm-linux-nat.c.orig
-+++ gdb-7.6/gdb/arm-linux-nat.c
-@@ -613,7 +613,7 @@ supply_fpregset (struct regcache *regcac
- /* Fetch the thread-local storage pointer for libthread_db.  */
- 
- ps_err_e
--ps_get_thread_area (const struct ps_prochandle *ph,
-+ps_get_thread_area (struct ps_prochandle *ph,
-                     lwpid_t lwpid, int idx, void **base)
- {
-   if (ptrace (PTRACE_GET_THREAD_AREA, lwpid, NULL, base) != 0)
---- gdb-7.6/gdb/i386-linux-nat.c.orig
-+++ gdb-7.6/gdb/i386-linux-nat.c
-@@ -849,7 +849,7 @@ i386_linux_new_fork (struct lwp_info *pa
-    storage (or its descriptor).  */
- 
- ps_err_e
--ps_get_thread_area (const struct ps_prochandle *ph, 
-+ps_get_thread_area (struct ps_prochandle *ph, 
- 		    lwpid_t lwpid, int idx, void **base)
- {
-   /* NOTE: cagney/2003-08-26: The definition of this buffer is found
---- gdb-7.6/gdb/mips-linux-nat.c.orig
-+++ gdb-7.6/gdb/mips-linux-nat.c
-@@ -154,7 +154,7 @@ mips64_linux_register_addr (struct gdbarch *gdbarch, int regno, int store)
- /* Fetch the thread-local storage pointer for libthread_db.  */
- 
- ps_err_e
--ps_get_thread_area (const struct ps_prochandle *ph,
-+ps_get_thread_area (struct ps_prochandle *ph,
-                     lwpid_t lwpid, int idx, void **base)
- {
-   if (ptrace (PTRACE_GET_THREAD_AREA, lwpid, NULL, base) != 0)
-

_service:tar_scm:7.3.0.tar.gz/gdb-7.6.patch Deleted

@@ -1,2558 +0,0 @@
-
-# When this file is updated in an existing source tree, it gets re-applied
-# during the next build using "patch -N --fuzz=0", which ignores patches
-# that have already been applied.  However, if a gdb file has been modified
-# multiple times, the subsequent patching may fail to recognize that a 
-# given patch has been previously applied, and will attempt to re-apply it.
-# To prevent any uninintended consequences, this file also acts as a 
-# shell script that can restore any gdb file to its original state prior 
-# to all subsequent patch applications.  
-
-# The gdb-7.6-ppc64le-support.patch will have modified both files below
-# during the initial build, so continue previous behavior.
-
-if  "$1" = "PPC64" 
-then
-  exit 0
-fi
- 
-tar xvzmf gdb-7.6.tar.gz \
-	gdb-7.6/gdb/symtab.c \
-	gdb-7.6/gdb/printcmd.c
-
-exit 0
-
---- gdb-7.6/libiberty/Makefile.in.orig
-+++ gdb-7.6/libiberty/Makefile.in
-@@ -175,6 +175,7 @@ REQUIRED_OFILES =							\
- 	./getruntime.$(objext) ./hashtab.$(objext) ./hex.$(objext)	\
- 	./lbasename.$(objext) ./lrealpath.$(objext)			\
- 	./make-relative-prefix.$(objext) ./make-temp-file.$(objext)	\
-+	./mkstemps.$(objext)						\
- 	./objalloc.$(objext)						\
- 	./obstack.$(objext)						\
- 	./partition.$(objext) ./pexecute.$(objext) ./physmem.$(objext)	\
-@@ -206,7 +207,7 @@ CONFIGURED_OFILES = ./asprintf.$(objext)
- 	./index.$(objext) ./insque.$(objext)				\
- 	./memchr.$(objext) ./memcmp.$(objext) ./memcpy.$(objext) 	\
- 	./memmem.$(objext) ./memmove.$(objext)				\
--	 ./mempcpy.$(objext) ./memset.$(objext) ./mkstemps.$(objext)	\
-+	 ./mempcpy.$(objext) ./memset.$(objext) 			\
- 	./pex-djgpp.$(objext) ./pex-msdos.$(objext)			\
- 	 ./pex-unix.$(objext) ./pex-win32.$(objext)			\
- 	 ./putenv.$(objext)						\
---- gdb-7.6/opcodes/i386-dis.c.orig
-+++ gdb-7.6/opcodes/i386-dis.c
-@@ -11510,6 +11510,10 @@ print_insn (bfd_vma pc, disassemble_info
-       threebyte = *++codep;
-       dp = &dis386_twobytethreebyte;
-       need_modrm = twobyte_has_modrm*codep;
-+      if (dp->name && ((strcmp(dp->name, "ud2a") == 0) || (strcmp(dp->name, "ud2") == 0))) {
-+        extern int kernel_BUG_encoding_bytes(void);
-+        codep += kernel_BUG_encoding_bytes();
-+      }
-       codep++;
-     }
-   else
---- gdb-7.6/gdb/dwarf2read.c.orig
-+++ gdb-7.6/gdb/dwarf2read.c
-@@ -2670,7 +2670,11 @@ read_index_from_section (struct objfile
-      indices.  */
-   if (version < 4)
-     {
-+#ifdef CRASH_MERGE
-+      static int warning_printed = 1;
-+#else
-       static int warning_printed = 0;
-+#endif
-       if (!warning_printed)
- 	{
- 	  warning (_("Skipping obsolete .gdb_index section in %s."),
-@@ -2689,7 +2693,11 @@ read_index_from_section (struct objfile
-      "set use-deprecated-index-sections on".  */
-   if (version < 6 && !deprecated_ok)
-     {
-+#ifdef CRASH_MERGE
-+      static int warning_printed = 1;
-+#else
-       static int warning_printed = 0;
-+#endif
-       if (!warning_printed)
- 	{
- 	  warning (_("\
---- gdb-7.6/gdb/amd64-linux-nat.c.orig
-+++ gdb-7.6/gdb/amd64-linux-nat.c
-@@ -45,6 +45,17 @@
- /* ezannoni-2003-07-09: I think this is fixed.  The extraneous defs have
-    been removed from ptrace.h in the kernel.  However, better safe than
-    sorry.  */
-+#ifdef CRASH_MERGE
-+/*
-+ * When compiling within a 2.6.25-based Fedora build environment with
-+ * gcc 4.3, four new "typedef unsigned int u32;" declarations were
-+ * required due to a new ptrace_bts_config structure declaration in
-+ * "asm-x86/ptrace-abi.h" that used u32 members, but u32 is defined in
-+ * "asm-x86/types.h" within a __KERNEL__ section.  They've been changed
-+ * to __u32, but this patch remains for building in that environment.
-+ */
-+typedef unsigned int u32;
-+#endif
- #include <asm/ptrace.h>
- #include <sys/reg.h>
- #include "gdb_proc_service.h"
---- gdb-7.6/gdb/symfile.c.orig
-+++ gdb-7.6/gdb/symfile.c
-@@ -693,7 +693,26 @@ default_symfile_offsets (struct objfile
-       for (cur_sec = abfd->sections; cur_sec != NULL; cur_sec = cur_sec->next)
- 	/* We do not expect this to happen; just skip this step if the
- 	   relocatable file has a section with an assigned VMA.  */
--	if (bfd_section_vma (abfd, cur_sec) != 0)
-+	if (bfd_section_vma (abfd, cur_sec) != 0
-+           /*
-+            *  Kernel modules may have some non-zero VMAs, i.e., like the
-+            *  __ksymtab and __ksymtab_gpl sections in this example:
-+            *     
-+            *    Section Headers:
-+            *      Nr Name              Type             Address           Offset
-+            *           Size              EntSize          Flags  Link  Info  Align
-+            *      ...
-+            *       8 __ksymtab         PROGBITS         0000000000000060  0000ad90
-+            *           0000000000000010  0000000000000000   A       0     0     16
-+            *       9 .rela__ksymtab    RELA             0000000000000000  0000ada0
-+            *           0000000000000030  0000000000000018          43     8     8
-+            *      10 __ksymtab_gpl     PROGBITS         0000000000000070  0000add0
-+            *           00000000000001a0  0000000000000000   A       0     0     16
-+            *      ...
-+            *
-+            *  but they should be treated as if they are NULL.
-+            */
-+	    && strncmp (bfd_get_section_name (abfd, cur_sec), "__k", 3) != 0)
- 	  break;
- 
-       if (cur_sec == NULL)
-@@ -1122,6 +1141,12 @@ symbol_file_add_with_addrs_or_offsets (b
-     error (_("Not confirmed."));
- 
-   objfile = allocate_objfile (abfd, flags | (mainline ? OBJF_MAINLINE : 0));
-+#ifdef CRASH_MERGE
-+  if (add_flags & SYMFILE_MAINLINE) {
-+    extern struct objfile *gdb_kernel_objfile;
-+    gdb_kernel_objfile = objfile;
-+  }
-+#endif
- 
-   if (parent)
-     add_separate_debug_objfile (objfile, parent);
-@@ -1484,6 +1509,9 @@ find_separate_debug_file (const char *di
-   VEC (char_ptr) *debugdir_vec;
-   struct cleanup *back_to;
-   int ix;
-+#ifdef CRASH_MERGE
-+  extern int check_specified_module_tree(char *, char *);
-+#endif
- 
-   /* Set I to max (strlen (canon_dir), strlen (dir)).  */
-   i = strlen (dir);
-@@ -1513,6 +1541,15 @@ find_separate_debug_file (const char *di
-   if (separate_debug_file_exists (debugfile, crc32, objfile))
-     return debugfile;
- 
-+#ifdef CRASH_MERGE
-+{
-+  if (check_specified_module_tree(objfile->name, debugfile) &&
-+      separate_debug_file_exists(debugfile, crc32, objfile)) {
-+        return debugfile;
-+  }
-+}
-+#endif
-+
-   /* Then try in the global debugfile directories.
- 
-      Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
-@@ -1583,6 +1620,10 @@ find_separate_debug_file_by_debuglink (s
-   char *debugfile;
-   unsigned long crc32;
-   struct cleanup *cleanups;
-+#ifdef CRASH_MERGE
-+  char *name_copy;
-+  extern char *check_specified_kernel_debug_file();
-+#endif
- 
-   debuglink = get_debug_link_info (objfile, &crc32);
- 
-@@ -1635,6 +1676,12 @@ find_separate_debug_file_by_debuglink (s
-     }
- 
-   do_cleanups (cleanups);
-+#ifdef CRASH_MERGE
-+  if (debugfile == NULL) {
-+       name_copy = check_specified_kernel_debug_file();
-+       return (name_copy ? xstrdup(name_copy) : NULL);
-+  }
-+#endif
-   return debugfile;
- }
- 
-@@ -2409,8 +2456,10 @@ add_symbol_file_command (char *args, int
- 	 so we can't determine what section names are valid.  */
-     }
-

_service:tar_scm:7.3.0.tar.gz/.gitignore -> _service:tar_scm:8.0.2.tar.gz/.gitignore Changed

_service:tar_scm:7.3.0.tar.gz/.rh_rpm_package -> _service:tar_scm:8.0.2.tar.gz/.rh_rpm_package Changed

_service:tar_scm:7.3.0.tar.gz/Makefile -> _service:tar_scm:8.0.2.tar.gz/Makefile Changed

@@ -17,6 +17,7 @@
 # GNU General Public License for more details.
 #
 
+MAKEFLAGS += --no-print-directory
 PROGRAM=crash
 
 #
@@ -72,7 +73,7 @@
 	xen_hyper.c xen_hyper_command.c xen_hyper_global_data.c \
 	xen_hyper_dump_tables.c kvmdump.c qemu.c qemu-load.c sadump.c ipcs.c \
 	ramdump.c vmware_vmss.c vmware_guestdump.c \
-	xen_dom0.c kaslr_helper.c
+	xen_dom0.c kaslr_helper.c sbitmap.c
 
 SOURCE_FILES=${CFILES} ${GENERIC_HFILES} ${MCORE_HFILES} \
 	${REDHAT_CFILES} ${REDHAT_HFILES} ${UNWIND_HFILES} \
@@ -92,7 +93,7 @@
 	xen_hyper.o xen_hyper_command.o xen_hyper_global_data.o \
 	xen_hyper_dump_tables.o kvmdump.o qemu.o qemu-load.o sadump.o ipcs.o \
 	ramdump.o vmware_vmss.o vmware_guestdump.o \
-	xen_dom0.o kaslr_helper.o
+	xen_dom0.o kaslr_helper.o sbitmap.o
 
 MEMORY_DRIVER_FILES=memory_driver/Makefile memory_driver/crash.c memory_driver/README
 
@@ -182,6 +183,9 @@
 GDB_7.6_FILES=
 GDB_7.6_OFILES=${GDB}/gdb/symtab.o
 
+GDB_10.2_FILES=
+GDB_10.2_OFILES=${GDB}/gdb/symtab.o crash_target.o
+
 # 
 # GDB_FLAGS is passed up from the gdb Makefile.
 #
@@ -207,7 +211,7 @@
 	${EXTENSION_SOURCE_FILES} ${MEMORY_DRIVER_FILES}
 CSCOPE_FILES=${SOURCE_FILES}
 
-READLINE_DIRECTORY=./${GDB}/readline
+READLINE_DIRECTORY=./${GDB}/readline/readline
 BFD_DIRECTORY=./${GDB}/bfd
 GDB_INCLUDE_DIRECTORY=./${GDB}/include
 
@@ -219,25 +223,47 @@
 CONF_TARGET_FLAG="-t$(target)"
 endif
 
+ifeq ($(findstring warn,$(MAKECMDGOALS)),warn)
+CONF_TARGET_FLAG += -w
+endif
+ifeq ($(findstring Warn,$(MAKECMDGOALS)),Warn)
+CONF_TARGET_FLAG += -W
+endif
+ifeq ($(findstring nowarn,$(MAKECMDGOALS)),nowarn)
+CONF_TARGET_FLAG += -n
+endif
+ifeq ($(findstring lzo,$(MAKECMDGOALS)),lzo)
+CONF_TARGET_FLAG += -x lzo
+endif
+ifeq ($(findstring snappy,$(MAKECMDGOALS)),snappy)
+CONF_TARGET_FLAG += -x snappy
+endif
+ifeq ($(findstring zstd,$(MAKECMDGOALS)),zstd)
+CONF_TARGET_FLAG += -x zstd
+endif
+ifeq ($(findstring valgrind,$(MAKECMDGOALS)),valgrind)
+CONF_TARGET_FLAG += -x valgrind
+endif
+
 # To build the extensions library by default, uncomment the third command
 # line below.  Otherwise they can be built by entering "make extensions".
 
 all: make_configure
 	@./configure ${CONF_TARGET_FLAG} -p "RPMPKG=${RPMPKG}" -b
-	@make --no-print-directory gdb_merge
-#	@make --no-print-directory extensions
+	@$(MAKE) gdb_merge
+#	@$(MAKE) extensions
 
 gdb_merge: force
 	@if  ! -f ${GDB}/README ; then \
-	  make --no-print-directory gdb_unzip; fi
+	  $(MAKE) gdb_unzip; fi
 	@echo "${LDFLAGS} -lz -ldl -rdynamic" > ${GDB}/gdb/mergelibs
 	@echo "../../${PROGRAM} ../../${PROGRAM}lib.a" > ${GDB}/gdb/mergeobj
 	@rm -f ${PROGRAM}
 	@if  ! -f ${GDB}/config.status ; then \
 	  (cd ${GDB}; ./configure ${GDB_CONF_FLAGS} --with-separate-debug-dir=/usr/lib/debug \
 	    --with-bugurl="" --with-expat=no --with-python=no --disable-sim; \
-	  make --no-print-directory CRASH_TARGET=${TARGET}; echo ${TARGET} > crash.target) \
-	else make --no-print-directory rebuild; fi
+	  $(MAKE) CRASH_TARGET=${TARGET}; echo ${TARGET} > crash.target) \
+	else $(MAKE) rebuild; fi
 	@if  ! -f ${PROGRAM} ; then \
 	  echo; echo "${PROGRAM} build failed"; \
 	  echo; exit 1; fi
@@ -246,10 +272,10 @@
 	@if  ! -f ${GDB}/${GDB}.patch ; then \
 	  touch ${GDB}/${GDB}.patch; fi
 	@if  -f ${GDB}.patch  &&  -s ${GDB}.patch  && \
-	   "`sum ${GDB}.patch`" != "`sum ${GDB}/${GDB}.patch`" ; then \
+	   "`md5sum < ${GDB}.patch`" != "`md5sum < ${GDB}/${GDB}.patch`" ; then \
 	  (sh -x ${GDB}.patch ${TARGET}; patch -N -p0 -r- --fuzz=0 < ${GDB}.patch; cp ${GDB}.patch ${GDB}; cd ${GDB}; \
-	  make --no-print-directory CRASH_TARGET=${TARGET}) \
-	else (cd ${GDB}/gdb; make --no-print-directory CRASH_TARGET=${TARGET}); fi
+	  $(MAKE) CRASH_TARGET=${TARGET}) \
+	else (cd ${GDB}/gdb; $(MAKE) CRASH_TARGET=${TARGET}); fi
 
 gdb_unzip:
 	@rm -f gdb.files
@@ -261,30 +287,18 @@
 	   ! -t 2  && WGET_OPTS="--progress=dot:mega"; \
 	  wget $$WGET_OPTS http://ftp.gnu.org/gnu/gdb/${GDB}.tar.gz; fi
 	@tar --exclude-from gdb.files -xzmf ${GDB}.tar.gz
-	@make --no-print-directory gdb_patch
+	@$(MAKE) gdb_patch
 
 gdb_patch:
 	if  -f ${GDB}.patch  &&  -s ${GDB}.patch ; then \
 		patch -p0 < ${GDB}.patch; cp ${GDB}.patch ${GDB}; fi
-	if  "${ARCH}" = "ppc64le"  &&  -f ${GDB}-ppc64le-support.patch ; then \
-		patch -d ${GDB} -p1 -F0 < ${GDB}-ppc64le-support.patch ; \
-	fi
-	if  "${ARCH}" = "x86_64"  &&  "${TARGET}" = "PPC64"  &&  -f ${GDB}-ppc64le-support.patch ; then \
-		patch -d ${GDB} -p1 -F0 < ${GDB}-ppc64le-support.patch ; \
-	fi
-	if  -f /usr/include/proc_service.h ; then \
-		grep 'extern ps_err_e ps_get_thread_area (struct' /usr/include/proc_service.h; \
-		if  $$? -eq 0 ; then \
-			patch -p0 < ${GDB}-proc_service.h.patch; \
-		fi; \
-	fi
 
-library: make_build_data ${OBJECT_FILES}
+library: ${OBJECT_FILES}
 	ar -rs ${PROGRAM}lib.a ${OBJECT_FILES}
 
 gdb: force
 	rm -f ${GDB_OFILES}
-	@make --no-print-directory all
+	@$(MAKE) all
 
 force:
 	
@@ -295,14 +309,14 @@
 
 clean: make_configure
 	@./configure ${CONF_TARGET_FLAG} -q -b
-	@make --no-print-directory do_clean
+	@$(MAKE) do_clean
 
 do_clean:
 	rm -f ${OBJECT_FILES} ${DAEMON_OBJECT_FILES} ${PROGRAM} ${PROGRAM}lib.a ${GDB_OFILES}
-	@(cd extensions; make --no-print-directory -i clean)
-	@(cd memory_driver; make --no-print-directory -i clean)
+	@$(MAKE) -C extensions -i clean
+	@$(MAKE) -C memory_driver -i clean
 
-make_build_data: force
+build_data.o: force
 	${CC} -c ${CRASH_CFLAGS} build_data.c ${WARNING_OPTIONS} ${WARNING_ERROR}
 
 install:
@@ -313,29 +327,8 @@
 unconfig: make_configure
 	@./configure -u
 
-warn: make_configure
-	@./configure ${CONF_TARGET_FLAG} -w -b
-	@make --no-print-directory gdb_merge
-
-Warn: make_configure
-	@./configure ${CONF_TARGET_FLAG} -W -b
-	@make --no-print-directory gdb_merge
-
-nowarn: make_configure
-	@./configure ${CONF_TARGET_FLAG} -n -b
-	@make --no-print-directory gdb_merge
-
-lzo: make_configure
-	@./configure -x lzo ${CONF_TARGET_FLAG} -w -b
-	@make --no-print-directory gdb_merge
-
-snappy: make_configure
-	@./configure -x snappy ${CONF_TARGET_FLAG} -w -b
-	@make --no-print-directory gdb_merge
-
-valgrind: make_configure
-	@./configure -x valgrind ${CONF_TARGET_FLAG} -w -b
-	@make --no-print-directory gdb_merge
+warn Warn nowarn lzo snappy zstd valgrind: all
+	@true  #dummy
 
 main.o: ${GENERIC_HFILES} main.c
 	${CC} -c ${CRASH_CFLAGS} main.c ${WARNING_OPTIONS} ${WARNING_ERROR} 
@@ -346,6 +339,9 @@
 tools.o: ${GENERIC_HFILES} tools.c
 	${CC} -c ${CRASH_CFLAGS} tools.c ${WARNING_OPTIONS} ${WARNING_ERROR}

_service:tar_scm:7.3.0.tar.gz/README -> _service:tar_scm:8.0.2.tar.gz/README Changed

@@ -74,8 +74,8 @@
 
   To build the crash utility: 
 
-    $ tar -xf crash-7.3.0.tar.gz
-    $ cd crash-7.3.0
+    $ tar -xf crash-8.0.2.tar.gz
+    $ cd crash-8.0.2
     $ make
 
   The initial build will take several minutes  because the embedded gdb module
@@ -102,8 +102,8 @@
   Traditionally when vmcores are compressed via the makedumpfile(8) facility
   the libz compression library is used, and by default the crash utility
   only supports libz.  Recently makedumpfile has been enhanced to optionally
-  use either the LZO or snappy compression libraries.  To build crash with
-  either or both of those libraries, type "make lzo" or "make snappy".
+  use the LZO, snappy or zstd compression libraries.  To build crash with any
+  or all of those libraries, type "make lzo", "make snappy" or "make zstd".
 
   crash supports valgrind Memcheck tool on the crash's custom memory allocator.
   To build crash with this feature enabled, type "make valgrind" and then run
@@ -122,7 +122,7 @@
   If neither /dev/mem or /dev/crash are available, then /proc/kcore will be
   be used as the live memory source.  If /proc/kcore is also restricted, then
   the Red Hat /dev/crash driver may be compiled and installed; its source
-  is included in the crash-7.3.0/memory_driver subdirectory.
+  is included in the crash-8.0.2/memory_driver subdirectory.
 
   If the kernel file is stored in /boot, /, /boot/efi, or in any /usr/src
   or /usr/lib/debug/lib/modules subdirectory, then no command line arguments
@@ -133,21 +133,22 @@
 
     $ crash
     
-    crash 7.3.0
-    Copyright (C) 2002-2021  Red Hat, Inc.
+    crash 8.0.2
+    Copyright (C) 2002-2022  Red Hat, Inc.
     Copyright (C) 2004, 2005, 2006, 2010  IBM Corporation
     Copyright (C) 1999-2006  Hewlett-Packard Co
     Copyright (C) 2005, 2006, 2011, 2012  Fujitsu Limited
     Copyright (C) 2006, 2007  VA Linux Systems Japan K.K.
-    Copyright (C) 2005, 2011, 2020-2021  NEC Corporation
+    Copyright (C) 2005, 2011, 2020-2022  NEC Corporation
     Copyright (C) 1999, 2002, 2007  Silicon Graphics, Inc.
     Copyright (C) 1999, 2000, 2001, 2002  Mission Critical Linux, Inc.
+    Copyright (C) 2015, 2021  VMware, Inc.
     This program is free software, covered by the GNU General Public License,
     and you are welcome to change it and/or distribute copies of it under
     certain conditions.  Enter "help copying" to see the conditions.
     This program has absolutely no warranty.  Enter "help warranty" for details.
      
-    GNU gdb 7.6
+    GNU gdb 10.2
     Copyright 2013 Free Software Foundation, Inc.
     License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
     This is free software: you are free to change and redistribute it.
@@ -158,7 +159,7 @@
           KERNEL: /boot/vmlinux
         DUMPFILE: /dev/mem
             CPUS: 1
-            DATE: Tue Apr 27 11:56:11 JST 2021
+            DATE: Wed Nov 16 13:11:21 JST 2022
           UPTIME: 10 days, 22:55:18
     LOAD AVERAGE: 0.08, 0.03, 0.01
            TASKS: 42
@@ -175,18 +176,19 @@
 
     crash> help
 
-    *              extend         log            rd             task           
-    alias          files          mach           repeat         timer          
-    ascii          foreach        mod            runq           tree           
-    bpf            fuser          mount          search         union          
-    bt             gdb            net            set            vm             
-    btop           help           p              sig            vtop           
-    dev            ipcs           ps             struct         waitq          
-    dis            irq            pte            swap           whatis         
-    eval           kmem           ptob           sym            wr             
-    exit           list           ptov           sys            q              
+    *              files          mod            sbitmapq       union          
+    alias          foreach        mount          search         vm             
+    ascii          fuser          net            set            vtop           
+    bpf            gdb            p              sig            waitq          
+    bt             help           ps             struct         whatis         
+    btop           ipcs           pte            swap           wr             
+    dev            irq            ptob           sym            q              
+    dis            kmem           ptov           sys            
+    eval           list           rd             task           
+    exit           log            repeat         timer          
+    extend         mach           runq           tree           
     
-    crash version: 7.3.0    gdb version: 7.6
+    crash version: 8.0.2    gdb version: 10.2
     For help on any command above, enter "help <command>".
     For help on input options, enter "help input".
     For help on output options, enter "help output".
@@ -199,21 +201,22 @@
 
     $ crash vmlinux vmcore
  
-    crash 7.3.0
-    Copyright (C) 2002-2021  Red Hat, Inc.
+    crash 8.0.2
+    Copyright (C) 2002-2022  Red Hat, Inc.
     Copyright (C) 2004, 2005, 2006, 2010  IBM Corporation
     Copyright (C) 1999-2006  Hewlett-Packard Co
     Copyright (C) 2005, 2006, 2011, 2012  Fujitsu Limited
     Copyright (C) 2006, 2007  VA Linux Systems Japan K.K.
-    Copyright (C) 2005, 2011, 2020-2021  NEC Corporation
+    Copyright (C) 2005, 2011, 2020-2022  NEC Corporation
     Copyright (C) 1999, 2002, 2007  Silicon Graphics, Inc.
     Copyright (C) 1999, 2000, 2001, 2002  Mission Critical Linux, Inc.
+    Copyright (C) 2015, 2021  VMware, Inc.
     This program is free software, covered by the GNU General Public License,
     and you are welcome to change it and/or distribute copies of it under
     certain conditions.  Enter "help copying" to see the conditions.
     This program has absolutely no warranty.  Enter "help warranty" for details.
      
-    GNU gdb 7.6
+    GNU gdb 10.2
     Copyright 2013 Free Software Foundation, Inc.
     License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
     This is free software: you are free to change and redistribute it.

_service:tar_scm:7.3.0.tar.gz/alpha.c -> _service:tar_scm:8.0.2.tar.gz/alpha.c Changed

_service:tar_scm:7.3.0.tar.gz/arm64.c -> _service:tar_scm:8.0.2.tar.gz/arm64.c Changed

@@ -20,6 +20,7 @@
 #include "defs.h"
 #include <elf.h>
 #include <endian.h>
+#include <math.h>
 #include <sys/ioctl.h>
 
 #define NOT_IMPLEMENTED(X) error((X), "%s: function not implemented\n", __func__)
@@ -45,6 +46,7 @@
 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 +65,7 @@
 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 +81,11 @@
 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);
@@ -87,6 +93,28 @@
 static int arm64_is_uvaddr(ulong, struct task_context *);
 static void arm64_calc_KERNELPACMASK(void);
 
+struct kernel_range {
+	unsigned long modules_vaddr, modules_end;
+	unsigned long vmalloc_start_addr, vmalloc_end;
+	unsigned long vmemmap_vaddr, vmemmap_end;
+};
+static struct kernel_range *arm64_get_va_range(struct machine_specific *ms);
+static void arm64_get_struct_page_size(struct machine_specific *ms);
+
+static void arm64_calc_kernel_start(void)
+{
+	struct machine_specific *ms = machdep->machspec;
+	struct syment *sp;
+
+	if (THIS_KERNEL_VERSION >= LINUX(5,11,0))
+		sp = kernel_symbol_search("_stext");
+	else
+		sp = kernel_symbol_search("_text");
+
+	ms->kimage_text = (sp ? sp->value : 0);
+	sp = kernel_symbol_search("_end");
+	ms->kimage_end = (sp ? sp->value : 0);
+}
 
 /*
  * Do all necessary machine-specific setup here. This is called several times
@@ -121,6 +149,14 @@
 
 		ms = machdep->machspec;
 
+		/*
+		 * The st->_stext_vmlinux is needed in arm64_init(PRE_GDB) when a
+		 * dumpfile does not have vmcoreinfo and we use -m vabits_actual
+		 * option, e.g. a raw RAM dumpfile.
+		 */
+		if (ms->VA_BITS_ACTUAL)
+			st->_stext_vmlinux = UNINITIALIZED;
+
 		if (!ms->kimage_voffset && STREQ(pc->live_memsrc, "/dev/crash"))
 			ioctl(pc->mfd, DEV_CRASH_ARCH_DATA, &ms->kimage_voffset);
 
@@ -214,13 +250,17 @@
 		machdep->pageoffset = machdep->pagesize - 1;
 		machdep->pagemask = ~((ulonglong)machdep->pageoffset);
 
+		ms = machdep->machspec;
+		arm64_get_struct_page_size(ms);
 		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;
+			/* 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;
@@ -230,35 +270,48 @@
 		}
 		machdep->is_kvaddr = generic_is_kvaddr;
 		machdep->kvtop = arm64_kvtop;
+
+		/* The defaults */
+		ms->vmalloc_end = ARM64_VMALLOC_END;
+		ms->vmemmap_vaddr = ARM64_VMEMMAP_VADDR;
+		ms->vmemmap_end = ARM64_VMEMMAP_END;
+
 		if (machdep->flags & NEW_VMEMMAP) {
 			struct syment *sp;
+			struct kernel_range *r;
 
+			/* It is finally decided in arm64_calc_kernel_start() */
 			sp = kernel_symbol_search("_text");
 			ms->kimage_text = (sp ? sp->value : 0);
 			sp = kernel_symbol_search("_end");
 			ms->kimage_end = (sp ? sp->value : 0);
 
-			if (ms->VA_BITS_ACTUAL) {
+			if (ms->struct_page_size && (r = arm64_get_va_range(ms))) {
+				/* We can get all the MODULES/VMALLOC/VMEMMAP ranges now.*/
+				ms->modules_vaddr	= r->modules_vaddr;
+				ms->modules_end		= r->modules_end - 1;
+				ms->vmalloc_start_addr	= r->vmalloc_start_addr;
+				ms->vmalloc_end		= r->vmalloc_end - 1;
+				ms->vmemmap_vaddr	= r->vmemmap_vaddr;
+				ms->vmemmap_end		= r->vmemmap_end - 1;
+			} else if (ms->VA_BITS_ACTUAL) {
 				ms->modules_vaddr = (st->_stext_vmlinux & TEXT_OFFSET_MASK) - ARM64_MODULES_VSIZE;
 				ms->modules_end = ms->modules_vaddr + ARM64_MODULES_VSIZE -1;
+				ms->vmalloc_start_addr = ms->modules_end + 1;
 			} else {
 				ms->modules_vaddr = ARM64_VA_START;
 				if (kernel_symbol_exists("kasan_init"))
 					ms->modules_vaddr += ARM64_KASAN_SHADOW_SIZE;
 				ms->modules_end = ms->modules_vaddr + ARM64_MODULES_VSIZE -1;
+				ms->vmalloc_start_addr = ms->modules_end + 1;
 			}
 
-			ms->vmalloc_start_addr = ms->modules_end + 1;
-
 			arm64_calc_kimage_voffset();
 		} else {
 			ms->modules_vaddr = ARM64_PAGE_OFFSET - MEGABYTES(64);
 			ms->modules_end = ARM64_PAGE_OFFSET - 1;
 			ms->vmalloc_start_addr = ARM64_VA_START;
 		}
-		ms->vmalloc_end = ARM64_VMALLOC_END;
-		ms->vmemmap_vaddr = ARM64_VMEMMAP_VADDR;
-		ms->vmemmap_end = ARM64_VMEMMAP_END;
 
 		switch (machdep->pagesize)
 		{
@@ -379,7 +432,14 @@
 		break;
 
 	case POST_GDB:
-		arm64_calc_virtual_memory_ranges();
+		/* Rely on kernel version to decide the kernel start address */
+		arm64_calc_kernel_start();
+
+		/*  Can we get the size of struct page before POST_GDB */
+		ms = machdep->machspec;
+		if (!ms->struct_page_size)
+			arm64_calc_virtual_memory_ranges();
+
 		arm64_get_section_size_bits();
 
 		if (!machdep->max_physmem_bits) {
@@ -394,14 +454,12 @@
 				machdep->max_physmem_bits = _MAX_PHYSMEM_BITS;
 		}
 
-		ms = machdep->machspec;
-
 		if (CRASHDEBUG(1)) {
 			if (ms->VA_BITS_ACTUAL) {
 				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);
 				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);
@@ -460,10 +518,11 @@
 			machdep->hz = 100;
 
 		arm64_irq_stack_init();
+		arm64_overflow_stack_init();
 		arm64_stackframe_init();
 		break;
 
-	case POST_VM:
+	case POST_INIT:
 		/*

_service:tar_scm:7.3.0.tar.gz/bpf.c -> _service:tar_scm:8.0.2.tar.gz/bpf.c Changed

@@ -63,6 +63,64 @@
 #define PROG_VERBOSE  (0x40)
 #define MAP_VERBOSE   (0x80)
 
+static int map_is_per_cpu(int type)
+{
+
+/* See the definition of bpf_map_type: include/uapi/linux/bpf.h */
+#define BPF_MAP_TYPE_PERCPU_HASH (5UL)
+#define BPF_MAP_TYPE_PERCPU_ARRAY (6UL)
+#define BPF_MAP_TYPE_LRU_PERCPU_HASH (10UL)
+#define BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE (21UL)
+
+	return type == BPF_MAP_TYPE_PERCPU_HASH ||
+	       type == BPF_MAP_TYPE_PERCPU_ARRAY ||
+	       type == BPF_MAP_TYPE_LRU_PERCPU_HASH ||
+	       type == BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE;
+}
+
+static int map_is_fd_map(int type)
+{
+
+/* See the definition of bpf_map_type: include/uapi/linux/bpf.h */
+#define BPF_MAP_TYPE_PROG_ARRAY (3UL)
+#define BPF_MAP_TYPE_PERF_EVENT_ARRAY (4UL)
+#define BPF_MAP_TYPE_CGROUP_ARRAY (8UL)
+#define BPF_MAP_TYPE_ARRAY_OF_MAPS (12UL)
+#define BPF_MAP_TYPE_HASH_OF_MAPS (13UL)
+
+	return type == BPF_MAP_TYPE_PROG_ARRAY ||
+	       type == BPF_MAP_TYPE_PERF_EVENT_ARRAY ||
+	       type == BPF_MAP_TYPE_CGROUP_ARRAY ||
+	       type == BPF_MAP_TYPE_ARRAY_OF_MAPS ||
+	       type == BPF_MAP_TYPE_HASH_OF_MAPS;
+
+}
+
+static ulong bpf_map_memory_size(int map_type, uint value_size,
+				uint key_size, uint max_entries)
+{
+	ulong size;
+	uint valsize;
+	int cpus = 0;
+
+	if (map_is_per_cpu(map_type)) {
+		cpus = get_cpus_possible();
+		if (!cpus) {
+			error(WARNING, "cpu_possible_map does not exist, possible cpus: %d\n", cpus);
+			return 0;
+		}
+
+		valsize = roundup(value_size, 8) * cpus;
+	} else if (map_is_fd_map(map_type))
+		valsize = sizeof(uint);
+	else
+		valsize = value_size;
+
+	size = roundup((key_size + valsize), 8);
+
+	return roundup((max_entries * size), PAGESIZE());
+}
+
 void
 cmd_bpf(void)
 {
@@ -332,7 +390,7 @@
 {
 	struct bpf_info *bpf;
 	int i, c, found, entries, type;
-	uint uid, map_pages, key_size, value_size, max_entries;
+	uint uid, map_pages, key_size = 0, value_size = 0, max_entries = 0;
 	ulong bpf_prog_aux, bpf_func, end_func, addr, insnsi, user;
 	ulong do_progs, do_maps;
 	ulonglong load_time;
@@ -572,6 +630,8 @@
 		fprintf(fp, "\n");
 
 		if (flags & (MAP_ID|MAP_VERBOSE)) {
+			ulong msize = 0;
+
 			fprintf(fp, "     KEY_SIZE: ");
 			if (VALID_MEMBER(bpf_map_key_size)) {
 				key_size = UINT(bpf->bpf_map_buf + OFFSET(bpf_map_key_size));
@@ -602,8 +662,10 @@
 			} else if (VALID_MEMBER(bpf_map_pages)) {
 				map_pages = UINT(bpf->bpf_map_buf + OFFSET(bpf_map_pages));
 				fprintf(fp, "%d\n", map_pages * PAGESIZE());
-			} else
-				fprintf(fp, "(unknown)\n");
+			} else if ((msize = bpf_map_memory_size(type, value_size, key_size, max_entries)))
+				fprintf(fp, "%ld\n", msize);
+			else
+				fprintf(fp, "(unknown)");
 
 			fprintf(fp, "     NAME: ");
 			if (VALID_MEMBER(bpf_map_name)) {
@@ -632,7 +694,7 @@
 				else
 					fprintf(fp, "(unknown)\n");
 			} else
-				fprintf(fp, "(unknown)\n");
+				fprintf(fp, "(unused)\n");
 		}
 
 		if (flags & DUMP_STRUCT) {

_service:tar_scm:7.3.0.tar.gz/cmdline.c -> _service:tar_scm:8.0.2.tar.gz/cmdline.c Changed

_service:tar_scm:7.3.0.tar.gz/configure.c -> _service:tar_scm:8.0.2.tar.gz/configure.c Changed

@@ -161,13 +161,13 @@
 
 #define GDB_TARGET_DEFAULT        "GDB_CONF_FLAGS="
 #define GDB_TARGET_ARM_ON_X86     "GDB_CONF_FLAGS=--target=arm-elf-linux"
-#define GDB_TARGET_ARM_ON_X86_64  "GDB_CONF_FLAGS=--target=arm-elf-linux CFLAGS=-m32"
-#define GDB_TARGET_X86_ON_X86_64  "GDB_CONF_FLAGS=--target=i686-pc-linux-gnu CFLAGS=-m32"
-#define GDB_TARGET_PPC_ON_PPC64   "GDB_CONF_FLAGS=--target=ppc-elf-linux CFLAGS=-m32"
+#define GDB_TARGET_ARM_ON_X86_64  "GDB_CONF_FLAGS=--target=arm-elf-linux CFLAGS=-m32 CXXFLAGS=-m32"
+#define GDB_TARGET_X86_ON_X86_64  "GDB_CONF_FLAGS=--target=i686-pc-linux-gnu CFLAGS=-m32 CXXFLAGS=-m32"
+#define GDB_TARGET_PPC_ON_PPC64   "GDB_CONF_FLAGS=--target=ppc-elf-linux CFLAGS=-m32 CXXFLAGS=-m32"
 #define GDB_TARGET_ARM64_ON_X86_64  "GDB_CONF_FLAGS=--target=aarch64-elf-linux"   /* TBD */
 #define GDB_TARGET_PPC64_ON_X86_64  "GDB_CONF_FLAGS=--target=powerpc64le-unknown-linux-gnu"
 #define GDB_TARGET_MIPS_ON_X86     "GDB_CONF_FLAGS=--target=mipsel-elf-linux"
-#define GDB_TARGET_MIPS_ON_X86_64  "GDB_CONF_FLAGS=--target=mipsel-elf-linux CFLAGS=-m32"
+#define GDB_TARGET_MIPS_ON_X86_64  "GDB_CONF_FLAGS=--target=mipsel-elf-linux CFLAGS=-m32 CXXFLAGS=-m32"
      
 /*
  *  The original plan was to allow the use of a particular version
@@ -182,9 +182,10 @@
 #define GDB_7_0   (3)
 #define GDB_7_3_1 (4)
 #define GDB_7_6   (5)
-#define SUPPORTED_GDB_VERSIONS (GDB_7_6 + 1)
+#define GDB_10_2   (6)
+#define SUPPORTED_GDB_VERSIONS (GDB_10_2 + 1)
 
-int default_gdb = GDB_7_6;
+int default_gdb = GDB_10_2;
 
 struct supported_gdb_version {
 	char *GDB;
@@ -249,6 +250,15 @@
 	    "GDB_FLAGS=-DGDB_7_6",
 	    "GPLv3"
 	},
+        {
+            "GDB=gdb-10.2",
+            "10.2",
+            "GDB_FILES=${GDB_10.2_FILES}",
+            "GDB_OFILES=${GDB_10.2_OFILES}",
+            "GDB_PATCH_FILES=gdb-10.2.patch",
+            "GDB_FLAGS=-DGDB_10_2",
+            "GPLv3"
+        },
 };
 
 #define DAEMON  0x1
@@ -1514,6 +1524,12 @@
 			fprintf(stderr, ".gdb configuration: %s\n", sp->GDB_VERSION_IN);
 			return store_gdb_defaults(sp);
 		}
+                if (strcmp(buf, "10.2") == 0) {
+                        fclose(fp);
+                        sp = &supported_gdb_versionsGDB_10_2;
+                        fprintf(stderr, ".gdb configuration: %s\n", sp->GDB_VERSION_IN);
+                        return store_gdb_defaults(sp);
+                }
 
         }
 	
@@ -1738,6 +1754,10 @@
  *    - enter -DSNAPPY in the CFLAGS.extra file
  *    - enter -lsnappy in the LDFLAGS.extra file
  *
+ *  For zstd:
+ *    - enter -DZSTD in the CFLAGS.extra file
+ *    - enter -lzstd in the LDFLAGS.extra file
+ *
  *  For valgrind:
  *    - enter -DVALGRIND in the CFLAGS.extra file
  */
@@ -1746,6 +1766,7 @@
 {
 	int lzo, add_DLZO, add_llzo2; 
 	int snappy, add_DSNAPPY, add_lsnappy;
+	int zstd, add_DZSTD, add_lzstd;
 	int valgrind, add_DVALGRIND;
 	char *cflags, *ldflags;
 	FILE *fp_cflags, *fp_ldflags;
@@ -1754,6 +1775,7 @@
 
 	lzo = add_DLZO = add_llzo2 = 0;
 	snappy = add_DSNAPPY = add_lsnappy = 0;
+	zstd = add_DZSTD = add_lzstd = 0;
 	valgrind = add_DVALGRIND = 0;
 
 	ldflags = get_extra_flags("LDFLAGS.extra", NULL);
@@ -1775,13 +1797,21 @@
 			add_lsnappy++;
 	}
 
+	if (strcmp(option, "zstd") == 0) {
+		zstd++;
+		if (!cflags || !strstr(cflags, "-DZSTD"))
+			add_DZSTD++;
+		if (!ldflags || !strstr(ldflags, "-lzstd"))
+			add_lzstd++;
+	}
+
 	if (strcmp(option, "valgrind") == 0) {
 		valgrind++;
 		if (!cflags || !strstr(cflags, "-DVALGRIND"))
 			add_DVALGRIND++;
 	}
 
-	if ((lzo || snappy) &&
+	if ((lzo || snappy || zstd) &&
 	    file_exists("diskdump.o") && (unlink("diskdump.o") < 0)) {
 		perror("diskdump.o");
 		return;
@@ -1806,24 +1836,28 @@
 		return;
 	}
 
-	if (add_DLZO || add_DSNAPPY || add_DVALGRIND) {
+	if (add_DLZO || add_DSNAPPY || add_DZSTD || add_DVALGRIND) {
 		while (fgets(inbuf, 512, fp_cflags))
 			;
 		if (add_DLZO)
 			fputs("-DLZO\n", fp_cflags);
 		if (add_DSNAPPY)
 			fputs("-DSNAPPY\n", fp_cflags);
+		if (add_DZSTD)
+			fputs("-DZSTD\n", fp_cflags);
 		if (add_DVALGRIND)
 			fputs("-DVALGRIND\n", fp_cflags);
 	}
 
-	if (add_llzo2 || add_lsnappy) {
+	if (add_llzo2 || add_lsnappy || add_lzstd) {
 		while (fgets(inbuf, 512, fp_ldflags))
 			;
 		if (add_llzo2)
 			fputs("-llzo2\n", fp_ldflags);
 		if (add_lsnappy)
 			fputs("-lsnappy\n", fp_ldflags);
+		if (add_lzstd)
+			fputs("-lzstd\n", fp_ldflags);
 	}
 
 	fclose(fp_cflags);

_service:tar_scm:7.3.0.tar.gz/crash.8 -> _service:tar_scm:8.0.2.tar.gz/crash.8 Changed

_service:tar_scm:8.0.2.tar.gz/crash_target.c Added

@@ -0,0 +1,135 @@
+/*
+ * crash_target.c
+ *
+ * Copyright (c) 2021 VMware, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Author: Alexey Makhalov <amakhalov@vmware.com>
+ */
+
+#include <defs.h>
+#include "top.h"
+#include "target.h"
+#include "inferior.h"
+#include "regcache.h"
+#include "gdbarch.h"
+
+void crash_target_init (void);
+
+extern "C" int gdb_readmem_callback(unsigned long, void *, int, int);
+extern "C" int crash_get_nr_cpus(void);
+extern "C" int crash_get_cpu_reg (int cpu, int regno, const char *regname,
+                                  int regsize, void *val);
+
+
+/* The crash target.  */
+
+static const target_info crash_target_info = {
+  "crash",
+  N_("Local core dump file"),
+  N_("Use a built-in crash instance as a target.")
+};
+
+class crash_target final : public process_stratum_target
+{
+public:
+
+  const target_info &info () const override
+  { return crash_target_info; }
+
+  void fetch_registers (struct regcache *, int) override;
+  enum target_xfer_status xfer_partial (enum target_object object,
+                                        const char *annex,
+                                        gdb_byte *readbuf,
+                                        const gdb_byte *writebuf,
+                                        ULONGEST offset, ULONGEST len,
+                                        ULONGEST *xfered_len) override;
+
+  bool has_all_memory () override { return true; }
+  bool has_memory () override { return true; }
+  bool has_stack () override { return true; }
+  bool has_registers () override { return true; }
+  bool thread_alive (ptid_t ptid) override { return true; }
+  std::string pid_to_str (ptid_t ptid) override
+  { return string_printf ("CPU %ld", ptid.tid ()); }
+
+};
+
+/* We just get all the registers, so we don't use regno.  */
+void
+crash_target::fetch_registers (struct regcache *regcache, int regno)
+{
+  gdb_byte regval16;
+  int cpu = inferior_ptid.tid();
+  struct gdbarch *arch = regcache->arch ();
+
+  for (int r = 0; r < gdbarch_num_regs (arch); r++)
+    {
+      const char *regname = gdbarch_register_name(arch, r);
+      int regsize = register_size (arch, r);
+      if (regsize > sizeof (regval))
+        error (_("fatal error: buffer size is not enough to fit register value"));
+
+      if (crash_get_cpu_reg (cpu, r, regname, regsize, (void *)&regval))
+        regcache->raw_supply (r, regval);
+      else
+        regcache->raw_supply (r, NULL);
+    }
+}
+
+
+enum target_xfer_status
+crash_target::xfer_partial (enum target_object object, const char *annex,
+                           gdb_byte *readbuf, const gdb_byte *writebuf,
+                           ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
+{
+  if (object != TARGET_OBJECT_MEMORY && object != TARGET_OBJECT_STACK_MEMORY
+      && object != TARGET_OBJECT_CODE_MEMORY)
+        return TARGET_XFER_E_IO;
+
+  if (gdb_readmem_callback(offset, (void *)(readbuf ? readbuf : writebuf), len, !readbuf))
+    {
+      *xfered_len = len;
+      return TARGET_XFER_OK;
+    }
+
+  return TARGET_XFER_E_IO;
+}
+
+#define CRASH_INFERIOR_PID 1
+
+void
+crash_target_init (void)
+{
+  int nr_cpus = crash_get_nr_cpus();
+  crash_target *target = new crash_target ();
+
+  /* Own the target until it is successfully pushed.  */
+  target_ops_up target_holder (target);
+
+  push_target (std::move (target_holder));
+
+  inferior_appeared (current_inferior (), CRASH_INFERIOR_PID);
+  for (int i = 0; i < nr_cpus; i++)
+    {
+      thread_info *thread = add_thread_silent (target,
+                                        ptid_t(CRASH_INFERIOR_PID, 0, i));
+      if (!i)
+        switch_to_thread (thread);
+    }
+
+  /* Fetch all registers from core file.  */
+  target_fetch_registers (get_current_regcache (), -1);
+
+  /* Now, set up the frame cache. */
+  reinit_frame_cache ();
+}

_service:tar_scm:7.3.0.tar.gz/defs.h -> _service:tar_scm:8.0.2.tar.gz/defs.h Changed

@@ -18,6 +18,7 @@
 
 #ifndef GDB_COMMON
 
+#include <stdbool.h>
 #include <stdio.h>
 #include <stdarg.h>
 #include <stdint.h>
@@ -54,6 +55,9 @@
 #ifdef SNAPPY
 #include <snappy-c.h>
 #endif
+#ifdef ZSTD
+#include <zstd.h>
+#endif
 
 #ifndef ATTRIBUTE_UNUSED
 #define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
@@ -132,7 +136,7 @@
 #define NR_CPUS  (4096)
 #endif
 #ifdef PPC64
-#define NR_CPUS  (2048)
+#define NR_CPUS  (8192)
 #endif
 #ifdef S390
 #define NR_CPUS  (512)
@@ -327,6 +331,7 @@
 #define NO_ELF_NOTES        (0x20)
 #define LZO_SUPPORTED       (0x40)
 #define SNAPPY_SUPPORTED    (0x80)
+#define ZSTD_SUPPORTED      (0x100)
 #define DISKDUMP_VALID()    (dd->flags & DISKDUMP_LOCAL)
 #define KDUMP_CMPRS_VALID() (dd->flags & KDUMP_CMPRS_LOCAL)
 #define KDUMP_SPLIT()       (dd->flags & DUMPFILE_SPLIT)
@@ -361,6 +366,7 @@
 #define READ_ERROR       (-2)
 #define WRITE_ERROR      (-3)
 #define PAGE_EXCLUDED    (-4)
+#define PAGE_INCOMPLETE  (-5)
 
 #define RESTART()         (longjmp(pc->main_loop_env, 1))
 #define RESUME_FOREACH()  (longjmp(pc->foreach_loop_env, 1))
@@ -510,7 +516,6 @@
 	struct sigaction gdb_sigaction; /* gdb's SIGINT sigaction. */
 	jmp_buf main_loop_env;          /* longjmp target default */
 	jmp_buf foreach_loop_env;       /* longjmp target within foreach */
-        jmp_buf gdb_interface_env;      /* longjmp target for gdb error catch */
 	struct termios termios_orig;    /* non-raw settings */
 	struct termios termios_raw;     /* while gathering command input */
 	int ncmds;                      /* number of commands in menu */
@@ -825,6 +830,7 @@
 struct tgid_context {               /* tgid and task stored for each task */
 	ulong tgid;
 	ulong task;
+	long rss_cache;
 };
 
 struct task_table {                      /* kernel/local task table data */
@@ -1058,6 +1064,7 @@
         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 *);
 };
 
 /*
@@ -2138,6 +2145,42 @@
 	long atomic_long_t_counter;
 	long block_device_bd_device;
 	long block_device_bd_stats;
+	long wait_queue_entry_private;
+	long wait_queue_head_head;
+	long wait_queue_entry_entry;
+	long printk_safe_seq_buf_len;
+	long printk_safe_seq_buf_message_lost;
+	long printk_safe_seq_buf_buffer;
+	long sbitmap_word_depth;
+	long sbitmap_word_word;
+	long sbitmap_word_cleared;
+	long sbitmap_depth;
+	long sbitmap_shift;
+	long sbitmap_map_nr;
+	long sbitmap_map;
+	long sbitmap_queue_sb;
+	long sbitmap_queue_alloc_hint;
+	long sbitmap_queue_wake_batch;
+	long sbitmap_queue_wake_index;
+	long sbitmap_queue_ws;
+	long sbitmap_queue_ws_active;
+	long sbitmap_queue_round_robin;
+	long sbitmap_queue_min_shallow_depth;
+	long sbq_wait_state_wait_cnt;
+	long sbq_wait_state_wait;
+	long sbitmap_alloc_hint;
+	long sbitmap_round_robin;
+	long request_cmd_flags;
+	long request_q;
+	long request_state;
+	long request_queue_queue_hw_ctx;
+	long request_queue_nr_hw_queues;
+	long blk_mq_hw_ctx_tags;
+	long blk_mq_tags_bitmap_tags;
+	long blk_mq_tags_breserved_tags;
+	long blk_mq_tags_nr_reserved_tags;
+	long blk_mq_tags_rqs;
+	long request_queue_hctx_table;
 };
 
 struct size_table {         /* stash of commonly-used sizes */
@@ -2300,6 +2343,14 @@
 	long printk_info;
 	long printk_ringbuffer;
 	long prb_desc;
+	long wait_queue_entry;
+	long task_struct_state;
+	long printk_safe_seq_buf_buffer;
+	long sbitmap_word;
+	long sbitmap;
+	long sbitmap_queue;
+	long sbq_wait_state;
+	long blk_mq_tags;
 };
 
 struct array_table {
@@ -2426,6 +2477,7 @@
 DEF_LOADER(short);
 typedef void *pointer_t;
 DEF_LOADER(pointer_t);
+DEF_LOADER(bool);
 
 #define LOADER(TYPE) load_##TYPE
 
@@ -2439,6 +2491,7 @@
 #define SHORT(ADDR)     LOADER(short) ((char *)(ADDR))
 #define UCHAR(ADDR)     *((unsigned char *)((char *)(ADDR)))
 #define VOID_PTR(ADDR)  ((void *) (LOADER(pointer_t) ((char *)(ADDR))))
+#define BOOL(ADDR)      LOADER(bool) ((char *)(ADDR)))
 
 #else
 
@@ -2452,6 +2505,7 @@
 #define SHORT(ADDR)     *((short *)((char *)(ADDR)))
 #define UCHAR(ADDR)     *((unsigned char *)((char *)(ADDR)))
 #define VOID_PTR(ADDR)  *((void **)((char *)(ADDR)))
+#define BOOL(ADDR)      *((bool *)((char *)(ADDR)))
 
 #endif /* NEED_ALIGNED_MEM_ACCESS */
 
@@ -2576,7 +2630,7 @@
 	long member_size;
 	int member_typecode;
 	ulong flags;
-	char *tagname;         /* tagname and value for enums */
+	const char *tagname;         /* tagname and value for enums */
 	long value;
 	ulong vaddr;
 };
@@ -2613,6 +2667,7 @@
 #define LIST_PARSE_MEMBER   (VERBOSE << 13)
 #define LIST_READ_MEMBER    (VERBOSE << 14)
 #define LIST_BRENT_ALGO     (VERBOSE << 15)
+#define LIST_HEAD_OFFSET_ENTERED  (VERBOSE << 16)
 
 struct tree_data {
 	ulong flags;
@@ -2717,8 +2772,6 @@
         (((vaddr) >> machdep->pageshift) % SYMVAL_HASH)
 
 #define SYMNAME_HASH (512)
-#define SYMNAME_HASH_INDEX(name) \
- ((name0 ^ (namestrlen(name)-1 * namestrlen(name)/2)) % SYMNAME_HASH)
 
 #define PATCH_KERNEL_SYMBOLS_START  ((char *)(1))
 #define PATCH_KERNEL_SYMBOLS_STOP   ((char *)(2))
@@ -2770,6 +2823,7 @@
 	ulong kaiser_init_vmlinux;
 	int kernel_symbol_type;
 	ulong linux_banner_vmlinux;
+	struct syment *mod_symname_hashSYMNAME_HASH;
 };
 
 /* flags for st */
@@ -2997,7 +3051,7 @@
 #define __swp_type(entry)	SWP_TYPE(entry)
 #define __swp_offset(entry)	SWP_OFFSET(entry)
 
-#define TIF_SIGPENDING		(2)
+#define TIF_SIGPENDING		(THIS_KERNEL_VERSION >= LINUX(2,6,23) ? 0 : 2)
 
 #define _SECTION_SIZE_BITS	28
 #define _MAX_PHYSMEM_BITS	32
@@ -3086,11 +3140,6 @@
 #define _64BIT_
 #define MACHINE_TYPE       "ARM64"    
 
-#define PTOV(X) \
-	((unsigned long)(X) - (machdep->machspec->physvirt_offset))
-
-#define VTOP(X)               arm64_VTOP((ulong)(X))

_service:tar_scm:7.3.0.tar.gz/dev.c -> _service:tar_scm:8.0.2.tar.gz/dev.c Changed

@@ -24,6 +24,7 @@
 static void dump_blkdevs_v3(ulong);
 static ulong search_cdev_map_probes(char *, int, int, ulong *);
 static ulong search_bdev_map_probes(char *, int, int, ulong *);
+static ulong search_blockdev_inodes(int, ulong *);
 static void do_pci(void); 
 static void do_pci2(void);
 static void do_io(void);
@@ -493,9 +494,10 @@
                 ulong ops;
         } blkdevsMAX_DEV, *bp;
 
-	if (kernel_symbol_exists("major_names") && 
-	    kernel_symbol_exists("bdev_map")) {
-                dump_blkdevs_v3(flags);
+	if (kernel_symbol_exists("major_names") &&
+	    (kernel_symbol_exists("bdev_map") ||
+	     kernel_symbol_exists("blockdev_superblock"))) {
+		dump_blkdevs_v3(flags);
 		return;
 	}
 
@@ -717,6 +719,7 @@
 	char bufBUFSIZE;
 	uint major;
 	ulong gendisk, addr, fops;
+	int use_bdev_map = kernel_symbol_exists("bdev_map");
 	
 	if (!(len = get_array_length("major_names", NULL, 0)))
 		len = MAX_DEV;
@@ -745,8 +748,11 @@
 		strncpy(buf, blk_major_name_buf +  
 			OFFSET(blk_major_name_name), 16);
 
-		fops = search_bdev_map_probes(buf, major == i ? major : i, 
-			UNUSED, &gendisk);
+		if (use_bdev_map)
+			fops = search_bdev_map_probes(buf, major == i ? major : i,
+				UNUSED, &gendisk);
+		else /* v5.11 and later */
+			fops = search_blockdev_inodes(major, &gendisk);
 
 		if (CRASHDEBUG(1))
 			fprintf(fp, "blk_major_name: %lx block major: %d name: %s gendisk: %lx fops: %lx\n", 
@@ -829,6 +835,67 @@
 	return fops;
 }
 
+/* For bdev_inode.  See block/bdev.c */
+#define I_BDEV(inode) (inode - SIZE(block_device))
+
+static ulong
+search_blockdev_inodes(int major, ulong *gendisk)
+{
+	struct list_data list_data, *ld;
+	ulong addr, bd_sb, disk, fops = 0;
+	int i, inode_count, gendisk_major;
+	char *gendisk_buf;
+
+	ld = &list_data;
+	BZERO(ld, sizeof(struct list_data));
+
+	get_symbol_data("blockdev_superblock", sizeof(void *), &bd_sb);
+
+	addr = bd_sb + OFFSET(super_block_s_inodes);
+	if (!readmem(addr, KVADDR, &ld->start, sizeof(ulong),
+	    "blockdev_superblock.s_inodes", QUIET|RETURN_ON_ERROR))
+		return 0;
+
+	if (empty_list(ld->start))
+		return 0;
+
+	ld->flags |= LIST_ALLOCATE;
+	ld->end = bd_sb + OFFSET(super_block_s_inodes);
+	ld->list_head_offset = OFFSET(inode_i_sb_list);
+
+	inode_count = do_list(ld);
+
+	gendisk_buf = GETBUF(SIZE(gendisk));
+
+	for (i = 0; i < inode_count; i++) {
+		addr = I_BDEV(ld->list_ptri) + OFFSET(block_device_bd_disk);
+		if (!readmem(addr, KVADDR, &disk, sizeof(ulong),
+		    "block_device.bd_disk", QUIET|RETURN_ON_ERROR))
+			continue;
+
+		if (!disk)
+			continue;
+
+		if (!readmem(disk, KVADDR, gendisk_buf, SIZE(gendisk),
+		    "gendisk buffer", QUIET|RETURN_ON_ERROR))
+			continue;
+
+		gendisk_major = INT(gendisk_buf + OFFSET(gendisk_major));
+		if (gendisk_major != major)
+			continue;
+
+		fops = ULONG(gendisk_buf + OFFSET(gendisk_fops));
+		if (fops) {
+			*gendisk = disk;
+			break;
+		}
+	}
+
+	FREEBUF(ld->list_ptr);
+	FREEBUF(gendisk_buf);
+	return fops;
+}
+
 void
 dump_dev_table(void)
 {
@@ -4238,15 +4305,219 @@
 	io->write = (dispatch1 - comp1);
 }
 
+typedef bool (busy_tag_iter_fn)(ulong rq, void *data);
+
+struct mq_inflight {
+	ulong q;
+	struct diskio *dio;
+};
+
+struct bt_iter_data {
+	ulong tags;
+	uint reserved;
+	uint nr_reserved_tags;
+	busy_tag_iter_fn *fn;
+	void *data;
+};
+
+/*
+ * See the include/linux/blk_types.h and include/linux/blk-mq.h
+ */
+#define MQ_RQ_IN_FLIGHT 1
+#define REQ_OP_BITS     8
+#define REQ_OP_MASK     ((1 << REQ_OP_BITS) - 1)
+
+static uint op_is_write(uint op)
+{
+	return (op & REQ_OP_MASK) & 1;
+}
+
+static bool mq_check_inflight(ulong rq, void *data)
+{
+	uint cmd_flags = 0, state = 0;
+	ulong addr = 0, queue = 0;
+	struct mq_inflight *mi = data;
+
+	if (!IS_KVADDR(rq))
+		return TRUE;
+
+	addr = rq + OFFSET(request_q);
+	if (!readmem(addr, KVADDR, &queue, sizeof(ulong), "request.q", RETURN_ON_ERROR))
+		return FALSE;
+
+	addr = rq + OFFSET(request_cmd_flags);
+	if (!readmem(addr, KVADDR, &cmd_flags, sizeof(uint), "request.cmd_flags", RETURN_ON_ERROR))
+		return FALSE;
+
+	addr = rq + OFFSET(request_state);
+	if (!readmem(addr, KVADDR, &state, sizeof(uint), "request.state", RETURN_ON_ERROR))
+		return FALSE;
+
+	if (queue == mi->q && state == MQ_RQ_IN_FLIGHT) {
+		if (op_is_write(cmd_flags))
+			mi->dio->write++;
+		else
+			mi->dio->read++;
+	}
+
+	return TRUE;
+}
+
+static bool bt_iter(uint bitnr, void *data)
+{
+	ulong addr = 0, rqs_addr = 0, rq = 0;
+	struct bt_iter_data *iter_data = data;
+	ulong tag = iter_data->tags;
+
+	if (!iter_data->reserved)
+		bitnr += iter_data->nr_reserved_tags;
+
+	/* rqs */
+	addr = tag + OFFSET(blk_mq_tags_rqs);
+	if (!readmem(addr, KVADDR, &rqs_addr, sizeof(void *), "blk_mq_tags.rqs", RETURN_ON_ERROR))
+		return FALSE;
+
+	addr = rqs_addr + bitnr * sizeof(ulong); /* rqsbitnr */
+	if (!readmem(addr, KVADDR, &rq, sizeof(ulong), "blk_mq_tags.rqs", RETURN_ON_ERROR))
+		return FALSE;
+
+	return iter_data->fn(rq, iter_data->data);
+}
+
+static void bt_for_each(ulong q, ulong tags, ulong sbq, uint reserved, uint nr_resvd_tags, struct diskio *dio)
+{
+	struct sbitmap_context sc = {0};
+	struct mq_inflight mi = {
+		.q = q,

_service:tar_scm:7.3.0.tar.gz/diskdump.c -> _service:tar_scm:8.0.2.tar.gz/diskdump.c Changed

@@ -74,6 +74,7 @@
 	ulong	evictions;		/* total evictions done */
 	ulong	cached_reads;
 	ulong  *valid_pages;
+	int     max_sect_len;           /* highest bucket of valid_pages */
 	ulong   accesses;
 	ulong	snapshot_task;
 };
@@ -110,8 +111,7 @@
 	if (pc->flags2 & QEMU_MEM_DUMP_COMPRESSED)  /* notes exist for all cpus */
 		goto resize_note_pointers;
 
-	if (!(online = get_cpus_online()) || (online == kt->cpus) || 
-	    machine_type("ARM64"))
+	if (!(online = get_cpus_online()) || (online == kt->cpus))
 		goto resize_note_pointers;
 
 	if (CRASHDEBUG(1))
@@ -509,6 +509,27 @@
 }
 #endif  /* __i386__ && (ARM || MIPS) */
 
+/*
+ * Read page descriptor.
+ */
+static int
+read_pd(int fd, off_t offset, page_desc_t *pd)
+{
+	const off_t failed = (off_t)-1;
+
+	if (FLAT_FORMAT()) {
+		if (!read_flattened_format(fd, offset, pd, sizeof(*pd)))
+			return READ_ERROR;
+	} else {
+		if (lseek(fd, offset, SEEK_SET) == failed)
+			return SEEK_ERROR;
+		if (read(fd, pd, sizeof(*pd)) != sizeof(*pd))
+			return READ_ERROR;
+	}
+
+	return 0;
+}
+
 static int 
 read_dump_header(char *file)
 {
@@ -517,15 +538,13 @@
 	struct kdump_sub_header *sub_header_kdump = NULL;
 	size_t size;
 	off_t bitmap_len;
-	char *bufptr;
-	size_t len;
-	ssize_t bytes_read;
 	int block_size = (int)sysconf(_SC_PAGESIZE);
 	off_t offset;
 	const off_t failed = (off_t)-1;
 	ulong pfn;
 	int i, j, max_sect_len;
 	int is_split = 0;
+	ulonglong tmp, *bitmap;
 
 	if (block_size < 0)
 		return FALSE;
@@ -702,10 +721,6 @@
 
 	offset = (off_t)block_size * (1 + header->sub_hdr_size);
 
-	if ((dd->bitmap = malloc(bitmap_len)) == NULL)
-		error(FATAL, "%s: cannot malloc bitmap buffer\n",
-			DISKDUMP_VALID() ? "diskdump" : "compressed kdump");
-
 	dd->dumpable_bitmap = calloc(bitmap_len, 1);
 
 	if (CRASHDEBUG(8))
@@ -714,30 +729,23 @@
 			(ulonglong)offset);
 
 	if (FLAT_FORMAT()) {
+		if ((dd->bitmap = malloc(bitmap_len)) == NULL)
+			error(FATAL, "%s: cannot malloc bitmap buffer\n",
+				DISKDUMP_VALID() ? "diskdump" : "compressed kdump");
+
 		if (!read_flattened_format(dd->dfd, offset, dd->bitmap, bitmap_len)) {
 			error(INFO, "%s: cannot read memory bitmap\n",
 				DISKDUMP_VALID() ? "diskdump" : "compressed kdump");
 			goto err;
 		}
 	} else {
-		if (lseek(dd->dfd, offset, SEEK_SET) == failed) {
-			error(INFO, "%s: cannot lseek memory bitmap\n",
+		dd->bitmap = mmap(NULL, bitmap_len, PROT_READ,
+					MAP_SHARED, dd->dfd, offset);
+		if (dd->bitmap == MAP_FAILED)
+			error(FATAL, "%s: cannot mmap bitmap buffer\n",
 				DISKDUMP_VALID() ? "diskdump" : "compressed kdump");
-			goto err;
-		}
-		bufptr = dd->bitmap;
-		len = bitmap_len;
-		while (len) {
-			bytes_read = read(dd->dfd, bufptr, len);
-			if (bytes_read <= 0) {
-				error(INFO, "%s: cannot read memory bitmap\n",
-					DISKDUMP_VALID() ? "diskdump"
-					: "compressed kdump");
-				goto err;
-			}
-			len -= bytes_read;
-			bufptr += bytes_read;
-		}
+
+		madvise(dd->bitmap, bitmap_len, MADV_WILLNEED);
 	}
 
 	if (dump_is_partial(header))
@@ -877,11 +885,17 @@
 	}
 
 	dd->valid_pages = calloc(sizeof(ulong), max_sect_len + 1);
+	dd->max_sect_len = max_sect_len;
+
+	/* It is safe to convert it to (ulonglong *). */
+	bitmap = (ulonglong *)dd->dumpable_bitmap;
 	for (i = 1; i < max_sect_len + 1; i++) {
 		dd->valid_pagesi = dd->valid_pagesi - 1;
-		for (j = 0; j < BITMAP_SECT_LEN; j++, pfn++)
-			if (page_is_dumpable(pfn))
-				dd->valid_pagesi++;
+		for (j = 0; j < BITMAP_SECT_LEN; j += 64, pfn += 64) {
+			tmp = bitmappfn >> 6;
+			if (tmp)
+				dd->valid_pagesi += hweight64(tmp);
+		}
 	}
 
         return TRUE;
@@ -892,8 +906,12 @@
 		free(sub_header);
 	if (sub_header_kdump)
 		free(sub_header_kdump);
-	if (dd->bitmap)
-		free(dd->bitmap);
+	if (dd->bitmap) {
+		if (FLAT_FORMAT())
+			free(dd->bitmap);
+		else
+			munmap(dd->bitmap, dd->bitmap_len);
+	}
 	if (dd->dumpable_bitmap)
 		free(dd->dumpable_bitmap);
 	if (dd->notes_buf)
@@ -978,6 +996,9 @@
 #ifdef SNAPPY
 	dd->flags |= SNAPPY_SUPPORTED;
 #endif
+#ifdef ZSTD
+	dd->flags |= ZSTD_SUPPORTED;
+#endif
 
 	pc->read_vmcoreinfo = vmcoreinfo_read_string;
 
@@ -1101,6 +1122,9 @@
 	const int block_size = dd->block_size;
 	const off_t failed = (off_t)-1;
 	ulong retlen;
+#ifdef ZSTD
+	static ZSTD_DCtx *dctx = NULL;
+#endif
 
 	for (i = found = 0; i < DISKDUMP_CACHED_PAGES; i++) {
 		if (DISKDUMP_VALID_PAGE(dd->page_cache_hdri.pg_flags))
@@ -1128,15 +1152,9 @@
 			+ (off_t)(desc_pos - 1)*sizeof(page_desc_t);
 
 	/* read page descriptor */
-	if (FLAT_FORMAT()) {
-		if (!read_flattened_format(dd->dfd, seek_offset, &pd, sizeof(pd)))
-			return READ_ERROR;
-	} else {
-		if (lseek(dd->dfd, seek_offset, SEEK_SET) == failed)
-			return SEEK_ERROR;
-		if (read(dd->dfd, &pd, sizeof(pd)) != sizeof(pd))
-			return READ_ERROR;
-	}
+	ret = read_pd(dd->dfd, seek_offset, &pd);
+	if (ret)
+		return ret;
 
 	/* sanity check */
 	if (pd.size > block_size)
@@ -1146,10 +1164,9 @@
 	if (FLAT_FORMAT()) {
 		if (!read_flattened_format(dd->dfd, pd.offset, dd->compressed_page, pd.size))
 			return READ_ERROR;
-	} else if (is_incomplete_dump() && (0 == pd.offset)) {
+	} else if (0 == pd.offset) {
 		/*
-		 *  If the incomplete flag has been set in the header, 
-		 *  first check whether zero_excluded has been set.
+		 *  First check whether zero_excluded has been set.

_service:tar_scm:7.3.0.tar.gz/diskdump.h -> _service:tar_scm:8.0.2.tar.gz/diskdump.h Changed

_service:tar_scm:7.3.0.tar.gz/extensions/Makefile -> _service:tar_scm:8.0.2.tar.gz/extensions/Makefile Changed

_service:tar_scm:7.3.0.tar.gz/extensions/eppic.mk -> _service:tar_scm:8.0.2.tar.gz/extensions/eppic.mk Changed

_service:tar_scm:7.3.0.tar.gz/filesys.c -> _service:tar_scm:8.0.2.tar.gz/filesys.c Changed

_service:tar_scm:8.0.2.tar.gz/gdb-10.2.patch Added

@@ -0,0 +1,1739 @@
+
+# When this file is updated in an existing source tree, it gets re-applied
+# during the next build using "patch -N --fuzz=0", which ignores patches
+# that have already been applied.  However, if a gdb file has been modified
+# multiple times, the subsequent patching may fail to recognize that a
+# given patch has been previously applied, and will attempt to re-apply it.
+# To prevent any uninintended consequences, this file also acts as a
+# shell script that can restore any gdb file to its original state prior
+# to all subsequent patch applications.
+
+tar xvzmf gdb-10.2.tar.gz \
+	gdb-10.2/gdb/symtab.c \
+	gdb-10.2/gdb/printcmd.c \
+	gdb-10.2/gdb/symfile.c \
+	gdb-10.2/gdb/Makefile.in
+
+exit 0
+
+--- gdb-10.2/Makefile.in.orig
++++ gdb-10.2/Makefile.in
+@@ -340,6 +340,9 @@ AR_FOR_BUILD = @AR_FOR_BUILD@
+ AS_FOR_BUILD = @AS_FOR_BUILD@
+ CC_FOR_BUILD = @CC_FOR_BUILD@
+ CFLAGS_FOR_BUILD = @CFLAGS_FOR_BUILD@
++ifeq (${CRASH_TARGET}, PPC64)
++CFLAGS_FOR_BUILD += -m64 -fPIC
++endif
+ CXXFLAGS_FOR_BUILD = @CXXFLAGS_FOR_BUILD@
+ CXX_FOR_BUILD = @CXX_FOR_BUILD@
+ DLLTOOL_FOR_BUILD = @DLLTOOL_FOR_BUILD@
+@@ -406,6 +409,9 @@ GNATBIND = @GNATBIND@
+ GNATMAKE = @GNATMAKE@
+ 
+ CFLAGS = @CFLAGS@
++ifeq (${CRASH_TARGET}, PPC64)
++CFLAGS += -m64 -fPIC
++endif
+ LDFLAGS = @LDFLAGS@
+ LIBCFLAGS = $(CFLAGS)
+ CXXFLAGS = @CXXFLAGS@
+--- gdb-10.2/gdb/Makefile.in.orig
++++ gdb-10.2/gdb/Makefile.in
+@@ -571,7 +571,7 @@ CONFIG_DEP_SUBDIR = $(addsuffix /$(DEPDIR),$(CONFIG_SRC_SUBDIR))
+ # It is also possible that you will need to add -I/usr/include/sys if
+ # your system doesn't have fcntl.h in /usr/include (which is where it
+ # should be according to Posix).
+-DEFS = @DEFS@
++DEFS = -DCRASH_MERGE @DEFS@
+ GDB_CFLAGS = -I. -I$(srcdir) -I$(srcdir)/config \
+ 	-DLOCALEDIR="\"$(localedir)\"" $(DEFS)
+ 
+@@ -1135,6 +1135,7 @@ COMMON_SFILES = \
+ 	symmisc.c \
+ 	symtab.c \
+ 	target.c \
++	../../crash_target.c \
+ 	target-connection.c \
+ 	target-dcache.c \
+ 	target-descriptions.c \
+@@ -1564,7 +1565,7 @@ COMMON_OBS = $(DEPFILES) $(CONFIG_OBS) $(YYOBJ) \
+ 	$(SUBDIR_TARGET_OBS) \
+ 	$(SUBDIR_GCC_COMPILE_OBS)
+ 
+-SUBDIRS = doc @subdirs@ data-directory
++SUBDIRS = build_no_subdirs
+ CLEANDIRS = $(SUBDIRS)
+ 
+ # List of subdirectories in the build tree that must exist.
+@@ -1606,8 +1607,8 @@ generated_files = \
+ # Flags needed to compile Python code
+ PYTHON_CFLAGS = @PYTHON_CFLAGS@
+ 
+-all: gdb$(EXEEXT) $(CONFIG_ALL) gdb-gdb.py gdb-gdb.gdb
+-	@$(MAKE) $(FLAGS_TO_PASS) DO=all "DODIRS=`echo $(SUBDIRS) | sed 's/testsuite//'`" subdir_do
++all: gdb$(EXEEXT) gdb-gdb.py gdb-gdb.gdb
++	@$(MAKE) -s $(FLAGS_TO_PASS) DO=all "DODIRS=`echo $(SUBDIRS) | sed 's/testsuite//'`" subdir_do
+ 
+ # Rule for compiling .c files in the top-level gdb directory.
+ # The order-only dependencies ensure that we create the build subdirectories.
+@@ -1864,9 +1865,10 @@ libgdb.a: $(LIBGDB_OBS)
+ # Removing the old gdb first works better if it is running, at least on SunOS.
+ gdb$(EXEEXT): gdb.o $(LIBGDB_OBS) $(CDEPS) $(TDEPLIBS)
+ 	$(SILENCE) rm -f gdb$(EXEEXT)
++	@(cd ../..; make --no-print-directory GDB_FLAGS=-DGDB_10_2 library)
+ 	$(ECHO_CXXLD) $(CC_LD) $(INTERNAL_LDFLAGS) $(WIN32LDAPP) \
+-		-o gdb$(EXEEXT) gdb.o $(LIBGDB_OBS) \
+-		$(TDEPLIBS) $(TUI_LIBRARY) $(CLIBS) $(LOADLIBES)
++                -o $(shell /bin/cat mergeobj) $(LIBGDB_OBS) \
++                $(TDEPLIBS) $(TUI_LIBRARY) $(CLIBS) $(LOADLIBES) $(shell /bin/cat mergelibs)
+ ifneq ($(CODESIGN_CERT),)
+ 	$(ECHO_SIGN) $(CODESIGN) -s $(CODESIGN_CERT) gdb$(EXEEXT)
+ endif
+@@ -2530,9 +2532,9 @@ ifeq ($(DEPMODE),depmode=gcc3)
+ # into place if the compile succeeds.  We need this because gcc does
+ # not atomically write the dependency output file.
+ override COMPILE.post = -c -o $@ -MT $@ -MMD -MP \
+-	-MF $(@D)/$(DEPDIR)/$(basename $(@F)).Tpo
+-override POSTCOMPILE = @mv $(@D)/$(DEPDIR)/$(basename $(@F)).Tpo \
+-	$(@D)/$(DEPDIR)/$(basename $(@F)).Po
++        -MF $(subst ../..,.,$(@D))/$(DEPDIR)/$(basename $(@F)).Tpo
++override POSTCOMPILE = @mv $(subst ../..,.,$(@D))/$(DEPDIR)/$(basename $(@F)).Tpo \
++        $(subst ../..,.,$(@D))/$(DEPDIR)/$(basename $(@F)).Po
+ else
+ override COMPILE.pre = source='$<' object='$@' libtool=no \
+ 	DEPDIR=$(DEPDIR) $(DEPMODE) $(depcomp) \
+--- gdb-10.2/gdb/cli/cli-cmds.c.orig
++++ gdb-10.2/gdb/cli/cli-cmds.c
+@@ -435,6 +435,11 @@ complete_command (const char *arg, int from_tty)
+     }
+ }
+ 
++#ifdef CRASH_MERGE
++static int crash_from_tty = 0;
++extern "C" void untrusted_file(FILE *, char *);
++#endif
++
+ int
+ is_complete_command (struct cmd_list_element *c)
+ {
+@@ -654,8 +659,32 @@ find_and_open_script (const char *script_file, int search_path)
+       close (fd);
+       errno = save_errno;
+     }
+-  else
+-    opened.emplace (gdb_file_up (result), std::move (full_path));
++#ifdef CRASH_MERGE
++  /*
++   * Only allow trusted versions of .gdbinit files to be
++   * sourced during session initialization.
++   */
++  if (crash_from_tty == -1)
++    {
++      struct stat statbuf;
++      FILE *stream = result;
++      int _fd = fileno (stream);
++      if (fstat (_fd, &statbuf) < 0)
++        {
++          perror_with_name (full_path.get());
++          fclose (stream);
++          return opened;
++        }
++      if (statbuf.st_uid != getuid () || (statbuf.st_mode & S_IWOTH))
++        {
++          untrusted_file(NULL, full_path.get());
++          fclose (stream);
++          return opened;
++        }
++    }
++#endif
++  opened.emplace (gdb_file_up (result), std::move (full_path));
++
+ 
+   return opened;
+ }
+@@ -719,7 +748,11 @@ source_script_with_search (const char *file, int from_tty, int search_path)
+          If the source command was invoked interactively, throw an
+ 	 error.  Otherwise (e.g. if it was invoked by a script),
+ 	 just emit a warning, rather than cause an error.  */
++#ifdef CRASH_MERGE
++      if (from_tty > 0)
++#else
+       if (from_tty)
++#endif
+ 	perror_with_name (file);
+       else
+ 	{
+@@ -743,7 +776,14 @@ source_script_with_search (const char *file, int from_tty, int search_path)
+ void
+ source_script (const char *file, int from_tty)
+ {
++#ifdef CRASH_MERGE
++  crash_from_tty = from_tty;
++#endif
+   source_script_with_search (file, from_tty, 0);
++#ifdef CRASH_MERGE
++  crash_from_tty = 0;
++#endif
++
+ }
+ 
+ static void
+--- gdb-10.2/gdb/defs.h.orig
++++ gdb-10.2/gdb/defs.h
+@@ -629,4 +629,7 @@ DEF_ENUM_FLAGS_TYPE (enum user_selected_what_flag, user_selected_what);
+ 
+ #include "utils.h"
+ 
++#ifdef CRASH_MERGE
++extern "C" int gdb_main_entry(int, char **);
++#endif
+ #endif /* #ifndef DEFS_H */
+--- gdb-10.2/gdb/dwarf2/read.c.orig
++++ gdb-10.2/gdb/dwarf2/read.c
+@@ -3015,7 +3015,11 @@ read_gdb_index_from_buffer (const char *filename,
+      indices.  */
+   if (version < 4)
+     {
++#ifdef CRASH_MERGE
++      static int warning_printed = 1;

_service:tar_scm:7.3.0.tar.gz/gdb_interface.c -> _service:tar_scm:8.0.2.tar.gz/gdb_interface.c Changed

@@ -17,18 +17,21 @@
 
 #include "defs.h"
 
+#ifndef GDB_10_2
 static void exit_after_gdb_info(void);
+#endif
 static int is_restricted_command(char *, ulong);
 static void strip_redirection(char *);
 int get_frame_offset(ulong);
 
 int *gdb_output_format;
 unsigned int *gdb_print_max;
-int *gdb_prettyprint_structs;
-int *gdb_prettyprint_arrays;
-int *gdb_repeat_count_threshold;
-int *gdb_stop_print_at_null;
+unsigned char *gdb_prettyprint_structs;
+unsigned char *gdb_prettyprint_arrays;
+unsigned int *gdb_repeat_count_threshold;
+unsigned char *gdb_stop_print_at_null;
 unsigned int *gdb_output_radix;
+static void gdb_error_debug(void);
 
 static ulong gdb_user_print_option_address(char *);
 
@@ -68,11 +71,13 @@
 	}
 
         optind = 0;
+#ifndef GDB_10_2
 #if defined(GDB_5_3) || defined(GDB_6_0) || defined(GDB_6_1)
         command_loop_hook = main_loop;
 #else
 	deprecated_command_loop_hook = main_loop;
 #endif
+#endif
         gdb_main_entry(argc, argv);
 }
 
@@ -117,22 +122,26 @@
 display_gdb_banner(void)
 {
 	optind = 0;
+#ifndef GDB_10_2
 #if defined(GDB_5_3) || defined(GDB_6_0) || defined(GDB_6_1)
         command_loop_hook = exit_after_gdb_info;
 #else
         deprecated_command_loop_hook = exit_after_gdb_info;
 #endif
+#endif
 	args0 = "gdb";
 	args1 = "-version";
 	gdb_main_entry(2, args);
 }
 
+#ifndef GDB_10_2
 static void
 exit_after_gdb_info(void)
 {
         fprintf(fp, "\n");
         clean_exit(0);
 }
+#endif
 
 /* 
  *  Stash a copy of the gdb version locally.  This can be called before
@@ -186,13 +195,13 @@
 		gdb_user_print_option_address("output_format");
 	gdb_print_max = (unsigned int *)
 		gdb_user_print_option_address("print_max");
-	gdb_prettyprint_structs = (int *)
+	gdb_prettyprint_structs = (unsigned char *)
 		gdb_user_print_option_address("prettyprint_structs");
-	gdb_prettyprint_arrays = (int *)
+	gdb_prettyprint_arrays = (unsigned char *)
 		gdb_user_print_option_address("prettyprint_arrays");
-	gdb_repeat_count_threshold = (int *)
+	gdb_repeat_count_threshold = (unsigned int *)
 		gdb_user_print_option_address("repeat_count_threshold");
-	gdb_stop_print_at_null = (int *)
+	gdb_stop_print_at_null = (unsigned char *)
 		gdb_user_print_option_address("stop_print_at_null");
 	gdb_output_radix = (unsigned int *)
 		gdb_user_print_option_address("output_radix");
@@ -291,6 +300,19 @@
 	sprintf(req->buf, "set width 0");
 	gdb_interface(req);
 
+#ifdef GDB_10_2
+	req->command = GNU_PASS_THROUGH;
+	req->name = NULL, req->flags = 0;
+	sprintf(req->buf, "set max-value-size unlimited");
+	gdb_interface(req);
+
+	req->command = GNU_PASS_THROUGH;
+	req->name = NULL, req->flags = 0;
+	sprintf(req->buf, "set max-completions unlimited");
+	gdb_interface(req);
+#endif
+
+#if 0
        /*
         *  Patch gdb's symbol values with the correct values from either
         *  the System.map or non-debug vmlinux, whichever is in effect.
@@ -303,6 +325,9 @@
         	if (req->flags & GNU_COMMAND_FAILED)
 			error(FATAL, "patching of gdb symbol values failed\n");
 	} else if (!(pc->flags & SILENT))
+#else
+        if (!(pc->flags & SILENT))
+#endif
 		fprintf(fp, "\n");
 
 
@@ -364,19 +389,6 @@
 	pc->cur_req = req;
 	pc->cur_gdb_cmd = req->command;
 
-	if (req->flags & GNU_RETURN_ON_ERROR) {
-		error_hook = gdb_error_hook;
-        	if (setjmp(pc->gdb_interface_env)) {
-			pc->last_gdb_cmd = pc->cur_gdb_cmd;
-			pc->cur_gdb_cmd = 0;
-			pc->cur_req = NULL;
-			req->flags |= GNU_COMMAND_FAILED;
-			pc->flags &= ~IN_GDB;
-			return;
-		}
-	} else
-		error_hook = NULL;
-
 	if (CRASHDEBUG(2))
 		dump_gnu_request(req, IN_GDB);
 
@@ -400,10 +412,12 @@
 	SIGACTION(SIGINT, restart, &pc->sigaction, NULL);
 	SIGACTION(SIGSEGV, SIG_DFL, &pc->sigaction, NULL);
 
+        if (req->flags & GNU_COMMAND_FAILED)
+                gdb_error_debug();
+
 	if (CRASHDEBUG(2))
 		dump_gnu_request(req, !IN_GDB);
 
-	error_hook = NULL;
         pc->last_gdb_cmd = pc->cur_gdb_cmd;
         pc->cur_gdb_cmd = 0;
 	pc->cur_req = NULL;
@@ -627,8 +641,6 @@
         *gdb_prettyprint_structs = 1;   /* these may piss somebody off... */
 	*gdb_repeat_count_threshold = 0x7fffffff;
 
-	error_hook = NULL;
-
 	if (st->flags & ADD_SYMBOL_FILE) {
 		error(INFO, 
 		    "%s\n     gdb add-symbol-file command failed\n", 
@@ -698,11 +710,10 @@
 	"run", "r", "break", "b", "tbreak", "hbreak", "thbreak", "rbreak",
 	"watch", "rwatch", "awatch", "attach", "continue", "c", "fg", "detach", 
 	"finish", "handle", "interrupt", "jump", "kill", "next", "nexti", 
-	"signal", "step", "s", "stepi", "target", "thread", "until", "delete", 
-	"clear", "disable", "enable", "condition", "ignore", "frame", 
-	"select-frame", "f", "up", "down", "catch", "tcatch", "return",
-	"file", "exec-file", "core-file", "symbol-file", "load", "si", "ni", 
-	"shell", "sy",
+	"signal", "step", "s", "stepi", "target", "until", "delete", 
+	"clear", "disable", "enable", "condition", "ignore", "frame", "catch",
+	"tcatch", "return", "file", "exec-file", "core-file", "symbol-file",
+	"load", "si", "ni", "shell", "sy",
 	NULL  /* must be last */
 };
 
@@ -742,13 +753,6 @@
 		}
 	}
 
-	if (kt->relocate && 
-	    STRNEQ("disassemble", cmd) && STRNEQ(cmd, "disas"))
-               	error(FATAL, 
-		    "the gdb \"disassemble\" command is prohibited because the kernel text\n"
-		    "%swas relocated%s; use the crash \"dis\" command instead.\n",
-			space(strlen(pc->curcmd)+2), kt->flags2 & KASLR ? " by KASLR" : "");
-	
 	return FALSE;
 }
 
@@ -824,7 +828,6 @@
 gdb_readmem_callback(ulong addr, void *buf, int len, int write)
 { 
 	char locbufSIZEOF_32BIT, *p1;
-	uint32_t *p2;
 	int memtype;
 	ulong readflags;
 
@@ -881,19 +884,12 @@
 		}
 
 		p1 = (char *)buf;

_service:tar_scm:7.3.0.tar.gz/global_data.c -> _service:tar_scm:8.0.2.tar.gz/global_data.c Changed

_service:tar_scm:7.3.0.tar.gz/help.c -> _service:tar_scm:8.0.2.tar.gz/help.c Changed

@@ -535,7 +535,7 @@
 	oflag = 0;
 
         while ((c = getopt(argcnt, args, 
-	        "efNDdmM:ngcaBbHhkKsvVoptTzLxOr")) != EOF) {
+	        "efNDdmM:ngcaBbHhkKsvVoptTzLOr")) != EOF) {
                 switch(c)
                 {
 		case 'e':
@@ -551,10 +551,6 @@
 			dumpfile_memory(DUMPFILE_MEM_DUMP);
 			return;
 
-		case 'x':
-			dump_text_value_cache(VERBOSE);
-			return;
-
 		case 'd':
 			dump_dev_table();
 			return;
@@ -666,7 +662,6 @@
 			fprintf(fp, " -T - task_table plus context_array\n");
 			fprintf(fp, " -v - vm_table\n");
 			fprintf(fp, " -V - vm_table (verbose)\n");
-			fprintf(fp, " -x - text cache\n");
 			fprintf(fp, " -z - help options\n");
 			return;
 
@@ -967,6 +962,111 @@
 NULL
 };
 
+char *help_sbitmapq = {
+"sbitmapq",
+"sbitmap_queue struct contents",
+"-s struct.member,member -a address -p -v -x|d address",
+"  The command dumps the contents of the sbitmap_queue structure and",
+"  the used bits in the bitmap. Also, it shows the dump of a structure",
+"  array associated with the sbitmap_queue.",
+"",
+"  The arguments are as follows:",
+"",
+"   -s struct  name of a C-code structure, that is stored in an array",
+"              associated with sbitmap_queue structure. Use the",
+"              \"struct.member\" format in order to display a particular",
+"              member of the structure. -s option requires -a option",
+"  -a address  address of a structure array associated with sbitmap_queue",
+"              structure. The set bits in sbitmap are used for the index",
+"              in an associated array.",
+"          -p  associated with sbitmap_queue array contains the points of",
+"              structure.",
+"          -x  override default output format with hexadecimal format.",
+"          -d  override default output format with decimal format.",
+"          -v  By default, the sbitmap command shows only a used sbitmap",
+"              index and a structure address in the associated array.",
+"              This flag says to print a formatted display of the",
+"              contents of a structure in an associated array. -v option",
+"              requires of -s.",
+"",
+"EXAMPLES",
+"",
+"  All examples are shown on the base of Linux Target system with iSCSI",
+"  transport.",
+"",
+"  Display the common sbitmap information for target session:",
+"",
+"    %s> struct -oh se_session 0xc0000000e118c760 | grep sbitmap_queue",
+"      c0000000e118c808 struct sbitmap_queue sess_tag_pool;",
+"    %s>",
+"    %s> sbitmapq c0000000e118c808",
+"    depth = 136",
+"    busy = 4",
+"    cleared = 26",
+"    bits_per_word = 32",
+"    map_nr = 5",
+"    alloc_hint = {74, 36, 123, 101}",
+"    wake_batch = 8",
+"    wake_index = 0",
+"    ws_active = 0",
+"    ws = {",
+"            { .wait_cnt = 8, .wait = inactive },",
+"            { .wait_cnt = 8, .wait = inactive },",
+"            { .wait_cnt = 8, .wait = inactive },",
+"            { .wait_cnt = 8, .wait = inactive },",
+"            { .wait_cnt = 8, .wait = inactive },",
+"            { .wait_cnt = 8, .wait = inactive },",
+"            { .wait_cnt = 8, .wait = inactive },",
+"            { .wait_cnt = 8, .wait = inactive },",
+"    }",
+"    round_robin = 0",
+"    min_shallow_depth = 4294967295",
+"",
+"    00000000: 0000 0000 0000 0000 0030 0000 0000 0000",
+"    00000010: 00",
+"",
+"  Display the addresses of structure are associated with",
+"  sbitmap_queue (for iscsi it is 'iscsi_cmd' structure):",
+"",
+"    %s> struct se_session 0xc0000000e118c760 | grep sess_cmd_map",
+"      sess_cmd_map = 0xc0000000671c0000,",
+"    %s>",
+"    %s> sbitmapq -s iscsi_cmd -a 0xc0000000671c0000 c0000000e118c808",
+"    76: 0xc0000000671d5600",
+"    77: 0xc0000000671d5a80",
+"",
+"  Dump of formatted content of structures:",
+"",
+"    %s> sbitmapq -s iscsi_cmd -a 0xc0000000671c0000 -v c0000000e118c808",
+"    76 (0xc0000000671d5600):",
+"    struct iscsi_cmd {",
+"      dataout_timer_flags = 0,",
+"      dataout_timeout_retries = 0 '\\000',",
+"      error_recovery_count = 0 '\\000',",
+"      deferred_i_state = ISTATE_NO_STATE,",
+"      i_state = ISTATE_SENT_STATUS,",
+"      ...",
+"      first_data_sg = 0xc0000000e306b080,",
+"      first_data_sg_off = 0,",
+"      kmapped_nents = 1,",
+"      sense_reason = 0",
+"    }",
+"    77 (0xc0000000671d5a80):",
+"    struct iscsi_cmd {",
+"      dataout_timer_flags = 0,",
+"      dataout_timeout_retries = 0 '\\000',",
+"      error_recovery_count = 0 '\\000',",
+"      deferred_i_state = ISTATE_NO_STATE,",
+"      i_state = ISTATE_NEW_CMD,",
+"      ...",
+"      first_data_sg = 0x0,",
+"      first_data_sg_off = 0,",
+"      kmapped_nents = 0,",
+"      sense_reason = 0",
+"    }",
+NULL
+};
+
 char *help_quit = {
 "quit",
 "exit this session",
@@ -1026,7 +1126,6 @@
 "    -T - task_table plus context_array",
 "    -v - vm_table",
 "    -V - vm_table (verbose)",
-"    -x - text cache",
 "    -z - help options",
 NULL               
 };
@@ -1810,12 +1909,14 @@
 "bt",
 "backtrace",
 "-a|-c cpu(s)|-g|-r|-t|-T|-l|-e|-E|-f|-F|-o|-O|-v|-p -R ref -s -x|d"
-"\n     -I ip -S sp pid | task",
+"\n     -I ip -S sp -n idle pid | task",
 "  Display a kernel stack backtrace.  If no arguments are given, the stack",
 "  trace of the current context will be displayed.\n",
 "       -a  displays the stack traces of the active task on each CPU.",
 "           (only applicable to crash dumps)",
 "       -A  same as -a, but also displays vector registers (S390X only).",
+"  -n idle  filter the stack of idle tasks (x86_64, arm64).",
+"           (only applicable to crash dumps)",
 "       -p  display the stack trace of the panic task only.",
 "           (only applicable to crash dumps)",
 "   -c cpu  display the stack trace of the active task on one or more CPUs,",
@@ -1905,6 +2006,35 @@
 "       DS:  002b      ESI: bfffc8a0  ES:  002b      EDI: 00000000 ",
 "       SS:  002b      ESP: bfffc82c  EBP: bfffd224 ",
 "       CS:  0023      EIP: 400d032e  ERR: 0000008e  EFLAGS: 00000246  ",
+" ",
+"  Display the stack trace of the active task(s) when the kernel panicked,",
+"  and filter out the stack of the idle tasks:",
+" ",
+"    %s> bt -a -n idle",
+"    ...",
+"    PID: 0      TASK: ffff889ff8c35a00  CPU: 11  COMMAND: \"swapper/11\"",
+" ",
+"    PID: 0      TASK: ffff889ff8c3c380  CPU: 12  COMMAND: \"swapper/12\"",
+" ",
+"    PID: 150773  TASK: ffff889fe85a1680  CPU: 13  COMMAND: \"bash\"",
+"    #0 ffffc9000d35bcd0 machine_kexec at ffffffff8105a407",
+"    #1 ffffc9000d35bd28 __crash_kexec at ffffffff8113033d",
+"    #2 ffffc9000d35bdf0 panic at ffffffff81081930",
+"    #3 ffffc9000d35be70 sysrq_handle_crash at ffffffff814e38d1",
+"    #4 ffffc9000d35be78 __handle_sysrq.cold.12 at ffffffff814e4175",
+"    #5 ffffc9000d35bea8 write_sysrq_trigger at ffffffff814e404b",
+"    #6 ffffc9000d35beb8 proc_reg_write at ffffffff81330d86",
+"    #7 ffffc9000d35bed0 vfs_write at ffffffff812a72d5",
+"    #8 ffffc9000d35bf00 ksys_write at ffffffff812a7579",
+"    #9 ffffc9000d35bf38 do_syscall_64 at ffffffff81004259",
+"       RIP: 00007fa7abcdc274  RSP: 00007fffa731f678  RFLAGS: 00000246",
+"       RAX: ffffffffffffffda  RBX: 0000000000000002  RCX: 00007fa7abcdc274",
+"       RDX: 0000000000000002  RSI: 0000563ca51ee6d0  RDI: 0000000000000001",
+"       RBP: 0000563ca51ee6d0   R8: 000000000000000a   R9: 00007fa7abd6be80",
+"       R10: 000000000000000a  R11: 0000000000000246  R12: 00007fa7abdad760",
+"       R13: 0000000000000002  R14: 00007fa7abda8760  R15: 0000000000000002",
+"       ORIG_RAX: 0000000000000001  CS: 0033  SS: 002b",
+"    ...",
 "\n  Display the stack trace of the active task on CPU 0 and 1:\n",
 "    %s> bt -c 0,1",
 "    PID: 0      TASK: ffffffff81a8d020  CPU: 0   COMMAND: \"swapper\"",

_service:tar_scm:7.3.0.tar.gz/kernel.c -> _service:tar_scm:8.0.2.tar.gz/kernel.c Changed

@@ -23,6 +23,11 @@
 #include <ctype.h>
 #include <stdbool.h>
 #include "xendump.h"
+#if defined(GDB_7_6) || defined(GDB_10_2)
+#define __CONFIG_H__ 1
+#include "config.h"
+#endif
+#include "bfd.h"
 
 static void do_module_cmd(ulong, char *, ulong, char *, char *);
 static void show_module_taint(void);
@@ -93,8 +98,11 @@
 static ulong dump_audit_skb_queue(ulong);
 static ulong __dump_audit(char *);
 static void dump_audit(void);
+static void dump_printk_safe_seq_buf(int);
 static char *vmcoreinfo_read_string(const char *);
 static void check_vmcoreinfo(void);
+static int is_pvops_xen(void);
+static int get_linux_banner_from_vmlinux(char *, size_t);
 
 
 /*
@@ -109,7 +117,6 @@
 	char *rqstruct;
 	char *rq_timestamp_name = NULL;
 	char *irq_desc_type_name;	
-	ulong pv_init_ops;
 	struct gnu_request req;
 
 	if (pc->flags & KERNEL_DEBUG_QUERY)
@@ -169,11 +176,7 @@
                        	error(FATAL, "cannot malloc m2p page.");
 	}
 
-	if (PVOPS() && symbol_exists("pv_init_ops") &&
-	    readmem(symbol_value("pv_init_ops"), KVADDR, &pv_init_ops,
-	    sizeof(void *), "pv_init_ops", RETURN_ON_ERROR) &&
-	    ((p1 = value_symbol(pv_init_ops)) &&
-	    (STREQ(p1, "xen_patch") || STREQ(p1, "paravirt_patch_default")))) {
+	if (is_pvops_xen()) {
 		kt->flags |= ARCH_XEN | ARCH_PVOPS_XEN;
 		kt->xen_flags |= WRITABLE_PAGE_TABLES;
 		if (machine_type("X86"))
@@ -615,7 +618,15 @@
 		kt->flags |= TVEC_BASES_V1;
 
         STRUCT_SIZE_INIT(__wait_queue, "__wait_queue");
-        if (VALID_STRUCT(__wait_queue)) {
+	STRUCT_SIZE_INIT(wait_queue_entry, "wait_queue_entry");
+	if (VALID_STRUCT(wait_queue_entry)) {
+		MEMBER_OFFSET_INIT(wait_queue_entry_private,
+			"wait_queue_entry", "private");
+		MEMBER_OFFSET_INIT(wait_queue_head_head,
+			"wait_queue_head", "head");
+		MEMBER_OFFSET_INIT(wait_queue_entry_entry,
+			"wait_queue_entry", "entry");
+	} else if (VALID_STRUCT(__wait_queue)) {
 		if (MEMBER_EXISTS("__wait_queue", "task"))
 			MEMBER_OFFSET_INIT(__wait_queue_task,
 				"__wait_queue", "task");
@@ -1049,6 +1060,7 @@
 	if (!(sp = symbol_search("linux_banner")))
 		error(FATAL, "linux_banner symbol does not exist?\n");
 	else if ((sp->type == 'R') || (sp->type == 'r') ||
+		(THIS_KERNEL_VERSION >= LINUX(2,6,11) && (sp->type == 'D' || sp->type == 'd')) ||
 		 (machine_type("ARM") && sp->type == 'T') ||
 		 (machine_type("ARM64")))
 		linux_banner = symbol_value("linux_banner");
@@ -1318,6 +1330,12 @@
 	target_smp = strstr(kt->utsname.version, " SMP ") ? TRUE : FALSE;
 	namelist_smp = FALSE;
 
+	if (get_linux_banner_from_vmlinux(buffer, sizeof(buffer)) &&
+	    strstr(buffer, kt->proc_version)) {
+		found = TRUE;
+		goto found;
+	}
+
         sprintf(command, "/usr/bin/strings %s", namelist);
         if ((pipe = popen(command, "r")) == NULL) {
                 error(INFO, "%s: %s\n", namelist, strerror(errno));
@@ -1378,6 +1396,7 @@
 		}
 	}
 
+found:
 	if (found) {
                 if (CRASHDEBUG(1)) {
                 	fprintf(fp, "verify_namelist:\n");
@@ -1480,8 +1499,7 @@
 		if (!(lm->mod_flags & MOD_LOAD_SYMS))
 			error(FATAL, "%s: module source code is not available\n", lm->mod_name);
 		get_line_number(req->addr, buf1, FALSE);
-	} else if (kt->flags2 & KASLR)
-		req->addr -= (kt->relocate * -1);
+	}
 
 	sprintf(buf1, "list *0x%lx", req->addr);
 	open_tmpfile();
@@ -2485,7 +2503,7 @@
 	if (kt->flags & USE_OPT_BT)
 		bt->flags |= BT_OPT_BACK_TRACE;
 
-	while ((c = getopt(argcnt, args, "D:fFI:S:c:aAloreEgstTdxR:Ovp")) != EOF) {
+	while ((c = getopt(argcnt, args, "D:fFI:S:c:n:aAloreEgstTdxR:Ovp")) != EOF) {
                 switch (c)
 		{
 		case 'f':
@@ -2654,6 +2672,14 @@
 			active++;
 			break;
 
+		case 'n':
+			if ((machine_type("X86_64") || machine_type("ARM64")) &&
+			    STREQ(optarg, "idle"))
+				bt->flags |= BT_SKIP_IDLE;
+			else
+				option_not_supported(c);
+			break;
+
 		case 'r':
 			bt->flags |= BT_RAW;
 			break;
@@ -3074,6 +3100,10 @@
 	} else
                 machdep->get_stack_frame(bt, &eip, &esp);
 
+	/* skip idle task stack */
+	if (bt->flags & BT_SKIP_IDLE)
+		return;
+
 	if (bt->flags & BT_KSTACKP) {
 		bt->stkptr = esp;
 		return;
@@ -4657,7 +4687,7 @@
         st->ext_module_symtable = NULL;
         st->load_modules = NULL;
         kt->mods_installed = 0;
-	clear_text_value_cache();
+	memset(st->mod_symname_hash, 0, sizeof(st->mod_symname_hash));
 
         module_init();
 }
@@ -4792,7 +4822,18 @@
 
 	sprintf(dir, "%s/%s", DEFAULT_REDHAT_DEBUG_LOCATION, 
 		kt->utsname.release);
-	retbuf = search_directory_tree(dir, file, 0);
+	if (!(retbuf = search_directory_tree(dir, file, 0))) {
+		switch (kt->flags & (KMOD_V1|KMOD_V2))
+		{
+		case KMOD_V2:
+			sprintf(file, "%s.ko", modref);
+			retbuf = search_directory_tree(dir, file, 0);
+			if (!retbuf) {
+				sprintf(file, "%s.ko.debug", modref);
+				retbuf = search_directory_tree(dir, file, 0);
+			}
+		}
+	}
 
 	if (!retbuf && (env = getenv("CRASH_MODULE_PATH"))) {
 		sprintf(dir, "%s", env);
@@ -4983,7 +5024,7 @@
 
 	msg_flags = 0;
 
-        while ((c = getopt(argcnt, args, "Ttdma")) != EOF) {
+        while ((c = getopt(argcnt, args, "Ttdmas")) != EOF) {
                 switch(c)
                 {
 		case 'T':
@@ -5001,6 +5042,9 @@
 		case 'a':
 			msg_flags |= SHOW_LOG_AUDIT;
 			break;
+		case 's':
+			msg_flags |= SHOW_LOG_SAFE;
+			break;
                 default:
                         argerrs++;
                         break;
@@ -5010,21 +5054,9 @@
         if (argerrs)
                 cmd_usage(pc->curcmd, SYNOPSIS);
 
-	if (msg_flags & SHOW_LOG_CTIME) {
-		if (pc->flags & MINIMAL_MODE) {
-			error(WARNING, "the option '-T' is not available in minimal mode\n");
-			return;
-		}
-
-		if (kt->boot_date.tv_sec == 0) {
-			ulonglong uptime_jiffies;
-			ulong  uptime_sec;
-
-			get_uptime(NULL, &uptime_jiffies);
-			uptime_sec = (uptime_jiffies)/(ulonglong)machdep->hz;

_service:tar_scm:7.3.0.tar.gz/kvmdump.c -> _service:tar_scm:8.0.2.tar.gz/kvmdump.c Changed

_service:tar_scm:7.3.0.tar.gz/kvmdump.h -> _service:tar_scm:8.0.2.tar.gz/kvmdump.h Changed

_service:tar_scm:7.3.0.tar.gz/lkcd_v1.c -> _service:tar_scm:8.0.2.tar.gz/lkcd_v1.c Changed

_service:tar_scm:7.3.0.tar.gz/lkcd_v2_v3.c -> _service:tar_scm:8.0.2.tar.gz/lkcd_v2_v3.c Changed

_service:tar_scm:7.3.0.tar.gz/lkcd_v5.c -> _service:tar_scm:8.0.2.tar.gz/lkcd_v5.c Changed

_service:tar_scm:7.3.0.tar.gz/lkcd_v7.c -> _service:tar_scm:8.0.2.tar.gz/lkcd_v7.c Changed

_service:tar_scm:7.3.0.tar.gz/lkcd_v8.c -> _service:tar_scm:8.0.2.tar.gz/lkcd_v8.c Changed

_service:tar_scm:7.3.0.tar.gz/main.c -> _service:tar_scm:8.0.2.tar.gz/main.c Changed

_service:tar_scm:7.3.0.tar.gz/makedumpfile.c -> _service:tar_scm:8.0.2.tar.gz/makedumpfile.c Changed

_service:tar_scm:7.3.0.tar.gz/memory.c -> _service:tar_scm:8.0.2.tar.gz/memory.c Changed

@@ -20,6 +20,7 @@
 #include <sys/mman.h>
 #include <ctype.h>
 #include <netinet/in.h>
+#include <byteswap.h>
 
 struct meminfo {           /* general purpose memory information structure */
         ulong cache;       /* used by the various memory searching/dumping */
@@ -47,6 +48,7 @@
 	int slab_offset;
         char *reqname;
 	char *curname;
+	ulong *spec_cpumask;
 	ulong *addrlist;
 	int *kmem_bufctl;
 	ulong *cpudataNR_CPUS;
@@ -419,6 +421,8 @@
 		MEMBER_OFFSET_INIT(page_prev, "page", "prev");
 	if (INVALID_MEMBER(page_next))
 		ANON_MEMBER_OFFSET_INIT(page_next, "page", "next");
+	if (INVALID_MEMBER(page_next))
+		MEMBER_OFFSET_INIT(page_next, "slab", "next");
 
 	MEMBER_OFFSET_INIT(page_list, "page", "list");
 	if (VALID_MEMBER(page_list)) {
@@ -537,6 +541,15 @@
 		ANON_MEMBER_OFFSET_INIT(page_s_mem, "page", "s_mem");
 		ANON_MEMBER_OFFSET_INIT(page_freelist, "page", "freelist");
 		ANON_MEMBER_OFFSET_INIT(page_active, "page", "active");
+		/*
+		 * Moved to struct slab in Linux 5.17
+		 */
+		if (INVALID_MEMBER(page_s_mem))
+			MEMBER_OFFSET_INIT(page_s_mem, "slab", "s_mem");
+		if (INVALID_MEMBER(page_freelist))
+			MEMBER_OFFSET_INIT(page_freelist, "slab", "freelist");
+		if (INVALID_MEMBER(page_active))
+			MEMBER_OFFSET_INIT(page_active, "slab", "active");
 	}
 
         if (!VALID_STRUCT(kmem_slab_s) && VALID_STRUCT(slab_s)) {
@@ -574,7 +587,8 @@
 		STRUCT_SIZE_INIT(cpucache_s, "cpucache_s");
 
         } else if (!VALID_STRUCT(kmem_slab_s) && 
-		   !VALID_STRUCT(slab_s) && 
+		   !VALID_STRUCT(slab_s) &&
+		   !MEMBER_EXISTS("kmem_cache", "cpu_slab") &&
 		   (VALID_STRUCT(slab) || (vt->flags & SLAB_OVERLOAD_PAGE))) {
                 vt->flags |= PERCPU_KMALLOC_V2;
 
@@ -744,11 +758,15 @@
 		MEMBER_OFFSET_INIT(kmem_cache_random, "kmem_cache", "random");
 		MEMBER_OFFSET_INIT(kmem_cache_cpu_freelist, "kmem_cache_cpu", "freelist");
 		MEMBER_OFFSET_INIT(kmem_cache_cpu_page, "kmem_cache_cpu", "page");
+		if (INVALID_MEMBER(kmem_cache_cpu_page))
+			MEMBER_OFFSET_INIT(kmem_cache_cpu_page, "kmem_cache_cpu", "slab");
 		MEMBER_OFFSET_INIT(kmem_cache_cpu_node, "kmem_cache_cpu", "node");
 		MEMBER_OFFSET_INIT(kmem_cache_cpu_partial, "kmem_cache_cpu", "partial");
 		MEMBER_OFFSET_INIT(page_inuse, "page", "inuse");
 		if (INVALID_MEMBER(page_inuse))
 			ANON_MEMBER_OFFSET_INIT(page_inuse, "page", "inuse");
+		if (INVALID_MEMBER(page_inuse))
+			MEMBER_OFFSET_INIT(page_inuse, "slab", "inuse");
 		MEMBER_OFFSET_INIT(page_offset, "page", "offset");
 		if (INVALID_MEMBER(page_offset))
 			ANON_MEMBER_OFFSET_INIT(page_offset, "page", "offset");
@@ -760,6 +778,9 @@
 			if (INVALID_MEMBER(page_slab))
 				ANON_MEMBER_OFFSET_INIT(page_slab, "page", "slab_cache");
 		}
+		if (INVALID_MEMBER(page_slab))
+			MEMBER_OFFSET_INIT(page_slab, "slab", "slab_cache");
+
 		MEMBER_OFFSET_INIT(page_slab_page, "page", "slab_page");
 		if (INVALID_MEMBER(page_slab_page))
 			ANON_MEMBER_OFFSET_INIT(page_slab_page, "page", "slab_page");
@@ -769,10 +790,14 @@
 		MEMBER_OFFSET_INIT(page_freelist, "page", "freelist");
 		if (INVALID_MEMBER(page_freelist))
 			ANON_MEMBER_OFFSET_INIT(page_freelist, "page", "freelist");
+		if (INVALID_MEMBER(page_freelist))
+			MEMBER_OFFSET_INIT(page_freelist, "slab", "freelist");
 		if (INVALID_MEMBER(kmem_cache_objects)) {
 			MEMBER_OFFSET_INIT(kmem_cache_oo, "kmem_cache", "oo");
 			/* NOTE: returns offset of containing bitfield */
 			ANON_MEMBER_OFFSET_INIT(page_objects, "page", "objects");
+			if (INVALID_MEMBER(page_objects))
+				ANON_MEMBER_OFFSET_INIT(page_objects, "slab", "objects");
 		}
 		if (VALID_MEMBER(kmem_cache_node)) {
                 	ARRAY_LENGTH_INIT(len, NULL, "kmem_cache.node", NULL, 0);
@@ -2211,6 +2236,7 @@
 #define READ_ERRMSG      "read error: %s address: %llx  type: \"%s\"\n"
 #define WRITE_ERRMSG     "write error: %s address: %llx  type: \"%s\"\n"
 #define PAGE_EXCLUDED_ERRMSG  "page excluded: %s address: %llx  type: \"%s\"\n"
+#define PAGE_INCOMPLETE_ERRMSG  "page incomplete: %s address: %llx  type: \"%s\"\n"
 
 #define RETURN_ON_PARTIAL_READ() \
 	if ((error_handle & RETURN_PARTIAL) && (size < orig_size)) {		\
@@ -2376,6 +2402,12 @@
                         	error(INFO, PAGE_EXCLUDED_ERRMSG, memtype_string(memtype, 0), addr, type);
                         goto readmem_error;
 
+		case PAGE_INCOMPLETE:
+			RETURN_ON_PARTIAL_READ();
+			if (PRINT_ERROR_MESSAGE)
+				error(INFO, PAGE_INCOMPLETE_ERRMSG, memtype_string(memtype, 0), addr, type);
+			goto readmem_error;
+
 		default:
 			break;
 		}
@@ -4655,7 +4687,7 @@
 get_task_mem_usage(ulong task, struct task_mem_usage *tm)
 {
 	struct task_context *tc;
-	long rss = 0;
+	long rss = 0, rss_cache = 0;
 
 	BZERO(tm, sizeof(struct task_mem_usage));
 
@@ -4682,18 +4714,29 @@
 		 *  Latest kernels have mm_struct.mm_rss_stat.
 		 */ 
 		if (VALID_MEMBER(mm_struct_rss_stat)) {
-			long anonpages, filepages;
+			long anonpages, filepages, count;
 
 			anonpages = tt->anonpages;
 			filepages = tt->filepages;
-			rss += LONG(tt->mm_struct +
+			count = LONG(tt->mm_struct +
 				OFFSET(mm_struct_rss_stat) +
 				OFFSET(mm_rss_stat_count) +
 				(filepages * sizeof(long)));
-			rss += LONG(tt->mm_struct +
+
+			/*
+			 * The counter is updated in asynchronous manner
+			 * and may become negative, see:
+			 * include/linux/mm.h: get_mm_counter()
+			 */
+			if (count > 0)
+				rss += count;
+
+			count = LONG(tt->mm_struct +
 				OFFSET(mm_struct_rss_stat) +
 				OFFSET(mm_rss_stat_count) +
 				(anonpages * sizeof(long)));
+			if (count > 0)
+				rss += count;
 		}
 
 		/* Check whether SPLIT_RSS_COUNTING is enabled */
@@ -4720,38 +4763,48 @@
 					(last->tgid == (last + 1)->tgid))
 					last++;
 
-				while (first <= last)
-				{
-					/* count 0 -> filepages */
-					if (!readmem(first->task +
-						OFFSET(task_struct_rss_stat) +
-						OFFSET(task_rss_stat_count), KVADDR,
-						&sync_rss,
-						sizeof(int),
-						"task_struct rss_stat MM_FILEPAGES",
-						RETURN_ON_ERROR))
-							continue;
-
-					rss += sync_rss;
-
-					/* count 1 -> anonpages */
-					if (!readmem(first->task +
-						OFFSET(task_struct_rss_stat) +
-						OFFSET(task_rss_stat_count) +
-						sizeof(int),
-						KVADDR, &sync_rss,
-						sizeof(int),
-						"task_struct rss_stat MM_ANONPAGES",
-						RETURN_ON_ERROR))
-							continue;
-
-					rss += sync_rss;
-
-					if (first == last)
-						break;
-					first++;
+				/*
+				 * Using rss cache for dumpfile is more beneficial than live debug
+				 * because its value never changes in dumpfile.
+				 */
+				if (ACTIVE() || last->rss_cache == UNINITIALIZED) {
+					while (first <= last)
+					{
+						/* count 0 -> filepages */
+						if (!readmem(first->task +
+							OFFSET(task_struct_rss_stat) +
+							OFFSET(task_rss_stat_count), KVADDR,

_service:tar_scm:7.3.0.tar.gz/mips.c -> _service:tar_scm:8.0.2.tar.gz/mips.c Changed

_service:tar_scm:7.3.0.tar.gz/mips64.c -> _service:tar_scm:8.0.2.tar.gz/mips64.c Changed

@@ -1160,6 +1160,9 @@
 	fprintf(fp, "       is_task_addr: mips64_is_task_addr()\n");
 	fprintf(fp, "      verify_symbol: mips64_verify_symbol()\n");
 	fprintf(fp, "         dis_filter: generic_dis_filter()\n");
+	fprintf(fp, "           dump_irq: generic_dump_irq()\n");
+	fprintf(fp, "    show_interrupts: generic_show_interrupts()\n");
+	fprintf(fp, "   get_irq_affinity: generic_get_irq_affinity()\n");
 	fprintf(fp, "           cmd_mach: mips64_cmd_mach()\n");
 	fprintf(fp, "       get_smp_cpus: mips64_get_smp_cpus()\n");
 	fprintf(fp, "          is_kvaddr: generic_is_kvaddr()\n");
@@ -1246,6 +1249,9 @@
 		machdep->is_task_addr = mips64_is_task_addr;
 		machdep->get_smp_cpus = mips64_get_smp_cpus;
 		machdep->dis_filter = generic_dis_filter;
+		machdep->dump_irq = generic_dump_irq;
+		machdep->show_interrupts = generic_show_interrupts;
+		machdep->get_irq_affinity = generic_get_irq_affinity;
 		machdep->value_to_symbol = generic_machdep_value_to_symbol;
 		machdep->init_kernel_pgd = NULL;
 		break;
@@ -1257,6 +1263,14 @@
 		mips64_stackframe_init();
 		if (!machdep->hz)
 			machdep->hz = 250;
+
+		if (symbol_exists("irq_desc"))
+			ARRAY_LENGTH_INIT(machdep->nr_irqs, irq_desc,
+					  "irq_desc", NULL, 0);
+		else if (kernel_symbol_exists("nr_irqs"))
+			get_symbol_data("nr_irqs", sizeof(unsigned int),
+				&machdep->nr_irqs);
+
 		MEMBER_OFFSET_INIT(elf_prstatus_pr_reg, "elf_prstatus",
 				   "pr_reg");
 		STRUCT_SIZE_INIT(note_buf, "note_buf_t");

_service:tar_scm:7.3.0.tar.gz/netdump.c -> _service:tar_scm:8.0.2.tar.gz/netdump.c Changed

@@ -819,10 +819,9 @@
 		read_ret = read(nd->ndfd, bufptr, cnt);
 		if (read_ret != cnt) {
 			/*
-	 		 *  If the incomplete flag has been set in the header, 
-			 *  first check whether zero_excluded has been set.
+			 *  First check whether zero_excluded has been set.
 			 */
-			if (is_incomplete_dump() && (read_ret >= 0) &&
+			if ((read_ret >= 0) &&
 			    (*diskdump_flags & ZERO_EXCLUDED)) {
 				if (CRASHDEBUG(8))
 					fprintf(fp, "read_netdump: zero-fill: "
@@ -1921,7 +1920,8 @@
 			sprintf(value, "%ld", nd->arch_data2 & 0xffffffff);
 			return value;
 		}
-		if (STREQ(key, "NUMBER(TCR_EL1_T1SZ)") && nd->arch_data2) {
+		if ((STREQ(key, "NUMBER(TCR_EL1_T1SZ)") ||
+		     STREQ(key, "NUMBER(tcr_el1_t1sz)")) && nd->arch_data2) {
 			value = calloc(VADDR_PRLEN+1, sizeof(char));
 			sprintf(value, "%lld", ((ulonglong)nd->arch_data2 >> 32) & 0xffffffff);
 			pc->read_vmcoreinfo = no_vmcoreinfo;
@@ -5206,11 +5206,17 @@
 		return FALSE;
 }
 
-#ifdef X86_64
 int
 kdump_get_nr_cpus(void)
 {
-	return nd->num_qemu_notes;
+        if (nd->num_prstatus_notes)
+                return nd->num_prstatus_notes;
+        else if (nd->num_qemu_notes)
+                return nd->num_qemu_notes;
+        else if (nd->num_vmcoredd_notes)
+                return nd->num_vmcoredd_notes;
+
+        return 1;
 }
 
 QEMUCPUState *
@@ -5232,7 +5238,6 @@
 
 	return (QEMUCPUState *)nd->nt_qemu_percpucpu;
 }
-#endif
 
 static void *
 get_kdump_device_dump_offset(void)

_service:tar_scm:7.3.0.tar.gz/ppc64.c -> _service:tar_scm:8.0.2.tar.gz/ppc64.c Changed

@@ -48,14 +48,19 @@
 static ulong ppc64_get_stacktop(ulong);
 void ppc64_compiler_warning_stub(void);
 static ulong ppc64_in_irqstack(ulong);
+static enum emergency_stack_type ppc64_in_emergency_stack(int cpu, ulong addr,
+							  bool verbose);
+static void ppc64_set_bt_emergency_stack(enum emergency_stack_type type,
+					 struct bt_info *bt);
 static char * ppc64_check_eframe(struct ppc64_pt_regs *);
 static void ppc64_print_eframe(char *, struct ppc64_pt_regs *, 
 		struct bt_info *);
 static void parse_cmdline_args(void);
-static int ppc64_paca_init(int);
+static int ppc64_paca_percpu_offset_init(int);
 static void ppc64_init_cpu_info(void);
 static int ppc64_get_cpu_map(void);
 static void ppc64_clear_machdep_cache(void);
+static void ppc64_init_paca_info(void);
 static void ppc64_vmemmap_init(void);
 static int ppc64_get_kvaddr_ranges(struct vaddr_range *);
 static uint get_ptetype(ulong pte);
@@ -256,7 +261,7 @@
 }
 
 struct machine_specific ppc64_machine_specific = { 
-	.hwintrstack = { 0 }, 
+	.hwintrstack = NULL,
 	.hwstackbuf = 0,
 	.hwstacksize = 0,
 	.pte_rpn_shift = PTE_RPN_SHIFT_DEFAULT,
@@ -275,7 +280,7 @@
 };
 
 struct machine_specific book3e_machine_specific = {
-	.hwintrstack = { 0 },
+	.hwintrstack = NULL,
 	.hwstackbuf = 0,
 	.hwstacksize = 0,
 	.pte_rpn_shift = PTE_RPN_SHIFT_L4_BOOK3E_64K,
@@ -302,6 +307,8 @@
 void
 ppc64_init(int when)
 {
+	struct machine_specific *ms;
+
 #if defined(__x86_64__)
         if (ACTIVE())
                 error(FATAL, "compiled for the PPC64 architecture\n");
@@ -411,16 +418,16 @@
 		break;
 
 	case POST_GDB:
-		if (!(machdep->flags & BOOK3E)) {
-			struct machine_specific *m = machdep->machspec;
+		ms = machdep->machspec;
 
+		if (!(machdep->flags & BOOK3E)) {
 			/*
 			 * To determine if the kernel was running on OPAL based platform,
 			 * use struct opal, which is populated with relevant values.
 			 */
 			if (symbol_exists("opal")) {
-				get_symbol_data("opal", sizeof(struct ppc64_opal), &(m->opal));
-				if (m->opal.base == SKIBOOT_BASE)
+				get_symbol_data("opal", sizeof(struct ppc64_opal), &(ms->opal));
+				if (ms->opal.base == SKIBOOT_BASE)
 					machdep->flags |= OPAL_FW;
 			}
 
@@ -448,18 +455,18 @@
 			 * _PAGE_WRITETHRU  can be used to infer it.
 			 */
 			if (THIS_KERNEL_VERSION >= LINUX(3,14,0))
-				m->_page_coherent = 0x0UL;
+				ms->_page_coherent = 0x0UL;
 
 			/*
 			 * In kernel v4.5, _PAGE_PTE bit is introduced to
 			 * distinguish PTEs from pointers.
 			 */
 			if (THIS_KERNEL_VERSION >= LINUX(4,5,0)) {
-				m->_page_pte = 0x1UL;
-				m->_page_present = 0x2UL;
-				m->_page_user = 0x4UL;
-				m->_page_rw = 0x8UL;
-				m->_page_guarded = 0x10UL;
+				ms->_page_pte = 0x1UL;
+				ms->_page_present = 0x2UL;
+				ms->_page_user = 0x4UL;
+				ms->_page_rw = 0x8UL;
+				ms->_page_guarded = 0x10UL;
 			}
 
 			/*
@@ -469,8 +476,8 @@
 			 * Also, page table entries store physical addresses.
 			 */
 			if (THIS_KERNEL_VERSION >= LINUX(4,6,0)) {
-				m->_page_pte = 0x1UL << 62;
-				m->_page_present = 0x1UL << 63;
+				ms->_page_pte = 0x1UL << 62;
+				ms->_page_present = 0x1UL << 63;
 				machdep->flags |= PHYS_ENTRY_L4;
 			}
 
@@ -499,118 +506,117 @@
 			machdep->ptrs_per_pgd = PTRS_PER_PGD;
 		} else {
 			/* 2.6.14 layout */
-			struct machine_specific *m = machdep->machspec;
 			if (machdep->pagesize == 65536) {
 				/* 64K pagesize */
 				if (machdep->flags & RADIX_MMU) {
-					m->l1_index_size = PTE_INDEX_SIZE_RADIX_64K;
-					m->l2_index_size = PMD_INDEX_SIZE_RADIX_64K;
-					m->l3_index_size = PUD_INDEX_SIZE_RADIX_64K;
-					m->l4_index_size = PGD_INDEX_SIZE_RADIX_64K;
+					ms->l1_index_size = PTE_INDEX_SIZE_RADIX_64K;
+					ms->l2_index_size = PMD_INDEX_SIZE_RADIX_64K;
+					ms->l3_index_size = PUD_INDEX_SIZE_RADIX_64K;
+					ms->l4_index_size = PGD_INDEX_SIZE_RADIX_64K;
 
 				} else if (!(machdep->flags & BOOK3E) &&
 				    (THIS_KERNEL_VERSION >= LINUX(4,6,0))) {
-					m->l1_index_size = PTE_INDEX_SIZE_L4_64K_3_10;
+					ms->l1_index_size = PTE_INDEX_SIZE_L4_64K_3_10;
 
 					if (THIS_KERNEL_VERSION >= LINUX(4,12,0)) {
-						m->l2_index_size = PMD_INDEX_SIZE_L4_64K_4_12;
+						ms->l2_index_size = PMD_INDEX_SIZE_L4_64K_4_12;
 						if (THIS_KERNEL_VERSION >= LINUX(4,17,0))
-							m->l3_index_size = PUD_INDEX_SIZE_L4_64K_4_17;
+							ms->l3_index_size = PUD_INDEX_SIZE_L4_64K_4_17;
 						else
-							m->l3_index_size = PUD_INDEX_SIZE_L4_64K_4_12;
-						m->l4_index_size = PGD_INDEX_SIZE_L4_64K_4_12;
+							ms->l3_index_size = PUD_INDEX_SIZE_L4_64K_4_12;
+						ms->l4_index_size = PGD_INDEX_SIZE_L4_64K_4_12;
 					} else {
-						m->l2_index_size = PMD_INDEX_SIZE_L4_64K_4_6;
-						m->l3_index_size = PUD_INDEX_SIZE_L4_64K_4_6;
-						m->l4_index_size = PGD_INDEX_SIZE_L4_64K_3_10;
+						ms->l2_index_size = PMD_INDEX_SIZE_L4_64K_4_6;
+						ms->l3_index_size = PUD_INDEX_SIZE_L4_64K_4_6;
+						ms->l4_index_size = PGD_INDEX_SIZE_L4_64K_3_10;
 					}
 				} else if (THIS_KERNEL_VERSION >= LINUX(3,10,0)) {
-					m->l1_index_size = PTE_INDEX_SIZE_L4_64K_3_10;
-					m->l2_index_size = PMD_INDEX_SIZE_L4_64K_3_10;
-					m->l3_index_size = PUD_INDEX_SIZE_L4_64K;
-					m->l4_index_size = PGD_INDEX_SIZE_L4_64K_3_10;
+					ms->l1_index_size = PTE_INDEX_SIZE_L4_64K_3_10;
+					ms->l2_index_size = PMD_INDEX_SIZE_L4_64K_3_10;
+					ms->l3_index_size = PUD_INDEX_SIZE_L4_64K;
+					ms->l4_index_size = PGD_INDEX_SIZE_L4_64K_3_10;
 
 				} else {
-					m->l1_index_size = PTE_INDEX_SIZE_L4_64K;
-					m->l2_index_size = PMD_INDEX_SIZE_L4_64K;
-					m->l3_index_size = PUD_INDEX_SIZE_L4_64K;
-					m->l4_index_size = PGD_INDEX_SIZE_L4_64K;
+					ms->l1_index_size = PTE_INDEX_SIZE_L4_64K;
+					ms->l2_index_size = PMD_INDEX_SIZE_L4_64K;
+					ms->l3_index_size = PUD_INDEX_SIZE_L4_64K;
+					ms->l4_index_size = PGD_INDEX_SIZE_L4_64K;
 				}
 
 				if (!(machdep->flags & BOOK3E))
-					m->pte_rpn_shift = symbol_exists("demote_segment_4k") ?
+					ms->pte_rpn_shift = symbol_exists("demote_segment_4k") ?
 						PTE_RPN_SHIFT_L4_64K_V2 : PTE_RPN_SHIFT_L4_64K_V1;
 
 				if (!(machdep->flags & BOOK3E) &&
 				    (THIS_KERNEL_VERSION >= LINUX(4,6,0))) {
-					m->pgd_masked_bits = PGD_MASKED_BITS_64K_4_6;
-					m->pud_masked_bits = PUD_MASKED_BITS_64K_4_6;
-					m->pmd_masked_bits = PMD_MASKED_BITS_64K_4_6;
+					ms->pgd_masked_bits = PGD_MASKED_BITS_64K_4_6;
+					ms->pud_masked_bits = PUD_MASKED_BITS_64K_4_6;
+					ms->pmd_masked_bits = PMD_MASKED_BITS_64K_4_6;
 				} else {
-					m->pgd_masked_bits = PGD_MASKED_BITS_64K;
-					m->pud_masked_bits = PUD_MASKED_BITS_64K;
+					ms->pgd_masked_bits = PGD_MASKED_BITS_64K;
+					ms->pud_masked_bits = PUD_MASKED_BITS_64K;
 					if ((machdep->flags & BOOK3E) &&
 					    (THIS_KERNEL_VERSION >= LINUX(4,5,0)))
-						m->pmd_masked_bits = PMD_MASKED_BITS_BOOK3E_64K_4_5;
+						ms->pmd_masked_bits = PMD_MASKED_BITS_BOOK3E_64K_4_5;
 					else if (THIS_KERNEL_VERSION >= LINUX(3,11,0))
-						m->pmd_masked_bits = PMD_MASKED_BITS_64K_3_11;
+						ms->pmd_masked_bits = PMD_MASKED_BITS_64K_3_11;
 					else
-						m->pmd_masked_bits = PMD_MASKED_BITS_64K;
+						ms->pmd_masked_bits = PMD_MASKED_BITS_64K;
 				}
 			} else {
 				/* 4K pagesize */
 				if (machdep->flags & RADIX_MMU) {
-					m->l1_index_size = PTE_INDEX_SIZE_RADIX_4K;

_service:tar_scm:7.3.0.tar.gz/ramdump.c -> _service:tar_scm:8.0.2.tar.gz/ramdump.c Changed

_service:tar_scm:7.3.0.tar.gz/s390.c -> _service:tar_scm:8.0.2.tar.gz/s390.c Changed

_service:tar_scm:7.3.0.tar.gz/s390x.c -> _service:tar_scm:8.0.2.tar.gz/s390x.c Changed

_service:tar_scm:7.3.0.tar.gz/sadump.c -> _service:tar_scm:8.0.2.tar.gz/sadump.c Changed

_service:tar_scm:8.0.2.tar.gz/sbitmap.c Added

@@ -0,0 +1,695 @@
+/* sbitmap.c
+ *
+ * Copyright (C) 2022 YADRO. All rights reserved
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include "defs.h"
+
+#define SBQ_WAIT_QUEUES 8
+
+/* sbitmap_queue struct context */
+struct sbitmap_queue_context {
+	ulong sb_addr;
+	ulong alloc_hint;
+	unsigned int wake_batch;
+	int wake_index;
+	ulong ws_addr;
+	int ws_active;
+	bool round_robin;
+	unsigned int min_shallow_depth;
+
+};
+
+struct sbitmapq_data {
+#define SBITMAPQ_DATA_FLAG_STRUCT_NAME    (VERBOSE << 1)
+#define SBITMAPQ_DATA_FLAG_STRUCT_MEMBER  (VERBOSE << 2)
+#define SBITMAPQ_DATA_FLAG_ARRAY_ADDR     (VERBOSE << 3)
+#define SBITMAPQ_DATA_FLAG_ARRAY_OF_POINTS (VERBOSE << 4)
+	ulong flags;
+	int radix;
+	/* sbitmap_queue info */
+	ulong addr;
+	/* data array info */
+	ulong data_addr;
+	char *data_name;
+	int data_size;
+};
+
+#define SB_FLAG_INIT   0x01
+
+static uint sb_flags = 0;
+
+
+#define BIT(nr)			(1UL << (nr))
+
+static inline unsigned long min(unsigned long a, unsigned long b)
+{
+	return (a < b) ? a : b;
+}
+
+static unsigned long __last_word_mask(unsigned long nbits)
+{
+	return ~0UL >> (-(nbits) & (BITS_PER_LONG - 1));
+}
+
+static unsigned long bitmap_hweight_long(unsigned long w)
+{
+	return sizeof(w) == 4 ? hweight32(w) : hweight64(w);
+}
+
+static unsigned long bitmap_weight(unsigned long bitmap, unsigned int bits)
+{
+	unsigned long w = 0;
+
+	w += bitmap_hweight_long(bitmap);
+	if (bits % BITS_PER_LONG)
+		w += bitmap_hweight_long(bitmap & __last_word_mask(bits));
+
+	return w;
+}
+
+static inline unsigned int __map_depth(const struct sbitmap_context *sc, int index)
+{
+       if (index == sc->map_nr - 1)
+               return sc->depth - (index << sc->shift);
+       return 1U << sc->shift;
+}
+
+static unsigned int __sbitmap_weight(const struct sbitmap_context *sc, bool set)
+{
+	const ulong sbitmap_word_size = SIZE(sbitmap_word);
+	const ulong w_word_off = OFFSET(sbitmap_word_word);
+
+	unsigned int weight = 0;
+	ulong addr = sc->map_addr;
+	ulong depth, word, cleared;
+	char *sbitmap_word_buf;
+	int i;
+
+	sbitmap_word_buf = GETBUF(sbitmap_word_size);
+
+	for (i = 0; i < sc->map_nr; i++) {
+		if (!readmem(addr, KVADDR, sbitmap_word_buf, sbitmap_word_size, "sbitmap_word", RETURN_ON_ERROR)) {
+			FREEBUF(sbitmap_word_buf);
+			error(FATAL, "cannot read sbitmap_word\n");
+		}
+
+		depth = __map_depth(sc, i);
+
+		if (set) {
+			word = ULONG(sbitmap_word_buf + w_word_off);
+			weight += bitmap_weight(word, depth);
+		} else {
+			if (VALID_MEMBER(sbitmap_word_cleared))
+				cleared = ULONG(sbitmap_word_buf + OFFSET(sbitmap_word_cleared));
+			else
+				cleared = 0;
+			weight += bitmap_weight(cleared, depth);
+		}
+
+		addr += sbitmap_word_size;
+	}
+
+	FREEBUF(sbitmap_word_buf);
+
+	return weight;
+}
+
+static unsigned int sbitmap_weight(const struct sbitmap_context *sc)
+{
+	return __sbitmap_weight(sc, true);
+}
+
+static unsigned int sbitmap_cleared(const struct sbitmap_context *sc)
+{
+	if (VALID_MEMBER(sbitmap_word_cleared)) /* 5.0 and later */
+		return __sbitmap_weight(sc, false);
+
+	return 0;
+}
+
+static void sbitmap_emit_byte(unsigned int offset, uint8_t byte)
+{
+	if ((offset &0xf) == 0) {
+		if (offset != 0)
+			fputc('\n', fp);
+		fprintf(fp, "%08x:", offset);
+	}
+	if ((offset & 0x1) == 0)
+		fputc(' ', fp);
+	fprintf(fp, "%02x", byte);
+}
+
+static void sbitmap_bitmap_show(const struct sbitmap_context *sc)
+{
+	const ulong sbitmap_word_size = SIZE(sbitmap_word);
+	const ulong w_word_off = OFFSET(sbitmap_word_word);
+
+	uint8_t byte = 0;
+	unsigned int byte_bits = 0;
+	unsigned int offset = 0;
+	ulong addr = sc->map_addr;
+	char *sbitmap_word_buf;
+	int i;
+
+	sbitmap_word_buf = GETBUF(sbitmap_word_size);
+
+	for (i = 0; i < sc->map_nr; i++) {
+		unsigned long word, cleared, word_bits;
+
+		if (!readmem(addr, KVADDR, sbitmap_word_buf, sbitmap_word_size, "sbitmap_word", RETURN_ON_ERROR)) {
+			FREEBUF(sbitmap_word_buf);
+			error(FATAL, "cannot read sbitmap_word\n");
+		}
+
+		word = ULONG(sbitmap_word_buf + w_word_off);
+		if (VALID_MEMBER(sbitmap_word_cleared))
+			cleared = ULONG(sbitmap_word_buf + OFFSET(sbitmap_word_cleared));
+		else
+			cleared = 0;
+		word_bits = __map_depth(sc, i);
+
+		word &= ~cleared;
+
+		while (word_bits > 0) {
+			unsigned int bits = min(8 - byte_bits, word_bits);
+
+			byte |= (word & (BIT(bits) - 1)) << byte_bits;
+			byte_bits += bits;
+			if (byte_bits == 8) {
+				sbitmap_emit_byte(offset, byte);
+				byte = 0;
+				byte_bits = 0;
+				offset++;
+			}
+			word >>= bits;
+			word_bits -= bits;
+		}
+
+		addr += sbitmap_word_size;

_service:tar_scm:7.3.0.tar.gz/symbols.c -> _service:tar_scm:8.0.2.tar.gz/symbols.c Changed

@@ -17,7 +17,7 @@
 
 #include "defs.h"
 #include <elf.h>
-#ifdef GDB_7_6
+#if defined(GDB_7_6) || defined(GDB_10_2)
 #define __CONFIG_H__ 1
 #include "config.h"
 #endif
@@ -34,7 +34,7 @@
 static int compare_prios(const void *v1, const void *v2);
 static int compare_size_name(const void *, const void *);
 struct type_request;
-static void append_struct_symbol (struct type_request *, struct gnu_request *);
+static void append_struct_symbol (struct gnu_request *, void *);
 static void request_types(ulong, ulong, char *);
 static asection *get_kernel_section(char *);
 static char * get_section(ulong vaddr, char *buf);
@@ -65,7 +65,7 @@
 static struct syment *symval_hash_search(ulong);
 static void symname_hash_init(void);
 static void symname_hash_install(struct syment *);
-static struct syment *symname_hash_search(char *);
+static struct syment *symname_hash_search(struct syment *, char *);
 static void gnu_qsort(bfd *, void *, long, unsigned int, asymbol *, asymbol *);
 static int check_gnu_debuglink(bfd *);
 static int separate_debug_file_exists(const char *, unsigned long, int *);
@@ -278,7 +278,7 @@
 		return FALSE;
 	}
 
-	debuglink_size = bfd_section_size(bfd, sect);
+	debuglink_size = bfd_section_size(sect);
 
 	contents = GETBUF(debuglink_size);
 
@@ -443,7 +443,7 @@
 #ifdef GDB_5_3
     		file_crc = calc_crc32(file_crc, buffer, count);
 #else
-#ifdef GDB_7_6
+#if defined(GDB_7_6) || defined(GDB_10_2)
     		file_crc = bfd_calc_gnu_debuglink_crc32(file_crc, 
 			(unsigned char *)buffer, count);
 #else
@@ -524,9 +524,9 @@
 		return;
 	}
 
-        kt->stext_init = (ulong)bfd_get_section_vma(st->bfd, section);
+        kt->stext_init = (ulong)bfd_section_vma(section);
         kt->etext_init = kt->stext_init +
-        	(ulong)bfd_section_size(st->bfd, section);
+		(ulong)bfd_section_size(section);
 
 	if (kt->relocate) {
 		kt->stext_init -= kt->relocate;
@@ -1127,6 +1127,21 @@
 		st->__per_cpu_end = sp->value;
 }
 
+static unsigned int
+symname_hash_index(char *name)
+{
+	unsigned int len, value;
+	unsigned char *array = (unsigned char *)name;
+
+	len = strlen(name);
+	if (!len)
+		error(FATAL, "The length of the symbol name is zero!\n");
+
+	value = arraylen - 1 * arraylen / 2;
+
+	return (array0 ^ value) % SYMNAME_HASH;
+}
+
 /*
  *  Install a single static kernel symbol into the symname_hash.
  */
@@ -1134,9 +1149,9 @@
 symname_hash_install(struct syment *spn)
 {
 	struct syment *sp;
-        int index;
+	unsigned int index;
 
-        index = SYMNAME_HASH_INDEX(spn->name);
+	index = symname_hash_index(spn->name);
 	spn->cnt = 1;
 
         if ((sp = st->symname_hashindex) == NULL) 
@@ -1158,14 +1173,87 @@
 }
 
 /*
+ *  Install a single kernel module symbol into the mod_symname_hash.
+ */
+static void
+mod_symname_hash_install(struct syment *spn)
+{
+	struct syment *sp;
+	unsigned int index;
+
+	if (!spn)
+		return;
+
+	index = symname_hash_index(spn->name);
+
+	sp = st->mod_symname_hashindex;
+
+	if (!sp || (spn->value < sp->value)) {
+		st->mod_symname_hashindex = spn;
+		spn->name_hash_next = sp;
+		return;
+	}
+	for (; sp; sp = sp->name_hash_next) {
+		if (!sp->name_hash_next ||
+		    spn->value < sp->name_hash_next->value) {
+			spn->name_hash_next = sp->name_hash_next;
+			sp->name_hash_next = spn;
+			return;
+		}
+	}
+}
+
+static void
+mod_symname_hash_remove(struct syment *spn)
+{
+	struct syment *sp;
+	unsigned int index;
+
+	if (!spn)
+		return;
+
+	index = symname_hash_index(spn->name);
+
+	if (st->mod_symname_hashindex == spn) {
+		st->mod_symname_hashindex = spn->name_hash_next;
+		return;
+	}
+
+	for (sp = st->mod_symname_hashindex; sp; sp = sp->name_hash_next) {
+		if (sp->name_hash_next == spn) {
+			sp->name_hash_next = spn->name_hash_next;
+			return;
+		}
+	}
+}
+
+static void
+mod_symtable_hash_install_range(struct syment *from, struct syment *to)
+{
+	struct syment *sp;
+
+	for (sp = from; sp <= to; sp++)
+		mod_symname_hash_install(sp);
+}
+
+static void
+mod_symtable_hash_remove_range(struct syment *from, struct syment *to)
+{
+	struct syment *sp;
+
+	for (sp = from; sp <= to; sp++)
+		mod_symname_hash_remove(sp);
+}
+
+/*
  *  Static kernel symbol value search
  */
 static struct syment *
-symname_hash_search(char *name)
+symname_hash_search(struct syment *table, char *name)
 {
 	struct syment *sp;
 
-        sp = st->symname_hashSYMNAME_HASH_INDEX(name);
+	sp = tablesymname_hash_index(name);
 
 	while (sp) {
 		if (STREQ(sp->name, name)) 
@@ -1595,6 +1683,7 @@
 				lm->mod_symend = sp;
 			}
 		}
+		mod_symtable_hash_install_range(lm->mod_symtable, lm->mod_symend);
 	}
 
 	st->flags |= MODULE_SYMS;
@@ -2075,6 +2164,8 @@
 				lm->mod_init_symend = sp;
 			}
 		}
+		mod_symtable_hash_install_range(lm->mod_symtable, lm->mod_symend);
+		mod_symtable_hash_install_range(lm->mod_init_symtable, lm->mod_init_symend);
 	}
 
 	st->flags |= MODULE_SYMS;
@@ -2864,10 +2955,8 @@
 	        for (i = 0; i < st->bfd->section_count; i++, sec++) {

_service:tar_scm:7.3.0.tar.gz/task.c -> _service:tar_scm:8.0.2.tar.gz/task.c Changed

@@ -278,8 +278,10 @@
 	} else if (VALID_MEMBER(task_struct_stack))
 		MEMBER_OFFSET_INIT(task_struct_thread_info, "task_struct", "stack");
 
+	MEMBER_OFFSET_INIT(task_struct_cpu, "task_struct", "cpu");
+
 	if (VALID_MEMBER(task_struct_thread_info)) {
-		if (tt->flags & THREAD_INFO_IN_TASK) {
+		if (tt->flags & THREAD_INFO_IN_TASK && VALID_MEMBER(task_struct_cpu)) {
 			MEMBER_OFFSET_INIT(thread_info_flags, "thread_info", "flags");
 			/* (unnecessary) reminders */
 			ASSIGN_OFFSET(thread_info_task) = INVALID_OFFSET;
@@ -297,6 +299,11 @@
 	}
 
         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");
@@ -310,7 +317,6 @@
         MEMBER_OFFSET_INIT(task_struct_has_cpu, "task_struct", "has_cpu");
         MEMBER_OFFSET_INIT(task_struct_cpus_runnable,  
 		"task_struct", "cpus_runnable");
-	MEMBER_OFFSET_INIT(task_struct_cpu, "task_struct", "cpu");
 	MEMBER_OFFSET_INIT(task_struct_active_mm, "task_struct", "active_mm");
 	MEMBER_OFFSET_INIT(task_struct_next_run, "task_struct", "next_run");
 	MEMBER_OFFSET_INIT(task_struct_flags, "task_struct", "flags");
@@ -434,6 +440,8 @@
 		}
 	} else if ((symbol_exists("dd_init_queue") &&
 	    gdb_set_crash_scope(symbol_value("dd_init_queue"), "dd_init_queue")) ||
+	    (symbol_exists("dd_init_sched") &&
+	    gdb_set_crash_scope(symbol_value("dd_init_sched"), "dd_init_sched")) ||
 	    (symbol_exists("deadline_init_queue") &&
 	    gdb_set_crash_scope(symbol_value("deadline_init_queue"), "deadline_init_queue"))) {
 		char bufBUFSIZE;
@@ -684,6 +692,16 @@
 
 	stack_overflow_check_init();
 
+	if (machdep->hz) {
+		ulonglong uptime_jiffies;
+		ulong  uptime_sec;
+
+		get_uptime(NULL, &uptime_jiffies);
+		uptime_sec = (uptime_jiffies)/(ulonglong)machdep->hz;
+		kt->boot_date.tv_sec = kt->date.tv_sec - uptime_sec;
+		kt->boot_date.tv_nsec = 0;
+	}
+
 	tt->flags |= TASK_INIT_DONE;
 }
 
@@ -2895,7 +2913,7 @@
 		else
 			tc->thread_info = ULONG(tp + OFFSET(task_struct_thread_info));
 		fill_thread_info(tc->thread_info);
-		if (tt->flags & THREAD_INFO_IN_TASK)
+		if (tt->flags & THREAD_INFO_IN_TASK && VALID_MEMBER(task_struct_cpu))
                 	processor_addr = (int *) (tp + OFFSET(task_struct_cpu));
 		else
 			processor_addr = (int *) (tt->thread_info + 
@@ -2929,6 +2947,7 @@
 	tg = tt->tgid_array + tt->running_tasks;
 	tg->tgid = *tgid_addr;
 	tg->task = task;
+	tg->rss_cache = UNINITIALIZED;
 
         if (do_verify && !verify_task(tc, do_verify)) {
 		error(INFO, "invalid task address: %lx\n", tc->task);
@@ -3417,7 +3436,8 @@
         while (fgets(buf, BUFSIZE, pc->tmpfile)) {
 		if (STREQ(buf, "  {\n"))
 			randomized = TRUE;
-		else if (randomized && STREQ(buf, "  }, \n"))
+		else if (randomized &&
+			 (STREQ(buf, "  }, \n") || STREQ(buf, "  },\n")))
 			randomized = FALSE;
 
 		if (strlen(lookfor2)) {
@@ -3809,7 +3829,7 @@
 	} else
 		fprintf(fp, "  ");
 
-	fprintf(fp, "%5ld  %5ld  %2s  %s %3s",
+	fprintf(fp, "%7ld %7ld %3s  %s %3s",
 		tc->pid, task_to_pid(tc->ptask),
 		task_cpu(tc->processor, buf2, !VERBOSE),
 		task_pointer_string(tc, flag & PS_KSTACKP, buf3),
@@ -3819,8 +3839,8 @@
 	if (strlen(buf1) == 3)
 		mkstring(buf1, 4, CENTER|RJUST, NULL);
 	fprintf(fp, "%s ", buf1);
-	fprintf(fp, "%7ld ", (tm->total_vm * PAGESIZE())/1024);
-	fprintf(fp, "%6ld  ", (tm->rss * PAGESIZE())/1024);
+	fprintf(fp, "%8ld ", (tm->total_vm * PAGESIZE())/1024);
+	fprintf(fp, "%8ld  ", (tm->rss * PAGESIZE())/1024);
 	if (is_kernel_thread(tc->task))
 		fprintf(fp, "%s\n", tc->comm);
 	else
@@ -3837,7 +3857,7 @@
 
 	if (!(flag & ((PS_EXCLUSIVE & ~PS_ACTIVE)|PS_NO_HEADER))) 
 		fprintf(fp, 
-		    "   PID    PPID  CPU %s  ST  %%MEM     VSZ    RSS  COMM\n",
+		    "      PID    PPID  CPU %s  ST  %%MEM      VSZ      RSS  COMM\n",
 			flag & PS_KSTACKP ?
 			mkstring(buf, VADDR_PRLEN, CENTER|RJUST, "KSTACKP") :
 			mkstring(buf, VADDR_PRLEN, CENTER, "TASK"));
@@ -4644,8 +4664,6 @@
 static int
 start_time_timespec(void)
 {
-        char bufBUFSIZE;
-
 	switch(tt->flags & (TIMESPEC | NO_TIMESPEC | START_TIME_NSECS))
 	{
 	case TIMESPEC:
@@ -4659,24 +4677,11 @@
 
 	tt->flags |= NO_TIMESPEC;
 
-        open_tmpfile();
-        sprintf(buf, "ptype struct task_struct");
-        if (!gdb_pass_through(buf, NULL, GNU_RETURN_ON_ERROR)) {
-                close_tmpfile();
-                return FALSE;
-        }
-
-        rewind(pc->tmpfile);
-        while (fgets(buf, BUFSIZE, pc->tmpfile)) {
-                if (strstr(buf, "start_time;")) {
-			if (strstr(buf, "struct timespec")) {
-				tt->flags &= ~NO_TIMESPEC;
-				tt->flags |= TIMESPEC;
-			}
-		}
-        }
-
-        close_tmpfile();
+	if (VALID_MEMBER(task_struct_start_time) &&
+	    STREQ(MEMBER_TYPE_NAME("task_struct", "start_time"), "timespec")) {
+			tt->flags &= ~NO_TIMESPEC;
+			tt->flags |= TIMESPEC;
+	}
 
 	if ((tt->flags & NO_TIMESPEC) && (SIZE(task_struct_start_time) == 8)) {
 		tt->flags &= ~NO_TIMESPEC;
@@ -5926,7 +5931,10 @@
 	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;
 
@@ -7706,7 +7714,7 @@
 	char bufBUFSIZE;
 	char buf1BUFSIZE;
 
-        fprintf(out, "%sPID: %-5ld  TASK: %s  CPU: %-2s  COMMAND: \"%s\"\n",
+        fprintf(out, "%sPID: %-7ld  TASK: %s  CPU: %-3s  COMMAND: \"%s\"\n",
 		newline ? "\n" : "", tc->pid, 
 		mkstring(buf1, VADDR_PRLEN, LJUST|LONG_HEX, MKSTR(tc->task)),
 		task_cpu(tc->processor, buf, !VERBOSE), tc->comm);
@@ -11193,7 +11201,7 @@
 {
 	int i, overflow, cpu_size, cpu, total;
 	char bufBUFSIZE;
-	ulong magic, task, stackbase;
+	ulong magic, task, stackbase, location;
 	struct task_context *tc;
 
 	if (!tt->stack_end_magic && 
@@ -11277,9 +11285,15 @@
 		if (magic != STACK_END_MAGIC) {
 			if (!overflow)
 				print_task_header(fp, tc, 0);
+
+			if (tt->flags & THREAD_INFO_IN_TASK)
+				location = task_to_stackbase(tc->task);
+			else
+				location = tc->thread_info + SIZE(thread_info);
+
 			fprintf(fp, 
 			    "  possible stack overflow: %lx: %lx != STACK_END_MAGIC\n",
-				tc->thread_info + SIZE(thread_info), magic);
+				location, magic);
 			overflow++, total++;
 		}

_service:tar_scm:7.3.0.tar.gz/tools.c -> _service:tar_scm:8.0.2.tar.gz/tools.c Changed

@@ -3343,6 +3343,7 @@
 cmd_list(void)
 {
 	int c;
+	long head_member_offset = 0; /* offset for head like denty.d_subdirs */
 	struct list_data list_data, *ld;
 	struct datatype_member struct_member, *sm;
 	struct syment *sp;
@@ -3353,7 +3354,7 @@
 	BZERO(ld, sizeof(struct list_data));
 	struct_list_offset = 0;
 
-	while ((c = getopt(argcnt, args, "BHhrs:S:e:o:xdl:")) != EOF) {
+	while ((c = getopt(argcnt, args, "BHhrs:S:e:o:O:xdl:")) != EOF) {
                 switch(c)
 		{
 		case 'B':
@@ -3394,6 +3395,20 @@
 					optarg);
 			break;
 
+		case 'O':
+			if (ld->flags & LIST_HEAD_OFFSET_ENTERED)
+				error(FATAL, "offset value %d (0x%lx) already entered\n",
+					head_member_offset, head_member_offset);
+			else if (IS_A_NUMBER(optarg))
+				head_member_offset = stol(optarg, FAULT_ON_ERROR, NULL);
+			else if (arg_to_datatype(optarg, sm, RETURN_ON_ERROR) > 1)
+				head_member_offset = sm->member_offset;
+			else
+				error(FATAL, "invalid -O argument: %s\n", optarg);
+
+			ld->flags |= LIST_HEAD_OFFSET_ENTERED;
+			break;
+
 		case 'o':
 			if (ld->flags & LIST_OFFSET_ENTERED) 
                                error(FATAL,
@@ -3599,8 +3614,19 @@
 				fprintf(fp, "(empty)\n");
 				return;
 			}
-		} else
-			ld->start += ld->list_head_offset;
+		} else {
+			if (ld->flags & LIST_HEAD_OFFSET_ENTERED) {
+				if (!ld->end)
+					ld->end = ld->start + head_member_offset;
+				readmem(ld->start + head_member_offset, KVADDR, &ld->start,
+					sizeof(void *), "LIST_HEAD contents", FAULT_ON_ERROR);
+				if (ld->start == ld->end) {
+					fprintf(fp, "(empty)\n");
+					return;
+				}
+			} else
+				ld->start += ld->list_head_offset;
+		}
 	}
 
 	ld->flags &= ~(LIST_OFFSET_ENTERED|LIST_START_ENTERED);
@@ -6213,7 +6239,7 @@
  *  The first time it's called, the device will be opened.
  */
 int
-console(char *fmt, ...)
+console(const char *fmt, ...)
 {
         char outputBUFSIZE*2;
 	va_list ap;

_service:tar_scm:7.3.0.tar.gz/vmware_guestdump.c -> _service:tar_scm:8.0.2.tar.gz/vmware_guestdump.c Changed

_service:tar_scm:7.3.0.tar.gz/vmware_vmss.c -> _service:tar_scm:8.0.2.tar.gz/vmware_vmss.c Changed

@@ -1,7 +1,7 @@
 /*
  * vmware_vmss.c
  *
- * Copyright (c) 2015 VMware, Inc.
+ * Copyright (c) 2015, 2020 VMware, Inc.
  * Copyright (c) 2018 Red Hat Inc.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -16,6 +16,7 @@
  *
  * Authors: Dyno Hongjun Fu <hfu@vmware.com>
  *          Sergio Lopez <slp@redhat.com>
+ *          Alexey Makhalov <amakhalov@vmware.com>
  */
 
 #include "defs.h"
@@ -443,11 +444,13 @@
 	if (vmss.memsize == 0) {
 		char *vmem_filename, *p;
 
-		fprintf(ofp, LOGPRX"Memory dump is not part of this vmss file.\n");
+		if (!(pc->flags & SILENT))
+			fprintf(ofp, LOGPRX"Memory dump is not part of this vmss file.\n");
 		fclose(fp);
 		fp = NULL;
 
-		fprintf(ofp, LOGPRX"Try to locate the companion vmem file ...\n");
+		if (!(pc->flags & SILENT))
+			fprintf(ofp, LOGPRX"Try to locate the companion vmem file ...\n");
 		/* check the companion vmem file */
 		vmem_filename = strdup(filename);
 		p = vmem_filename + strlen(vmem_filename) - 4;
@@ -470,7 +473,8 @@
 		vmss.separate_vmem = TRUE;
 		vmss.filename = filename;
 
-		fprintf(ofp, LOGPRX"vmem file: %s\n\n", vmem_filename);
+		if (!(pc->flags & SILENT))
+			fprintf(ofp, LOGPRX"vmem file: %s\n\n", vmem_filename);
 		free(vmem_filename);
 	}
 
@@ -892,6 +896,54 @@
 }
 
 int
+vmware_vmss_get_cpu_reg(int cpu, int regno, const char *name, int size,
+                        void *value)
+{
+        if (cpu >= vmss.num_vcpus)
+                return FALSE;
+
+        /* All supported registers are 8 bytes long. */
+        if (size != 8)
+                return FALSE;
+
+#define CASE(R,r) \
+                case R##_REGNUM: \
+                        if (!(vmss.vcpu_regscpu & REGS_PRESENT_##R)) \
+                                return FALSE; \
+                        memcpy(value, &vmss.regs64cpu->r, size); \
+                        break
+
+
+        switch (regno) {
+                CASE (RAX, rax);
+                CASE (RBX, rbx);
+                CASE (RCX, rcx);
+                CASE (RDX, rdx);
+                CASE (RSI, rsi);
+                CASE (RDI, rdi);
+                CASE (RBP, rbp);
+                CASE (RSP, rsp);
+                CASE (R8, r8);
+                CASE (R9, r9);
+                CASE (R10, r10);
+                CASE (R11, r11);
+                CASE (R12, r12);
+                CASE (R13, r13);
+                CASE (R14, r14);
+                CASE (R15, r15);
+                CASE (RIP, rip);
+                case EFLAGS_REGNUM:
+                        if (!(vmss.vcpu_regscpu & REGS_PRESENT_RFLAGS))
+                                return FALSE;
+                        memcpy(value, &vmss.regs64cpu->rflags, size);
+                        break;
+                default:
+                        return FALSE;
+        }
+        return TRUE;
+}
+
+int
 vmware_vmss_phys_base(ulong *phys_base)
 {
 	*phys_base = vmss.phys_base;

_service:tar_scm:7.3.0.tar.gz/x86.c -> _service:tar_scm:8.0.2.tar.gz/x86.c Changed

_service:tar_scm:7.3.0.tar.gz/x86_64.c -> _service:tar_scm:8.0.2.tar.gz/x86_64.c Changed

@@ -126,6 +126,7 @@
 static void x86_64_framesize_debug(struct bt_info *);
 static void x86_64_get_active_set(void);
 static int x86_64_get_kvaddr_ranges(struct vaddr_range *);
+static int x86_64_get_cpu_reg(int, int, const char *, int, void *);
 static int x86_64_verify_paddr(uint64_t);
 static void GART_init(void);
 static void x86_64_exception_stacks_init(void);
@@ -194,6 +195,7 @@
 		machdep->machspec->irq_eframe_link = UNINITIALIZED;
 		machdep->machspec->irq_stack_gap = UNINITIALIZED;
 		machdep->get_kvaddr_ranges = x86_64_get_kvaddr_ranges;
+		machdep->get_cpu_reg = x86_64_get_cpu_reg;
                 if (machdep->cmdline_args0)
                         parse_cmdline_args();
 		if ((string = pc->read_vmcoreinfo("relocate"))) {
@@ -206,6 +208,10 @@
 			machdep->machspec->kernel_image_size = dtol(string, QUIET, NULL);
 			free(string);
 		}
+		if ((string = pc->read_vmcoreinfo("NUMBER(sme_mask)"))) {
+			machdep->machspec->sme_mask = dtol(string, QUIET, NULL);
+			free(string);
+		}
 		if (SADUMP_DUMPFILE() || QEMU_MEM_DUMP_NO_VMCOREINFO() ||
 		    VMSS_DUMPFILE())
 			/* Need for calculation of kaslr_offset and phys_base */
@@ -370,9 +376,8 @@
 		}
 
 		/*
-		 *  Check for CONFIG_RANDOMIZE_MEMORY, and set page_offset here.
-		 *  The remainder of the virtual address range setups will get
-		 *  done below in POST_GDB.
+		 *  Check for CONFIG_RANDOMIZE_MEMORY, and set page_offset and
+		 *  the virtual address ranges.
 		 */
 		if (kernel_symbol_exists("page_offset_base") &&
 		    kernel_symbol_exists("vmalloc_base")) {
@@ -382,6 +387,31 @@
 				"page_offset_base", QUIET|FAULT_ON_ERROR);
 			machdep->kvbase = machdep->machspec->page_offset;
 			machdep->identity_map_base = machdep->machspec->page_offset;
+
+			readmem(symbol_value("vmalloc_base"), KVADDR,
+					&machdep->machspec->vmalloc_start_addr,
+					sizeof(ulong), "vmalloc_base", FAULT_ON_ERROR);
+			if (machdep->flags & VM_5LEVEL)
+				machdep->machspec->vmalloc_end =
+					machdep->machspec->vmalloc_start_addr + TERABYTES(1280) - 1;
+			else
+				machdep->machspec->vmalloc_end =
+					machdep->machspec->vmalloc_start_addr + TERABYTES(32) - 1;
+			if (kernel_symbol_exists("vmemmap_base")) {
+				readmem(symbol_value("vmemmap_base"), KVADDR,
+					&machdep->machspec->vmemmap_vaddr, sizeof(ulong),
+					"vmemmap_base", FAULT_ON_ERROR);
+				machdep->machspec->vmemmap_end =
+					machdep->machspec->vmemmap_vaddr +
+					TERABYTES(1) - 1;
+			} else {
+				machdep->machspec->vmemmap_vaddr = VMEMMAP_VADDR_2_6_31;
+				machdep->machspec->vmemmap_end = VMEMMAP_END_2_6_31;
+			}
+			machdep->machspec->modules_vaddr = __START_KERNEL_map +
+				(machdep->machspec->kernel_image_size ?
+				machdep->machspec->kernel_image_size : GIGABYTES(1));
+			machdep->machspec->modules_end = MODULES_END_2_6_31;
 		}
 		break;
 
@@ -412,32 +442,7 @@
 			machdep->machspec->modules_end = MODULES_END_2_6_27;
 		}
 		if (THIS_KERNEL_VERSION >= LINUX(2,6,31)) {
-			if (machdep->flags & RANDOMIZED) {
-				readmem(symbol_value("vmalloc_base"), KVADDR,
-					&machdep->machspec->vmalloc_start_addr,
-					sizeof(ulong), "vmalloc_base", FAULT_ON_ERROR);
-				if (machdep->flags & VM_5LEVEL)
-					machdep->machspec->vmalloc_end =
-						machdep->machspec->vmalloc_start_addr + TERABYTES(1280) - 1;
-				else
-					machdep->machspec->vmalloc_end =
-						machdep->machspec->vmalloc_start_addr + TERABYTES(32) - 1;
-				if (kernel_symbol_exists("vmemmap_base")) {
-					readmem(symbol_value("vmemmap_base"), KVADDR,
-						&machdep->machspec->vmemmap_vaddr, sizeof(ulong),
-						"vmemmap_base", FAULT_ON_ERROR);
-					machdep->machspec->vmemmap_end = 
-						machdep->machspec->vmemmap_vaddr +
-						TERABYTES(1) - 1;
-				} else {
-					machdep->machspec->vmemmap_vaddr = VMEMMAP_VADDR_2_6_31;
-					machdep->machspec->vmemmap_end = VMEMMAP_END_2_6_31;
-				}
-				machdep->machspec->modules_vaddr = __START_KERNEL_map + 
-					(machdep->machspec->kernel_image_size ?
-					machdep->machspec->kernel_image_size : GIGABYTES(1));
-				machdep->machspec->modules_end = MODULES_END_2_6_31;
-			} else {
+			if (!(machdep->flags & RANDOMIZED)) {
 				machdep->machspec->vmalloc_start_addr = VMALLOC_START_ADDR_2_6_31;
 				machdep->machspec->vmalloc_end = VMALLOC_END_2_6_31;
 				machdep->machspec->vmemmap_vaddr = VMEMMAP_VADDR_2_6_31;
@@ -884,6 +889,7 @@
         fprintf(fp, "        is_page_ptr: x86_64_is_page_ptr()\n");
         fprintf(fp, "       verify_paddr: x86_64_verify_paddr()\n");
         fprintf(fp, "  get_kvaddr_ranges: x86_64_get_kvaddr_ranges()\n");
+	fprintf(fp, "        get_cpu_reg: x86_64_get_cpu_reg()\n");
         fprintf(fp, "    init_kernel_pgd: x86_64_init_kernel_pgd()\n");
         fprintf(fp, "clear_machdep_cache: x86_64_clear_machdep_cache()\n");
 	fprintf(fp, " xendump_p2m_create: %s\n", PVOPS_XEN() ?
@@ -938,6 +944,7 @@
 			ms->kernel_image_size/MEGABYTES(1));
 	else
 		fprintf(fp, "(uninitialized)\n");
+	fprintf(fp, "                 sme_mask: %lx\n", ms->sme_mask);
 	fprintf(fp, "      physical_mask_shift: %ld\n", ms->physical_mask_shift);
 	fprintf(fp, "              pgdir_shift: %ld\n", ms->pgdir_shift);
 	fprintf(fp, "               GART_start: %lx\n", ms->GART_start);
@@ -1285,6 +1292,7 @@
 	struct machine_specific *ms;
 	struct syment *irq_sp, *curr_sp, *cpu_sp, *hardirq_stack_ptr_sp;
 	ulong hardirq_stack_ptr;
+	ulong __per_cpu_load = 0;
 
 	ms = machdep->machspec;
 
@@ -1326,7 +1334,12 @@
 	else if (!ms->stkinfo.isize)
 		ms->stkinfo.isize = 16384;
 
+	if (kernel_symbol_exists("__per_cpu_load"))
+		__per_cpu_load = symbol_value("__per_cpu_load");
+
 	for (i = cpus = 0; i < NR_CPUS; i++) {
+		if (__per_cpu_load && kt->__per_cpu_offseti == __per_cpu_load)
+			break;
 		if (!readmem(cpu_sp->value + kt->__per_cpu_offseti,
 		    KVADDR, &cpunumber, sizeof(int),
 		    "cpu number (per_cpu)", QUIET|RETURN_ON_ERROR))
@@ -1809,7 +1822,7 @@
 		if (IS_XEN)
 			fprintf(fp, "PAGE DIRECTORY: %lx machine\n", *pgd);
 		else
-			fprintf(fp, "PAGE DIRECTORY: %lx\n", *pgd);
+			fprintf(fp, "PAGE DIRECTORY: %lx\n", *pgd & ~machdep->machspec->sme_mask);
 	}
 
 	return pgd;
@@ -1846,7 +1859,8 @@
 		if (IS_XEN)
 			fprintf(fp, "   PGD: %lx => %lx machine\n", (ulong)pud, pud_pte);
 		else
-			fprintf(fp, "   PGD: %lx => %lx\n", (ulong)pud, pud_pte);
+			fprintf(fp, "   PGD: %lx => %lx\n",
+				(ulong)pud, pud_pte & ~machdep->machspec->sme_mask);
         }
 
 	return pud_pte;
@@ -1877,7 +1891,8 @@
 		if (IS_XEN)
 			fprintf(fp, "   PGD: %lx => %lx machine\n", (ulong)pgd, pgd_pte);
 		else
-			fprintf(fp, "   PGD: %lx => %lx\n", (ulong)pgd, pgd_pte);
+			fprintf(fp, "   PGD: %lx => %lx\n",
+				(ulong)pgd, pgd_pte & ~machdep->machspec->sme_mask);
         }
 
 	return pgd_pte;
@@ -1895,9 +1910,11 @@
 	ulong p4d_pte;
 
 	p4d_paddr = pgd_pte & PHYSICAL_PAGE_MASK;
+	p4d_paddr &= ~machdep->machspec->sme_mask;
 	FILL_P4D(p4d_paddr, PHYSADDR, PAGESIZE());
 	p4d = ((ulong *)p4d_paddr) + p4d_index(vaddr);
 	p4d_pte = ULONG(machdep->machspec->p4d + PAGEOFFSET(p4d));
+	p4d_pte &= ~machdep->machspec->sme_mask;
         if (verbose) {
 		if (IS_XEN)
 			fprintf(fp, "   P4D: %lx => %lx machine\n", (ulong)p4d, p4d_pte);
@@ -1920,6 +1937,7 @@
 	ulong pud_pte;
 
 	pud_paddr = pgd_pte & PHYSICAL_PAGE_MASK;
+	pud_paddr &= ~machdep->machspec->sme_mask;
 
 	if (IS_XEN) {
 		pud_paddr = xen_m2p(pud_paddr);
@@ -1930,6 +1948,7 @@
 	FILL_PUD(pud_paddr, PHYSADDR, PAGESIZE());
 	pud = ((ulong *)pud_paddr) + pud_index(vaddr);
 	pud_pte = ULONG(machdep->pud + PAGEOFFSET(pud));
+	pud_pte &= ~machdep->machspec->sme_mask;
 	if (verbose) {
 		if (IS_XEN)
 			fprintf(fp, "   PUD: %lx => %lx machine\n", (ulong)pud, pud_pte);
@@ -1952,6 +1971,7 @@

_service:tar_scm:gdb-7.6.tar.gz -> _service:tar_scm:gdb-10.2.tar.gz Changed