File crash-4.0-3.7-3.8.patch of Package crash

Overview Repositories Revisions Requests Users Attributes Meta

File crash-4.0-3.7-3.8.patch of Package crash (Revision 4e212cfae17dcbfea71a02de321cbb7f)

Currently displaying revision 4e212cfae17dcbfea71a02de321cbb7f , Show latest

diff -purN crash-4.0-3.7/.rh_rpm_package crash-4.0-3.8/.rh_rpm_package
--- crash-4.0-3.7/.rh_rpm_package	2006-10-23 13:40:07.000000000 +0200
+++ crash-4.0-3.8/.rh_rpm_package	2006-10-20 21:46:27.000000000 +0200
@@ -1 +1 @@
-4.0-3.7
+4.0-3.8
diff -purN crash-4.0-3.7/Makefile crash-4.0-3.8/Makefile
--- crash-4.0-3.7/Makefile	2006-10-23 13:40:07.000000000 +0200
+++ crash-4.0-3.8/Makefile	2006-10-20 21:46:27.000000000 +0200
@@ -69,7 +69,7 @@ LKCD_DUMP_HFILES=lkcd_vmdump_v1.h lkcd_v
         lkcd_dump_v7.h lkcd_dump_v8.h lkcd_fix_mem.h
 LKCD_TRACE_HFILES=lkcd_x86_trace.h
 IBM_HFILES=ibm_common.h
-UNWIND_HFILES=unwind.h unwind_i.h rse.h
+UNWIND_HFILES=unwind.h unwind_i.h rse.h unwind_x86.h unwind_x86_64.h
 
 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 \
@@ -77,7 +77,8 @@ CFILES=main.c tools.c global_data.c memo
 	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\
 	lkcd_fix_mem.c s390_dump.c lkcd_x86_trace.c \
-	netdump.c diskdump.c xendump.c unwind.c unwind_decoder.c
+	netdump.c diskdump.c xendump.c unwind.c unwind_decoder.c \
+	unwind_x86_32_64.c
 
 SOURCE_FILES=${CFILES} ${GENERIC_HFILES} ${MCORE_HFILES} \
 	${REDHAT_CFILES} ${REDHAT_HFILES} ${UNWIND_HFILES} \
@@ -89,7 +90,8 @@ OBJECT_FILES=main.o tools.o global_data.
 	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 \
 	lkcd_fix_mem.o s390_dump.o netdump.o diskdump.o xendump.o \
-	lkcd_x86_trace.o unwind_v1.o unwind_v2.o unwind_v3.o
+	lkcd_x86_trace.o unwind_v1.o unwind_v2.o unwind_v3.o \
+	unwind_x86_32_64.o
 
 # These are the current set of crash extensions sources.  They are not built
 # by default unless the third command line of the "all:" stanza is uncommented.
@@ -387,6 +389,9 @@ extensions.o: ${GENERIC_HFILES} extensio
 lkcd_x86_trace.o: ${GENERIC_HFILES} ${LKCD_TRACE_HFILES} lkcd_x86_trace.c 
 	cc -c ${CFLAGS} -DREDHAT lkcd_x86_trace.c ${WARNING_OPTIONS} ${WARNING_ERROR}
 
+unwind_x86_32_64.o: ${GENERIC_HFILES} ${UNWIND_HFILES} unwind_x86_32_64.c
+	cc -c ${CFLAGS} unwind_x86_32_64.c -o unwind_x86_32_64.o ${WARNING_OPTIONS} ${WARNING_ERROR}
+
 unwind_v1.o: ${GENERIC_HFILES} ${UNWIND_HFILES} unwind.c unwind_decoder.c
 	cc -c ${CFLAGS} -DREDHAT -DUNWIND_V1 unwind.c -o unwind_v1.o ${WARNING_OPTIONS} ${WARNING_ERROR}
 
@@ -449,7 +454,7 @@ do_tar:
 # spec file will have its own release number, which will in turn get passed 
 # to the "all" target upon the initial build.
 
-RELEASE=4.0-3.7
+RELEASE=4.0-3.8
 
 release: make_configure
 	@if [ "`id --user`" != "0" ]; then \
diff -purN crash-4.0-3.7/README crash-4.0-3.8/README
--- crash-4.0-3.7/README	2006-10-23 13:40:07.000000000 +0200
+++ crash-4.0-3.8/README	2006-10-20 21:46:27.000000000 +0200
@@ -69,7 +69,7 @@
      After the kernel is re-compiled, the uncompressed "vmlinux" kernel
      that is created in the top-level kernel build directory must be saved.
 
-  To build this utility, simply uncompress the tar file, enter the crash-4.0-3.7
+  To build this utility, simply uncompress the tar file, enter the crash-4.0-3.8
   subdirectory, and type "make".  The initial build will take several minutes 
   because the gdb module must be configured and and built.  Alternatively, the
   crash source RPM file may be installed and built, and the resultant crash
@@ -89,7 +89,7 @@
 
     $ crash
     
-    crash 4.0-3.7
+    crash 4.0-3.8
     Copyright (C) 2002, 2003, 2004, 2005, 2006  Red Hat, Inc.
     Copyright (C) 2004, 2005, 2006  IBM Corporation
     Copyright (C) 1999-2006  Hewlett-Packard Co
@@ -113,7 +113,7 @@
           KERNEL: /boot/vmlinux
         DUMPFILE: /dev/mem
             CPUS: 1
-            DATE: Thu Oct 12 16:27:26 2006
+            DATE: Fri Oct 20 15:46:26 2006
           UPTIME: 10 days, 22:55:18
     LOAD AVERAGE: 0.08, 0.03, 0.01
            TASKS: 42
@@ -141,7 +141,7 @@
     exit           log            rd             task           
     extend         mach           repeat         timer          
     
-    crash version: 4.0-3.7   gdb version: 6.1
+    crash version: 4.0-3.8   gdb version: 6.1
     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".
@@ -154,7 +154,7 @@
 
     $ crash vmlinux vmcore
  
-    crash 4.0-3.7
+    crash 4.0-3.8
     Copyright (C) 2002, 2003, 2004, 2005, 2006  Red Hat, Inc.
     Copyright (C) 2004, 2005, 2006  IBM Corporation
     Copyright (C) 1999-2006  Hewlett-Packard Co
@@ -200,7 +200,7 @@
 
     $ crash vmlinux.17 lcore.cr.17
 
-    crash 4.0-3.7
+    crash 4.0-3.8
     Copyright (C) 2002, 2003, 2004, 2005, 2006  Red Hat, Inc.
     Copyright (C) 2004, 2005, 2006  IBM Corporation
     Copyright (C) 1999-2006  Hewlett-Packard Co
diff -purN crash-4.0-3.7/defs.h crash-4.0-3.8/defs.h
--- crash-4.0-3.7/defs.h	2006-10-23 13:40:07.000000000 +0200
+++ crash-4.0-3.8/defs.h	2006-10-20 21:46:27.000000000 +0200
@@ -435,6 +435,12 @@ struct new_utsname {
 #define USE_OLD_BT   (0x10000)
 #define ARCH_XEN     (0x20000)
 #define NO_IKCONFIG  (0x40000)
+#define DWARF_UNWIND (0x80000)
+#define NO_DWARF_UNWIND       (0x100000)
+#define DWARF_UNWIND_MEMORY   (0x200000)
+#define DWARF_UNWIND_EH_FRAME (0x400000)
+#define DWARF_UNWIND_CAPABLE  (DWARF_UNWIND_MEMORY|DWARF_UNWIND_EH_FRAME)
+#define DWARF_UNWIND_MODULES  (0x800000)
 
 #define GCC_VERSION_DEPRECATED (GCC_3_2|GCC_3_2_3|GCC_2_96|GCC_3_3_2|GCC_3_3_3)
 
@@ -1039,6 +1045,7 @@ struct offset_table {                   
 	long block_device_bd_disk;
 	long irq_desc_t_status;
 	long irq_desc_t_handler;
+	long irq_desc_t_chip;
 	long irq_desc_t_action;
 	long irq_desc_t_depth;
 	long irqdesc_action;
@@ -1059,6 +1066,21 @@ struct offset_table {                   
 	long hw_interrupt_type_ack;
 	long hw_interrupt_type_end;
 	long hw_interrupt_type_set_affinity;
+	long irq_chip_typename;
+	long irq_chip_startup;
+	long irq_chip_shutdown;
+	long irq_chip_enable;
+	long irq_chip_disable;
+	long irq_chip_ack;
+	long irq_chip_end;
+	long irq_chip_set_affinity;
+	long irq_chip_mask;
+	long irq_chip_mask_ack;
+	long irq_chip_unmask;
+	long irq_chip_eoi;
+	long irq_chip_retrigger;
+	long irq_chip_set_type;
+	long irq_chip_set_wake;
 	long irq_cpustat_t___softirq_active;
 	long irq_cpustat_t___softirq_mask;
 	long fdtable_max_fds;
@@ -1317,6 +1339,12 @@ struct offset_table {                   
 	long cpu_user_regs_esp;
 	long cpu_user_regs_rip;
 	long cpu_user_regs_rsp;
+        long unwind_table_core;
+        long unwind_table_init;
+        long unwind_table_address;
+        long unwind_table_size;
+        long unwind_table_link;
+        long unwind_table_name;
 };
 
 struct size_table {         /* stash of commonly-used sizes */
@@ -1413,6 +1441,7 @@ struct size_table {         /* stash of 
 	long cputime_t;
 	long mem_section;
 	long pid_link;
+	long unwind_table;
 };
 
 struct array_table {
@@ -1717,6 +1746,8 @@ struct symbol_table_data {
 	int mods_installed;
 	struct load_module *current;
 	struct load_module *load_modules;
+	off_t dwarf_eh_frame_file_offset;
+	ulong dwarf_eh_frame_size;
 };
 
 #define KERNEL_SYMS        (0x1)
@@ -3582,9 +3613,20 @@ struct machine_specific {
 #define VM_FLAGS (VM_ORIG|VM_2_6_11|VM_XEN|VM_XEN_RHEL4)
 
 #define _2MB_PAGE_MASK (~((MEGABYTES(2))-1))
+
+#endif
+
+#if defined(X86) || defined(X86_64)
+
+/*
+ *  unwind_x86_32_64.c
+ */
+void init_unwind_table(void);
+int dwarf_backtrace(struct bt_info *, ulong);
+void dwarf_debug(struct bt_info *);
+
 #endif
 
-void x86_64_backtrace_notice(ulong);
 
 /*
  * ppc64.c
diff -purN crash-4.0-3.7/kernel.c crash-4.0-3.8/kernel.c
--- crash-4.0-3.7/kernel.c	2006-10-23 13:40:07.000000000 +0200
+++ crash-4.0-3.8/kernel.c	2006-10-20 21:46:27.000000000 +0200
@@ -262,27 +262,66 @@ kernel_init()
 	STRUCT_SIZE_INIT(hlist_node, "hlist_node"); 
 
 	MEMBER_OFFSET_INIT(irq_desc_t_status,  "irq_desc_t", "status");
-	MEMBER_OFFSET_INIT(irq_desc_t_handler, "irq_desc_t", "handler");
+	if (MEMBER_EXISTS("irq_desc_t", "handler"))
+		MEMBER_OFFSET_INIT(irq_desc_t_handler, "irq_desc_t", "handler");
+	else
+		MEMBER_OFFSET_INIT(irq_desc_t_chip, "irq_desc_t", "chip");
 	MEMBER_OFFSET_INIT(irq_desc_t_action, "irq_desc_t", "action");
 	MEMBER_OFFSET_INIT(irq_desc_t_depth, "irq_desc_t", "depth");
-	MEMBER_OFFSET_INIT(hw_interrupt_type_typename, 
-		"hw_interrupt_type", "typename");
-	MEMBER_OFFSET_INIT(hw_interrupt_type_startup,
-		"hw_interrupt_type", "startup");
-	MEMBER_OFFSET_INIT(hw_interrupt_type_shutdown,
-		"hw_interrupt_type", "shutdown");
-	MEMBER_OFFSET_INIT(hw_interrupt_type_handle, 
-                "hw_interrupt_type", "handle");
-	MEMBER_OFFSET_INIT(hw_interrupt_type_enable,
-		"hw_interrupt_type", "enable");
-	MEMBER_OFFSET_INIT(hw_interrupt_type_disable,
-		"hw_interrupt_type", "disable");
-	MEMBER_OFFSET_INIT(hw_interrupt_type_ack, 
-		"hw_interrupt_type", "ack");
-	MEMBER_OFFSET_INIT(hw_interrupt_type_end, 
-		"hw_interrupt_type", "end");
-	MEMBER_OFFSET_INIT(hw_interrupt_type_set_affinity,
-		"hw_interrupt_type", "set_affinity");
+	if (STRUCT_EXISTS("hw_interrupt_type")) {
+		MEMBER_OFFSET_INIT(hw_interrupt_type_typename,
+			"hw_interrupt_type", "typename");
+		MEMBER_OFFSET_INIT(hw_interrupt_type_startup,
+			"hw_interrupt_type", "startup");
+		MEMBER_OFFSET_INIT(hw_interrupt_type_shutdown,
+			"hw_interrupt_type", "shutdown");
+		MEMBER_OFFSET_INIT(hw_interrupt_type_handle,
+        	        "hw_interrupt_type", "handle");
+		MEMBER_OFFSET_INIT(hw_interrupt_type_enable,
+			"hw_interrupt_type", "enable");
+		MEMBER_OFFSET_INIT(hw_interrupt_type_disable,
+			"hw_interrupt_type", "disable");
+		MEMBER_OFFSET_INIT(hw_interrupt_type_ack,
+			"hw_interrupt_type", "ack");
+		MEMBER_OFFSET_INIT(hw_interrupt_type_end,
+			"hw_interrupt_type", "end");
+		MEMBER_OFFSET_INIT(hw_interrupt_type_set_affinity,
+			"hw_interrupt_type", "set_affinity");
+	} else { /*
+		  * On later kernels where hw_interrupt_type was replaced
+		  * by irq_chip
+		  */
+		MEMBER_OFFSET_INIT(irq_chip_typename,
+			"irq_chip", "name");
+		MEMBER_OFFSET_INIT(irq_chip_startup,
+			"irq_chip", "startup");
+		MEMBER_OFFSET_INIT(irq_chip_shutdown,
+			"irq_chip", "shutdown");
+		MEMBER_OFFSET_INIT(irq_chip_enable,
+			"irq_chip", "enable");
+		MEMBER_OFFSET_INIT(irq_chip_disable,
+			"irq_chip", "disable");
+		MEMBER_OFFSET_INIT(irq_chip_ack,
+			"irq_chip", "ack");
+		MEMBER_OFFSET_INIT(irq_chip_mask,
+			"irq_chip", "mask");
+		MEMBER_OFFSET_INIT(irq_chip_mask_ack,
+			"irq_chip", "mask_ack");
+		MEMBER_OFFSET_INIT(irq_chip_unmask,
+			"irq_chip", "unmask");
+		MEMBER_OFFSET_INIT(irq_chip_eoi,
+			"irq_chip", "eoi");
+		MEMBER_OFFSET_INIT(irq_chip_end,
+			"irq_chip", "end");
+		MEMBER_OFFSET_INIT(irq_chip_set_affinity,
+			"irq_chip", "set_affinity");
+		MEMBER_OFFSET_INIT(irq_chip_retrigger,
+			"irq_chip", "retrigger");
+		MEMBER_OFFSET_INIT(irq_chip_set_type,
+			"irq_chip", "set_type");
+		MEMBER_OFFSET_INIT(irq_chip_set_wake,
+			"irq_chip", "set_wake");
+	}
 	MEMBER_OFFSET_INIT(irqaction_handler, "irqaction", "handler");
 	MEMBER_OFFSET_INIT(irqaction_flags, "irqaction", "flags");
 	MEMBER_OFFSET_INIT(irqaction_mask, "irqaction", "mask");
@@ -402,6 +441,9 @@ kernel_init()
 		if (!(kt->flags & NO_KALLSYMS))
 			kt->flags |= KALLSYMS_V2;
 	}
+
+	if (!(kt->flags & DWARF_UNWIND))
+		kt->flags |= NO_DWARF_UNWIND; 
 }
 
 /*
@@ -1185,7 +1227,7 @@ cmd_bt(void)
 		bt->flags |= BT_OLD_BACK_TRACE;
 
         while ((c = getopt(argcnt, args, "fF:I:S:aloreEgstTd:R:O")) != EOF) {
-                switch(c)
+                switch (c)
 		{
 		case 'f':
 			bt->flags |= BT_FULL;
@@ -1283,6 +1325,9 @@ cmd_bt(void)
 			} else if (*optarg == '-') {
 				hook.esp = dtol(optarg+1, FAULT_ON_ERROR, NULL);
 				hook.esp = (ulong)(0 - (long)hook.esp);
+			} else if (STREQ(optarg, "dwarf") || STREQ(optarg, "cfi")) {
+                        	if (!(kt->flags & DWARF_UNWIND_CAPABLE))
+					return;
 			} else
 				hook.esp = dtol(optarg, FAULT_ON_ERROR, NULL);
 			break;
@@ -3378,6 +3423,16 @@ dump_kernel_table(int verbose)
 		fprintf(fp, "%sARCH_XEN", others++ ? "|" : "");
 	if (kt->flags & NO_IKCONFIG)
 		fprintf(fp, "%sNO_IKCONFIG", others++ ? "|" : "");
+	if (kt->flags & DWARF_UNWIND)
+		fprintf(fp, "%sDWARF_UNWIND", others++ ? "|" : "");
+	if (kt->flags & NO_DWARF_UNWIND)
+		fprintf(fp, "%sNO_DWARF_UNWIND", others++ ? "|" : "");
+	if (kt->flags & DWARF_UNWIND_MEMORY)
+		fprintf(fp, "%sDWARF_UNWIND_MEMORY", others++ ? "|" : "");
+	if (kt->flags & DWARF_UNWIND_EH_FRAME)
+		fprintf(fp, "%sDWARF_UNWIND_EH_FRAME", others++ ? "|" : "");
+	if (kt->flags & DWARF_UNWIND_MODULES)
+		fprintf(fp, "%sDWARF_UNWIND_MODULES", others++ ? "|" : "");
 	fprintf(fp, ")\n");
         fprintf(fp, "         stext: %lx\n", kt->stext);
         fprintf(fp, "         etext: %lx\n", kt->etext);
@@ -3588,8 +3643,14 @@ generic_dump_irq(int irq)
 
         readmem(irq_desc_addr + OFFSET(irq_desc_t_status), KVADDR, &status,
                 sizeof(int), "irq_desc entry", FAULT_ON_ERROR);
-        readmem(irq_desc_addr + OFFSET(irq_desc_t_handler), KVADDR, &handler,
-                sizeof(long), "irq_desc entry", FAULT_ON_ERROR);
+	if (VALID_MEMBER(irq_desc_t_handler))
+	        readmem(irq_desc_addr + OFFSET(irq_desc_t_handler), KVADDR,
+        	        &handler, sizeof(long), "irq_desc entry",
+			FAULT_ON_ERROR);
+	else if (VALID_MEMBER(irq_desc_t_chip))
+	        readmem(irq_desc_addr + OFFSET(irq_desc_t_chip), KVADDR,
+        	        &handler, sizeof(long), "irq_desc entry",
+			FAULT_ON_ERROR);
         readmem(irq_desc_addr + OFFSET(irq_desc_t_action), KVADDR, &action,
                 sizeof(long), "irq_desc entry", FAULT_ON_ERROR);
         readmem(irq_desc_addr + OFFSET(irq_desc_t_depth), KVADDR, &depth,
@@ -3627,19 +3688,30 @@ generic_dump_irq(int irq)
 	} else
 		fprintf(fp, "%lx\n", handler);
 
-	if (handler) { 
-        	readmem(handler+OFFSET(hw_interrupt_type_typename), KVADDR, 
-			&tmp1, sizeof(void *),
-                	"hw_interrupt_type typename", FAULT_ON_ERROR);
+	if (handler) {
+		if (VALID_MEMBER(hw_interrupt_type_typename))
+	        	readmem(handler+OFFSET(hw_interrupt_type_typename),
+				KVADDR,	&tmp1, sizeof(void *),
+        	        	"hw_interrupt_type typename", FAULT_ON_ERROR);
+		else if (VALID_MEMBER(irq_chip_typename))
+	        	readmem(handler+OFFSET(irq_chip_typename),
+				KVADDR,	&tmp1, sizeof(void *),
+                		"hw_interrupt_type typename", FAULT_ON_ERROR);
+
 	 	fprintf(fp, "         typename: %lx  ", tmp1);
 		BZERO(buf, BUFSIZE);
         	if (read_string(tmp1, buf, BUFSIZE-1))
 			fprintf(fp, "\"%s\"", buf);
 		fprintf(fp, "\n");
 
-		readmem(handler+OFFSET(hw_interrupt_type_startup), KVADDR,
-			&tmp1, sizeof(void *),
-			"hw_interrupt_type startup", FAULT_ON_ERROR);
+		if (VALID_MEMBER(hw_interrupt_type_startup))
+			readmem(handler+OFFSET(hw_interrupt_type_startup),
+				KVADDR,	&tmp1, sizeof(void *),
+				"hw_interrupt_type startup", FAULT_ON_ERROR);
+		else if (VALID_MEMBER(irq_chip_startup))
+			readmem(handler+OFFSET(irq_chip_startup),
+				KVADDR,	&tmp1, sizeof(void *),
+				"hw_interrupt_type startup", FAULT_ON_ERROR);
 		fprintf(fp, "          startup: %lx  ", tmp1); 
 		if (is_kernel_text(tmp1)) 
 			fprintf(fp, "<%s>", value_to_symstr(tmp1, buf, 0));
@@ -3650,9 +3722,15 @@ generic_dump_irq(int irq)
                                 	value_to_symstr(tmp2, buf, 0));
 		fprintf(fp, "\n");
 
-                readmem(handler+OFFSET(hw_interrupt_type_shutdown), KVADDR,
-                        &tmp1, sizeof(void *),
-                        "hw_interrupt_type shutdown", FAULT_ON_ERROR);
+		if (VALID_MEMBER(hw_interrupt_type_shutdown))
+	                readmem(handler+OFFSET(hw_interrupt_type_shutdown),
+				KVADDR, &tmp1, sizeof(void *),
+	                        "hw_interrupt_type shutdown", FAULT_ON_ERROR);
+		else if (VALID_MEMBER(irq_chip_shutdown))
+	                readmem(handler+OFFSET(irq_chip_shutdown),
+				KVADDR, &tmp1, sizeof(void *),
+	                        "hw_interrupt_type shutdown", FAULT_ON_ERROR);
+
                 fprintf(fp, "         shutdown: %lx  ", tmp1);
                 if (is_kernel_text(tmp1))
                         fprintf(fp, "<%s>", value_to_symstr(tmp1, buf, 0));
@@ -3680,9 +3758,14 @@ generic_dump_irq(int irq)
 	                fprintf(fp, "\n");
 		}
 
-                readmem(handler+OFFSET(hw_interrupt_type_enable), KVADDR,
-                        &tmp1, sizeof(void *),
-                        "hw_interrupt_type enable", FAULT_ON_ERROR);
+		if (VALID_MEMBER(hw_interrupt_type_enable))
+	                readmem(handler+OFFSET(hw_interrupt_type_enable),
+				KVADDR, &tmp1, sizeof(void *),
+	                        "hw_interrupt_type enable", FAULT_ON_ERROR);
+		else if (VALID_MEMBER(irq_chip_enable))
+	                readmem(handler+OFFSET(irq_chip_enable),
+				KVADDR, &tmp1, sizeof(void *),
+	                        "hw_interrupt_type enable", FAULT_ON_ERROR);
                 fprintf(fp, "           enable: %lx  ", tmp1);
                 if (is_kernel_text(tmp1))
                         fprintf(fp, "<%s>", value_to_symstr(tmp1, buf, 0));
@@ -3693,9 +3776,14 @@ generic_dump_irq(int irq)
                                         value_to_symstr(tmp2, buf, 0));
                 fprintf(fp, "\n");
 
-                readmem(handler+OFFSET(hw_interrupt_type_disable), KVADDR,
-                        &tmp1, sizeof(void *),
-                        "hw_interrupt_type disable", FAULT_ON_ERROR);
+		if (VALID_MEMBER(hw_interrupt_type_disable))
+	                readmem(handler+OFFSET(hw_interrupt_type_disable),
+				KVADDR, &tmp1, sizeof(void *),
+	                        "hw_interrupt_type disable", FAULT_ON_ERROR);
+		else if (VALID_MEMBER(irq_chip_disable))
+	                readmem(handler+OFFSET(irq_chip_disable),
+				KVADDR, &tmp1, sizeof(void *),
+	                        "hw_interrupt_type disable", FAULT_ON_ERROR);
                 fprintf(fp, "          disable: %lx  ", tmp1);
                 if (is_kernel_text(tmp1))
                         fprintf(fp, "<%s>", value_to_symstr(tmp1, buf, 0));
@@ -3720,6 +3808,84 @@ generic_dump_irq(int irq)
                                 	fprintf(fp, "<%s>",
                                         	value_to_symstr(tmp2, buf, 0));
                 	fprintf(fp, "\n");
+		} else if (VALID_MEMBER(irq_chip_ack)) {
+                	readmem(handler+OFFSET(irq_chip_ack), KVADDR,
+                        	&tmp1, sizeof(void *),
+                        	"irq_chip ack", FAULT_ON_ERROR);
+                	fprintf(fp, "              ack: %lx  ", tmp1);
+                	if (is_kernel_text(tmp1))
+                        	fprintf(fp, "<%s>",
+					value_to_symstr(tmp1, buf, 0));
+                	else if (readmem(tmp1, KVADDR, &tmp2,
+                        	sizeof(ulong), "ack indirection",
+                        	RETURN_ON_ERROR|QUIET) && is_kernel_text(tmp2))
+                                	fprintf(fp, "<%s>",
+                                        	value_to_symstr(tmp2, buf, 0));
+                	fprintf(fp, "\n");
+		}
+
+		if (VALID_MEMBER(irq_chip_mask)) {
+			readmem(handler+OFFSET(irq_chip_mask), KVADDR,
+				&tmp1, sizeof(void *),
+				"irq_chip mask", FAULT_ON_ERROR);
+                        fprintf(fp, "             mask: %lx  ", tmp1);
+                        if (is_kernel_text(tmp1))
+                                fprintf(fp, "<%s>",
+                                        value_to_symstr(tmp1, buf, 0));
+                        else if (readmem(tmp1, KVADDR, &tmp2,
+                                sizeof(ulong), "mask indirection",
+                                RETURN_ON_ERROR|QUIET) && is_kernel_text(tmp2))
+                                        fprintf(fp, "<%s>",
+                                                value_to_symstr(tmp2, buf, 0));
+                        fprintf(fp, "\n");
+		}
+		
+		if (VALID_MEMBER(irq_chip_mask_ack)) {
+			readmem(handler+OFFSET(irq_chip_mask_ack), KVADDR,
+				&tmp1, sizeof(void *),
+				"irq_chip mask_ack", FAULT_ON_ERROR);
+                        fprintf(fp, "         mask_ack: %lx  ", tmp1);
+                        if (is_kernel_text(tmp1))
+                                fprintf(fp, "<%s>",
+                                        value_to_symstr(tmp1, buf, 0));
+                        else if (readmem(tmp1, KVADDR, &tmp2,
+                                sizeof(ulong), "mask_ack indirection",
+                                RETURN_ON_ERROR|QUIET) && is_kernel_text(tmp2))
+                                        fprintf(fp, "<%s>",
+                                                value_to_symstr(tmp2, buf, 0));
+                        fprintf(fp, "\n");
+		}
+
+		if (VALID_MEMBER(irq_chip_unmask)) {
+			readmem(handler+OFFSET(irq_chip_unmask), KVADDR,
+				&tmp1, sizeof(void *),
+				"irq_chip unmask", FAULT_ON_ERROR);
+                        fprintf(fp, "           unmask: %lx  ", tmp1);
+                        if (is_kernel_text(tmp1))
+                                fprintf(fp, "<%s>",
+                                        value_to_symstr(tmp1, buf, 0));
+                        else if (readmem(tmp1, KVADDR, &tmp2,
+                                sizeof(ulong), "unmask indirection",
+                                RETURN_ON_ERROR|QUIET) && is_kernel_text(tmp2))
+                                        fprintf(fp, "<%s>",
+                                                value_to_symstr(tmp2, buf, 0));
+                        fprintf(fp, "\n");
+		}
+
+		if (VALID_MEMBER(irq_chip_eoi)) {
+			readmem(handler+OFFSET(irq_chip_eoi), KVADDR,
+				&tmp1, sizeof(void *),
+				"irq_chip eoi", FAULT_ON_ERROR);
+                        fprintf(fp, "              eoi: %lx  ", tmp1);
+                        if (is_kernel_text(tmp1))
+                                fprintf(fp, "<%s>",
+                                        value_to_symstr(tmp1, buf, 0));
+                        else if (readmem(tmp1, KVADDR, &tmp2,
+                                sizeof(ulong), "eoi indirection",
+                                RETURN_ON_ERROR|QUIET) && is_kernel_text(tmp2))
+                                        fprintf(fp, "<%s>",
+                                                value_to_symstr(tmp2, buf, 0));
+                        fprintf(fp, "\n");
 		}
 
 		if (VALID_MEMBER(hw_interrupt_type_end)) {
@@ -3736,6 +3902,20 @@ generic_dump_irq(int irq)
                                         fprintf(fp, "<%s>",
                                                 value_to_symstr(tmp2, buf, 0));
                         fprintf(fp, "\n");
+		} else if (VALID_MEMBER(irq_chip_end)) {
+                	readmem(handler+OFFSET(irq_chip_end), KVADDR,
+                        	&tmp1, sizeof(void *),
+                        	"irq_chip end", FAULT_ON_ERROR);
+                        fprintf(fp, "              end: %lx  ", tmp1);
+                        if (is_kernel_text(tmp1))
+                                fprintf(fp, "<%s>",
+                                        value_to_symstr(tmp1, buf, 0));
+                        else if (readmem(tmp1, KVADDR, &tmp2,
+                                sizeof(ulong), "end indirection",
+                                RETURN_ON_ERROR|QUIET) && is_kernel_text(tmp2))
+                                        fprintf(fp, "<%s>",
+                                                value_to_symstr(tmp2, buf, 0));
+                        fprintf(fp, "\n");
 		}
 
 		if (VALID_MEMBER(hw_interrupt_type_set_affinity)) {
@@ -3753,6 +3933,66 @@ generic_dump_irq(int irq)
                                         fprintf(fp, "<%s>",
                                                 value_to_symstr(tmp2, buf, 0));
                         fprintf(fp, "\n");
+		} else if (VALID_MEMBER(irq_chip_set_affinity)) {
+                	readmem(handler+OFFSET(irq_chip_set_affinity),
+				KVADDR, &tmp1, sizeof(void *),
+                        	"irq_chip set_affinity",
+				FAULT_ON_ERROR);
+                        fprintf(fp, "     set_affinity: %lx  ", tmp1);
+                        if (is_kernel_text(tmp1))
+                                fprintf(fp, "<%s>",
+                                        value_to_symstr(tmp1, buf, 0));
+                        else if (readmem(tmp1, KVADDR, &tmp2,
+                                sizeof(ulong), "set_affinity indirection",
+                                RETURN_ON_ERROR|QUIET) && is_kernel_text(tmp2))
+                                        fprintf(fp, "<%s>",
+                                                value_to_symstr(tmp2, buf, 0));
+                        fprintf(fp, "\n");
+		}
+		if (VALID_MEMBER(irq_chip_retrigger)) {
+			readmem(handler+OFFSET(irq_chip_retrigger), KVADDR,
+				&tmp1, sizeof(void *),
+				"irq_chip retrigger", FAULT_ON_ERROR);
+                        fprintf(fp, "        retrigger: %lx  ", tmp1);
+                        if (is_kernel_text(tmp1))
+                                fprintf(fp, "<%s>",
+                                        value_to_symstr(tmp1, buf, 0));
+                        else if (readmem(tmp1, KVADDR, &tmp2,
+                                sizeof(ulong), "retrigger indirection",
+                                RETURN_ON_ERROR|QUIET) && is_kernel_text(tmp2))
+                                        fprintf(fp, "<%s>",
+                                                value_to_symstr(tmp2, buf, 0));
+                        fprintf(fp, "\n");
+		}
+		if (VALID_MEMBER(irq_chip_set_type)) {
+			readmem(handler+OFFSET(irq_chip_set_type), KVADDR,
+				&tmp1, sizeof(void *),
+				"irq_chip set_type", FAULT_ON_ERROR);
+                        fprintf(fp, "         set_type: %lx  ", tmp1);
+                        if (is_kernel_text(tmp1))
+                                fprintf(fp, "<%s>",
+                                        value_to_symstr(tmp1, buf, 0));
+                        else if (readmem(tmp1, KVADDR, &tmp2,
+                                sizeof(ulong), "set_type indirection",
+                                RETURN_ON_ERROR|QUIET) && is_kernel_text(tmp2))
+                                        fprintf(fp, "<%s>",
+                                                value_to_symstr(tmp2, buf, 0));
+                        fprintf(fp, "\n");
+		}
+		if (VALID_MEMBER(irq_chip_set_wake)) {
+			readmem(handler+OFFSET(irq_chip_set_wake), KVADDR,
+				&tmp1, sizeof(void *),
+				"irq_chip set wake", FAULT_ON_ERROR);
+                        fprintf(fp, "         set_wake: %lx  ", tmp1);
+                        if (is_kernel_text(tmp1))
+                                fprintf(fp, "<%s>",
+                                        value_to_symstr(tmp1, buf, 0));
+                        else if (readmem(tmp1, KVADDR, &tmp2,
+                                sizeof(ulong), "set_wake indirection",
+                                RETURN_ON_ERROR|QUIET) && is_kernel_text(tmp2))
+                                        fprintf(fp, "<%s>",
+                                                value_to_symstr(tmp2, buf, 0));
+                        fprintf(fp, "\n");
 		}
 	}
 
diff -purN crash-4.0-3.7/main.c crash-4.0-3.8/main.c
--- crash-4.0-3.7/main.c	2006-10-23 13:40:07.000000000 +0200
+++ crash-4.0-3.8/main.c	2006-10-20 21:46:27.000000000 +0200
@@ -381,6 +381,7 @@ main(int argc, char **argv)
 	buf_init();
         cmdline_init();
         mem_init();
+       	hq_init();
 	machdep_init(PRE_SYMTAB);
         symtab_init();
 	machdep_init(PRE_GDB);
@@ -412,7 +413,6 @@ main_loop(void)
 		kernel_init();
 		machdep_init(POST_GDB);
         	vm_init();
-        	hq_init();
         	module_init();
         	help_init();
         	task_init();
diff -purN crash-4.0-3.7/netdump.c crash-4.0-3.8/netdump.c
--- crash-4.0-3.7/netdump.c	2006-10-23 13:40:07.000000000 +0200
+++ crash-4.0-3.8/netdump.c	2006-10-20 21:46:27.000000000 +0200
@@ -1562,8 +1562,10 @@ get_netdump_regs_x86_64(struct bt_info *
         if (is_task_active(bt->task)) 
                 bt->flags |= BT_DUMPFILE_SEARCH;
 
-	if ((NETDUMP_DUMPFILE() || KDUMP_DUMPFILE()) &&
-            VALID_STRUCT(user_regs_struct) && (bt->task == tt->panic_task)) {
+	if (((NETDUMP_DUMPFILE() || KDUMP_DUMPFILE()) &&
+   	      VALID_STRUCT(user_regs_struct) && (bt->task == tt->panic_task)) ||
+	      (KDUMP_DUMPFILE() && (kt->flags & DWARF_UNWIND) && 
+	      (bt->flags & BT_DUMPFILE_SEARCH))) {
 		if (nd->num_prstatus_notes > 1)
                 	note = (Elf64_Nhdr *)
 				nd->nt_prstatus_percpu[bt->tc->processor];
@@ -1574,9 +1576,21 @@ get_netdump_regs_x86_64(struct bt_info *
                 len = roundup(len + note->n_namesz, 4);
                 len = roundup(len + note->n_descsz, 4);
 
+		if KDUMP_DUMPFILE() {
+			ASSIGN_SIZE(user_regs_struct) = 27 * sizeof(unsigned long);
+			ASSIGN_OFFSET(user_regs_struct_rsp) = 19 * sizeof(unsigned long);
+			ASSIGN_OFFSET(user_regs_struct_rip) = 16 * sizeof(unsigned long);
+		}
                 user_regs = ((char *)note + len)
                         - SIZE(user_regs_struct) - sizeof(long);
 
+		if KDUMP_DUMPFILE() {
+			*rspp = *(ulong *)(user_regs + OFFSET(user_regs_struct_rsp));
+			*ripp = *(ulong *)(user_regs + OFFSET(user_regs_struct_rip));
+			if (*ripp && *rspp)
+				return;
+		}
+			
 		if (CRASHDEBUG(1)) {
                 	rsp = ULONG(user_regs + OFFSET(user_regs_struct_rsp));
                 	rip = ULONG(user_regs + OFFSET(user_regs_struct_rip));
diff -purN crash-4.0-3.7/symbols.c crash-4.0-3.8/symbols.c
--- crash-4.0-3.7/symbols.c	2006-10-23 13:40:07.000000000 +0200
+++ crash-4.0-3.8/symbols.c	2006-10-20 21:46:27.000000000 +0200
@@ -2322,6 +2322,11 @@ dump_symbol_table(void)
 			}
                 }
 	}
+
+	fprintf(fp, "\n");
+	fprintf(fp, "dwarf_eh_frame_file_offset: %llx\n", 
+		(unsigned long long)st->dwarf_eh_frame_file_offset);
+        fprintf(fp, "       dwarf_eh_frame_size: %ld\n", st->dwarf_eh_frame_size);
 }
 
 
@@ -5220,7 +5225,7 @@ show_member_offset(FILE *ofp, struct dat
 {
 	int i, c, len;
 	long offset;
-	char *target;
+	char *t1, *target;
 	char *arglist[MAXARGS];
 	char buf1[BUFSIZE];
 	char fmt[BUFSIZE];
@@ -5232,6 +5237,9 @@ show_member_offset(FILE *ofp, struct dat
 		return FALSE;
 	}
 
+	if (STRNEQ(inbuf, "        "))
+		goto do_empty_offset;
+
 	if (STRNEQ(inbuf, "    union {")) 
 		dm->flags |= IN_UNION;
 	if (STRNEQ(inbuf, "    struct {")) 
@@ -5261,9 +5269,20 @@ show_member_offset(FILE *ofp, struct dat
 			}
 		}
 	} else if (c) { 
-		target = arglist[c-1];
-		if (!strstr(target, ";"))
-			target = NULL;
+		for (i = 0; i < c; i++) {
+			if (STRNEQ(arglist[i], "(*")) {
+				target = arglist[i]+2;
+				if (!(t1 = strstr(target, ")")))
+					continue;
+				*t1 = NULLCHAR;
+				break;
+			}
+		}
+		if (i == c) {
+			target = arglist[c-1];
+			if (!strstr(target, ";"))
+				target = NULL;
+		}
 	}
 
 	if (!target) 
@@ -5982,6 +6001,8 @@ dump_offset_table(char *spec, ulong make
 		OFFSET(irq_desc_t_status));
 	fprintf(fp, "            irq_desc_t_handler: %ld\n",
 		OFFSET(irq_desc_t_handler));
+	fprintf(fp, "               irq_desc_t_chip: %ld\n",
+		OFFSET(irq_desc_t_chip));
 	fprintf(fp, "             irq_desc_t_action: %ld\n",
 		OFFSET(irq_desc_t_action));
 	fprintf(fp, "              irq_desc_t_depth: %ld\n",
@@ -6027,6 +6048,37 @@ dump_offset_table(char *spec, ulong make
 	fprintf(fp, "hw_interrupt_type_set_affinity: %ld\n",
 		OFFSET(hw_interrupt_type_set_affinity));
 
+	fprintf(fp, "             irq_chip_typename: %ld\n",
+		OFFSET(irq_chip_typename));
+	fprintf(fp, "              irq_chip_startup: %ld\n",
+		OFFSET(irq_chip_startup));
+	fprintf(fp, "             irq_chip_shutdown: %ld\n",
+		OFFSET(irq_chip_shutdown));
+	fprintf(fp, "               irq_chip_enable: %ld\n",
+		OFFSET(irq_chip_enable));
+	fprintf(fp, "              irq_chip_disable: %ld\n",
+		OFFSET(irq_chip_disable));
+	fprintf(fp, "                  irq_chip_ack: %ld\n",
+		OFFSET(irq_chip_ack));
+	fprintf(fp, "                 irq_chip_mask: %ld\n",
+		OFFSET(irq_chip_mask));
+	fprintf(fp, "             irq_chip_mask_ack: %ld\n",
+		OFFSET(irq_chip_mask_ack));
+	fprintf(fp, "               irq_chip_unmask: %ld\n",
+		OFFSET(irq_chip_unmask));
+	fprintf(fp, "                  irq_chip_eoi: %ld\n",
+		OFFSET(irq_chip_eoi));
+	fprintf(fp, "                  irq_chip_end: %ld\n",
+		OFFSET(irq_chip_end));
+	fprintf(fp, "         irq_chip_set_affinity: %ld\n",
+		OFFSET(irq_chip_set_affinity));
+	fprintf(fp, "            irq_chip_retrigger: %ld\n",
+		OFFSET(irq_chip_retrigger));
+	fprintf(fp, "             irq_chip_set_type: %ld\n",
+		OFFSET(irq_chip_set_type));
+	fprintf(fp, "             irq_chip_set_wake: %ld\n",
+		OFFSET(irq_chip_set_wake));
+
 	fprintf(fp, "irq_cpustat_t___softirq_active: %ld\n",
         	OFFSET(irq_cpustat_t___softirq_active));
 	fprintf(fp, "  irq_cpustat_t___softirq_mask: %ld\n",
@@ -6566,7 +6618,18 @@ dump_offset_table(char *spec, ulong make
 		OFFSET(cpu_user_regs_rip));
 	fprintf(fp, "             cpu_user_regs_rsp: %ld\n",
 		OFFSET(cpu_user_regs_rsp));
-	
+	fprintf(fp, "             unwind_table_core: %ld\n",
+		OFFSET(unwind_table_core));
+	fprintf(fp, "             unwind_table_init: %ld\n",
+		OFFSET(unwind_table_init));
+	fprintf(fp, "          unwind_table_address: %ld\n",
+		OFFSET(unwind_table_address));
+	fprintf(fp, "             unwind_table_size: %ld\n",
+		OFFSET(unwind_table_size));
+	fprintf(fp, "             unwind_table_link: %ld\n",
+		OFFSET(unwind_table_link));
+	fprintf(fp, "             unwind_table_name: %ld\n",
+		OFFSET(unwind_table_name));
 
 	fprintf(fp, "\n                    size_table:\n");
 	fprintf(fp, "                          page: %ld\n", SIZE(page));
@@ -6711,6 +6774,8 @@ dump_offset_table(char *spec, ulong make
 		SIZE(mem_section));
 	fprintf(fp, "                      pid_link: %ld\n", 
 		SIZE(pid_link));
+	fprintf(fp, "                  unwind_table: %ld\n", 
+		SIZE(unwind_table));
 
         fprintf(fp, "\n                   array_table:\n");
 	/*
@@ -6991,6 +7056,10 @@ section_header_info(bfd *bfd, asection *
                             SEC_HAS_CONTENTS))
                                 st->flags |= NO_SEC_CONTENTS;
                 }
+                if (STREQ(bfd_get_section_name(bfd, section), ".eh_frame")) {
+			st->dwarf_eh_frame_file_offset = (off_t)section->filepos;
+			st->dwarf_eh_frame_size = (ulong)bfd_section_size(bfd, section);
+		}
 		break;
 
 	case (uint)MODULE_SECTIONS:
@@ -7007,6 +7076,10 @@ section_header_info(bfd *bfd, asection *
 			    SEC_HAS_CONTENTS))
 				st->flags |= NO_SEC_CONTENTS;
 		}
+                if (STREQ(bfd_get_section_name(bfd, section), ".eh_frame")) {
+			st->dwarf_eh_frame_file_offset = (off_t)section->filepos;
+			st->dwarf_eh_frame_size = (ulong)bfd_section_size(bfd, section);
+		}
 		break;
 
 	default:
diff -purN crash-4.0-3.7/task.c crash-4.0-3.8/task.c
--- crash-4.0-3.7/task.c	2006-10-23 13:40:07.000000000 +0200
+++ crash-4.0-3.8/task.c	2006-10-20 21:46:27.000000000 +0200
@@ -4779,7 +4779,7 @@ panic_search(void)
 	if (dietask == (NO_TASK+1))
 		error(WARNING, "multiple active tasks have called die\n\n");
 
-	if (CRASHDEBUG(1))
+	if (CRASHDEBUG(1) && found)
 		error(INFO, "panic_search: %lx (via foreach bt)\n", 
 			lasttask);
 
@@ -5131,6 +5131,9 @@ is_kernel_thread(ulong task)
 	if ((tc->pid == 0) && !STREQ(tc->comm, pc->program_name))
 		return TRUE;
 
+        if (_ZOMBIE_ == TASK_STATE_UNINITIALIZED)
+                initialize_task_state();
+
 	if (IS_ZOMBIE(task) || IS_EXITING(task))
                 return FALSE;
 
diff -purN crash-4.0-3.7/tools.c crash-4.0-3.8/tools.c
--- crash-4.0-3.7/tools.c	2006-10-23 13:40:07.000000000 +0200
+++ crash-4.0-3.8/tools.c	2006-10-20 21:46:27.000000000 +0200
@@ -1771,6 +1771,42 @@ cmd_set(void)
                                 	pc->flags & HASH ? "on" : "off");
 			return;
 
+                } else if (STREQ(args[optind], "unwind")) {
+                        if (args[optind+1]) {
+                                optind++;
+                                if (STREQ(args[optind], "on")) {
+				    	if ((kt->flags & DWARF_UNWIND_CAPABLE) ||
+					    !runtime) {
+                                        	kt->flags |= DWARF_UNWIND;
+						kt->flags &= ~NO_DWARF_UNWIND;
+					}
+                                } else if (STREQ(args[optind], "off")) {
+                                        kt->flags &= ~DWARF_UNWIND;
+					if (!runtime)
+						kt->flags |= NO_DWARF_UNWIND;
+				} else if (IS_A_NUMBER(args[optind])) {
+					value = stol(args[optind],
+                                    		FAULT_ON_ERROR, NULL);
+					if (value) {
+				    		if ((kt->flags & DWARF_UNWIND_CAPABLE) ||
+						    !runtime) {
+							kt->flags |= DWARF_UNWIND;
+							kt->flags &= ~NO_DWARF_UNWIND;
+						}
+					} else {
+						kt->flags &= ~DWARF_UNWIND;
+						if (!runtime)
+							kt->flags |= NO_DWARF_UNWIND;
+					}
+				} else
+					goto invalid_set_command;
+                        }
+
+			if (runtime)
+                        	fprintf(fp, "unwind: %s\n",
+                                	kt->flags & DWARF_UNWIND ? "on" : "off");
+			return;
+
                } else if (STREQ(args[optind], "refresh")) {
                         if (args[optind+1]) {
                                 optind++;
@@ -2126,6 +2162,7 @@ show_options(void)
 	fprintf(fp, "          edit: %s\n", pc->editing_mode);
 	fprintf(fp, "      namelist: %s\n", pc->namelist);
 	fprintf(fp, "      dumpfile: %s\n", pc->dumpfile);
+	fprintf(fp, "        unwind: %s\n", kt->flags & DWARF_UNWIND ? "on" : "off");
 }
 
 
diff -purN crash-4.0-3.7/unwind_x86.h crash-4.0-3.8/unwind_x86.h
--- crash-4.0-3.7/unwind_x86.h	1970-01-01 01:00:00.000000000 +0100
+++ crash-4.0-3.8/unwind_x86.h	2006-10-20 21:46:27.000000000 +0200
@@ -0,0 +1,2 @@
+
+
diff -purN crash-4.0-3.7/unwind_x86_32_64.c crash-4.0-3.8/unwind_x86_32_64.c
--- crash-4.0-3.7/unwind_x86_32_64.c	1970-01-01 01:00:00.000000000 +0100
+++ crash-4.0-3.8/unwind_x86_32_64.c	2006-10-20 21:46:27.000000000 +0200
@@ -0,0 +1,1135 @@
+#if defined(X86_64)
+/*
+ * Support for genarating DWARF CFI based backtraces.
+ * Borrowed heavily from the kernel's implementation of unwinding using the
+ * DWARF CFI written by Jan Beulich
+ */
+
+#ifdef X86_64
+#include "unwind_x86_64.h"
+#endif
+#ifdef X86
+#include "unwind_x86.h"
+#endif
+
+#include "defs.h"
+
+#define MAX_STACK_DEPTH 8
+
+static struct local_unwind_table {
+        struct {
+                unsigned long pc;
+                unsigned long range;
+        } core, init;
+        void *address;
+        unsigned long size;
+} *local_unwind_tables, default_unwind_table;
+
+static int gather_in_memory_unwind_tables(void);
+static int populate_local_tables(ulong, char *);
+static int unwind_tables_cnt = 0;
+static struct local_unwind_table *find_table(unsigned long);
+static void dump_local_unwind_tables(void);
+
+static const struct {
+	unsigned offs:BITS_PER_LONG / 2;
+	unsigned width:BITS_PER_LONG / 2;
+} reg_info[] = {
+	UNW_REGISTER_INFO
+};
+
+#undef PTREGS_INFO
+#undef EXTRA_INFO
+
+#ifndef REG_INVALID
+#define REG_INVALID(r) (reg_info[r].width == 0)
+#endif
+
+#define DW_CFA_nop                          0x00
+#define DW_CFA_set_loc                      0x01
+#define DW_CFA_advance_loc1                 0x02
+#define DW_CFA_advance_loc2                 0x03
+#define DW_CFA_advance_loc4                 0x04
+#define DW_CFA_offset_extended              0x05
+#define DW_CFA_restore_extended             0x06
+#define DW_CFA_undefined                    0x07
+#define DW_CFA_same_value                   0x08
+#define DW_CFA_register                     0x09
+#define DW_CFA_remember_state               0x0a
+#define DW_CFA_restore_state                0x0b
+#define DW_CFA_def_cfa                      0x0c
+#define DW_CFA_def_cfa_register             0x0d
+#define DW_CFA_def_cfa_offset               0x0e
+#define DW_CFA_def_cfa_expression           0x0f
+#define DW_CFA_expression                   0x10
+#define DW_CFA_offset_extended_sf           0x11
+#define DW_CFA_def_cfa_sf                   0x12
+#define DW_CFA_def_cfa_offset_sf            0x13
+#define DW_CFA_val_offset                   0x14
+#define DW_CFA_val_offset_sf                0x15
+#define DW_CFA_val_expression               0x16
+#define DW_CFA_lo_user                      0x1c
+#define DW_CFA_GNU_window_save              0x2d
+#define DW_CFA_GNU_args_size                0x2e
+#define DW_CFA_GNU_negative_offset_extended 0x2f
+#define DW_CFA_hi_user                      0x3f
+
+#define DW_EH_PE_FORM     0x07
+#define DW_EH_PE_native   0x00
+#define DW_EH_PE_leb128   0x01
+#define DW_EH_PE_data2    0x02
+#define DW_EH_PE_data4    0x03
+#define DW_EH_PE_data8    0x04
+#define DW_EH_PE_signed   0x08
+#define DW_EH_PE_ADJUST   0x70
+#define DW_EH_PE_abs      0x00
+#define DW_EH_PE_pcrel    0x10
+#define DW_EH_PE_textrel  0x20
+#define DW_EH_PE_datarel  0x30
+#define DW_EH_PE_funcrel  0x40
+#define DW_EH_PE_aligned  0x50
+#define DW_EH_PE_indirect 0x80
+#define DW_EH_PE_omit     0xff
+
+#define min(x,y) ({ \
+        typeof(x) _x = (x);     \
+        typeof(y) _y = (y);     \
+        (void) (&_x == &_y);            \
+        _x < _y ? _x : _y; })
+
+#define max(x,y) ({ \
+        typeof(x) _x = (x);     \
+        typeof(y) _y = (y);     \
+        (void) (&_x == &_y);            \
+        _x > _y ? _x : _y; })
+#define STACK_LIMIT(ptr)     (((ptr) - 1) & ~(THREAD_SIZE - 1))
+
+typedef unsigned long uleb128_t;
+typedef   signed long sleb128_t;
+
+struct unwind_item {
+	enum item_location {
+		Nowhere,
+		Memory,
+		Register,
+		Value
+	} where;
+	uleb128_t value;
+};
+
+struct unwind_state {
+	uleb128_t loc, org;
+	const u8 *cieStart, *cieEnd;
+	uleb128_t codeAlign;
+	sleb128_t dataAlign;
+	struct cfa {
+		uleb128_t reg, offs;
+	} cfa;
+	struct unwind_item regs[ARRAY_SIZE(reg_info)];
+	unsigned stackDepth:8;
+	unsigned version:8;
+	const u8 *label;
+	const u8 *stack[MAX_STACK_DEPTH];
+};
+
+static const struct cfa badCFA = { ARRAY_SIZE(reg_info), 1 };
+
+static uleb128_t get_uleb128(const u8 **pcur, const u8 *end)
+{
+	const u8 *cur = *pcur;
+	uleb128_t value;
+	unsigned shift;
+
+	for (shift = 0, value = 0; cur < end; shift += 7) {
+		if (shift + 7 > 8 * sizeof(value)
+		    && (*cur & 0x7fU) >= (1U << (8 * sizeof(value) - shift))) {
+			cur = end + 1;
+			break;
+		}
+		value |= (uleb128_t)(*cur & 0x7f) << shift;
+		if (!(*cur++ & 0x80))
+			break;
+	}
+	*pcur = cur;
+
+	return value;
+}
+
+static sleb128_t get_sleb128(const u8 **pcur, const u8 *end)
+{
+	const u8 *cur = *pcur;
+	sleb128_t value;
+	unsigned shift;
+
+	for (shift = 0, value = 0; cur < end; shift += 7) {
+		if (shift + 7 > 8 * sizeof(value)
+		    && (*cur & 0x7fU) >= (1U << (8 * sizeof(value) - shift))) {
+			cur = end + 1;
+			break;
+		}
+		value |= (sleb128_t)(*cur & 0x7f) << shift;
+		if (!(*cur & 0x80)) {
+			value |= -(*cur++ & 0x40) << shift;
+			break;
+		}
+	}
+	*pcur = cur;
+
+	return value;
+}
+
+static unsigned long read_pointer(const u8 **pLoc,
+                                  const void *end,
+                                  signed ptrType)
+{
+	unsigned long value = 0;
+	union {
+		const u8 *p8;
+		const u16 *p16u;
+		const s16 *p16s;
+		const u32 *p32u;
+		const s32 *p32s;
+		const unsigned long *pul;
+	} ptr;
+
+	if (ptrType < 0 || ptrType == DW_EH_PE_omit)
+		return 0;
+	ptr.p8 = *pLoc;
+	switch(ptrType & DW_EH_PE_FORM) {
+	case DW_EH_PE_data2:
+		if (end < (const void *)(ptr.p16u + 1))
+			return 0;
+		if(ptrType & DW_EH_PE_signed)
+			value = get_unaligned(ptr.p16s++);
+		else
+			value = get_unaligned(ptr.p16u++);
+		break;
+	case DW_EH_PE_data4:
+#ifdef CONFIG_64BIT
+		if (end < (const void *)(ptr.p32u + 1))
+			return 0;
+		if(ptrType & DW_EH_PE_signed)
+			value = get_unaligned(ptr.p32s++);
+		else
+			value = get_unaligned(ptr.p32u++);
+		break;
+	case DW_EH_PE_data8:
+		BUILD_BUG_ON(sizeof(u64) != sizeof(value));
+#else
+		BUILD_BUG_ON(sizeof(u32) != sizeof(value));
+#endif
+	case DW_EH_PE_native:
+		if (end < (const void *)(ptr.pul + 1))
+			return 0;
+		value = get_unaligned(ptr.pul++);
+		break;
+	case DW_EH_PE_leb128:
+		BUILD_BUG_ON(sizeof(uleb128_t) > sizeof(value));
+		value = ptrType & DW_EH_PE_signed
+		        ? get_sleb128(&ptr.p8, end)
+		        : get_uleb128(&ptr.p8, end);
+		if ((const void *)ptr.p8 > end)
+			return 0;
+		break;
+	default:
+		return 0;
+	}
+	switch(ptrType & DW_EH_PE_ADJUST) {
+	case DW_EH_PE_abs:
+		break;
+	case DW_EH_PE_pcrel:
+		value += (unsigned long)*pLoc;
+		break;
+	default:
+		return 0;
+	}
+
+/*	TBD
+	if ((ptrType & DW_EH_PE_indirect)
+	    && __get_user(value, (unsigned long *)value))
+		return 0;
+*/
+	*pLoc = ptr.p8;
+
+	return value;
+}
+
+static signed fde_pointer_type(const u32 *cie)
+{
+	const u8 *ptr = (const u8 *)(cie + 2);
+	unsigned version = *ptr;
+
+	if (version != 1)
+		return -1; /* unsupported */
+	if (*++ptr) {
+		const char *aug;
+		const u8 *end = (const u8 *)(cie + 1) + *cie;
+		uleb128_t len;
+
+		/* check if augmentation size is first (and thus present) */
+		if (*ptr != 'z')
+			return -1;
+		/* check if augmentation string is nul-terminated */
+		if ((ptr = memchr(aug = (const void *)ptr, 0, end - ptr)) == NULL)
+			return -1;
+		++ptr; /* skip terminator */
+		get_uleb128(&ptr, end); /* skip code alignment */
+		get_sleb128(&ptr, end); /* skip data alignment */
+		/* skip return address column */
+		version <= 1 ? (void)++ptr : (void)get_uleb128(&ptr, end);
+		len = get_uleb128(&ptr, end); /* augmentation length */
+		if (ptr + len < ptr || ptr + len > end)
+			return -1;
+		end = ptr + len;
+		while (*++aug) {
+			if (ptr >= end)
+				return -1;
+			switch(*aug) {
+			case 'L':
+				++ptr;
+				break;
+			case 'P': {
+					signed ptrType = *ptr++;
+
+					if (!read_pointer(&ptr, end, ptrType) || 					     ptr > end)
+						return -1;
+				}
+				break;
+			case 'R':
+				return *ptr;
+			default:
+				return -1;
+			}
+		}
+	}
+	return DW_EH_PE_native|DW_EH_PE_abs;
+}
+
+static int advance_loc(unsigned long delta, struct unwind_state *state)
+{
+	state->loc += delta * state->codeAlign;
+
+	return delta > 0;
+}
+
+static void set_rule(uleb128_t reg,
+                     enum item_location where,
+                     uleb128_t value,
+                     struct unwind_state *state)
+{
+	if (reg < ARRAY_SIZE(state->regs)) {
+		state->regs[reg].where = where;
+		state->regs[reg].value = value;
+	}
+}
+
+static int processCFI(const u8 *start,
+                      const u8 *end,
+                      unsigned long targetLoc,
+                      signed ptrType,
+                      struct unwind_state *state)
+{
+	union {
+		const u8 *p8;
+		const u16 *p16;
+		const u32 *p32;
+	} ptr;
+	int result = 1;
+
+	if (start != state->cieStart) {
+		state->loc = state->org;
+		result = processCFI(state->cieStart, state->cieEnd, 0, ptrType, state);
+		if (targetLoc == 0 && state->label == NULL)
+			return result;
+	}
+	for (ptr.p8 = start; result && ptr.p8 < end; ) {
+		switch(*ptr.p8 >> 6) {
+			uleb128_t value;
+
+		case 0:
+			switch(*ptr.p8++) {
+			case DW_CFA_nop:
+				break;
+			case DW_CFA_set_loc:
+				if ((state->loc = read_pointer(&ptr.p8, end,
+								ptrType)) == 0)
+					result = 0;
+				break;
+			case DW_CFA_advance_loc1:
+				result = ptr.p8 < end && advance_loc(*ptr.p8++, state);
+				break;
+			case DW_CFA_advance_loc2:
+				result = ptr.p8 <= end + 2
+				         && advance_loc(*ptr.p16++, state);
+				break;
+			case DW_CFA_advance_loc4:
+				result = ptr.p8 <= end + 4
+				         && advance_loc(*ptr.p32++, state);
+				break;
+			case DW_CFA_offset_extended:
+				value = get_uleb128(&ptr.p8, end);
+				set_rule(value, Memory,
+					get_uleb128(&ptr.p8, end), state);
+				break;
+			case DW_CFA_val_offset:
+				value = get_uleb128(&ptr.p8, end);
+				set_rule(value, Value,
+					get_uleb128(&ptr.p8, end), state);
+				break;
+			case DW_CFA_offset_extended_sf:
+				value = get_uleb128(&ptr.p8, end);
+				set_rule(value, Memory,
+					get_sleb128(&ptr.p8, end), state);
+				break;
+			case DW_CFA_val_offset_sf:
+				value = get_uleb128(&ptr.p8, end);
+				set_rule(value, Value,
+					get_sleb128(&ptr.p8, end), state);
+				break;
+			case DW_CFA_restore_extended:
+			case DW_CFA_undefined:
+			case DW_CFA_same_value:
+				set_rule(get_uleb128(&ptr.p8, end), Nowhere, 0,	state);
+				break;
+			case DW_CFA_register:
+				value = get_uleb128(&ptr.p8, end);
+				set_rule(value, Register,
+				         get_uleb128(&ptr.p8, end), state);
+				break;
+			case DW_CFA_remember_state:
+				if (ptr.p8 == state->label) {
+					state->label = NULL;
+					return 1;
+				}
+				if (state->stackDepth >= MAX_STACK_DEPTH)
+					return 0;
+				state->stack[state->stackDepth++] = ptr.p8;
+				break;
+			case DW_CFA_restore_state:
+				if (state->stackDepth) {
+					const uleb128_t loc = state->loc;
+					const u8 *label = state->label;
+
+					state->label = state->stack[state->stackDepth - 1];
+					memcpy(&state->cfa, &badCFA, sizeof(state->cfa));
+					memset(state->regs, 0, sizeof(state->regs));
+					state->stackDepth = 0;
+					result = processCFI(start, end, 0, ptrType, state);
+					state->loc = loc;
+					state->label = label;
+				} else
+					return 0;
+				break;
+			case DW_CFA_def_cfa:
+				state->cfa.reg = get_uleb128(&ptr.p8, end);
+				/*nobreak*/
+			case DW_CFA_def_cfa_offset:
+				state->cfa.offs = get_uleb128(&ptr.p8, end);
+				break;
+			case DW_CFA_def_cfa_sf:
+				state->cfa.reg = get_uleb128(&ptr.p8, end);
+				/*nobreak*/
+			case DW_CFA_def_cfa_offset_sf:
+				state->cfa.offs = get_sleb128(&ptr.p8, end)
+				                  * state->dataAlign;
+				break;
+			case DW_CFA_def_cfa_register:
+				state->cfa.reg = get_uleb128(&ptr.p8, end);
+				break;
+			/*todo case DW_CFA_def_cfa_expression: */
+			/*todo case DW_CFA_expression: */
+			/*todo case DW_CFA_val_expression: */
+			case DW_CFA_GNU_args_size:
+				get_uleb128(&ptr.p8, end);
+				break;
+			case DW_CFA_GNU_negative_offset_extended:
+				value = get_uleb128(&ptr.p8, end);
+				set_rule(value, Memory, (uleb128_t)0 -
+				         get_uleb128(&ptr.p8, end), state);
+				break;
+			case DW_CFA_GNU_window_save:
+			default:
+				result = 0;
+				break;
+			}
+			break;
+		case 1:
+			result = advance_loc(*ptr.p8++ & 0x3f, state);
+			break;
+		case 2:
+			value = *ptr.p8++ & 0x3f;
+			set_rule(value, Memory, get_uleb128(&ptr.p8, end),
+				 state);
+			break;
+		case 3:
+			set_rule(*ptr.p8++ & 0x3f, Nowhere, 0, state);
+			break;
+		}
+		if (ptr.p8 > end)
+			result = 0;
+		if (result && targetLoc != 0 && targetLoc < state->loc)
+			return 1;
+	}
+
+	return result
+	   && ptr.p8 == end
+	   && (targetLoc == 0
+	    || (/*todo While in theory this should apply, gcc in practice omits
+	          everything past the function prolog, and hence the location
+	          never reaches the end of the function.
+	        targetLoc < state->loc &&*/ state->label == NULL));
+}
+
+
+/* Unwind to previous to frame.  Returns 0 if successful, negative
+ * number in case of an error. */
+int 
+unwind(struct unwind_frame_info *frame)
+{
+#define FRAME_REG(r, t) (((t *)frame)[reg_info[r].offs])
+	const u32 *fde = NULL, *cie = NULL;
+	const u8 *ptr = NULL, *end = NULL;
+	unsigned long startLoc = 0, endLoc = 0, cfa;
+	unsigned i;
+	signed ptrType = -1;
+	uleb128_t retAddrReg = 0;
+//	struct unwind_table *table;
+	void *unwind_table;
+	struct local_unwind_table *table;
+	struct unwind_state state;
+	u64 reg_ptr = 0;
+
+
+	if (UNW_PC(frame) == 0)
+		return -EINVAL;
+
+	if ((table = find_table(UNW_PC(frame)))) {
+//		unsigned long tableSize = unwind_table_size;
+		unsigned long tableSize = table->size;
+
+		unwind_table = table->address;
+
+		for (fde = unwind_table;
+		     tableSize > sizeof(*fde) && tableSize - sizeof(*fde) >= *fde;
+		     tableSize -= sizeof(*fde) + *fde,
+		     fde += 1 + *fde / sizeof(*fde)) {
+			if (!*fde || (*fde & (sizeof(*fde) - 1)))
+				break;
+			if (!fde[1])
+				continue; /* this is a CIE */
+			if ((fde[1] & (sizeof(*fde) - 1))
+			    || fde[1] > (unsigned long)(fde + 1)
+			                - (unsigned long)unwind_table)
+				continue; /* this is not a valid FDE */
+			cie = fde + 1 - fde[1] / sizeof(*fde);
+			if (*cie <= sizeof(*cie) + 4
+			    || *cie >= fde[1] - sizeof(*fde)
+			    || (*cie & (sizeof(*cie) - 1))
+			    || cie[1]
+			    || (ptrType = fde_pointer_type(cie)) < 0) {
+				cie = NULL; /* this is not a (valid) CIE */
+				continue;
+			}
+			ptr = (const u8 *)(fde + 2);
+			startLoc = read_pointer(&ptr,
+			                        (const u8 *)(fde + 1) + *fde,
+			                        ptrType);
+			endLoc = startLoc
+			         + read_pointer(&ptr,
+			                        (const u8 *)(fde + 1) + *fde,
+			                        ptrType & DW_EH_PE_indirect
+			                        ? ptrType
+			                        : ptrType & (DW_EH_PE_FORM|DW_EH_PE_signed));
+			if (UNW_PC(frame) >= startLoc && UNW_PC(frame) < endLoc)
+				break;
+			cie = NULL;
+		}
+	}
+	if (cie != NULL) {
+		memset(&state, 0, sizeof(state));
+		state.cieEnd = ptr; /* keep here temporarily */
+		ptr = (const u8 *)(cie + 2);
+		end = (const u8 *)(cie + 1) + *cie;
+		if ((state.version = *ptr) != 1)
+			cie = NULL; /* unsupported version */
+		else if (*++ptr) {
+			/* check if augmentation size is first (and thus present) */
+			if (*ptr == 'z') {
+				/* check for ignorable (or already handled)
+				 * nul-terminated augmentation string */
+				while (++ptr < end && *ptr)
+					if (strchr("LPR", *ptr) == NULL)
+						break;
+			}
+			if (ptr >= end || *ptr)
+				cie = NULL;
+		}
+		++ptr;
+	}
+	if (cie != NULL) {
+		/* get code aligment factor */
+		state.codeAlign = get_uleb128(&ptr, end);
+		/* get data aligment factor */
+		state.dataAlign = get_sleb128(&ptr, end);
+		if (state.codeAlign == 0 || state.dataAlign == 0 || ptr >= end)
+			cie = NULL;
+		else {
+			retAddrReg = state.version <= 1 ? *ptr++ : get_uleb128(&ptr, end);
+			/* skip augmentation */
+			if (((const char *)(cie + 2))[1] == 'z')
+				ptr += get_uleb128(&ptr, end);
+			if (ptr > end
+			   || retAddrReg >= ARRAY_SIZE(reg_info)
+			   || REG_INVALID(retAddrReg)
+			   || reg_info[retAddrReg].width != sizeof(unsigned long))
+				cie = NULL;
+		}
+	}
+	if (cie != NULL) {
+		state.cieStart = ptr;
+		ptr = state.cieEnd;
+		state.cieEnd = end;
+		end = (const u8 *)(fde + 1) + *fde;
+		/* skip augmentation */
+		if (((const char *)(cie + 2))[1] == 'z') {
+			uleb128_t augSize = get_uleb128(&ptr, end);
+
+			if ((ptr += augSize) > end)
+				fde = NULL;
+		}
+	}
+	if (cie == NULL || fde == NULL)
+		return -ENXIO;
+
+	state.org = startLoc;
+	memcpy(&state.cfa, &badCFA, sizeof(state.cfa));
+	/* process instructions */
+	if (!processCFI(ptr, end, UNW_PC(frame), ptrType, &state)
+	   || state.loc > endLoc
+	   || state.regs[retAddrReg].where == Nowhere
+	   || state.cfa.reg >= ARRAY_SIZE(reg_info)
+	   || reg_info[state.cfa.reg].width != sizeof(unsigned long)
+	   || state.cfa.offs % sizeof(unsigned long)) {
+		return -EIO;
+		}
+	/* update frame */
+	cfa = FRAME_REG(state.cfa.reg, unsigned long) + state.cfa.offs;
+	startLoc = min((unsigned long)UNW_SP(frame), cfa);
+	endLoc = max((unsigned long)UNW_SP(frame), cfa);
+	if (STACK_LIMIT(startLoc) != STACK_LIMIT(endLoc)) {
+		startLoc = min(STACK_LIMIT(cfa), cfa);
+		endLoc = max(STACK_LIMIT(cfa), cfa);
+	}
+#ifndef CONFIG_64BIT
+# define CASES CASE(8); CASE(16); CASE(32)
+#else
+# define CASES CASE(8); CASE(16); CASE(32); CASE(64)
+#endif
+	for (i = 0; i < ARRAY_SIZE(state.regs); ++i) {
+		if (REG_INVALID(i)) {
+			if (state.regs[i].where == Nowhere)
+				continue;
+			return -EIO;
+		}
+		switch(state.regs[i].where) {
+		default:
+			break;
+		case Register:
+			if (state.regs[i].value >= ARRAY_SIZE(reg_info)
+			   || REG_INVALID(state.regs[i].value)
+			   || reg_info[i].width > reg_info[state.regs[i].value].width){
+				return -EIO;
+	}
+			switch(reg_info[state.regs[i].value].width) {
+#define CASE(n) \
+			case sizeof(u##n): \
+				state.regs[i].value = FRAME_REG(state.regs[i].value, \
+				                                const u##n); \
+				break
+			CASES;
+#undef CASE
+			default:
+				return -EIO;
+			}
+			break;
+		}
+	}
+	for (i = 0; i < ARRAY_SIZE(state.regs); ++i) {
+		if (REG_INVALID(i))
+			continue;
+		switch(state.regs[i].where) {
+		case Nowhere:
+			if (reg_info[i].width != sizeof(UNW_SP(frame))
+			   || &FRAME_REG(i, __typeof__(UNW_SP(frame)))
+			      != &UNW_SP(frame))
+				continue;
+			UNW_SP(frame) = cfa;
+			break;
+		case Register:
+			switch(reg_info[i].width) {
+#define CASE(n) case sizeof(u##n): \
+				FRAME_REG(i, u##n) = state.regs[i].value; \
+				break
+			CASES;
+#undef CASE
+			default:
+				return -EIO;
+			}
+			break;
+		case Value:
+			if (reg_info[i].width != sizeof(unsigned long)){
+				return -EIO;}
+			FRAME_REG(i, unsigned long) = cfa + state.regs[i].value
+			                                    * state.dataAlign;
+			break;
+		case Memory: {
+				unsigned long addr = cfa + state.regs[i].value
+				                           * state.dataAlign;
+				if ((state.regs[i].value * state.dataAlign)
+				    % sizeof(unsigned long)
+				    || addr < startLoc
+				    || addr + sizeof(unsigned long) < addr
+				    || addr + sizeof(unsigned long) > endLoc){
+					return -EIO;}
+				switch(reg_info[i].width) {
+#define CASE(n)     case sizeof(u##n): \
+					readmem(addr, KVADDR, &reg_ptr,sizeof(u##n), "register", RETURN_ON_ERROR|QUIET); \
+					FRAME_REG(i, u##n) = (u##n)reg_ptr;\
+					break
+				CASES;
+#undef CASE
+				default:
+					return -EIO;
+				}
+			}
+			break;
+		}
+	}
+	return 0;
+#undef CASES
+#undef FRAME_REG
+}
+
+/*
+ *  Initialize the unwind table(s) in the best-case order:
+ *
+ *   1. Use the in-memory kernel and module unwind tables.
+ *   2. Use the in-memory kernel-only .eh_frame data. (possible?)
+ *   3. Use the kernel-only .eh_frame data from the vmlinux file.
+ */ 
+void 
+init_unwind_table(void)
+{
+	ulong unwind_table_size;
+	void *unwind_table;
+
+	kt->flags &= ~DWARF_UNWIND;
+
+	if (gather_in_memory_unwind_tables()) {
+                if (CRASHDEBUG(1))
+                        fprintf(fp, "init_unwind_table: DWARF_UNWIND_MEMORY (%d tables)\n",
+				unwind_tables_cnt);
+
+                kt->flags |= DWARF_UNWIND_MEMORY;
+		if (unwind_tables_cnt > 1)
+                	kt->flags |= DWARF_UNWIND_MODULES;
+                if (!(kt->flags & NO_DWARF_UNWIND))
+                        kt->flags |= DWARF_UNWIND;
+
+		return;
+	}
+
+	if (symbol_exists("__start_unwind") &&
+	    symbol_exists("__end_unwind")) {
+		unwind_table_size = symbol_value("__end_unwind") - 
+			symbol_value("__start_unwind");
+
+		if (!(unwind_table = malloc(unwind_table_size))) {
+			error(WARNING, "cannot malloc unwind table space\n");
+			goto try_eh_frame;
+		}
+
+		if (!readmem(symbol_value("__start_unwind"), KVADDR, unwind_table,
+            	    unwind_table_size, "unwind table", RETURN_ON_ERROR)) {
+			error(WARNING, "cannot read unwind table data\n");
+			free(unwind_table);
+			goto try_eh_frame;
+		}
+
+		kt->flags |= DWARF_UNWIND_MEMORY;
+		if (!(kt->flags & NO_DWARF_UNWIND))
+			kt->flags |= DWARF_UNWIND;
+
+		default_unwind_table.size = unwind_table_size;
+		default_unwind_table.address = unwind_table;
+
+		if (CRASHDEBUG(1)) 
+			fprintf(fp, "init_unwind_table: DWARF_UNWIND_MEMORY\n");
+
+		return;
+	}
+
+try_eh_frame:
+
+	if (st->dwarf_eh_frame_size) {
+		int fd;
+
+		unwind_table_size = st->dwarf_eh_frame_size;
+
+		if (!(unwind_table = malloc(unwind_table_size))) {
+			error(WARNING, "cannot malloc unwind table space\n");
+			return;
+		}
+
+		if ((fd = open(pc->namelist, O_RDONLY)) < 0) {
+			error(WARNING, "cannot open %s for .eh_frame data\n",
+				pc->namelist);
+			free(unwind_table);
+			return;
+		}
+
+		lseek(fd, st->dwarf_eh_frame_file_offset, SEEK_SET);
+
+		if (read(fd, unwind_table, st->dwarf_eh_frame_size) !=
+		    st->dwarf_eh_frame_size) {
+			error(WARNING, "cannot read .eh_frame data from %s\n",
+				pc->namelist);
+			free(unwind_table);
+			return;
+		}
+
+		close(fd);
+
+		default_unwind_table.size = unwind_table_size;
+		default_unwind_table.address = unwind_table;
+
+		kt->flags |= DWARF_UNWIND_EH_FRAME;
+		if (!(kt->flags & NO_DWARF_UNWIND))
+			kt->flags |= DWARF_UNWIND;
+
+		if (CRASHDEBUG(1)) 
+			fprintf(fp, "init_unwind_table: DWARF_UNWIND_EH_FRAME\n");
+
+		return;
+	}
+}
+
+/*
+ *  Find the appropriate kernel-only "root_table" unwind_table,
+ *  and pass it to populate_local_tables() to do the heavy lifting.
+ */
+static int 
+gather_in_memory_unwind_tables(void)
+{
+	int i, cnt, found;
+	struct syment *sp, *root_tables[10];
+	char *root_table_buf;
+	char buf[BUFSIZE];
+	ulong name;
+
+	STRUCT_SIZE_INIT(unwind_table, "unwind_table");
+	MEMBER_OFFSET_INIT(unwind_table_core, "unwind_table", "core");
+	MEMBER_OFFSET_INIT(unwind_table_init, "unwind_table", "init");
+	MEMBER_OFFSET_INIT(unwind_table_address, "unwind_table", "address");
+	MEMBER_OFFSET_INIT(unwind_table_size, "unwind_table", "size");
+	MEMBER_OFFSET_INIT(unwind_table_link, "unwind_table", "link");
+	MEMBER_OFFSET_INIT(unwind_table_name, "unwind_table", "name");
+
+	if (INVALID_SIZE(unwind_table) ||
+	    INVALID_MEMBER(unwind_table_core) ||
+	    INVALID_MEMBER(unwind_table_init) ||
+	    INVALID_MEMBER(unwind_table_address) ||
+	    INVALID_MEMBER(unwind_table_size) ||
+	    INVALID_MEMBER(unwind_table_link) ||
+	    INVALID_MEMBER(unwind_table_name)) {
+		if (CRASHDEBUG(1)) 
+			error(NOTE, 
+	    "unwind_table structure has changed, or does not exist in this kernel\n");
+		return 0;
+	}
+
+	/*
+	 *  Unfortunately there are two kernel root_table symbols.
+	 */
+	if (!(cnt = get_syment_array("root_table", root_tables, 10)))
+		return 0;
+
+	root_table_buf = GETBUF(SIZE(unwind_table));
+	for (i = found = 0; i < cnt; i++) {
+		sp = root_tables[i];
+		if (!readmem(sp->value, KVADDR, root_table_buf,
+                    SIZE(unwind_table), "root unwind_table", 
+		    RETURN_ON_ERROR|QUIET))
+			goto gather_failed;
+
+		name = ULONG(root_table_buf + OFFSET(unwind_table_name));
+		if (read_string(name, buf, strlen("kernel")+1) && 
+		    STREQ("kernel", buf)) {
+			found++;
+			if (CRASHDEBUG(1))
+				fprintf(fp, "root_table name: %lx [%s]\n", 
+					name, buf);
+			break;
+		}
+	}
+
+	if (!found)
+		goto gather_failed;
+
+	cnt = populate_local_tables(sp->value, root_table_buf);
+
+	FREEBUF(root_table_buf);
+	return cnt;
+
+gather_failed:
+
+	FREEBUF(root_table_buf);
+	return 0;
+}
+
+/*
+ *  Transfer the relevant data from the kernel and module unwind_table
+ *  structures to the local_unwind_table structures.
+ */
+static int
+populate_local_tables(ulong root, char *buf)
+{
+	struct list_data list_data, *ld;
+	int i, cnt;
+	ulong *table_list;
+	ulong vaddr;
+	struct local_unwind_table *tp;
+
+        ld = &list_data;
+        BZERO(ld, sizeof(struct list_data));
+        ld->start = root;
+        ld->member_offset = OFFSET(unwind_table_link);
+	if (CRASHDEBUG(1))
+        	ld->flags |= VERBOSE;
+
+	hq_open();
+        cnt = do_list(ld);
+        table_list = (ulong *)GETBUF(cnt * sizeof(ulong));
+	cnt = retrieve_list(table_list, cnt);
+	hq_close();
+
+	if (!(local_unwind_tables = 
+	    malloc(sizeof(struct local_unwind_table) * cnt))) {
+		error(WARNING, "cannot malloc unwind_table space (%d tables)\n",
+			cnt);
+		FREEBUF(table_list);
+		return 0;
+	}
+
+	for (i = 0; i < cnt; i++, tp++) {
+
+                if (!readmem(table_list[i], KVADDR, buf,
+                    SIZE(unwind_table), "unwind_table",
+                    RETURN_ON_ERROR|QUIET)) {
+			error(WARNING, "cannot read unwind_table\n");
+			goto failed;
+		}
+
+		tp = &local_unwind_tables[i];
+
+		/*
+		 *  Copy the required table info for find_table().
+		 */
+        	BCOPY(buf + OFFSET(unwind_table_core),
+                	(char *)&tp->core.pc, sizeof(ulong)*2);
+        	BCOPY(buf + OFFSET(unwind_table_init),
+                	(char *)&tp->init.pc, sizeof(ulong)*2);
+        	BCOPY(buf + OFFSET(unwind_table_size),
+                	(char *)&tp->size, sizeof(ulong));
+
+		/*
+		 *  Then read the DWARF CFI data.
+		 */
+		vaddr = ULONG(buf + OFFSET(unwind_table_address));
+
+		if (!(tp->address = malloc(tp->size))) {
+			error(WARNING, "cannot malloc unwind_table space\n");
+			goto failed;
+			break;
+		}
+                if (!readmem(vaddr, KVADDR, tp->address,
+                    tp->size, "DWARF CFI data", RETURN_ON_ERROR|QUIET)) {
+			error(WARNING, "cannot read unwind_table data\n");
+			goto failed;
+		}
+	}
+
+	unwind_tables_cnt = cnt;
+
+	if (CRASHDEBUG(7))
+		dump_local_unwind_tables();
+
+failed:
+
+	FREEBUF(table_list);
+	return unwind_tables_cnt;
+}
+
+/*
+ *  Find the unwind_table containing a pc.
+ */
+static struct local_unwind_table *
+find_table(unsigned long pc)
+{
+	int i;
+	struct local_unwind_table *tp, *table;
+
+	table = &default_unwind_table;
+
+        for (i = 0; i < unwind_tables_cnt; i++, tp++) {
+		tp = &local_unwind_tables[i];
+                if ((pc >= tp->core.pc
+                    && pc < tp->core.pc + tp->core.range)
+                    || (pc >= tp->init.pc
+                    && pc < tp->init.pc + tp->init.range)) {
+			table = tp;
+                        break;
+		}
+	}
+
+        return table;
+}
+
+static void 
+dump_local_unwind_tables(void)
+{
+	int i, others; 
+	struct local_unwind_table *tp;
+
+	others = 0;
+	fprintf(fp, "DWARF flags: (");
+        if (kt->flags & DWARF_UNWIND)
+                fprintf(fp, "%sDWARF_UNWIND", others++ ? "|" : "");
+        if (kt->flags & NO_DWARF_UNWIND)
+                fprintf(fp, "%sNO_DWARF_UNWIND", others++ ? "|" : "");
+        if (kt->flags & DWARF_UNWIND_MEMORY)
+                fprintf(fp, "%sDWARF_UNWIND_MEMORY", others++ ? "|" : "");
+        if (kt->flags & DWARF_UNWIND_EH_FRAME)
+                fprintf(fp, "%sDWARF_UNWIND_EH_FRAME", others++ ? "|" : "");
+        if (kt->flags & DWARF_UNWIND_MODULES)
+                fprintf(fp, "%sDWARF_UNWIND_MODULES", others++ ? "|" : "");
+	fprintf(fp, ")\n\n");
+
+	fprintf(fp, "default_unwind_table:\n");
+	fprintf(fp, "      address: %lx\n",
+		(ulong)default_unwind_table.address);
+	fprintf(fp, "         size: %ld\n\n",
+		(ulong)default_unwind_table.size);
+
+	fprintf(fp, "local_unwind_tables[%d]:\n", unwind_tables_cnt);
+        for (i = 0; i < unwind_tables_cnt; i++, tp++) {
+		tp = &local_unwind_tables[i];
+		fprintf(fp, "[%d]\n", i);
+		fprintf(fp, "         core: pc: %lx\n", tp->core.pc);
+		fprintf(fp, "        range: %ld\n", tp->core.range);
+		fprintf(fp, "     init: pc: %lx\n", tp->init.pc);
+		fprintf(fp, "        range: %ld\n", tp->init.range);
+		fprintf(fp, "      address: %lx\n", (ulong)tp->address);
+		fprintf(fp, "         size: %ld\n", tp->size);
+	}
+}
+
+
+int 
+dwarf_backtrace(struct bt_info *bt, ulong stacktop)
+{
+	int n = 0;
+	unsigned long bp, offset;
+	struct syment *sp;
+	char *name;
+	struct unwind_frame_info *frame;
+
+	frame = (struct unwind_frame_info *)GETBUF(sizeof(struct unwind_frame_info));
+//	frame->regs.rsp = bt->stkptr;
+//	frame->regs.rip = bt->instptr;
+	UNW_SP(frame) = bt->stkptr;
+	UNW_PC(frame) = bt->instptr;
+
+	/* read rbp from stack for non active tasks */
+	if (!(bt->flags & BT_DUMPFILE_SEARCH) ) {
+//		readmem(frame->regs.rsp, KVADDR, &bp,
+		readmem(UNW_SP(frame), KVADDR, &bp,
+	                sizeof(unsigned long), "reading bp", FAULT_ON_ERROR);
+		frame->regs.rbp = bp;  /* fixme for x86 */
+	}
+
+	sp = value_search(UNW_PC(frame), &offset);
+	/*
+	 * If offset is zero, it means we have crossed over to the next
+	 *  function. Recalculate by adjusting the text address
+	 */
+	if (!offset)
+		sp = value_search(UNW_PC(frame) - 1, &offset);
+		
+        name = sp->name;
+	fprintf(fp, " #0 [%016lx] %s at %016lx \n", UNW_SP(frame), name, UNW_PC(frame));
+
+	if (CRASHDEBUG(2))
+		fprintf(fp, "    < SP: %lx PC: %lx FP: %lx >\n", UNW_SP(frame), 
+			UNW_PC(frame), frame->regs.rbp);
+
+       	while ((UNW_SP(frame) < stacktop)
+				&& !unwind(frame) && UNW_PC(frame)) {
+               	n++;
+		sp = value_search(UNW_PC(frame), &offset);
+		if (!sp)
+			break;
+	        name = sp->name;
+		fprintf(fp, "%s#%d [%016lx] %s at %016lx \n", n < 10 ? " " : "",
+			n, UNW_SP(frame), name, UNW_PC(frame));
+
+		if (CRASHDEBUG(2))
+			fprintf(fp, "    < SP: %lx PC: %lx FP: %lx >\n", UNW_SP(frame), 
+				UNW_PC(frame), frame->regs.rbp);
+       	}
+	FREEBUF(frame);
+	return TRUE;
+}
+
+void
+dwarf_debug(struct bt_info *bt)
+{
+	struct unwind_frame_info *frame;
+	ulong bp;
+
+	if (!bt->hp->eip) {
+		dump_local_unwind_tables();
+		return;
+	}
+
+	if (!(kt->flags & DWARF_UNWIND_CAPABLE)) {
+		error(INFO, "not DWARF capable\n");
+		return;
+	}
+
+        frame = (struct unwind_frame_info *)GETBUF(sizeof(struct unwind_frame_info));
+
+	/*
+	 *  XXX: This only works for the first PC/SP pair seen in a normal
+	 *  backtrace, so it's not particularly helpful.  Ideally it should
+         *  be capable to take any PC/SP pair in a stack, but it appears to
+	 *  related to the rbp value. 
+	 */
+
+	UNW_PC(frame) = bt->hp->eip;
+	UNW_SP(frame) = bt->hp->esp;
+
+        readmem(UNW_SP(frame), KVADDR, &bp,
+ 		sizeof(unsigned long), "reading bp", FAULT_ON_ERROR);
+        frame->regs.rbp = bp;  /* fixme for x86 */
+
+	unwind(frame);
+
+	fprintf(fp, "frame size: %lx (%lx)\n", 
+		(ulong)UNW_SP(frame), (ulong)UNW_SP(frame) - bt->hp->esp);
+
+	FREEBUF(frame);
+}
+
+
+#endif 
diff -purN crash-4.0-3.7/unwind_x86_64.h crash-4.0-3.8/unwind_x86_64.h
--- crash-4.0-3.7/unwind_x86_64.h	1970-01-01 01:00:00.000000000 +0100
+++ crash-4.0-3.8/unwind_x86_64.h	2006-10-20 21:46:27.000000000 +0200
@@ -0,0 +1,92 @@
+#define CONFIG_64BIT 1
+#define NULL ((void *)0)
+
+typedef unsigned long size_t;
+typedef unsigned char u8;
+typedef signed short s16;
+typedef unsigned short u16;
+typedef signed int s32;
+typedef unsigned int u32;
+typedef unsigned long long u64;
+
+struct pt_regs {
+        unsigned long r15;
+        unsigned long r14;
+        unsigned long r13;
+        unsigned long r12;
+        unsigned long rbp;
+        unsigned long rbx;
+/* arguments: non interrupts/non tracing syscalls only save upto here*/
+        unsigned long r11;
+        unsigned long r10;
+        unsigned long r9;
+        unsigned long r8;
+        unsigned long rax;
+        unsigned long rcx;
+        unsigned long rdx;
+        unsigned long rsi;
+        unsigned long rdi;
+        unsigned long orig_rax;
+/* end of arguments */
+/* cpu exception frame or undefined */
+        unsigned long rip;
+        unsigned long cs;
+        unsigned long eflags;
+        unsigned long rsp;
+        unsigned long ss;
+/* top of stack page */
+};
+
+struct unwind_frame_info
+{
+        struct pt_regs regs;
+};
+
+extern int unwind(struct unwind_frame_info *);
+extern void init_unwind_table(void);
+extern void free_unwind_table(void);
+
+#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
+#define BUILD_BUG_ON_ZERO(e) (sizeof(char[1 - 2 * !!(e)]) - 1)
+#define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))
+#define get_unaligned(ptr) (*(ptr))
+//#define __get_user(x,ptr)  __get_user_nocheck((x),(ptr),sizeof(*(ptr)))
+#define THREAD_ORDER 1
+#define THREAD_SIZE  (PAGE_SIZE << THREAD_ORDER)
+
+#define UNW_PC(frame)        (frame)->regs.rip
+#define UNW_SP(frame)        (frame)->regs.rsp
+#ifdef CONFIG_FRAME_POINTER
+	#define UNW_FP(frame)        (frame)->regs.rbp
+	#define FRAME_RETADDR_OFFSET 8
+	#define FRAME_LINK_OFFSET    0
+	#define STACK_BOTTOM(tsk)    (((tsk)->thread.rsp0 - 1) & ~(THREAD_SIZE - 1))
+	#define STACK_TOP(tsk)       ((tsk)->thread.rsp0)
+#endif
+
+
+#define EXTRA_INFO(f) { BUILD_BUG_ON_ZERO(offsetof(struct unwind_frame_info, f) % FIELD_SIZEOF(struct unwind_frame_info, f)) + offsetof(struct unwind_frame_info, f)/ FIELD_SIZEOF(struct unwind_frame_info, f), FIELD_SIZEOF(struct unwind_frame_info, f) }
+
+#define PTREGS_INFO(f) EXTRA_INFO(regs.f)
+
+#define UNW_REGISTER_INFO \
+	PTREGS_INFO(rax),\
+	PTREGS_INFO(rdx),\
+	PTREGS_INFO(rcx),\
+	PTREGS_INFO(rbx), \
+	PTREGS_INFO(rsi), \
+	PTREGS_INFO(rdi), \
+	PTREGS_INFO(rbp), \
+	PTREGS_INFO(rsp), \
+	PTREGS_INFO(r8), \
+	PTREGS_INFO(r9), \
+	PTREGS_INFO(r10),\
+	PTREGS_INFO(r11), \
+	PTREGS_INFO(r12), \
+	PTREGS_INFO(r13), \
+	PTREGS_INFO(r14), \
+	PTREGS_INFO(r15), \
+	PTREGS_INFO(rip)
+
diff -purN crash-4.0-3.7/x86_64.c crash-4.0-3.8/x86_64.c
--- crash-4.0-3.7/x86_64.c	2006-10-23 13:40:07.000000000 +0200
+++ crash-4.0-3.8/x86_64.c	2006-10-20 21:46:27.000000000 +0200
@@ -41,6 +41,7 @@ static void x86_64_back_trace_cmd(struct
 static ulong x86_64_in_exception_stack(struct bt_info *);
 static ulong x86_64_in_irqstack(struct bt_info *);
 static void x86_64_low_budget_back_trace_cmd(struct bt_info *);
+static void x86_64_dwarf_back_trace_cmd(struct bt_info *);
 static void x86_64_get_dumpfile_stack_frame(struct bt_info *, ulong *, ulong *);
 static struct syment *x86_64_function_called_by(ulong);
 static int is_direct_call_target(struct bt_info *);
@@ -122,6 +123,7 @@ x86_64_init(int when)
 		machdep->verify_paddr = generic_verify_paddr;
 		machdep->ptrs_per_pgd = PTRS_PER_PGD;
 		machdep->flags |= MACHDEP_BT_TEXT;
+		machdep->flags |= FRAMESIZE_DEBUG;
                 if (machdep->cmdline_arg)
                         parse_cmdline_arg();
 		break;
@@ -245,6 +247,7 @@ x86_64_init(int when)
 		STRUCT_SIZE_INIT(user_regs_struct, "user_regs_struct");
 		x86_64_cpu_pda_init();
 		x86_64_ist_init();
+                init_unwind_table();
                 if ((machdep->machspec->irqstack = (char *)
 		    malloc(machdep->machspec->stkinfo.isize)) == NULL)
                         error(FATAL, "cannot malloc irqstack space.");
@@ -321,6 +324,8 @@ x86_64_dump_machdep_table(ulong arg)
 		fprintf(fp, "%sSCHED_TEXT", others++ ? "|" : "");
 	if (machdep->flags & PHYS_BASE)
 		fprintf(fp, "%sPHYS_BASE", others++ ? "|" : "");
+	if (machdep->flags & FRAMESIZE_DEBUG)
+		fprintf(fp, "%sFRAMESIZE_DEBUG", others++ ? "|" : "");
         fprintf(fp, ")\n");
 
 	fprintf(fp, "             kvbase: %lx\n", machdep->kvbase);
@@ -341,7 +346,14 @@ x86_64_dump_machdep_table(ulong arg)
         	fprintf(fp, "         back_trace: x86_64_back_trace_cmd()\n");
 	else if (machdep->back_trace == x86_64_low_budget_back_trace_cmd)
         	fprintf(fp, 
-		   "         back_trace: x86_64_low_budget_back_trace_cmd()\n");
+		   "         back_trace: x86_64_low_budget_back_trace_cmd() %s\n",
+			kt->flags & DWARF_UNWIND ?
+			"-> x86_64_dwarf_back_trace_cmd()" : "");
+	else if (machdep->back_trace == x86_64_dwarf_back_trace_cmd)
+        	fprintf(fp, 
+		   "         back_trace: x86_64_dwarf_back_trace_cmd() %s\n",
+			kt->flags & DWARF_UNWIND ? 
+			"" : "->x86_64_low_budget_back_trace_cmd()");
 	else
 		fprintf(fp, "         back_trace: %lx\n",
 			(ulong)machdep->back_trace);
@@ -2094,9 +2106,23 @@ x86_64_low_budget_back_trace_cmd(struct 
 	ulong last_process_stack_eframe;
 	ulong user_mode_eframe;
 
+        /*
+         *  User may have made a run-time switch.
+         */
+	if (kt->flags & DWARF_UNWIND) {
+		machdep->back_trace = x86_64_dwarf_back_trace_cmd;
+		x86_64_dwarf_back_trace_cmd(bt_in);
+		return;
+	}
+
 	bt = &bt_local;
 	BCOPY(bt_in, bt, sizeof(struct bt_info));
 
+	if (bt->flags & BT_FRAMESIZE_DEBUG) {
+		dwarf_debug(bt);
+		return;
+	}
+
 	level = 0;
 	done = FALSE;
 	irq_eframe = 0;
@@ -2469,6 +2495,422 @@ in_exception_stack:
 }
 
 /*
+ *  Use dwarf CFI encodings to correctly follow the call chain.
+ */
+static void
+x86_64_dwarf_back_trace_cmd(struct bt_info *bt_in)
+{
+	int i, level, done;
+	ulong rsp, offset, stacktop;
+	ulong *up;
+	long cs;
+	struct syment *sp, *spt;
+	FILE *ofp;
+	ulong estack, irqstack;
+	ulong irq_eframe;
+	struct bt_info bt_local, *bt;
+	struct machine_specific *ms;
+	ulong last_process_stack_eframe;
+	ulong user_mode_eframe;
+
+	/*
+	 *  User may have made a run-time switch.
+	 */
+        if (!(kt->flags & DWARF_UNWIND)) {
+                machdep->back_trace = x86_64_low_budget_back_trace_cmd;
+                x86_64_low_budget_back_trace_cmd(bt_in);
+                return;
+        }
+
+	bt = &bt_local;
+	BCOPY(bt_in, bt, sizeof(struct bt_info));
+
+        if (bt->flags & BT_FRAMESIZE_DEBUG) {
+		dwarf_debug(bt);
+		return;
+	}
+
+	level = 0;
+	done = FALSE;
+	irq_eframe = 0;
+	last_process_stack_eframe = 0;
+	bt->call_target = NULL;
+	rsp = bt->stkptr;
+	if (!rsp) {
+		error(INFO, "cannot determine starting stack pointer\n");
+		return;
+	}
+	ms = machdep->machspec;
+	if (BT_REFERENCE_CHECK(bt))
+		ofp = pc->nullfp;
+	else
+		ofp = fp;
+
+        if (bt->flags & BT_TEXT_SYMBOLS) {
+		if (!(bt->flags & BT_TEXT_SYMBOLS_ALL))
+                	fprintf(ofp, "%sSTART: %s%s at %lx\n",
+                	    space(VADDR_PRLEN > 8 ? 14 : 6),
+                	    closest_symbol(bt->instptr), 
+			    STREQ(closest_symbol(bt->instptr), "thread_return") ?
+			    " (schedule)" : "",
+			    bt->instptr);
+        } else if (bt->flags & BT_START) {
+                x86_64_print_stack_entry(bt, ofp, level,
+                        0, bt->instptr);
+		bt->flags &= ~BT_START;
+		level++;
+	}
+
+
+        if ((estack = x86_64_in_exception_stack(bt))) {
+in_exception_stack:
+		bt->flags |= BT_EXCEPTION_STACK;
+		/*
+	 	 *  The stack buffer will have been loaded with the process
+		 *  stack, so switch to the indicated exception stack.
+		 */
+                bt->stackbase = estack;
+                bt->stacktop = estack + ms->stkinfo.esize;
+                bt->stackbuf = ms->irqstack;
+
+                if (!readmem(bt->stackbase, KVADDR, bt->stackbuf,
+                    bt->stacktop - bt->stackbase,
+		    bt->hp && (bt->hp->esp == bt->stkptr) ? 
+	 	    "irqstack contents via hook" : "irqstack contents", 
+		    RETURN_ON_ERROR))
+                    	error(FATAL, "read of exception stack at %lx failed\n",
+                        	bt->stackbase);
+
+		/*
+	 	 *  If irq_eframe is set, we've jumped back here from the
+		 *  IRQ stack dump below.  Do basically the same thing as if
+		 *  had come from the processor stack, but presume that we
+		 *  must have been in kernel mode, i.e., took an exception
+	 	 *  while operating on an IRQ stack.  (untested)
+		 */
+                if (irq_eframe) {
+                        bt->flags |= BT_EXCEPTION_FRAME;
+                        i = (irq_eframe - bt->stackbase)/sizeof(ulong);
+                        x86_64_print_stack_entry(bt, ofp, level, i, 
+				bt->instptr);
+                        bt->flags &= ~(ulonglong)BT_EXCEPTION_FRAME;
+                        cs = x86_64_exception_frame(EFRAME_PRINT|EFRAME_CS, 0,
+                        	bt->stackbuf + (irq_eframe - bt->stackbase), 
+				bt, ofp);
+                        rsp += SIZE(pt_regs);  /* guaranteed kernel mode */
+                        level++;
+                        irq_eframe = 0;
+                }
+
+		stacktop = bt->stacktop - SIZE(pt_regs);
+		
+		if ((kt->flags & DWARF_UNWIND) && !done)
+			done = dwarf_backtrace(bt, stacktop);
+
+        	for (i = (rsp - bt->stackbase)/sizeof(ulong);
+	     	    !done && (rsp < stacktop); i++, rsp += sizeof(ulong)) {
+
+			up = (ulong *)(&bt->stackbuf[i*sizeof(ulong)]);
+
+			if (!is_kernel_text(*up))
+		        	continue;
+
+	                switch (x86_64_print_stack_entry(bt, ofp, level, i,*up))
+	                {
+	                case BACKTRACE_ENTRY_AND_EFRAME_DISPLAYED:
+				rsp += SIZE(pt_regs);
+				i += SIZE(pt_regs)/sizeof(ulong);
+	                case BACKTRACE_ENTRY_DISPLAYED:
+	                        level++;
+	                        break;
+	                case BACKTRACE_ENTRY_IGNORED:
+	                        break;
+	                case BACKTRACE_COMPLETE:
+	                        done = TRUE;
+	                        break;
+	                }
+		}
+
+                cs = x86_64_exception_frame(EFRAME_PRINT|EFRAME_CS, 0, 
+			bt->stackbuf + (bt->stacktop - bt->stackbase) - 
+			SIZE(pt_regs), bt, ofp);
+
+		if (!BT_REFERENCE_CHECK(bt))
+			fprintf(fp, "--- <exception stack> ---\n");
+
+                /* 
+		 *  stack = (unsigned long *) estack_end[-2]; 
+		 */
+		up = (ulong *)(&bt->stackbuf[bt->stacktop - bt->stackbase]);
+		up -= 2;
+		rsp = bt->stkptr = *up;
+		up -= 3;
+		bt->instptr = *up;  
+		if (cs & 3)
+			done = TRUE;   /* user-mode exception */
+		else
+			done = FALSE;  /* kernel-mode exception */
+		bt->frameptr = 0;
+
+		/*
+		 *  Print the return values from the estack end.
+		 */
+		if (!done) {
+                	bt->flags |= BT_START;
+                	x86_64_print_stack_entry(bt, ofp, level,
+                        	0, bt->instptr);
+                	bt->flags &= ~BT_START;
+			level++;
+		}
+	}
+
+	/*
+	 *  IRQ stack entry always comes in via the process stack, regardless
+	 *  whether it happened while running in user or kernel space.
+	 */
+        if (!done && (irqstack = x86_64_in_irqstack(bt))) {
+		bt->flags |= BT_IRQSTACK;
+		/*
+		 *  Until coded otherwise, the stackbase will be pointing to
+		 *  either the exception stack or, more likely, the process
+		 *  stack base.  Switch it to the IRQ stack.
+		 */
+                bt->stackbase = irqstack;
+                bt->stacktop = irqstack + ms->stkinfo.isize;
+                bt->stackbuf = ms->irqstack;
+
+                if (!readmem(bt->stackbase, KVADDR, 
+	  	    bt->stackbuf, bt->stacktop - bt->stackbase,
+                    bt->hp && (bt->hp->esp == bt_in->stkptr) ?
+		    "irqstack contents via hook" : "irqstack contents", 
+		    RETURN_ON_ERROR))
+                    	error(FATAL, "read of IRQ stack at %lx failed\n",
+				bt->stackbase);
+
+		stacktop = bt->stacktop - 64; /* from kernel code */
+
+		if ((kt->flags & DWARF_UNWIND) && !done)
+			done = dwarf_backtrace(bt, stacktop);
+
+                for (i = (rsp - bt->stackbase)/sizeof(ulong);
+                    !done && (rsp < stacktop); i++, rsp += sizeof(ulong)) {
+
+                        up = (ulong *)(&bt->stackbuf[i*sizeof(ulong)]);
+
+                        if (!is_kernel_text(*up))
+                                continue;
+
+                        switch (x86_64_print_stack_entry(bt, ofp, level, i,*up))
+                        {
+			case BACKTRACE_ENTRY_AND_EFRAME_DISPLAYED:
+				rsp += SIZE(pt_regs);
+				i += SIZE(pt_regs)/sizeof(ulong);
+                        case BACKTRACE_ENTRY_DISPLAYED:
+                                level++;
+                                break;
+                        case BACKTRACE_ENTRY_IGNORED:
+                                break;
+                        case BACKTRACE_COMPLETE:
+                                done = TRUE;
+                                break;
+                        }
+                }
+
+		if (!BT_REFERENCE_CHECK(bt))
+                	fprintf(fp, "--- <IRQ stack> ---\n");
+
+                /*
+		 *  stack = (unsigned long *) (irqstack_end[-1]);
+		 *  (where irqstack_end is 64 bytes below page end)
+                 */
+                up = (ulong *)(&bt->stackbuf[stacktop - bt->stackbase]);
+                up -= 1;
+                irq_eframe = rsp = bt->stkptr = *up;
+		up -= 1;
+                bt->instptr = *up;
+                bt->frameptr = 0;
+                done = FALSE;
+        } else
+		irq_eframe = 0;
+
+        if (!done && (estack = x86_64_in_exception_stack(bt))) 
+		goto in_exception_stack;
+
+	if (!done && (bt->flags & (BT_EXCEPTION_STACK|BT_IRQSTACK))) {
+		/*
+		 *  Verify that the rsp pointer taken from either the
+		 *  exception or IRQ stack points into the process stack.
+		 */
+		bt->stackbase = GET_STACKBASE(bt->tc->task);
+		bt->stacktop = GET_STACKTOP(bt->tc->task);
+
+		if (!INSTACK(rsp, bt)) {
+			switch (bt->flags & (BT_EXCEPTION_STACK|BT_IRQSTACK))
+			{
+			case (BT_EXCEPTION_STACK|BT_IRQSTACK):
+				error(FATAL, STACK_TRANSITION_ERRMSG_E_I_P,
+					bt_in->stkptr, bt->stkptr, rsp,
+					bt->stackbase);
+
+			case BT_EXCEPTION_STACK:
+				error(FATAL, STACK_TRANSITION_ERRMSG_E_P,
+					bt_in->stkptr, rsp, bt->stackbase);
+
+			case BT_IRQSTACK:
+				error(FATAL, STACK_TRANSITION_ERRMSG_I_P,
+					bt_in->stkptr, rsp, bt->stackbase);
+			}
+		}
+
+		/*
+	 	 *  Now fill the local stack buffer from the process stack.
+	  	 */
+               	if (!readmem(bt->stackbase, KVADDR, bt->stackbuf,
+                    bt->stacktop - bt->stackbase, 
+		    "irqstack contents", RETURN_ON_ERROR))
+                	error(FATAL, "read of process stack at %lx failed\n",
+				bt->stackbase);
+	}
+
+	/*
+	 *  For a normally blocked task, hand-create the first level.
+	 */
+        if (!done && !(kt->flags & DWARF_UNWIND) &&
+	    !(bt->flags & (BT_TEXT_SYMBOLS|BT_EXCEPTION_STACK|BT_IRQSTACK)) &&
+	    STREQ(closest_symbol(bt->instptr), "thread_return")) {
+		bt->flags |= BT_SCHEDULE;
+		i = (rsp - bt->stackbase)/sizeof(ulong);
+		x86_64_print_stack_entry(bt, ofp, level, 
+			i, bt->instptr);
+		bt->flags &= ~(ulonglong)BT_SCHEDULE;
+		rsp += sizeof(ulong);
+		level++;
+	}
+
+	/*
+	 *  Dump the IRQ exception frame from the process stack.
+	 *  If the CS register indicates a user exception frame,
+	 *  then set done to TRUE to avoid the process stack walk-through.
+	 *  Otherwise, bump up the rsp past the kernel-mode eframe.
+	 */
+        if (irq_eframe) {
+                bt->flags |= BT_EXCEPTION_FRAME;
+                i = (irq_eframe - bt->stackbase)/sizeof(ulong);
+                x86_64_print_stack_entry(bt, ofp, level, i, bt->instptr);
+                bt->flags &= ~(ulonglong)BT_EXCEPTION_FRAME;
+                cs = x86_64_exception_frame(EFRAME_PRINT|EFRAME_CS, 0, 
+			bt->stackbuf + (irq_eframe - bt->stackbase), bt, ofp);
+		if (cs & 3)
+			done = TRUE;   /* IRQ from user-mode */
+		else {
+			if (x86_64_print_eframe_location(rsp, level, ofp))
+				level++;
+			rsp += SIZE(pt_regs);
+			irq_eframe = 0;
+		}
+		level++;
+        }
+
+	/*
+	 *  Walk the process stack.  
+	 */
+	if ((kt->flags & DWARF_UNWIND) && !done)
+		done = dwarf_backtrace(bt, bt->stacktop);
+
+        for (i = (rsp - bt->stackbase)/sizeof(ulong);
+	     !done && (rsp < bt->stacktop); i++, rsp += sizeof(ulong)) {
+
+		up = (ulong *)(&bt->stackbuf[i*sizeof(ulong)]);
+
+		if (!is_kernel_text(*up))
+			continue;
+
+		if ((bt->flags & BT_CHECK_CALLER)) {
+			/*
+			 *  A non-zero offset value from the value_search() 
+			 *  lets us know if it's a real text return address.
+			 */
+			spt = value_search(*up, &offset);
+			/*
+		         *  sp gets the syment of the function that the text 
+			 *  routine above called before leaving its return 
+			 *  address on the stack -- if it can be determined.
+			 */
+			sp = x86_64_function_called_by((*up)-5); 
+
+			if (sp == NULL) {
+				/* 
+				 *  We were unable to get the called function.
+				 *  If the text address had an offset, then
+				 *  it must have made an indirect call, and
+				 *  can't have called our target function.
+				 */
+				if (offset) {
+					if (CRASHDEBUG(1))
+						fprintf(ofp, 
+                       "< ignoring %s() -- makes indirect call and NOT %s()>\n",
+						    	spt->name, 
+						    	bt->call_target);
+					continue;
+				}
+			} else if ((machdep->flags & SCHED_TEXT) &&
+				STREQ(bt->call_target, "schedule") &&
+				STREQ(sp->name, "__sched_text_start")) {
+				;  /*  bait and switch */
+			} else if (!STREQ(sp->name, bt->call_target)) {
+				/*
+				 *  We got function called by the text routine,
+			 	 *  but it's not our target function.
+				 */
+				if (CRASHDEBUG(2))
+					fprintf(ofp, 
+ 		                "< ignoring %s() -- calls %s() and NOT %s()>\n",
+						spt->name, sp->name, 
+						bt->call_target);
+				continue;
+			}
+		}
+
+		switch (x86_64_print_stack_entry(bt, ofp, level, i,*up))
+		{
+		case BACKTRACE_ENTRY_AND_EFRAME_DISPLAYED:
+			last_process_stack_eframe = rsp + 8;
+			if (x86_64_print_eframe_location(last_process_stack_eframe, level, ofp))
+				level++;
+			rsp += SIZE(pt_regs);
+			i += SIZE(pt_regs)/sizeof(ulong);
+		case BACKTRACE_ENTRY_DISPLAYED:
+			level++;
+			break;
+		case BACKTRACE_ENTRY_IGNORED:	
+			break;
+		case BACKTRACE_COMPLETE:
+			done = TRUE;
+			break;
+		}
+        }
+
+        if (!irq_eframe && !is_kernel_thread(bt->tc->task) &&
+            (GET_STACKBASE(bt->tc->task) == bt->stackbase)) {
+		user_mode_eframe = bt->stacktop - SIZE(pt_regs);
+		if (last_process_stack_eframe < user_mode_eframe)
+                	x86_64_exception_frame(EFRAME_PRINT, 0, bt->stackbuf +
+                        	(bt->stacktop - bt->stackbase) - SIZE(pt_regs),
+                        	bt, ofp);
+	}
+
+        if (bt->flags & BT_TEXT_SYMBOLS) {
+        	if (BT_REFERENCE_FOUND(bt)) {
+                	print_task_header(fp, task_to_context(bt->task), 0);
+			BCOPY(bt_in, bt, sizeof(struct bt_info));
+                	bt->ref = NULL;
+                	machdep->back_trace(bt);
+                	fprintf(fp, "\n");
+        	}
+	}
+}
+
+/*
  *  Functions that won't be called indirectly.
  *  Add more to this as they are discovered.
  */

Places

File crash-4.0-3.7-3.8.patch of Package crash (Revision 4e212cfae17dcbfea71a02de321cbb7f)

Places