File crash-4.0-3.9-3.14.patch of Package crash

Overview Repositories Revisions Requests Users Attributes Meta

File crash-4.0-3.9-3.14.patch of Package crash (Revision 4e212cfae17dcbfea71a02de321cbb7f)

Currently displaying revision 4e212cfae17dcbfea71a02de321cbb7f , Show latest

diff -purN crash-4.0-3.9/.rh_rpm_package crash-4.0-3.14/.rh_rpm_package
--- crash-4.0-3.9/.rh_rpm_package	2006-12-08 17:00:30.000000000 +0100
+++ crash-4.0-3.14/.rh_rpm_package	2006-12-01 21:39:42.000000000 +0100
@@ -1 +1 @@
-4.0-3.9
+4.0-3.14
diff -purN crash-4.0-3.9/Makefile crash-4.0-3.14/Makefile
--- crash-4.0-3.9/Makefile	2006-12-08 17:00:30.000000000 +0100
+++ crash-4.0-3.14/Makefile	2006-12-01 21:39:42.000000000 +0100
@@ -62,7 +62,7 @@ INSTALLDIR=${DESTDIR}/usr/bin
 # (2) Or invoke make like so:
 #    make LDFLAGS=-static NAT_CLIBS="-lc -lresolv" GDBSERVER_LIBS="-lc -lresolv"
 
-GENERIC_HFILES=defs.h 
+GENERIC_HFILES=defs.h xen_hyper_defs.h
 MCORE_HFILES=va_server.h vas_crash.h
 REDHAT_HFILES=netdump.h diskdump.h xendump.h
 LKCD_DUMP_HFILES=lkcd_vmdump_v1.h lkcd_vmdump_v2_v3.h lkcd_dump_v5.h \
@@ -78,7 +78,9 @@ CFILES=main.c tools.c global_data.c memo
 	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 \
-	unwind_x86_32_64.c
+	unwind_x86_32_64.c \
+ 	xen_hyper.c xen_hyper_command.c xen_hyper_global_data.c \
+	xen_hyper_dump_tables.c
 
 SOURCE_FILES=${CFILES} ${GENERIC_HFILES} ${MCORE_HFILES} \
 	${REDHAT_CFILES} ${REDHAT_HFILES} ${UNWIND_HFILES} \
@@ -91,7 +93,9 @@ OBJECT_FILES=main.o tools.o global_data.
 	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 \
-	unwind_x86_32_64.o
+	unwind_x86_32_64.o \
+ 	xen_hyper.o xen_hyper_command.o xen_hyper_global_data.o \
+	xen_hyper_dump_tables.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.
@@ -404,6 +408,18 @@ unwind_v3.o: ${GENERIC_HFILES} ${UNWIND_
 lkcd_fix_mem.o: ${GENERIC_HFILES} ${LKCD_HFILES} lkcd_fix_mem.c
 	cc -c ${CFLAGS} lkcd_fix_mem.c ${WARNING_OPTIONS} ${WARNING_ERROR}
 
+xen_hyper.o: ${GENERIC_HFILES} xen_hyper.c
+	cc -c ${CFLAGS} xen_hyper.c ${WARNING_OPTIONS} ${WARNING_ERROR}
+
+xen_hyper_command.o: ${GENERIC_HFILES} xen_hyper_command.c
+	cc -c ${CFLAGS} xen_hyper_command.c ${WARNING_OPTIONS} ${WARNING_ERROR}
+
+xen_hyper_global_data.o: ${GENERIC_HFILES} xen_hyper_global_data.c
+	cc -c ${CFLAGS} xen_hyper_global_data.c ${WARNING_OPTIONS} ${WARNING_ERROR}
+
+xen_hyper_dump_tables.o: ${GENERIC_HFILES} xen_hyper_dump_tables.c
+	cc -c ${CFLAGS} xen_hyper_dump_tables.c ${WARNING_OPTIONS} ${WARNING_ERROR}
+
 ${PROGRAM}: force
 	@make --no-print-directory all
 
@@ -454,7 +470,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.9
+RELEASE=4.0-3.14
 
 release: make_configure
 	@if [ "`id --user`" != "0" ]; then \
diff -purN crash-4.0-3.9/README crash-4.0-3.14/README
--- crash-4.0-3.9/README	2006-12-08 17:00:30.000000000 +0100
+++ crash-4.0-3.14/README	2006-12-01 21:39:42.000000000 +0100
@@ -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.9
+  To build this utility, simply uncompress the tar file, enter the crash-4.0-3.14
   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.9
+    crash 4.0-3.14
     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 Nov  2 13:26:50 2006
+            DATE: Fri Dec  1 15:39:42 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.9   gdb version: 6.1
+    crash version: 4.0-3.14   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.9
+    crash 4.0-3.14
     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.9
+    crash 4.0-3.14
     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.9/defs.h crash-4.0-3.14/defs.h
--- crash-4.0-3.9/defs.h	2006-12-08 17:00:30.000000000 +0100
+++ crash-4.0-3.14/defs.h	2006-12-01 21:39:42.000000000 +0100
@@ -174,6 +174,8 @@ struct number_option {
 #define NOCRASHRC      (0x10000000000000ULL)
 #define INIT_IFILE     (0x20000000000000ULL)
 #define XENDUMP        (0x40000000000000ULL)
+#define XEN_HYPER      (0x80000000000000ULL)
+#define XEN_CORE      (0x100000000000000ULL)
 
 #define ACTIVE()            (pc->flags & LIVE_SYSTEM)
 #define DUMPFILE()          (!(pc->flags & LIVE_SYSTEM))
@@ -189,7 +191,9 @@ struct number_option {
 #define DISKDUMP_DUMPFILE() (pc->flags & DISKDUMP)
 #define KDUMP_DUMPFILE()    (pc->flags & KDUMP)
 #define XENDUMP_DUMPFILE()  (pc->flags & XENDUMP)
+#define XEN_HYPER_MODE()    (pc->flags & XEN_HYPER)
 #define SYSRQ_TASK(X)       ((pc->flags & SYSRQ) && is_task_active(X))
+#define XEN_CORE_DUMPFILE() (pc->flags & XEN_CORE)
 
 #define NETDUMP_LOCAL    (0x1)  /* netdump_data flags */
 #define NETDUMP_REMOTE   (0x2)  
@@ -200,7 +204,6 @@ struct number_option {
 #define KDUMP_ELF32     (0x20)
 #define KDUMP_ELF64     (0x40)
 #define KDUMP_LOCAL     (0x80)  
-#define KDUMP_XEN_HV    (0x100)
 
 #define DUMPFILE_FORMAT(flags) ((flags) & \
 		        (NETDUMP_ELF32|NETDUMP_ELF64|KDUMP_ELF32|KDUMP_ELF64))
@@ -344,6 +347,7 @@ struct program_context {
 	pid_t pipe_pid;                 /* per-cmd output pipe's pid */
 	pid_t pipe_shell_pid;           /* per-cmd output pipe's shell pid */
 	char pipe_command[BUFSIZE];     /* pipe command line */
+	struct command_table_entry *cmd_table;	/* linux/xen command table */
 	char *curcmd;                   /* currently-executing command */
 	char *lastcmd;                  /* previously-executed command */
 	ulong cmdgencur;		/* current command generation number */
@@ -645,6 +649,7 @@ struct bt_info {
         ulonglong flags;
         ulong instptr;
         ulong stkptr;
+	ulong bptr;
 	ulong stackbase;
 	ulong stacktop;
 	char *stackbuf;
@@ -745,6 +750,7 @@ struct machdep_table {
 #define DEVMEMRD         (0x8000000)
 #define INIT             (0x4000000)
 #define VM_4_LEVEL       (0x2000000)
+#define MCA              (0x1000000)
 
 extern struct machdep_table *machdep;
 
@@ -1539,6 +1545,7 @@ struct node_table {
 	ulong pgdat;
 	ulong mem_map;
 	ulong size;
+	ulong present;
 	ulonglong start_paddr;
 	ulong start_mapnr;
 };
@@ -2014,6 +2021,15 @@ struct load_module {
                 machdep->machspec->last_pml4_read = (ulong)(vt->kernel_pgd[0]); \
 	}
 
+#define FILL_PML4_HYPER() { \
+	if (!machdep->machspec->last_pml4_read) { \
+		readmem(symbol_value("idle_pg_table_4"), KVADDR, \
+			machdep->machspec->pml4, PAGESIZE(), "idle_pg_table_4", \
+			FAULT_ON_ERROR); \
+		machdep->machspec->last_pml4_read = symbol_value("idle_pg_table_4"); \
+	}\
+}
+
 #define IS_LAST_UPML_READ(pml) ((ulong)(pml) == machdep->machspec->last_upml_read)
 
 #define FILL_UPML(PML, TYPE, SIZE) 					      \
@@ -2818,7 +2834,7 @@ extern FILE *fp; 
 extern struct program_context program_context, *pc;
 extern struct task_table task_table, *tt;
 extern struct kernel_table kernel_table, *kt;
-extern struct command_table_entry base_command_table[];
+extern struct command_table_entry linux_command_table[];
 extern char *args[MAXARGS];      
 extern int argcnt;            
 extern int argerrs;
@@ -3242,6 +3258,7 @@ int cleanup_memory_driver(void);
 void help_init(void);
 void cmd_usage(char *, int);
 void display_version(void);
+void display_help_screen(char *);
 #ifdef X86
 #define dump_machdep_table(X) x86_dump_machdep_table(X)
 #endif
@@ -3396,6 +3413,7 @@ void generic_dump_irq(int);
 int generic_dis_filter(ulong, char *);
 void display_sys_stats(void);
 char *get_uptime(char *, ulonglong *);
+void clone_bt_info(struct bt_info *, struct bt_info *, struct task_context *);
 void dump_kernel_table(int);
 void dump_bt_info(struct bt_info *);
 void dump_log(int);
@@ -3415,6 +3433,7 @@ void back_trace(struct bt_info *);
 #define BT_EXCEPTION_FRAME        (0x80ULL)
 #define BT_LINE_NUMBERS          (0x100ULL)
 #define BT_USER_EFRAME           (0x200ULL)
+#define BT_INCOMPLETE_USER_EFRAME  (BT_USER_EFRAME)
 #define BT_SAVE_LASTSP           (0x400ULL)
 #define BT_FROM_EXCEPTION        (0x800ULL)
 #define BT_FROM_CALLFRAME       (0x1000ULL)
@@ -3626,8 +3645,9 @@ struct machine_specific {
  *  unwind_x86_32_64.c
  */
 void init_unwind_table(void);
-int dwarf_backtrace(struct bt_info *, ulong);
+int dwarf_backtrace(struct bt_info *, int, ulong);
 void dwarf_debug(struct bt_info *);
+int dwarf_print_stack_entry(struct bt_info *, int);
 
 #endif
 
@@ -3901,6 +3921,7 @@ void get_xendump_regs(struct bt_info *, 
 char *xc_core_mfn_to_page(ulong, char *);
 int xc_core_mfn_to_page_index(ulong);
 void xendump_panic_hook(char *);
+int read_xendump_hyper(int, void *, int, ulong, physaddr_t);
 
 /*
  *  net.c
@@ -4300,4 +4321,8 @@ extern int gdb_main(int, char **);
 extern int have_partial_symbols(void); 
 extern int have_full_symbols(void);
 
+#if defined(X86) || defined(X86_64)
+#define XEN_HYPERVISOR_ARCH 
+#endif
+
 #endif /* !GDB_COMMON */
diff -purN crash-4.0-3.9/filesys.c crash-4.0-3.14/filesys.c
--- crash-4.0-3.9/filesys.c	2006-12-08 17:00:30.000000000 +0100
+++ crash-4.0-3.14/filesys.c	2006-12-01 21:39:42.000000000 +0100
@@ -43,6 +43,7 @@ static int get_memory_driver_dev(dev_t *
 static int memory_driver_init(void);
 static int create_memory_device(dev_t);
 static void *radix_tree_lookup(ulong, ulong, int);
+static int match_file_string(char *, char *, char *);
 
 #define DENTRY_CACHE (20)
 #define INODE_CACHE  (20)
@@ -99,6 +100,10 @@ fd_init(void)
 		}
 
 		if (pc->namelist) {
+			if (XEN_HYPER_MODE() && !pc->dumpfile)
+				error(FATAL, 
+				    "Xen hypervisor mode requires a dumpfile\n");
+
 			if (!pc->dumpfile && !get_proc_version())
 	                	error(INFO, "/proc/version: %s\n", 
 					strerror(errno));
@@ -225,10 +230,7 @@ memory_source_init(void)
 static void
 match_proc_version(void)
 {
-	char command[BUFSIZE];
 	char buffer[BUFSIZE];
-	FILE *pipe;
-	int found;
 
 	if (pc->flags & KERNEL_DEBUG_QUERY)
 		return;
@@ -236,26 +238,7 @@ match_proc_version(void)
 	if (!strlen(kt->proc_version)) 
 		return;
 
-        sprintf(command, "/usr/bin/strings %s", pc->namelist);
-        if ((pipe = popen(command, "r")) == NULL) {
-                error(INFO, "%s: %s\n", pc->namelist, strerror(errno));
-                return;
-        }
-
-	found = FALSE;
-        while (fgets(buffer, BUFSIZE-1, pipe)) {
-		char* ptr;
-		ptr = strstr(buffer, "Linux version 2.");
-		if (!ptr)
-			continue;
-
-                if (STREQ(ptr, kt->proc_version)) 
-                	found = TRUE;
-		break;
-        }
-        pclose(pipe);
-
-	if (found) {
+	if (match_file_string(pc->namelist, kt->proc_version, buffer)) {
                 if (CRASHDEBUG(1)) {
 			fprintf(fp, "/proc/version:\n%s", kt->proc_version);
 			fprintf(fp, "%s:\n%s", pc->namelist, buffer);
@@ -505,13 +488,11 @@ static int
 find_booted_kernel(void)
 {
 	char kernel[BUFSIZE];
-	char command[BUFSIZE];
 	char buffer[BUFSIZE];
 	char **searchdirs;
 	int i, preferred, wrapped;
         DIR *dirp;
         struct dirent *dp;
-	FILE *pipe;
 	int found;
 
 	pc->flags |= FINDKERNEL;
@@ -560,24 +541,11 @@ find_booted_kernel(void)
                             !is_elf_file(kernel))
 				continue;
 
-			sprintf(command, "/usr/bin/strings %s", kernel);
-	        	if ((pipe = popen(command, "r")) == NULL) {
-	        		error(INFO, "%s: %s\n", 
-					kernel, strerror(errno));
-				continue;
-			}
-
 			if (CRASHDEBUG(1)) 
 				fprintf(fp, "find_booted_kernel: check: %s\n", 
 					kernel);
 
-			while (fgets(buffer, BUFSIZE-1, pipe)) {
-				if (STREQ(buffer, kt->proc_version)) {
-					found = TRUE;
-					break;
-				}
-			}
-			pclose(pipe);
+			found = match_file_string(kernel, kt->proc_version, buffer);
 	
 			if (found)
 				break;
@@ -819,30 +787,14 @@ find_booted_system_map(void)
 static int
 verify_utsname(char *system_map)
 {
-	char command[BUFSIZE];
 	char buffer[BUFSIZE];
-	FILE *pipe;
-	int found;
 	ulong value;
 	struct new_utsname new_utsname;
 
-	sprintf(command, "/usr/bin/strings %s", system_map);
-       	if ((pipe = popen(command, "r")) == NULL) 
-		return FALSE;
-	
 	if (CRASHDEBUG(1)) 
 		fprintf(fp, "verify_utsname: check: %s\n", system_map);
 
-	found = FALSE;
-	while (fgets(buffer, BUFSIZE-1, pipe)) {
-		if (strstr(buffer, "D system_utsname")) {
-			found = TRUE;
-			break;
-		}
-	}
-	pclose(pipe);
-
-	if (!found)
+	if (!match_file_string(system_map, "D system_utsname", buffer))
 		return FALSE;
 	
 	if (extract_hex(buffer, &value, NULLCHAR, TRUE) &&
@@ -3674,3 +3626,29 @@ is_readable(char *filename)
 
 	return TRUE;
 }
+
+static int
+match_file_string(char *filename, char *string, char *buffer)
+{
+	int found;
+	char command[BUFSIZE];
+	FILE *pipe;
+
+
+	sprintf(command, "/usr/bin/strings %s", filename);
+        if ((pipe = popen(command, "r")) == NULL) {
+                error(INFO, "%s: %s\n", filename, strerror(errno));
+                return FALSE;
+        }
+
+        found = FALSE;
+        while (fgets(buffer, BUFSIZE-1, pipe)) {
+                if (strstr(buffer, string)) {
+                        found = TRUE;
+                        break;
+                }
+        }
+        pclose(pipe);
+
+	return found;
+}
diff -purN crash-4.0-3.9/gdb_interface.c crash-4.0-3.14/gdb_interface.c
--- crash-4.0-3.9/gdb_interface.c	2006-12-08 17:00:30.000000000 +0100
+++ crash-4.0-3.14/gdb_interface.c	2006-12-01 21:39:42.000000000 +0100
@@ -195,11 +195,14 @@ gdb_session_init(void)
 retry:
 	BZERO(req->buf, BUFSIZE);
         req->command = GNU_GET_DATATYPE;
-        req->name = "task_struct";
+	req->name = XEN_HYPER_MODE() ? "page_info" : "task_struct";
         req->flags = GNU_RETURN_ON_ERROR;
         gdb_interface(req);
 
         if (req->flags & GNU_COMMAND_FAILED) {
+		if (XEN_HYPER_MODE())
+			no_debugging_data(WARNING);  /* just bail out */
+
 		if (!debug_data_pulled_in) {
 			if (CRASHDEBUG(1))
 				error(INFO, 
@@ -239,6 +242,11 @@ retry:
 	sprintf(req->buf, "set height 0");
 	gdb_interface(req);
 
+	req->command = GNU_PASS_THROUGH;
+	req->name = NULL, req->flags = 0;
+	sprintf(req->buf, "set width 0");
+	gdb_interface(req);
+
        /*
         *  Patch gdb's symbol values with the correct values from either
         *  the System.map or non-debug vmlinux, whichever is in effect.
diff -purN crash-4.0-3.9/global_data.c crash-4.0-3.14/global_data.c
--- crash-4.0-3.9/global_data.c	2006-12-08 17:00:29.000000000 +0100
+++ crash-4.0-3.14/global_data.c	2006-12-01 21:39:42.000000000 +0100
@@ -68,7 +68,7 @@ int argerrs;            /* argument erro
  *  To add a new command, declare it in defs.h and enter it in this table.
  */
 
-struct command_table_entry base_command_table[] = {
+struct command_table_entry linux_command_table[] = {
 	{"*", 	    cmd_pointer, help_pointer, 0},
 	{"alias",   cmd_alias,   help_alias,   0},
         {"ascii",   cmd_ascii,   help_ascii,   0},
diff -purN crash-4.0-3.9/help.c crash-4.0-3.14/help.c
--- crash-4.0-3.9/help.c	2006-12-08 17:00:30.000000000 +0100
+++ crash-4.0-3.14/help.c	2006-12-01 21:39:42.000000000 +0100
@@ -19,7 +19,6 @@
 
 static void reshuffle_cmdlist(void);
 static int sort_command_name(const void *, const void *);
-static void display_help_screen(char *);
 static void display_commands(void);
 static void display_copying_info(void);
 static void display_warranty_info(void);
@@ -147,7 +146,7 @@ help_init(void)
         struct command_table_entry *cp;
 	struct extension_table *ext;
 
-	for (pc->ncmds = 0, cp = &base_command_table[0]; cp->name; cp++) {
+	for (pc->ncmds = 0, cp = pc->cmd_table; cp->name; cp++) {
 		if (!(cp->flags & HIDDEN_COMMAND))
                 	pc->ncmds++;
 	}
@@ -188,7 +187,7 @@ reshuffle_cmdlist(void)
 	for (i = 0; i < pc->cmdlistsz; i++) 
 		pc->cmdlist[i] = NULL;
 
-        for (cnt = 0, cp = &base_command_table[0]; cp->name; cp++) {
+        for (cnt = 0, cp = pc->cmd_table; cp->name; cp++) {
 		if (!(cp->flags & HIDDEN_COMMAND))
                 	pc->cmdlist[cnt++] = cp->name;
 	}
@@ -403,7 +402,7 @@ cmd_help(void)
  *  Format and display the help menu.
  */
 
-static void
+void
 display_help_screen(char *indent)
 {
         int i, j, rows;
diff -purN crash-4.0-3.9/ia64.c crash-4.0-3.14/ia64.c
--- crash-4.0-3.9/ia64.c	2006-12-08 17:00:30.000000000 +0100
+++ crash-4.0-3.14/ia64.c	2006-12-01 21:39:42.000000000 +0100
@@ -50,6 +50,7 @@ static ulong check_mem_limit(void);
 static int ia64_verify_paddr(uint64_t);
 static int ia64_available_memory(struct efi_memory_desc_t *);
 static void ia64_post_init(void);
+static ulong ia64_in_per_cpu_mca_stack(void);
 static struct line_number_hook ia64_line_number_hooks[];
 static ulong ia64_get_stackbase(ulong);
 static ulong ia64_get_stacktop(ulong);
@@ -380,6 +381,58 @@ ia64_in_init_stack(ulong addr)
 	return TRUE;
 }
 
+
+static ulong
+ia64_in_per_cpu_mca_stack(void)
+{
+	int plen, i;
+	ulong flag;
+	ulong vaddr, paddr, stackbase, stacktop;
+	ulong *__per_cpu_mca;
+	struct task_context *tc;
+
+	tc = CURRENT_CONTEXT();
+
+	if (STRNEQ(CURRENT_COMM(), "INIT"))
+		flag = INIT;
+	else if (STRNEQ(CURRENT_COMM(), "MCA"))
+		flag = MCA;
+	else
+		return 0;
+
+	if (!symbol_exists("__per_cpu_mca") ||
+	    !(plen = get_array_length("__per_cpu_mca", NULL, 0)) ||
+	    (plen < kt->cpus))
+		return 0;
+
+	vaddr = SWITCH_STACK_ADDR(CURRENT_TASK());
+	if (VADDR_REGION(vaddr) != KERNEL_CACHED_REGION)
+		return 0;
+	paddr = ia64_VTOP(vaddr);
+
+	__per_cpu_mca = (ulong *)GETBUF(sizeof(ulong) * kt->cpus);
+
+	if (!readmem(symbol_value("__per_cpu_mca"), KVADDR, __per_cpu_mca,
+	    sizeof(ulong) * kt->cpus, "__per_cpu_mca", RETURN_ON_ERROR|QUIET))
+		return 0;
+
+	if (CRASHDEBUG(1)) {
+		for (i = 0; i < kt->cpus; i++) {
+			fprintf(fp, "__per_cpu_mca[%d]: %lx\n", 
+		 		i, __per_cpu_mca[i]);
+		}
+	}
+
+	stackbase = __per_cpu_mca[tc->processor];
+	stacktop = stackbase + (STACKSIZE() * 2);
+	FREEBUF(__per_cpu_mca);
+
+	if ((paddr >= stackbase) && (paddr < stacktop))
+		return flag;
+	else
+		return 0;
+}
+
 void
 ia64_dump_machdep_table(ulong arg)
 {
@@ -471,6 +524,8 @@ ia64_dump_machdep_table(ulong arg)
 		fprintf(fp, "%sDEVMEMRD", others++ ? "|" : "");
 	if (machdep->flags & INIT)
 		fprintf(fp, "%sINIT", others++ ? "|" : "");
+	if (machdep->flags & MCA)
+		fprintf(fp, "%sMCA", others++ ? "|" : "");
 	if (machdep->flags & VM_4_LEVEL)
 		fprintf(fp, "%sVM_4_LEVEL", others++ ? "|" : "");
         fprintf(fp, ")\n");
@@ -1709,6 +1764,12 @@ ia64_exception_frame(ulong addr, struct 
 
 	fprintf(fp, "  EFRAME: %lx\n", addr);
 
+	if (bt->flags & BT_INCOMPLETE_USER_EFRAME) {
+		fprintf(fp, 
+    "  [exception frame incomplete -- check salinfo for complete context]\n");
+		bt->flags &= ~BT_INCOMPLETE_USER_EFRAME;
+	}
+
 	fprintf(fp, "      B0: %016lx      CR_IIP: %016lx\n", 
 		eframe[P_b0], eframe[P_cr_iip]);
 /**
@@ -2745,6 +2806,7 @@ ia64_post_init(void)
 {
 	struct machine_specific *ms;
 	struct gnu_request req;
+	ulong flag;
 
 	ms = &ia64_machine_specific;
 
@@ -2824,6 +2886,9 @@ ia64_post_init(void)
 
 	if (DUMPFILE() && ia64_in_init_stack(SWITCH_STACK_ADDR(CURRENT_TASK())))
 		machdep->flags |= INIT;
+
+	if (DUMPFILE() && (flag = ia64_in_per_cpu_mca_stack()))
+		machdep->flags |= flag;
 }
 
 /*
diff -purN crash-4.0-3.9/kernel.c crash-4.0-3.14/kernel.c
--- crash-4.0-3.9/kernel.c	2006-12-08 17:00:30.000000000 +0100
+++ crash-4.0-3.14/kernel.c	2006-12-01 21:39:42.000000000 +0100
@@ -16,6 +16,7 @@
  */
 
 #include "defs.h"
+#include "xen_hyper_defs.h"
 #include <elf.h>
 
 static void do_module_cmd(ulong, char *, ulong, char *, char *);
@@ -1191,18 +1192,25 @@ generic_dis_filter(ulong value, char *bu
  *     -s  displays arguments symbolically.
  */
 
+void
+clone_bt_info(struct bt_info *orig, struct bt_info *new,
+	      struct task_context *tc)
+{
+	BCOPY(orig, new, sizeof(*new));
+	new->stackbuf = NULL;
+	new->tc = tc;
+	new->task = tc->task;
+	new->stackbase = GET_STACKBASE(tc->task);
+	new->stacktop = GET_STACKTOP(tc->task);
+}
+
 #define BT_SETUP(TC)                                          \
-	BCOPY(&bt_setup, bt, sizeof(struct bt_info));         \
+	clone_bt_info(&bt_setup, bt, (TC));         	      \
         if (refptr) {                                         \
 		BZERO(&reference, sizeof(struct reference));  \
 		bt->ref = &reference;                         \
         	bt->ref->str = refptr;                        \
-	}                                                     \
-        bt->tc = (TC);                                        \
-        bt->task = ((TC)->task);			      \
-	bt->stackbase = GET_STACKBASE((TC)->task);            \
-	bt->stacktop = GET_STACKTOP((TC)->task);              \
-	bt->stackbuf = NULL;
+	}
  
 void
 cmd_bt(void)
@@ -1368,6 +1376,11 @@ cmd_bt(void)
 		}
 	}
 
+	if (XEN_HYPER_MODE()) {
+		if (bt->flags & BT_EFRAME_SEARCH)
+			argerrs++;
+	}
+
 	if (argerrs)
 		cmd_usage(pc->curcmd, SYNOPSIS);
 
@@ -1399,6 +1412,32 @@ cmd_bt(void)
                 return;
 	}
 
+	if (XEN_HYPER_MODE()) {
+#ifdef XEN_HYPERVISOR_ARCH
+		/* "task" means physical cpu id */
+		if (active) {
+			for (c = 0; c < xht->pcpus; c++) {
+				fake_tc.task = c;
+				BT_SETUP(&fake_tc);
+				print_pcpu_header_hyper(fp, c, subsequent++);
+				back_trace(bt);
+			}
+		} else {
+			if (args[optind]) {
+				fake_tc.task = atoi(args[optind]);
+			} else {
+				fake_tc.task = 0; /* ODA: set current */
+			}
+			BT_SETUP(&fake_tc);
+			print_pcpu_header_hyper(fp, fake_tc.task, 0);
+			back_trace(bt);
+		}
+		return;
+#else
+		error(FATAL, XEN_HYPERVISOR_NOT_SUPPORTED);
+#endif
+	}
+
 	if (active) {
 		if (ACTIVE())
 			error(FATAL, 
@@ -1586,7 +1625,9 @@ back_trace(struct bt_info *bt)
 		machdep->get_stack_frame(bt, eip ? NULL : &eip, 
 			esp ? NULL : &esp);
 	 
-        } else if (NETDUMP_DUMPFILE())
+        } else if (XEN_HYPER_MODE())
+		machdep->get_stack_frame(bt, &eip, &esp);
+	else if (NETDUMP_DUMPFILE())
                 get_netdump_regs(bt, &eip, &esp);
 	else if (KDUMP_DUMPFILE())
                 get_kdump_regs(bt, &eip, &esp);
@@ -1794,6 +1835,7 @@ dump_bt_info(struct bt_info *bt)
 	fprintf(fp, "       flags: %llx\n", bt->flags);
 	fprintf(fp, "     instptr: %lx\n", bt->instptr);
 	fprintf(fp, "      stkptr: %lx\n", bt->stkptr);
+	fprintf(fp, "        bptr: %lx\n", bt->bptr);
 	fprintf(fp, "   stackbase: %lx\n", bt->stackbase);
 	fprintf(fp, "    stacktop: %lx\n", bt->stacktop);
 	fprintf(fp, "          tc: %lx ", (ulong)bt->tc);
@@ -3066,7 +3108,11 @@ display_sys_stats(void)
 	if (DUMPFILE()) {
 		fprintf(fp, "       PANIC: ");
 		if (machdep->flags & HWRESET)
-			fprintf(fp, "HARDWARE RESET\n");
+			fprintf(fp, "(HARDWARE RESET)\n");
+		else if (machdep->flags & INIT)
+			fprintf(fp, "(INIT)\n");
+		else if (machdep->flags & MCA)
+			fprintf(fp, "(MCA)\n");
 		else {
         		strip_linefeeds(get_panicmsg(buf));
 			fprintf(fp, "\"%s\"%s\n", buf, 
diff -purN crash-4.0-3.9/lkcd_x86_trace.c crash-4.0-3.14/lkcd_x86_trace.c
--- crash-4.0-3.9/lkcd_x86_trace.c	2006-12-08 17:00:30.000000000 +0100
+++ crash-4.0-3.14/lkcd_x86_trace.c	2006-12-01 21:39:42.000000000 +0100
@@ -21,6 +21,9 @@
 
 #include "lkcd_x86_trace.h"
 
+#undef XEN_HYPER_MODE
+static int XEN_HYPER_MODE(void) { return (pc->flags & XEN_HYPER) != 0; }
+
 static void *kl_alloc_block(int, int);
 static void kl_free_block(void *);
 static void GET_BLOCK(kaddr_t, unsigned, void *);
@@ -1417,7 +1420,16 @@ find_trace(
 			}
 		}
 		asp = (uaddr_t*)((uaddr_t)sbp + (STACK_SIZE - (saddr - sp)));
+
 #ifdef REDHAT
+		if (XEN_HYPER_MODE()) {
+			func_name = kl_funcname(pc);
+			if (STREQ(func_name, "idle_loop") || STREQ(func_name, "hypercall")) {
+				UPDATE_FRAME(func_name, pc, 0, sp, bp, asp, 0, 0, bp - sp, 0);
+				return(trace->nframes);
+			}
+		}
+
 		ra = GET_STACK_ULONG(bp + 4);
 		/*
 	  	 *  HACK: The get_framesize() function can return the proper
@@ -1542,7 +1554,8 @@ find_trace(
 			bp = curframe->fp + frame_size;
 		}
 #endif
-		if ((func_name = kl_funcname(pc))) {
+		if ((func_name = kl_funcname(pc))
+			&& !XEN_HYPER_MODE()) {
 			if (strstr(func_name, "kernel_thread")) {
 				ra = 0;
 				bp = saddr - 4;
@@ -2028,12 +2041,14 @@ task_trace(kaddr_t task, int flags, FILE
 		return(0);
 #endif
 
-        if (!(tsp = kl_alloc_block(TASK_STRUCT_SZ, K_TEMP))) {
-		return(1);
-	}
-	if (kl_get_task_struct(task, 2, tsp)) {
-		kl_free_block(tsp);
-		return(1);
+	if (!XEN_HYPER_MODE()) {
+	        if (!(tsp = kl_alloc_block(TASK_STRUCT_SZ, K_TEMP))) {
+			return(1);
+		}
+		if (kl_get_task_struct(task, 2, tsp)) {
+			kl_free_block(tsp);
+			return(1);
+		}
 	}
 	trace = (trace_t *)alloc_trace_rec(C_TEMP);
 	if (!trace) {
@@ -2105,7 +2120,9 @@ task_trace(kaddr_t task, int flags, FILE
 #endif
 		print_trace(trace, flags, ofp);
 	}
-	kl_free_block(tsp);
+	if (!XEN_HYPER_MODE())
+		kl_free_block(tsp);
+
 	free_trace_rec(trace);
 #ifdef REDHAT
 	if (KL_ERROR == KLE_PRINT_TRACE_ERROR) {
@@ -2132,13 +2149,15 @@ verify_back_trace(struct bt_info *bt)
 	errcnt = 0;
         KL_ERROR = 0;
 
-        if (!(tsp = kl_alloc_block(TASK_STRUCT_SZ, K_TEMP))) 
-                return FALSE;
-        
-        if (kl_get_task_struct(bt->task, 2, tsp)) {
-                kl_free_block(tsp);
-                return FALSE;
-        }
+	if (!XEN_HYPER_MODE()) {
+	        if (!(tsp = kl_alloc_block(TASK_STRUCT_SZ, K_TEMP))) 
+	                return FALSE;
+	        
+	        if (kl_get_task_struct(bt->task, 2, tsp)) {
+	                kl_free_block(tsp);
+	                return FALSE;
+	        }
+	}
 
         trace = (trace_t *)alloc_trace_rec(C_TEMP);
 	if (!trace) 
@@ -2183,7 +2202,9 @@ verify_back_trace(struct bt_info *bt)
                 } while (frmp != trace->frame);
 	}
 
-	kl_free_block(tsp);
+	if (!XEN_HYPER_MODE())
+		kl_free_block(tsp);
+
 	free_trace_rec(trace);
         return (errcnt ? FALSE : TRUE);
 }
@@ -2468,6 +2489,9 @@ eframe_label(char *funcname, ulong eip)
 	struct eframe_labels *efp;
 	struct syment *sp;
 
+	if (XEN_HYPER_MODE())
+		return NULL;	/* ODA: need support ? */
+
 	efp = &eframe_labels;
 
 	if (!efp->init) {
diff -purN crash-4.0-3.9/main.c crash-4.0-3.14/main.c
--- crash-4.0-3.9/main.c	2006-12-08 17:00:30.000000000 +0100
+++ crash-4.0-3.14/main.c	2006-12-01 21:39:42.000000000 +0100
@@ -16,6 +16,7 @@
  */
 
 #include "defs.h"
+#include "xen_hyper_defs.h"
 #include <curses.h>
 #include <getopt.h>
 
@@ -23,6 +24,7 @@ static void setup_environment(int, char 
 static int is_external_command(void);
 static int is_builtin_command(void);
 static int is_input_file(void);
+static void check_xen_hyper(void);
 
 static struct option long_options[] = {
         {"memory_module", 1, 0, 0},
@@ -44,6 +46,7 @@ static struct option long_options[] = {
 	{"shadow_page_tables", 0, 0, 0},
         {"cpus", 1, 0, 0},
         {"no_ikconfig", 0, 0, 0},
+        {"hyper", 0, 0, 0},
         {0, 0, 0, 0}
 };
 
@@ -142,6 +145,9 @@ main(int argc, char **argv)
 		        if (STREQ(long_options[option_index].name, "cpus")) 
 				kt->cpus_override = optarg;
 
+			if (STREQ(long_options[option_index].name, "hyper"))
+				pc->flags |= XEN_HYPER;
+
 			break;
 
 		case 'f':
@@ -371,6 +377,8 @@ main(int argc, char **argv)
 		optind++;
 	}
 	
+	check_xen_hyper();
+
         if (setjmp(pc->main_loop_env))
                 clean_exit(1);
 
@@ -409,18 +417,31 @@ main_loop(void)
 {
         if (!(pc->flags & GDB_INIT)) {
 		gdb_session_init();
-		read_in_kernel_config(IKCFG_INIT);
-		kernel_init();
-		machdep_init(POST_GDB);
-        	vm_init();
-		machdep_init(POST_VM);
-        	module_init();
-        	help_init();
-        	task_init();
-        	vfs_init();
-		net_init();
-		dev_init();
-		machdep_init(POST_INIT);
+		if (XEN_HYPER_MODE()) {
+#ifdef XEN_HYPERVISOR_ARCH
+			machdep_init(POST_GDB);
+			xen_hyper_init();
+			xhmachdep->pcpu_init();
+			xen_hyper_domain_init();
+			xen_hyper_vcpu_init();
+			xen_hyper_post_init();
+#else
+        		error(FATAL, XEN_HYPERVISOR_NOT_SUPPORTED);
+#endif
+		} else {
+			read_in_kernel_config(IKCFG_INIT);
+			kernel_init();
+			machdep_init(POST_GDB);
+        		vm_init();
+			machdep_init(POST_VM);
+        		module_init();
+        		help_init();
+        		task_init();
+        		vfs_init();
+			net_init();
+			dev_init();
+			machdep_init(POST_INIT);
+		}
 	} else
 		SIGACTION(SIGINT, restart, &pc->sigaction, NULL);
 
@@ -428,8 +449,17 @@ main_loop(void)
          *  Display system statistics and current context.
          */
         if (!(pc->flags & SILENT) && !(pc->flags & RUNTIME)) {
-                display_sys_stats();
-                show_context(CURRENT_CONTEXT());
+		if (XEN_HYPER_MODE()) {
+#ifdef XEN_HYPERVISOR_ARCH
+			display_xen_hyper_sys_stats();
+			show_xen_hyper_vcpu_context(XEN_HYPER_VCPU_LAST_CONTEXT());
+#else
+        		error(FATAL, XEN_HYPERVISOR_NOT_SUPPORTED);
+#endif
+		} else {
+			display_sys_stats();
+			show_context(CURRENT_CONTEXT());
+		}
                 fprintf(fp, "\n");
         }
 
@@ -475,8 +505,17 @@ reattempt:
 
 	if ((ct = get_command_table_entry(args[0]))) {
                 if (ct->flags & REFRESH_TASK_TABLE) {
-                        tt->refresh_task_table();
-			sort_context_array();
+			if (XEN_HYPER_MODE()) {
+#ifdef XEN_HYPERVISOR_ARCH
+				xen_hyper_refresh_domain_context_space();
+				xen_hyper_refresh_vcpu_context_space();
+#else
+        			error(FATAL, XEN_HYPERVISOR_NOT_SUPPORTED);
+#endif
+			} else {
+				tt->refresh_task_table();
+				sort_context_array();
+			}
 		}
                 if (!STREQ(pc->curcmd, pc->program_name))
                         pc->lastcmd = pc->curcmd;
@@ -523,7 +562,7 @@ get_command_table_entry(char *name)
         struct command_table_entry *cp;
         struct extension_table *ext;
   
-        for (cp = &base_command_table[0]; cp->name; cp++) {
+	for (cp = pc->cmd_table; cp->name; cp++) {
                 if (STREQ(cp->name, name))
                         return cp;
         }
@@ -680,6 +719,7 @@ setup_environment(int argc, char **argv)
 	pc->redhat_debug_loc = DEFAULT_REDHAT_DEBUG_LOCATION;
 	pc->cmdgencur = 0;
 	pc->cmdgenspec = ~pc->cmdgencur;
+	pc->cmd_table = linux_command_table;
 
 	/*
 	 *  Get gdb version before initializing it since this might be one 
@@ -937,6 +977,12 @@ dump_program_context(void)
         if (pc->flags & INIT_IFILE)
                 sprintf(&buf[strlen(buf)],
                         "%sINIT_IFILE", others++ ? "|" : "");
+        if (pc->flags & XEN_HYPER)
+                sprintf(&buf[strlen(buf)],
+                        "%sXEN_HYPER", others++ ? "|" : "");
+        if (pc->flags & XEN_CORE)
+                sprintf(&buf[strlen(buf)],
+                        "%sXEN_CORE", others++ ? "|" : "");
 
 	if (pc->flags)
 		strcat(buf, ")");
@@ -1075,6 +1121,8 @@ dump_program_context(void)
 	fprintf(fp, "           tmp_fp: %lx\n", (ulong)pc->tmp_fp);
 	fprintf(fp, "         tmpfile2: %lx\n", (ulong)pc->tmpfile2);
 
+	fprintf(fp, "        cmd_table: %s\n", XEN_HYPER_MODE() ?
+		"xen_hyper_command_table" : "linux_command_table");
 	fprintf(fp, "           curcmd: %s\n", pc->curcmd);
 	fprintf(fp, "          lastcmd: %s\n", pc->lastcmd);
 	fprintf(fp, "      cur_gdb_cmd: %d  %s\n", pc->cur_gdb_cmd,
@@ -1135,6 +1183,10 @@ dump_program_context(void)
 		fprintf(fp, "          readmem: read_kdump()\n");
 	else if (pc->readmem == read_memory_device)
 		fprintf(fp, "          readmem: read_memory_device()\n");
+	else if (pc->readmem == read_xendump_hyper)
+		fprintf(fp, "          readmem: read_xendump_hyper()\n");
+	else if (pc->readmem == read_diskdump)
+		fprintf(fp, "          readmem: read_diskdump()\n");
 	else
 		fprintf(fp, "          readmem: %lx\n", (ulong)pc->readmem);
         if (pc->writemem == write_dev_mem)
@@ -1153,6 +1205,8 @@ dump_program_context(void)
                 fprintf(fp, "         writemem: write_kdump()\n");
         else if (pc->writemem == write_memory_device)
                 fprintf(fp, "         writemem: write_memory_device()\n");
+        else if (pc->writemem == write_diskdump)
+                fprintf(fp, "         writemem: write_diskdump()\n");
         else
                 fprintf(fp, "         writemem: %lx\n", (ulong)pc->writemem);
 
@@ -1186,3 +1240,28 @@ clean_exit(int status)
 
 	exit(status);
 }
+
+/*
+ *  Check whether this session is for xen hypervisor analysis.
+ */
+static void
+check_xen_hyper(void)
+{
+	if (!pc->namelist)
+		return;
+
+	if (!XEN_HYPER_MODE()) {
+		if (STRNEQ(basename(pc->namelist), "xen-syms"))
+			pc->flags |= XEN_HYPER;
+		else
+			return;
+	}
+
+#ifdef XEN_HYPERVISOR_ARCH
+	pc->cmd_table = xen_hyper_command_table;
+	if (pc->flags & XENDUMP)
+		pc->readmem = read_xendump_hyper;
+#else
+	error(FATAL, XEN_HYPERVISOR_NOT_SUPPORTED);
+#endif
+}
diff -purN crash-4.0-3.9/memory.c crash-4.0-3.14/memory.c
--- crash-4.0-3.9/memory.c	2006-12-08 17:00:30.000000000 +0100
+++ crash-4.0-3.14/memory.c	2006-12-01 21:39:42.000000000 +0100
@@ -10150,6 +10150,7 @@ dump_vm_table(int verbose)
 		fprintf(fp, "                   id: %d\n", nt->node_id);
 		fprintf(fp, "                pgdat: %lx\n", nt->pgdat);
 		fprintf(fp, "                 size: %ld\n", nt->size);
+		fprintf(fp, "              present: %ld\n", nt->present);
 		fprintf(fp, "              mem_map: %lx\n", nt->mem_map);
 		fprintf(fp, "          start_paddr: %llx\n", nt->start_paddr);
 		fprintf(fp, "          start_mapnr: %ld\n", nt->start_mapnr);
@@ -10223,12 +10224,16 @@ total_node_memory()
                 	console("           id: %d\n", nt->node_id);
                 	console("        pgdat: %lx\n", nt->pgdat);
                 	console("         size: %ld\n", nt->size);
+                	console("      present: %ld\n", nt->present);
                 	console("      mem_map: %lx\n", nt->mem_map);
                 	console("  start_paddr: %lx\n", nt->start_paddr);
                 	console("  start_mapnr: %ld\n", nt->start_mapnr);
 		}
 
-		total += (uint64_t)((uint64_t)nt->size * (uint64_t)PAGESIZE());
+		if (nt->present)
+			total += (uint64_t)((uint64_t)nt->present * (uint64_t)PAGESIZE());
+		else
+			total += (uint64_t)((uint64_t)nt->size * (uint64_t)PAGESIZE());
         }
 
 	return total;
@@ -11122,7 +11127,7 @@ dump_memory_nodes(int initialize)
         ulong node_start_paddr;
 	ulong node_start_pfn;
         ulong node_start_mapnr;
-	ulong node_spanned_pages;
+	ulong node_spanned_pages, node_present_pages;
         ulong free_pages, zone_size, node_size, cum_zone_size;
 	ulong zone_start_paddr, zone_start_mapnr, zone_mem_map;
 	physaddr_t phys;
@@ -11155,6 +11160,7 @@ dump_memory_nodes(int initialize)
                         fprintf(fp, "             id: %d\n", nt->node_id);
                         fprintf(fp, "          pgdat: %lx\n", nt->pgdat);
                         fprintf(fp, "           size: %ld\n", nt->size);
+                        fprintf(fp, "        present: %ld\n", nt->present);
                         fprintf(fp, "        mem_map: %lx\n", nt->mem_map);
                         fprintf(fp, "    start_paddr: %llx\n", nt->start_paddr);
                         fprintf(fp, "    start_mapnr: %ld\n", nt->start_mapnr);
@@ -11238,6 +11244,13 @@ dump_memory_nodes(int initialize)
 			node_size = node_spanned_pages;
 		} else error(INFO, "cannot determine zone size\n");
 
+		if (VALID_MEMBER(pglist_data_node_present_pages))
+                        readmem(pgdat+OFFSET(pglist_data_node_present_pages),
+                                KVADDR, &node_present_pages, sizeof(ulong),
+                                "pglist node_present_pages", FAULT_ON_ERROR);
+		else
+			node_present_pages = 0;
+
 		readmem(pgdat+OFFSET(pglist_data_bdata), KVADDR, &bdata,
 			sizeof(ulong), "pglist bdata", FAULT_ON_ERROR);
 
@@ -11248,6 +11261,7 @@ dump_memory_nodes(int initialize)
 				nt->size = 0;  /* initialize below */
 			else 
 				nt->size = node_size;
+			nt->present = node_present_pages;
 			nt->mem_map = node_mem_map;
 			nt->start_paddr = node_start_paddr;
 			nt->start_mapnr = node_start_mapnr;
@@ -11257,6 +11271,7 @@ dump_memory_nodes(int initialize)
                 		fprintf(fp, "             id: %d\n", nt->node_id);
                 		fprintf(fp, "          pgdat: %lx\n", nt->pgdat);
                 		fprintf(fp, "           size: %ld\n", nt->size);
+                		fprintf(fp, "        present: %ld\n", nt->present);
                 		fprintf(fp, "        mem_map: %lx\n", nt->mem_map);
                 		fprintf(fp, "    start_paddr: %llx\n", nt->start_paddr);
                 		fprintf(fp, "    start_mapnr: %ld\n", nt->start_mapnr);
diff -purN crash-4.0-3.9/netdump.c crash-4.0-3.14/netdump.c
--- crash-4.0-3.9/netdump.c	2006-12-08 17:00:30.000000000 +0100
+++ crash-4.0-3.14/netdump.c	2006-12-01 21:39:42.000000000 +0100
@@ -326,6 +326,11 @@ read_netdump(int fd, void *bufptr, int c
 					pls->file_offset;
 				break;
 			}
+			if (pls->zero_fill && (paddr >= pls->phys_end) &&
+			    (paddr < pls->zero_fill)) {
+				memset(bufptr, 0, cnt);
+                		return cnt;
+			}
 		}
 	
 		if (!offset) 
@@ -666,8 +671,6 @@ netdump_memory_dump(FILE *fp)
 		netdump_print("%sKDUMP_ELF64", others++ ? "|" : "");
 	if (nd->flags & PARTIAL_DUMP)
 		netdump_print("%sPARTIAL_DUMP", others++ ? "|" : "");
-	if (nd->flags & KDUMP_XEN_HV)
-		netdump_print("%sKDUMP_XEN_HV", others++ ? "|" : "");
 	netdump_print(")\n");
 	netdump_print("                   ndfd: %d\n", nd->ndfd);
 	netdump_print("                    ofp: %lx\n", nd->ofp);
@@ -682,6 +685,8 @@ netdump_memory_dump(FILE *fp)
 			pls->phys_start);
 		netdump_print("               phys_end: %llx\n", 
 			pls->phys_end);
+		netdump_print("              zero_fill: %llx\n", 
+			pls->zero_fill);
 	}
 	netdump_print("             elf_header: %lx\n", nd->elf_header);
 	netdump_print("                  elf32: %lx\n", nd->elf32);
@@ -697,8 +702,8 @@ netdump_memory_dump(FILE *fp)
 	netdump_print("              page_size: %d\n", nd->page_size);
 	netdump_print("           switch_stack: %lx\n", nd->switch_stack);
 	netdump_print("         xen_kdump_data: %s\n",
-		nd->flags & KDUMP_XEN_HV ? " " : "(unused)");
-	if (nd->flags & KDUMP_XEN_HV) {
+		XEN_CORE_DUMPFILE() ? " " : "(unused)");
+	if (XEN_CORE_DUMPFILE()) {
 		netdump_print("                    flags: %lx (", nd->xen_kdump_data->flags);
 		others = 0;
         	if (nd->xen_kdump_data->flags & KDUMP_P2M_INIT)
@@ -732,8 +737,8 @@ netdump_memory_dump(FILE *fp)
 				nd->xen_kdump_data->p2m_mfn_frame_list[i]);
 		if (i) netdump_print("\n");
 	}
-	netdump_print("     num_prstatus_notes: %d\n", nd->num_prstatus_notes);	
-	netdump_print("     nt_prstatus_percpu: ");
+	netdump_print("       num_prstatus_notes: %d\n", nd->num_prstatus_notes);	
+	netdump_print("       nt_prstatus_percpu: ");
         wrap = sizeof(void *) == SIZEOF_32BIT ? 8 : 4;
         flen = sizeof(void *) == SIZEOF_32BIT ? 8 : 16;
 	if (nd->num_prstatus_notes == 1)
@@ -1135,8 +1140,11 @@ dump_Elf32_Phdr(Elf32_Phdr *prog, int st
 		pls->phys_start = prog->p_paddr; 
 	netdump_print("               p_filesz: %lu (%lx)\n", prog->p_filesz, 
 		prog->p_filesz);
-	if (store_pt_load_data)
+	if (store_pt_load_data) {
 		pls->phys_end = pls->phys_start + prog->p_filesz;
+		pls->zero_fill = (prog->p_filesz == prog->p_memsz) ? 
+			0 : pls->phys_start + prog->p_memsz;
+	}
 	netdump_print("                p_memsz: %lu (%lx)\n", prog->p_memsz,
 		prog->p_memsz);
 	netdump_print("                p_flags: %lx (", prog->p_flags);
@@ -1214,8 +1222,11 @@ dump_Elf64_Phdr(Elf64_Phdr *prog, int st
 		pls->phys_start = prog->p_paddr; 
 	netdump_print("               p_filesz: %lu (%lx)\n", prog->p_filesz, 
 		prog->p_filesz);
-	if (store_pt_load_data)
+	if (store_pt_load_data) {
 		pls->phys_end = pls->phys_start + prog->p_filesz;
+		pls->zero_fill = (prog->p_filesz == prog->p_memsz) ?
+			0 : pls->phys_start + prog->p_memsz;
+	}
 	netdump_print("                p_memsz: %lu (%lx)\n", prog->p_memsz,
 		prog->p_memsz);
 	netdump_print("                p_flags: %lx (", prog->p_flags);
@@ -1237,12 +1248,13 @@ dump_Elf64_Phdr(Elf64_Phdr *prog, int st
 static size_t 
 dump_Elf32_Nhdr(Elf32_Off offset, int store)
 {
-	int i, lf;
+	int i, lf, words;
 	Elf32_Nhdr *note;
 	size_t len;
 	char buf[BUFSIZE];
 	char *ptr;
 	ulong *uptr;
+	int xen_core;
 
 	note = (Elf32_Nhdr *)((char *)nd->elf32 + offset);
 
@@ -1308,26 +1320,58 @@ dump_Elf32_Nhdr(Elf32_Off offset, int st
 		}
 		break;
 #endif
-	case NT_XEN_KDUMP_CR3:
-                netdump_print("(NT_XEN_KDUMP_CR3)\n");
+	default:
+		xen_core = STRNEQ(buf, "XEN CORE");
+		if (xen_core) {
+			netdump_print("(unknown XEN CORE n_type)\n"); 
+			error(WARNING, "unknown XEN CORE n_type: %lx\n\n", 
+				note->n_type);
+		} else
+			netdump_print("(?)\n");
+		break;
+
+	case NT_XEN_KDUMP_CR3: 
+                netdump_print("(NT_XEN_KDUMP_CR3) [obsolete]\n");
+		if (store)
+			error(WARNING, 
+			    "obsolete XEN CORE n_type: %lx (NT_XEN_KDUMP_CR3)\n\n", 
+				note->n_type);
+		/* FALL THROUGH */
+
+	case XEN_ELFNOTE_CRASH_INFO:
+		if (note->n_type == XEN_ELFNOTE_CRASH_INFO)
+                	netdump_print("(XEN_ELFNOTE_CRASH_INFO)\n");
+		xen_core = TRUE;
 		if (store) { 
-			nd->flags |= KDUMP_XEN_HV;
+			pc->flags |= XEN_CORE;
 			nd->xen_kdump_data = &xen_kdump_data;
 			nd->xen_kdump_data->last_mfn_read = BADVAL;
-			nd->xen_kdump_data->flags |= KDUMP_CR3;
-			/*
-			 *  Use the first cr3 found.
-			 */
-			if (!nd->xen_kdump_data->cr3) {
+
+			if ((note->n_type == NT_XEN_KDUMP_CR3) &&
+			    ((note->n_descsz/sizeof(ulong)) == 1)) {
+				nd->xen_kdump_data->flags |= KDUMP_CR3;
+				/*
+				 *  Use the first cr3 found.
+				 */
+				if (!nd->xen_kdump_data->cr3) {
+					uptr = (ulong *)(ptr + note->n_namesz);
+					uptr = (ulong *)roundup((ulong)uptr, 4);
+					nd->xen_kdump_data->cr3 = *uptr;
+				}
+			} else {
+				nd->xen_kdump_data->flags |= KDUMP_MFN_LIST;
 				uptr = (ulong *)(ptr + note->n_namesz);
 				uptr = (ulong *)roundup((ulong)uptr, 4);
-				nd->xen_kdump_data->cr3 = *uptr;
+				words = note->n_descsz/sizeof(ulong);
+				nd->xen_kdump_data->p2m_mfn = *(uptr+(words-1));
 			}
 		}
 		break;
 
-	default:
-		netdump_print("(?)\n");
+	case XEN_ELFNOTE_CRASH_REGS:
+		xen_core = TRUE;	
+               	netdump_print("(XEN_ELFNOTE_CRASH_REGS)\n");
+		break;
 	}
 
 	uptr = (ulong *)(ptr + note->n_namesz);
@@ -1338,7 +1382,7 @@ dump_Elf32_Nhdr(Elf32_Off offset, int st
 	if ((nd->flags & KDUMP_ELF32) && (note->n_namesz == 5))
 		uptr = (ulong *)(ptr + ((note->n_namesz + 3) & ~3));
 
-	if (note->n_type == NT_XEN_KDUMP_CR3)
+	if (xen_core)
 		uptr = (ulong *)roundup((ulong)uptr, 4);
 
 	for (i = lf = 0; i < note->n_descsz/sizeof(ulong); i++) {
@@ -1351,8 +1395,7 @@ dump_Elf32_Nhdr(Elf32_Off offset, int st
 		netdump_print("%08lx ", *uptr++);
 	}
 	if (!lf || (note->n_type == NT_TASKSTRUCT) ||
-	    (note->n_type == NT_DISKDUMP) || 
-	    (note->n_type == NT_XEN_KDUMP_CR3))
+	    (note->n_type == NT_DISKDUMP) || xen_core)
 		netdump_print("\n");
 
   	len = sizeof(Elf32_Nhdr);
@@ -1366,7 +1409,7 @@ dump_Elf32_Nhdr(Elf32_Off offset, int st
 static size_t 
 dump_Elf64_Nhdr(Elf64_Off offset, int store)
 {
-	int i, lf;
+	int i, lf, words;
 	Elf64_Nhdr *note;
 	size_t len;
 	char buf[BUFSIZE];
@@ -1374,6 +1417,7 @@ dump_Elf64_Nhdr(Elf64_Off offset, int st
 	ulonglong *uptr;
 	int *iptr;
 	ulong *up;
+	int xen_core;
 
 	note = (Elf64_Nhdr *)((char *)nd->elf64 + offset);
 
@@ -1452,26 +1496,59 @@ dump_Elf64_Nhdr(Elf64_Off offset, int st
 		}
                 break;
 #endif
-	case NT_XEN_KDUMP_CR3:
-                netdump_print("(NT_XEN_KDUMP_CR3)\n");
+	default:
+                if ((xen_core = STRNEQ(buf, "XEN CORE"))) {
+                        netdump_print("(unknown XEN CORE n_type)\n");
+			if (store)
+                        	error(WARNING, 
+				    "unknown XEN CORE n_type: %lx\n\n",
+                                	note->n_type);
+                } else
+                        netdump_print("(?)\n");
+                break;
+
+	case NT_XEN_KDUMP_CR3: 
+                netdump_print("(NT_XEN_KDUMP_CR3) [obsolete]\n");
+               	if (store)
+                	error(WARNING,
+                            "obsolete XEN CORE n_type: %lx (NT_XEN_KDUMP_CR3)\n\n",
+                                note->n_type);
+		/* FALL THROUGH */
+
+	case XEN_ELFNOTE_CRASH_INFO:
+		if (note->n_type == XEN_ELFNOTE_CRASH_INFO)
+                	netdump_print("(XEN_ELFNOTE_CRASH_INFO)\n");
+		xen_core = TRUE;
 		if (store) {
-			nd->flags |= KDUMP_XEN_HV;
+			pc->flags |= XEN_CORE;
 			nd->xen_kdump_data = &xen_kdump_data;
 			nd->xen_kdump_data->last_mfn_read = BADVAL;
-			nd->xen_kdump_data->flags |= KDUMP_CR3;
-                        /*
-                         *  Use the first cr3 found.
-                         */
-                        if (!nd->xen_kdump_data->cr3) {
+
+			if ((note->n_type == NT_XEN_KDUMP_CR3) &&
+			    ((note->n_descsz/sizeof(ulong)) == 1)) {
+				nd->xen_kdump_data->flags |= KDUMP_CR3;
+	                        /*
+	                         *  Use the first cr3 found.
+	                         */
+	                        if (!nd->xen_kdump_data->cr3) {
+					up = (ulong *)(ptr + note->n_namesz);
+	                                up = (ulong *)roundup((ulong)up, 4);
+	                                nd->xen_kdump_data->cr3 = *up;
+	                        }
+			} else {
+				nd->xen_kdump_data->flags |= KDUMP_MFN_LIST;
 				up = (ulong *)(ptr + note->n_namesz);
-                                up = (ulong *)roundup((ulong)up, 4);
-                                nd->xen_kdump_data->cr3 = *up;
-                        }
+	                        up = (ulong *)roundup((ulong)up, 4);
+				words = note->n_descsz/sizeof(ulong);
+	                        nd->xen_kdump_data->p2m_mfn = *(up+(words-1));
+			}
 		}
                 break;
 
-	default:
-		netdump_print("(?)\n");
+        case XEN_ELFNOTE_CRASH_REGS:
+                xen_core = TRUE;
+                netdump_print("(XEN_ELFNOTE_CRASH_REGS)\n");
+                break;
 	}
 
 	uptr = (ulonglong *)(ptr + note->n_namesz);
@@ -1482,7 +1559,7 @@ dump_Elf64_Nhdr(Elf64_Off offset, int st
         if ((nd->flags & KDUMP_ELF64) && (note->n_namesz == 5))
                 uptr = (ulonglong *)(ptr + ((note->n_namesz + 3) & ~3));
 
-       if (note->n_type == NT_XEN_KDUMP_CR3)
+       if (xen_core)
                 uptr = (ulonglong *)roundup((ulong)uptr, 4);
 
 	for (i = lf = 0; i < note->n_descsz/sizeof(ulonglong); i++) {
@@ -1551,13 +1628,23 @@ get_netdump_regs(struct bt_info *bt, ulo
 	}
 }
 
+struct x86_64_user_regs_struct {
+        unsigned long r15,r14,r13,r12,rbp,rbx,r11,r10;
+        unsigned long r9,r8,rax,rcx,rdx,rsi,rdi,orig_rax;
+        unsigned long rip,cs,eflags;
+        unsigned long rsp,ss;
+        unsigned long fs_base, gs_base;
+        unsigned long ds,es,fs,gs;
+};
+#define offsetof(TYPE, MEMBER) ((ulong)&((TYPE *)0)->MEMBER)
+
 void 
 get_netdump_regs_x86_64(struct bt_info *bt, ulong *ripp, ulong *rspp)
 {
         Elf64_Nhdr *note;
         size_t len;
         char *user_regs;
-        ulong rsp, rip;
+	ulong regs_size, rsp_offset, rip_offset;
 
         if (is_task_active(bt->task)) 
                 bt->flags |= BT_DUMPFILE_SEARCH;
@@ -1576,28 +1663,31 @@ 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);
+		regs_size = VALID_STRUCT(user_regs_struct) ?
+			SIZE(user_regs_struct) : 
+			sizeof(struct x86_64_user_regs_struct);
+		rsp_offset = VALID_MEMBER(user_regs_struct_rsp) ?
+			OFFSET(user_regs_struct_rsp) : 
+			offsetof(struct x86_64_user_regs_struct, rsp);
+		rip_offset = VALID_MEMBER(user_regs_struct_rip) ?
+			OFFSET(user_regs_struct_rip) :
+                        offsetof(struct x86_64_user_regs_struct, rip);
+
+                user_regs = ((char *)note + len) - regs_size - sizeof(long);
+
+		if (CRASHDEBUG(1))
+			netdump_print("ELF prstatus rsp: %lx rip: %lx\n", 
+                		ULONG(user_regs + rsp_offset),
+                		ULONG(user_regs + rip_offset));
+
+		if (KDUMP_DUMPFILE()) {
+			*rspp = ULONG(user_regs + rsp_offset);
+			*ripp = ULONG(user_regs + rip_offset);
 
-		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));
-			netdump_print("ELF prstatus rsp: %lx rip: %lx\n", 
-				rsp, rip);
-		}
-
 		bt->machdep = (void *)user_regs;
 	}
 
@@ -1612,10 +1702,11 @@ get_netdump_regs_x86_64(struct bt_info *
 void
 get_netdump_regs_x86(struct bt_info *bt, ulong *eip, ulong *esp)
 {
-	int i, search, panic;
+	int i, search, panic, panic_task;
 	char *sym;
 	ulong *up;
 	ulong ipintr_eip, ipintr_esp, ipintr_func;
+	ulong halt_eip, halt_esp;
 	int check_hardirq, check_softirq;
 
 	if (!is_task_active(bt->task)) {
@@ -1623,15 +1714,28 @@ get_netdump_regs_x86(struct bt_info *bt,
 		return;
 	}
 
+	panic_task = tt->panic_task == bt->task ? TRUE : FALSE;
+
 	ipintr_eip = ipintr_esp = ipintr_func = panic = 0;
+	halt_eip = halt_esp = 0;
 	check_hardirq = check_softirq = tt->flags & IRQSTACKS ? TRUE : FALSE;
 	search = ((bt->flags & BT_TEXT_SYMBOLS) && (tt->flags & TASK_INIT_DONE))
 		|| (machdep->flags & OMIT_FRAME_PTR);
-
 retry:
 	for (i = 0, up = (ulong *)bt->stackbuf; i < LONGS_PER_STACK; i++, up++){
 		sym = closest_symbol(*up);
-		if (STREQ(sym, "netconsole_netdump") || 
+
+		if (XEN_CORE_DUMPFILE()) {
+			if (STREQ(sym, "xen_machine_kexec")) {
+				*eip = *up;
+				*esp = bt->stackbase + ((char *)(up+1) - bt->stackbuf);
+				return;
+			}
+			if (STREQ(sym, "crash_kexec")) {
+                        	halt_eip = *up;
+				halt_esp = bt->stackbase + ((char *)(up+1) - bt->stackbuf);
+			}
+		} else if (STREQ(sym, "netconsole_netdump") || 
 		    STREQ(sym, "netpoll_start_netdump") ||
 		    STREQ(sym, "start_disk_dump") ||
 		    STREQ(sym, "crash_kexec") ||
@@ -1708,6 +1812,18 @@ next_sysrq:
 			    bt->stackbase + ((char *)(up-1) - bt->stackbuf);
 			ipintr_func = *(up - 2);
                 }
+
+                if (XEN_CORE_DUMPFILE() && !panic_task && (bt->tc->pid == 0) &&
+                    STREQ(sym, "safe_halt")) {
+                        halt_eip = *up;
+			halt_esp = bt->stackbase + ((char *)(up+1) - bt->stackbuf);
+                }
+
+                if (XEN_CORE_DUMPFILE() && !panic_task && (bt->tc->pid == 0) &&
+                    !halt_eip && STREQ(sym, "xen_idle")) {
+                        halt_eip = *up;
+			halt_esp = bt->stackbase + ((char *)(up+1) - bt->stackbuf);
+                }
 	}
 
 	if (ipintr_eip) {
@@ -1741,7 +1857,15 @@ next_sysrq:
                 goto retry;
         }
 
-	console("get_netdump_regs_x86: cannot find anything useful for task: %lx\n", bt->task);
+	if (halt_eip && halt_esp) {
+        	*eip = halt_eip;
+        	*esp = halt_esp;
+		return;
+	}
+
+	if (CRASHDEBUG(1))
+		error(INFO, 
+    "get_netdump_regs_x86: cannot find anything useful (task: %lx)\n", bt->task);
  
 	machdep->get_stack_frame(bt, eip, esp);
 }
@@ -1808,7 +1932,7 @@ get_kdump_panic_task(void)
 int
 read_kdump(int fd, void *bufptr, int cnt, ulong addr, physaddr_t paddr)
 {
-	if ((nd->flags & KDUMP_XEN_HV)) {
+	if (XEN_CORE_DUMPFILE() && !XEN_HYPER_MODE()) {
 	    	if (!(nd->xen_kdump_data->flags & KDUMP_P2M_INIT)) {
         		if (!machdep->xen_kdump_p2m_create)
                 		error(FATAL,
diff -purN crash-4.0-3.9/netdump.h crash-4.0-3.14/netdump.h
--- crash-4.0-3.9/netdump.h	2006-12-08 17:00:29.000000000 +0100
+++ crash-4.0-3.14/netdump.h	2006-12-01 21:39:42.000000000 +0100
@@ -40,6 +40,7 @@ struct pt_load_segment {
 	off_t file_offset;
 	physaddr_t phys_start;
 	physaddr_t phys_end;
+	physaddr_t zero_fill;
 };
 
 struct vmcore_data {
@@ -68,7 +69,32 @@ struct vmcore_data {
 };
 
 /*
- *  Proposed ELF note for Xen (writable pagetable) per-vcpu CR3.
+ *  ELF note types for Xen dom0/hypervisor kdumps.
+ *  The comments below are from xen/include/public/elfnote.h.
+ */
+
+/*
+ * System information exported through crash notes.
+ *
+ * The kexec / kdump code will create one XEN_ELFNOTE_CRASH_INFO
+ * note in case of a system crash. This note will contain various
+ * information about the system, see xen/include/xen/elfcore.h.
+ */
+#define XEN_ELFNOTE_CRASH_INFO 0x1000001
+
+/*
+ * System registers exported through crash notes.
+ *
+ * The kexec / kdump code will create one XEN_ELFNOTE_CRASH_REGS
+ * note per cpu in case of a system crash. This note is architecture
+ * specific and will contain registers not saved in the "CORE" note.
+ * See xen/include/xen/elfcore.h for more information.
+ */
+#define XEN_ELFNOTE_CRASH_REGS 0x1000002
+
+
+/* 
+ * For (temporary) backwards compatibility.
  */
 #define NT_XEN_KDUMP_CR3 0x10000001
 
diff -purN crash-4.0-3.9/symbols.c crash-4.0-3.14/symbols.c
--- crash-4.0-3.9/symbols.c	2006-12-08 17:00:30.000000000 +0100
+++ crash-4.0-3.14/symbols.c	2006-12-01 21:39:42.000000000 +0100
@@ -62,6 +62,7 @@ struct elf_common;
 static void Elf32_Sym_to_common(Elf32_Sym *, struct elf_common *); 
 static void Elf64_Sym_to_common(Elf64_Sym *, struct elf_common *); 
 static void cmd_datatype_common(ulong);
+static int display_per_cpu_info(struct syment *);
 
 
 #define KERNEL_SECTIONS  (void *)(1)
@@ -4626,6 +4627,8 @@ cmd_p(void)
                 cmd_usage(pc->curcmd, SYNOPSIS);
 
 	if ((sp = symbol_search(args[optind])) && !args[optind+1]) {
+		if (STRNEQ(sp->name, "per_cpu__") && display_per_cpu_info(sp))
+			return;
 		sprintf(buf2, "%s = ", args[optind]);
 		leader = strlen(buf2);
 		if (module_symbol(sp->value, NULL, NULL, NULL, output_radix))
@@ -4679,6 +4682,39 @@ cmd_p(void)
 }
 
 /*
+ *  Display the datatype of the per_cpu__xxx symbol and 
+ *  the addresses of each its per-cpu instances.
+ */
+static int
+display_per_cpu_info(struct syment *sp)
+{
+	int c;
+	ulong addr;
+	char buf[BUFSIZE];
+
+	if (((kt->flags & (SMP|PER_CPU_OFF)) != (SMP|PER_CPU_OFF)) ||
+	    (sp->value < symbol_value("__per_cpu_start")) || 
+	    (sp->value >= symbol_value("__per_cpu_end")) ||
+	    !((sp->type == 'd') || (sp->type == 'D')))
+		return FALSE;
+
+	fprintf(fp, "PER-CPU DATA TYPE:\n  ");
+        sprintf(buf, "whatis %s", sp->name);
+        if (!gdb_pass_through(buf, pc->nullfp, GNU_RETURN_ON_ERROR))
+                fprintf(fp, "[undetermined type] %s;\n", sp->name);
+	else
+        	whatis_variable(sp);
+
+	fprintf(fp, "PER-CPU ADDRESSES:\n");
+	for (c = 0; c < kt->cpus; c++) {
+		addr = sp->value + kt->__per_cpu_offset[c];
+		fprintf(fp, "  [%d]: %lx\n", c, addr);
+	}
+
+	return TRUE;
+}
+
+/*
  *  As a latch ditch effort before a command is thrown away by exec_command(),
  *  args[0] is checked to see whether it's the name of a variable, structure, 
  *  union, or typedef.  If so, args[0] is changed to the appropriate command, 
diff -purN crash-4.0-3.9/task.c crash-4.0-3.14/task.c
--- crash-4.0-3.9/task.c	2006-12-08 17:00:30.000000000 +0100
+++ crash-4.0-3.14/task.c	2006-12-01 21:39:42.000000000 +0100
@@ -1850,6 +1850,9 @@ sort_context_array_by_last_run(void)
 char *
 fill_task_struct(ulong task)
 {
+	if (XEN_HYPER_MODE())
+		return NULL;
+
 	if (!IS_LAST_TASK_READ(task)) { 
         	if (!readmem(task, KVADDR, tt->task_struct, 
 	     		SIZE(task_struct), "fill_task_struct", 
@@ -3308,15 +3311,15 @@ str_to_context(char *string, ulong *valu
 int
 comm_exists(char *s)
 {
-        int i;
+        int i, cnt;
         struct task_context *tc;
 
         tc = FIRST_CONTEXT();
-        for (i = 0; i < RUNNING_TASKS(); i++, tc++) 
+        for (i = cnt = 0; i < RUNNING_TASKS(); i++, tc++) 
                 if (STREQ(tc->comm, s))
-                        return TRUE;
+                        cnt++;
         
-        return FALSE;
+        return cnt;
 }
 
 /*
@@ -3412,7 +3415,11 @@ show_context(struct task_context *tc)
 	fprintf(fp, "COMMAND: \"%s\"\n", tc->comm);
 	INDENT(indent);
 	fprintf(fp, "   TASK: %lx  ", tc->task);
-	if ((cnt = TASKS_PER_PID(tc->pid)) > 1)
+	if ((machdep->flags & (INIT|MCA)) && (tc->pid == 0))
+		cnt = comm_exists(tc->comm);
+	else
+		cnt = TASKS_PER_PID(tc->pid);
+	if (cnt > 1)
 		fprintf(fp, "(1 of %d)  ", cnt);
 	if (tt->flags & THREAD_INFO)
 		fprintf(fp, "[THREAD_INFO: %lx]", tc->thread_info);
@@ -3429,6 +3436,8 @@ show_context(struct task_context *tc)
 			fprintf(fp, "(SYSRQ)");
 		else if (machdep->flags & INIT)
 			fprintf(fp, "(INIT)");
+		else if ((machdep->flags & MCA) && (tc->task == tt->panic_task))
+			fprintf(fp, "(MCA)");
 		else if ((tc->processor >= 0) && 
 		        (tc->processor < NR_CPUS) && 
 			(kt->cpu_flags[tc->processor] & NMI))
@@ -5457,6 +5466,10 @@ clear_active_set(void)
                     strstr(buf, " .crash_kexec+")) {    \
 			crash_kexec_task = task;	\
                 }                                       \
+                if (strstr(buf, " machine_kexec+") ||     \
+                    strstr(buf, " .machine_kexec+")) {    \
+			crash_kexec_task = task;	\
+                }                                       \
                 if (strstr(buf, " xen_panic_event+") || \
                     strstr(buf, " .xen_panic_event+")){ \
 			xen_panic_task = task;	        \
@@ -5492,7 +5505,6 @@ get_active_set_panic_task()
                         	if ((tc = store_context(NULL, task, tp))) 
                                 	tt->running_tasks++;
                 	}
-			continue;
 		}
 
         	open_tmpfile();
diff -purN crash-4.0-3.9/unwind.c crash-4.0-3.14/unwind.c
--- crash-4.0-3.9/unwind.c	2006-07-13 20:51:50.000000000 +0200
+++ crash-4.0-3.14/unwind.c	2006-12-01 21:39:42.000000000 +0100
@@ -64,6 +64,8 @@ static int unw_switch_from_osinit_v1(str
 	struct bt_info *);
 static int unw_switch_from_osinit_v2(struct unw_frame_info *,
 	struct bt_info *);
+static int unw_switch_from_osinit_v3(struct unw_frame_info *,
+	struct bt_info *, char *);
 static unsigned long get_init_stack_ulong(unsigned long addr);
 static void unw_init_frame_info(struct unw_frame_info *, 
 	struct bt_info *, ulong);
@@ -1733,11 +1735,28 @@ restart:
 		 * ia64_init_handler.  
 		 */
 		if (STREQ(name, "ia64_init_handler")) {
-			unw_switch_from_osinit_v2(info, bt);
-			frame++;
-			goto restart;
+			if (symbol_exists("ia64_mca_modify_original_stack")) {
+				/*
+				 * 2.6.14 or later kernels no longer keep
+				 * minstate info in pt_regs/switch_stack.
+				 * unw_switch_from_osinit_v3() will try
+				 * to find the interrupted task and restart
+				 * backtrace itself.
+				 */
+				if (unw_switch_from_osinit_v3(info, bt, "INIT") == FALSE)
+					break;
+			} else {
+				unw_switch_from_osinit_v2(info, bt);
+				frame++;
+				goto restart;
+			}
 		}
 
+		if (STREQ(name, "ia64_mca_handler") &&
+		    symbol_exists("ia64_mca_modify_original_stack"))
+			if (unw_switch_from_osinit_v3(info, bt, "MCA") == FALSE)
+				break;
+
                 frame++;
 
         } while (unw_unwind(info) >= 0);
@@ -1980,6 +1999,124 @@ unw_switch_from_osinit_v2(struct unw_fra
 	return TRUE;
 }
 
+/* CPL (current privilege level) is 2-bit field */
+#define IA64_PSR_CPL0_BIT	32
+#define IA64_PSR_CPL_MASK	(3UL << IA64_PSR_CPL0_BIT)
+
+static int
+user_mode(struct bt_info *bt, unsigned long pt)
+{
+	unsigned long cr_ipsr;
+
+	cr_ipsr = IA64_GET_STACK_ULONG(pt + offsetof(struct pt_regs, cr_ipsr));
+	if (cr_ipsr & IA64_PSR_CPL_MASK)
+		return 1;
+	return 0;
+}
+
+/*
+ * Cope with INIT/MCA stack for the kernel 2.6.14 or later
+ *
+ * Returns FALSE if no more unwinding is needed.
+ */
+#define ALIGN16(x) ((x)&~15)
+static int
+unw_switch_from_osinit_v3(struct unw_frame_info *info, struct bt_info *bt,
+			  char *type)
+{
+	unsigned long pt, sw, pid;
+	int processor;
+	char *p, *q;
+	struct task_context *tc = NULL;
+	struct bt_info clone_bt;
+
+	/*
+	 *    The structure of INIT/MCA stack
+	 *
+	 *    +---------------------------+ <-------- IA64_STK_OFFSET
+	 *    |          pt_regs          |
+	 *    +---------------------------+
+	 *    |        switch_stack       |
+	 *    +---------------------------+
+	 *    |        SAL/OS state       |
+	 *    +---------------------------+
+	 *    |    16 byte scratch area   |
+	 *    +---------------------------+ <-------- SP at start of C handler
+	 *    |           .....           |
+	 *    +---------------------------+
+	 *    | RBS for MCA/INIT handler  |
+	 *    +---------------------------+
+	 *    | struct task for MCA/INIT  |
+	 *    +---------------------------+ <-------- bt->task
+	 */
+	pt = ALIGN16(bt->task + IA64_STK_OFFSET - STRUCT_SIZE("pt_regs"));
+	sw = ALIGN16(pt - STRUCT_SIZE("switch_stack"));
+
+	/*
+	 * 1. Try to find interrupted task from comm
+	 *
+	 *    comm format of INIT/MCA task:
+	 *       - "<type> <pid>"
+	 *       - "<type> <comm> <processor>"
+	 *    where "<type>" is either "INIT" or "MCA".
+	 *    The latter form is chosen if PID is 0.
+	 * 
+	 *    See ia64_mca_modify_comm() in arch/ia64/kernel/mca.c
+	 */
+	if (!bt->tc || !bt->tc->comm)
+		goto find_exframe;
+
+	if ((p = strstr(bt->tc->comm, type))) {
+		p += strlen(type);
+		if (*p != ' ')
+			goto find_exframe;
+		if ((q = strchr(++p, ' '))) {
+			/* "<type> <comm> <processor>" */
+			if (sscanf(++q, "%d", &processor) > 0) {
+				tc = pid_to_context(0);
+				while (tc) {
+					if (tc != bt->tc &&
+					    tc->processor == processor)
+						break;
+					tc = tc->tc_next;
+				}
+			}
+		} else if (sscanf(p, "%lu", &pid) > 0)
+			/* "<type> <pid>" */
+			tc = pid_to_context(pid);
+	}
+
+	if (tc) {
+		/* Clone bt_info and do backtrace */
+		clone_bt_info(bt, &clone_bt, tc);
+		if (!BT_REFERENCE_CHECK(&clone_bt)) {
+			fprintf(fp, "(%s) INTERRUPTED TASK\n", type);
+			print_task_header(fp, tc, 0);
+		}
+		if (!user_mode(bt, pt))
+			back_trace(&clone_bt);
+		else if (!BT_REFERENCE_CHECK(bt)) {
+			fprintf(fp, " #0 [interrupted in user space]\n");
+			/* at least show the incomplete exception frame */
+			bt->flags |= BT_INCOMPLETE_USER_EFRAME;
+			ia64_exception_frame(pt, bt);
+		}
+		return FALSE;
+	}
+
+	/* task matching with INIT/MCA task's comm is not found */
+
+find_exframe:
+	/*
+	 * 2. If step 1 doesn't work, try best to find exception frame
+	 */
+	unw_init_from_interruption(info, bt, pt, sw);
+	if (!BT_REFERENCE_CHECK(bt))
+		ia64_exception_frame(pt, bt);
+
+	return TRUE;
+}
+
 static void
 unw_init_frame_info (struct unw_frame_info *info, struct bt_info *bt, ulong sw)
 {
diff -purN crash-4.0-3.9/unwind_x86_32_64.c crash-4.0-3.14/unwind_x86_32_64.c
--- crash-4.0-3.9/unwind_x86_32_64.c	2006-12-08 17:00:30.000000000 +0100
+++ crash-4.0-3.14/unwind_x86_32_64.c	2006-12-01 21:39:42.000000000 +0100
@@ -1036,9 +1036,8 @@ dump_local_unwind_tables(void)
 
 
 int 
-dwarf_backtrace(struct bt_info *bt, ulong stacktop)
+dwarf_backtrace(struct bt_info *bt, int level, ulong stacktop)
 {
-	int n = 0;
 	unsigned long bp, offset;
 	struct syment *sp;
 	char *name;
@@ -1051,7 +1050,7 @@ dwarf_backtrace(struct bt_info *bt, ulon
 	UNW_PC(frame) = bt->instptr;
 
 	/* read rbp from stack for non active tasks */
-	if (!(bt->flags & BT_DUMPFILE_SEARCH) ) {
+	if (!(bt->flags & BT_DUMPFILE_SEARCH) && !bt->bptr) {
 //		readmem(frame->regs.rsp, KVADDR, &bp,
 		readmem(UNW_SP(frame), KVADDR, &bp,
 	                sizeof(unsigned long), "reading bp", FAULT_ON_ERROR);
@@ -1084,7 +1083,7 @@ dwarf_backtrace(struct bt_info *bt, ulon
 
 
         name = sp->name;
-	fprintf(fp, " #0 [%016lx] %s at %016lx \n", UNW_SP(frame), name, UNW_PC(frame));
+	fprintf(fp, " #%d [%016lx] %s at %016lx \n", level, UNW_SP(frame), name, UNW_PC(frame));
 
 	if (CRASHDEBUG(2))
 		fprintf(fp, "    < SP: %lx PC: %lx FP: %lx >\n", UNW_SP(frame), 
@@ -1092,18 +1091,38 @@ dwarf_backtrace(struct bt_info *bt, ulon
 
        	while ((UNW_SP(frame) < stacktop)
 				&& !unwind(frame) && UNW_PC(frame)) {
-               	n++;
+		/* To prevent rip pushed on IRQ stack being reported both
+		 * both on the IRQ and process stacks
+		 */
+		if ((bt->flags & BT_IRQSTACK) && (UNW_SP(frame) >= stacktop - 16))
+			break;
+               	level++;
 		sp = value_search(UNW_PC(frame), &offset);
 		if (!sp) {
 			if (CRASHDEBUG(1))
 				fprintf(fp, 
-				    "normal?: cannot find symbol for PC: %lx\n",
+				    "unwind: cannot find symbol for PC: %lx\n",
 					UNW_PC(frame));
 			break;
 		}
+
+		/*
+		 * 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);
+			if (!sp) {
+				if (CRASHDEBUG(1))
+					fprintf(fp,
+					    "unwind: cannot find symbol for PC: %lx\n",
+						UNW_PC(frame)-1);
+				goto bailout;
+			}
+		}
 	        name = sp->name;
-		fprintf(fp, "%s#%d [%016lx] %s at %016lx \n", n < 10 ? " " : "",
-			n, UNW_SP(frame), name, UNW_PC(frame));
+		fprintf(fp, "%s#%d [%016lx] %s at %016lx \n", level < 10 ? " " : "",
+			level, UNW_SP(frame), name, UNW_PC(frame));
 
 		if (CRASHDEBUG(2))
 			fprintf(fp, "    < SP: %lx PC: %lx FP: %lx >\n", UNW_SP(frame), 
@@ -1112,7 +1131,49 @@ dwarf_backtrace(struct bt_info *bt, ulon
 
 bailout:
 	FREEBUF(frame);
-	return TRUE;
+	return ++level;
+}
+
+int 
+dwarf_print_stack_entry(struct bt_info *bt, int level)
+{
+	unsigned long offset;
+	struct syment *sp;
+	char *name;
+	struct unwind_frame_info *frame;
+
+	frame = (struct unwind_frame_info *)GETBUF(sizeof(struct unwind_frame_info));
+	UNW_SP(frame) = bt->stkptr;
+	UNW_PC(frame) = bt->instptr;
+
+	sp = value_search(UNW_PC(frame), &offset);
+	if (!sp) {
+		if (CRASHDEBUG(1))
+		    fprintf(fp, "unwind: cannot find symbol for PC: %lx\n",
+			UNW_PC(frame));
+		goto bailout;
+	}
+
+	/*
+	 * 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);
+		if (!sp) {
+			if (CRASHDEBUG(1))
+				fprintf(fp,
+				    "unwind: cannot find symbol for PC: %lx\n",
+					UNW_PC(frame)-1);
+			goto bailout;
+		}
+	}
+        name = sp->name;
+	fprintf(fp, " #%d [%016lx] %s at %016lx \n", level, UNW_SP(frame), name, UNW_PC(frame));
+
+bailout:
+	FREEBUF(frame);
+	return level;
 }
 
 void
diff -purN crash-4.0-3.9/x86.c crash-4.0-3.14/x86.c
--- crash-4.0-3.9/x86.c	2006-12-08 17:00:30.000000000 +0100
+++ crash-4.0-3.14/x86.c	2006-12-01 21:39:42.000000000 +0100
@@ -51,6 +51,7 @@
  * rights to redistribute these changes.
  */
 #include "defs.h"
+#include "xen_hyper_defs.h"
 
 #ifndef MCLX
 
@@ -1003,7 +1004,9 @@ static char *x86_xendump_load_page(ulong
 static char *x86_xendump_load_page_PAE(ulong, char *);
 static int x86_xendump_page_index(ulong);
 static int x86_xendump_page_index_PAE(ulong);
-
+static void x86_init_hyper(int);
+static ulong x86_get_stackbase_hyper(ulong);
+static ulong x86_get_stacktop_hyper(ulong);
 
 #define INT_EFRAME_SS      (14)
 #define INT_EFRAME_ESP     (13)
@@ -1673,6 +1676,11 @@ x86_init(int when)
 {
 	struct syment *sp, *spn;
 
+	if (XEN_HYPER_MODE()) {
+		x86_init_hyper(when);
+		return;
+	}
+
 	switch (when)
 	{
 	case PRE_SYMTAB:
@@ -2490,21 +2498,29 @@ x86_kvtop(struct task_context *tc, ulong
 	if (!IS_KVADDR(kvaddr))
 		return FALSE;
 
-	if (!vt->vmalloc_start) {
-		*paddr = VTOP(kvaddr);
-		return TRUE;
-	}
-
-	if (!IS_VMALLOC_ADDR(kvaddr)) { 
-		*paddr = VTOP(kvaddr);
-		if (!verbose)
+	if (XEN_HYPER_MODE()) {
+		if (DIRECTMAP_VIRT_ADDR(kvaddr)) {
+			*paddr = kvaddr - DIRECTMAP_VIRT_START;
 			return TRUE;
-	}
+		}
+		pgd = (ulong *)symbol_value("idle_pg_table_l2");
+	} else {
+		if (!vt->vmalloc_start) {
+			*paddr = VTOP(kvaddr);
+			return TRUE;
+		}
 
-	if (XEN() && (kt->xen_flags & WRITABLE_PAGE_TABLES))
-		return (x86_kvtop_xen_wpt(tc, kvaddr, paddr, verbose));
+		if (!IS_VMALLOC_ADDR(kvaddr)) { 
+			*paddr = VTOP(kvaddr);
+			if (!verbose)
+				return TRUE;
+		}
 
-	pgd = (ulong *)vt->kernel_pgd[0];
+		if (XEN() && (kt->xen_flags & WRITABLE_PAGE_TABLES))
+			return (x86_kvtop_xen_wpt(tc, kvaddr, paddr, verbose));
+
+		pgd = (ulong *)vt->kernel_pgd[0];
+	}
 
 	if (verbose) 
 		fprintf(fp, "PAGE DIRECTORY: %lx\n", (ulong)pgd);
@@ -2734,21 +2750,29 @@ x86_kvtop_PAE(struct task_context *tc, u
 	if (!IS_KVADDR(kvaddr))
 		return FALSE;
 
-	if (!vt->vmalloc_start) {
-		*paddr = VTOP(kvaddr);
-		return TRUE;
-	}
-
-	if (!IS_VMALLOC_ADDR(kvaddr)) { 
-		*paddr = VTOP(kvaddr);
-		if (!verbose)
+	if (XEN_HYPER_MODE()) {
+		if (DIRECTMAP_VIRT_ADDR(kvaddr)) {
+			*paddr = kvaddr - DIRECTMAP_VIRT_START;
 			return TRUE;
-	}
+		}
+		pgd = (ulonglong *)symbol_value("idle_pg_table_l3");
+	} else {
+		if (!vt->vmalloc_start) {
+			*paddr = VTOP(kvaddr);
+			return TRUE;
+		}
 
-        if (XEN() && (kt->xen_flags & WRITABLE_PAGE_TABLES))
-                return (x86_kvtop_xen_wpt_PAE(tc, kvaddr, paddr, verbose));
+		if (!IS_VMALLOC_ADDR(kvaddr)) { 
+			*paddr = VTOP(kvaddr);
+			if (!verbose)
+				return TRUE;
+		}
 
-	pgd = (ulonglong *)vt->kernel_pgd[0];
+	        if (XEN() && (kt->xen_flags & WRITABLE_PAGE_TABLES))
+	       	        return (x86_kvtop_xen_wpt_PAE(tc, kvaddr, paddr, verbose));
+
+		pgd = (ulonglong *)vt->kernel_pgd[0];
+	}
 
 	if (verbose) 
 		fprintf(fp, "PAGE DIRECTORY: %lx\n", (ulong)pgd);
@@ -4089,6 +4113,12 @@ x86_xen_kdump_p2m_create(struct xen_kdum
 		frames -= mfns[i];
 	}
 
+        if (CRASHDEBUG(2)) {
+                for (i = 0; i < xkd->p2m_frames; i++)
+                        fprintf(fp, "%lx ", xkd->p2m_mfn_frame_list[i]);
+                fprintf(fp, "\n");
+        }
+
 	pc->readmem = read_kdump;
 	return TRUE;
 
@@ -4674,4 +4704,180 @@ x86_get_xendump_regs(struct xendump_data
 generic:
 	return machdep->get_stack_frame(bt, eip, esp);
 }
+
+/* for Xen Hypervisor analysis */
+
+static int
+x86_xenhyper_is_kvaddr(ulong addr)
+{
+	if (machdep->flags & PAE) {
+		return (addr >= HYPERVISOR_VIRT_START_PAE);
+	}
+	return (addr >= HYPERVISOR_VIRT_START);
+}
+
+static ulong
+x86_get_stackbase_hyper(ulong task)
+{
+	ulong init_tss;
+	ulong esp, base;
+	char *buf;
+
+	/* task means pcpu here */
+	if (task < 0 || task >= xht->pcpus) {
+		error(FATAL, "invalid pcpu number\n");
+	}
+	init_tss = symbol_value("init_tss");
+	buf = GETBUF(XEN_HYPER_SIZE(tss_struct));
+	init_tss += XEN_HYPER_SIZE(tss_struct) * task;
+	if (!readmem(init_tss, KVADDR, buf,
+			XEN_HYPER_SIZE(tss_struct), "init_tss", RETURN_ON_ERROR)) {
+		error(FATAL, "cannot read init_tss.\n");
+	}
+	esp = ULONG(buf + XEN_HYPER_OFFSET(tss_struct_esp0));
+	FREEBUF(buf);
+	base = esp & (~(STACKSIZE() - 1));
+
+	return base;
+}
+
+static ulong
+x86_get_stacktop_hyper(ulong task)
+{
+	return x86_get_stackbase_hyper(task) + STACKSIZE();
+}
+
+static void
+x86_get_stack_frame_hyper(struct bt_info *bt, ulong *pcp, ulong *spp)
+{
+	int pcpu;
+	ulong *regs;
+	ulong esp, eip;
+
+	/* task means pcpu here */
+	pcpu = bt->task;
+	if (pcpu < 0 || pcpu >= xht->pcpus) {
+		error(FATAL, "invalid pcpu number\n");
+	}
+
+	if (bt->flags & BT_TEXT_SYMBOLS_ALL) {
+		if (spp)
+			*spp = x86_get_stackbase_hyper(pcpu);
+		if (pcp)
+			*pcp = 0;
+		bt->flags &= ~BT_TEXT_SYMBOLS_ALL;
+		return;
+	}
+
+	regs = (ulong *)xhdit->context[pcpu].pr_reg_ptr;
+	esp = XEN_HYPER_X86_NOTE_ESP(regs);
+	eip = XEN_HYPER_X86_NOTE_EIP(regs);
+
+	if (spp) {
+		if (esp < x86_get_stackbase_hyper(pcpu) ||
+			esp >= x86_get_stacktop_hyper(pcpu))
+			*spp = x86_get_stackbase_hyper(pcpu);
+		else
+			*spp = esp;
+	}
+	if (pcp) {
+		if (is_kernel_text(eip))
+			*pcp = eip;
+		else
+			*pcp = 0;
+	}
+}
+
+static void
+x86_init_hyper(int when)
+{
+	switch (when)
+	{
+	case PRE_SYMTAB:
+		machdep->verify_symbol = x86_verify_symbol;
+                if (pc->flags & KERNEL_DEBUG_QUERY)
+                        return;
+                machdep->pagesize = memory_page_size();
+                machdep->pageshift = ffs(machdep->pagesize) - 1;
+                machdep->pageoffset = machdep->pagesize - 1;
+                machdep->pagemask = ~((ulonglong)machdep->pageoffset);
+		machdep->stacksize = machdep->pagesize * 4; /* ODA: magic num */
+        	if ((machdep->pgd = (char *)malloc(PAGESIZE())) == NULL)
+                	error(FATAL, "cannot malloc pgd space.");
+                if ((machdep->pmd = (char *)malloc(PAGESIZE())) == NULL)
+                        error(FATAL, "cannot malloc pmd space.");
+        	if ((machdep->ptbl = (char *)malloc(PAGESIZE())) == NULL)
+                	error(FATAL, "cannot malloc ptbl space.");
+		machdep->last_pgd_read = 0;
+		machdep->last_pmd_read = 0;
+		machdep->last_ptbl_read = 0;
+		machdep->machspec = &x86_machine_specific; /* some members used */
+		break;
+
+	case PRE_GDB:
+		if (symbol_exists("idle_pg_table_l3")) {
+                	machdep->flags |= PAE;
+			PGDIR_SHIFT = PGDIR_SHIFT_3LEVEL;
+			PTRS_PER_PTE = PTRS_PER_PTE_3LEVEL;
+			PTRS_PER_PGD = PTRS_PER_PGD_3LEVEL;
+                        machdep->kvtop = x86_kvtop_PAE;
+			machdep->kvbase = HYPERVISOR_VIRT_START_PAE;
+		} else {
+			PGDIR_SHIFT = PGDIR_SHIFT_2LEVEL;
+                        PTRS_PER_PTE = PTRS_PER_PTE_2LEVEL;
+                        PTRS_PER_PGD = PTRS_PER_PGD_2LEVEL;
+                	machdep->kvtop = x86_kvtop;
+			free(machdep->pmd);
+			machdep->pmd = machdep->pgd;   
+			machdep->kvbase = HYPERVISOR_VIRT_START;
+		}
+		machdep->ptrs_per_pgd = PTRS_PER_PGD;
+		machdep->identity_map_base = DIRECTMAP_VIRT_START;
+                machdep->is_kvaddr = x86_xenhyper_is_kvaddr;
+	        machdep->eframe_search = x86_eframe_search;
+	        machdep->back_trace = x86_back_trace_cmd;
+	        machdep->processor_speed = x86_processor_speed;		/* ODA: check */
+		machdep->dump_irq = generic_dump_irq; 			/* ODA: check */
+		machdep->get_stack_frame = x86_get_stack_frame_hyper;
+		machdep->get_stackbase = x86_get_stackbase_hyper;
+		machdep->get_stacktop = x86_get_stacktop_hyper;
+		machdep->translate_pte = x86_translate_pte;
+		machdep->memory_size = x86_memory_size_hyper;
+		machdep->dis_filter = x86_dis_filter;
+//		machdep->cmd_mach = x86_cmd_mach;			/* ODA: check */
+		machdep->get_smp_cpus = x86_get_smp_cpus_hyper;
+//		machdep->line_number_hooks = x86_line_number_hooks;	/* ODA: check */
+		machdep->flags |= FRAMESIZE_DEBUG;			/* ODA: check */
+		machdep->value_to_symbol = generic_machdep_value_to_symbol;
+		machdep->clear_machdep_cache = x86_clear_machdep_cache;
+
+		/* machdep table for Xen Hypervisor */
+		xhmachdep->pcpu_init = x86_xen_hyper_pcpu_init;
+		break;
+
+	case POST_GDB:
+#if 0	/* ODA: need this ? */
+		if (x86_omit_frame_pointer()) {
+			machdep->flags |= OMIT_FRAME_PTR;
+#endif
+		XEN_HYPER_STRUCT_SIZE_INIT(cpu_time, "cpu_time");
+		XEN_HYPER_STRUCT_SIZE_INIT(cpuinfo_x86, "cpuinfo_x86");
+		XEN_HYPER_STRUCT_SIZE_INIT(tss_struct, "tss_struct");
+		XEN_HYPER_MEMBER_OFFSET_INIT(tss_struct_esp0, "tss_struct", "esp0");
+		XEN_HYPER_MEMBER_OFFSET_INIT(cpu_time_local_tsc_stamp, "cpu_time", "local_tsc_stamp");
+		XEN_HYPER_MEMBER_OFFSET_INIT(cpu_time_stime_local_stamp, "cpu_time", "stime_local_stamp");
+		XEN_HYPER_MEMBER_OFFSET_INIT(cpu_time_stime_master_stamp, "cpu_time", "stime_master_stamp");
+		XEN_HYPER_MEMBER_OFFSET_INIT(cpu_time_tsc_scale, "cpu_time", "tsc_scale");
+		XEN_HYPER_MEMBER_OFFSET_INIT(cpu_time_calibration_timer, "cpu_time", "calibration_timer");
+/* KAK Can this be calculated? */
+		if (!machdep->hz) {
+			machdep->hz = XEN_HYPER_HZ;
+		}
+		break;
+
+	case POST_INIT:
+		break;
+	}
+}
+
 #endif /* X86 */
diff -purN crash-4.0-3.9/x86_64.c crash-4.0-3.14/x86_64.c
--- crash-4.0-3.9/x86_64.c	2006-12-08 17:00:30.000000000 +0100
+++ crash-4.0-3.14/x86_64.c	2006-12-01 21:39:42.000000000 +0100
@@ -14,6 +14,7 @@
  * GNU General Public License for more details.
  */
 #include "defs.h"
+#include "xen_hyper_defs.h"
 
 #ifdef X86_64
 
@@ -83,6 +84,9 @@ static ulong x86_64_xen_kdump_page_mfn(u
 static void x86_64_debug_dump_page(FILE *, char *, char *);
 static void x86_64_get_xendump_regs(struct xendump_data *, struct bt_info *, ulong *, ulong *);
 static ulong x86_64_xendump_panic_task(struct xendump_data *);
+static void x86_64_init_hyper(int);
+static ulong x86_64_get_stackbase_hyper(ulong);
+static ulong x86_64_get_stacktop_hyper(ulong);
 
 struct machine_specific x86_64_machine_specific = { 0 };
 
@@ -93,6 +97,11 @@ struct machine_specific x86_64_machine_s
 void
 x86_64_init(int when)
 {
+        if (XEN_HYPER_MODE()) {
+                x86_64_init_hyper(when);
+                return;
+        }
+
 	switch (when)
 	{
 	case PRE_SYMTAB:
@@ -582,8 +591,9 @@ x86_64_cpu_pda_init(void)
 	 *  the address of &boot_cpu_stack[0].
 	 */
 	sp = value_search(machdep->machspec->stkinfo.ibase[0], &offset);
-	if (!sp || offset || !STREQ(sp->name, "boot_cpu_stack")) {
-		if (symbol_value("boot_cpu_stack")) {
+	nsp = symbol_search("boot_cpu_stack");
+	if (!sp || offset || !nsp || (sp->value != nsp->value)) {
+		if (symbol_exists("boot_cpu_stack")) {
 			error(WARNING, 
 		       "cpu 0 IRQ stack: %lx\n         boot_cpu_stack: %lx\n\n",
 				machdep->machspec->stkinfo.ibase[0], 
@@ -1336,28 +1346,41 @@ x86_64_kvtop(struct task_context *tc, ul
         if (!IS_KVADDR(kvaddr))
                 return FALSE;
 
-        if (!vt->vmalloc_start) {
-                *paddr = x86_64_VTOP(kvaddr);
-                return TRUE;
-        }
+	if (XEN_HYPER_MODE()) {
+		if (DIRECTMAP_VIRT_ADDR(kvaddr)) {
+			*paddr = kvaddr - DIRECTMAP_VIRT_START;
+			return TRUE;
+		}
+		FILL_PML4_HYPER();
+		pml4 = ((ulong *)machdep->machspec->pml4) + pml4_index(kvaddr);  
+        	if (verbose) {
+			fprintf(fp, "PML4 DIRECTORY: %lx\n", vt->kernel_pgd[0]);
+               		fprintf(fp, "PAGE DIRECTORY: %lx\n", *pml4);
+		}
+	} else {
+        	if (!vt->vmalloc_start) {
+                	*paddr = x86_64_VTOP(kvaddr);
+                	return TRUE;
+        	}
 
-        if (!IS_VMALLOC_ADDR(kvaddr)) {
-                *paddr = x86_64_VTOP(kvaddr);
-                if (!verbose)
-                        return TRUE;
-        }
+        	if (!IS_VMALLOC_ADDR(kvaddr)) {
+                	*paddr = x86_64_VTOP(kvaddr);
+                	if (!verbose)
+                        	return TRUE;
+        	}
 
-	if (XEN() && (kt->xen_flags & WRITABLE_PAGE_TABLES))
-		return (x86_64_kvtop_xen_wpt(tc, kvaddr, paddr, verbose));
+		if (XEN() && (kt->xen_flags & WRITABLE_PAGE_TABLES))
+			return (x86_64_kvtop_xen_wpt(tc, kvaddr, paddr, verbose));
 
- 	/*	
-	 *  pgd = pgd_offset_k(addr);
-	 */
-	FILL_PML4();
-	pml4 = ((ulong *)machdep->machspec->pml4) + pml4_index(kvaddr);  
-        if (verbose) {
-		fprintf(fp, "PML4 DIRECTORY: %lx\n", vt->kernel_pgd[0]);
-                fprintf(fp, "PAGE DIRECTORY: %lx\n", *pml4);
+ 		/*	
+		 *  pgd = pgd_offset_k(addr);
+		 */
+		FILL_PML4();
+		pml4 = ((ulong *)machdep->machspec->pml4) + pml4_index(kvaddr);  
+        	if (verbose) {
+			fprintf(fp, "PML4 DIRECTORY: %lx\n", vt->kernel_pgd[0]);
+               		fprintf(fp, "PAGE DIRECTORY: %lx\n", *pml4);
+		}
 	}
 	if (!(*pml4) & _PAGE_PRESENT)
 		goto no_kpage;
@@ -2517,7 +2540,7 @@ x86_64_dwarf_back_trace_cmd(struct bt_in
 	ulong rsp, offset, stacktop;
 	ulong *up;
 	long cs;
-	struct syment *sp, *spt;
+	struct syment *sp;
 	FILE *ofp;
 	ulong estack, irqstack;
 	ulong irq_eframe;
@@ -2548,6 +2571,7 @@ x86_64_dwarf_back_trace_cmd(struct bt_in
 	irq_eframe = 0;
 	last_process_stack_eframe = 0;
 	bt->call_target = NULL;
+	bt->bptr = 0;
 	rsp = bt->stkptr;
 	if (!rsp) {
 		error(INFO, "cannot determine starting stack pointer\n");
@@ -2617,31 +2641,9 @@ in_exception_stack:
 
 		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;
-	                }
+		if (!done) {
+			level = dwarf_backtrace(bt, level, stacktop);
+			done = TRUE;
 		}
 
                 cs = x86_64_exception_frame(EFRAME_PRINT|EFRAME_CS, 0, 
@@ -2702,32 +2704,10 @@ in_exception_stack:
 
 		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 (!done) {
+			level = dwarf_backtrace(bt, level, stacktop);
+			done = TRUE;
+		}
 
 		if (!BT_REFERENCE_CHECK(bt))
                 	fprintf(fp, "--- <IRQ stack> ---\n");
@@ -2792,21 +2772,6 @@ in_exception_stack:
 	}
 
 	/*
-	 *  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.
@@ -2814,8 +2779,7 @@ in_exception_stack:
 	 */
         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);
+		level = dwarf_print_stack_entry(bt, level);
                 bt->flags &= ~(ulonglong)BT_EXCEPTION_FRAME;
                 cs = x86_64_exception_frame(EFRAME_PRINT|EFRAME_CS, 0, 
 			bt->stackbuf + (irq_eframe - bt->stackbase), bt, ofp);
@@ -2833,81 +2797,10 @@ in_exception_stack:
 	/*
 	 *  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 (!done) {
+		level = dwarf_backtrace(bt, level, bt->stacktop);
+		done = TRUE;
+	}
 
         if (!irq_eframe && !is_kernel_thread(bt->tc->task) &&
             (GET_STACKBASE(bt->tc->task) == bt->stackbase)) {
@@ -3193,6 +3086,13 @@ x86_64_exception_frame(ulong flags, ulon
                 x86_64_do_bt_reference_check(bt, r15, NULL);
         }
 
+	/* Remember the rip and rsp for unwinding the process stack */
+	if (kt->flags & DWARF_UNWIND){
+		bt->instptr = rip;
+		bt->stkptr = rsp;
+		bt->bptr = rbp;
+	}
+
 	if (kvaddr)
 		FREEBUF(pt_regs_buf);
 
@@ -3334,13 +3234,14 @@ x86_64_get_dumpfile_stack_frame(struct b
 	struct bt_info bt_local, *bt;
         struct machine_specific *ms;
 	char *user_regs;
-	ulong ur_rip;
-	ulong ur_rsp;
+	ulong ur_rip, ur_rsp;
+	ulong halt_rip, halt_rsp;
 
         bt = &bt_local;
         BCOPY(bt_in, bt, sizeof(struct bt_info));
         ms = machdep->machspec;
 	ur_rip = ur_rsp = 0;
+	halt_rip = halt_rsp = 0;
 	stage = 0;
 	estack = -1;
 
@@ -3378,15 +3279,21 @@ next_stack:
 	     i < (bt->stacktop - bt->stackbase)/sizeof(ulong); i++, up++) {
                 sym = closest_symbol(*up);
 
-                if (STREQ(sym, "netconsole_netdump") || 
+		if (XEN_CORE_DUMPFILE()) {
+			if (STREQ(sym, "xen_machine_kexec")) {
+                       		*rip = *up;
+                       		*rsp = bt->stackbase + ((char *)(up) - bt->stackbuf);
+				return;
+			}
+		} else if (STREQ(sym, "netconsole_netdump") || 
 		    STREQ(sym, "netpoll_start_netdump") ||
 		    STREQ(sym, "start_disk_dump") ||
 		    STREQ(sym, "disk_dump") ||
 		    STREQ(sym, "crash_kexec") ||
 		    STREQ(sym, "try_crashdump")) {
-                        *rip = *up;
-                        *rsp = bt->stackbase + ((char *)(up) - bt->stackbuf);
-                        return;
+                       	*rip = *up;
+                       	*rsp = bt->stackbase + ((char *)(up) - bt->stackbuf);
+                       	return;
                 }
 
                 if ((estack >= 0) && 
@@ -3446,6 +3353,24 @@ next_sysrq:
                         *rsp = bt->stackbase + ((char *)(up) - bt->stackbuf);
                         return;
                 }
+
+		if (XEN_CORE_DUMPFILE() && !panic_task && (bt->tc->pid == 0) &&
+		    (stage == 0) && STREQ(sym, "safe_halt")) {
+			halt_rip = *up;
+			halt_rsp = bt->stackbase + ((char *)(up) - bt->stackbuf);
+		}
+
+		if (XEN_CORE_DUMPFILE() && !panic_task && (bt->tc->pid == 0) &&
+		    !halt_rip && (stage == 0) && STREQ(sym, "xen_idle")) {
+			halt_rip = *up;
+			halt_rsp = bt->stackbase + ((char *)(up) - bt->stackbuf);
+		}
+
+		if (!XEN_CORE_DUMPFILE() && !panic_task && (bt->tc->pid == 0) && 
+		    !halt_rip && (stage == 0) && STREQ(sym, "cpu_idle")) { 
+			halt_rip = *up;
+			halt_rsp = bt->stackbase + ((char *)(up) - bt->stackbuf);
+		}
 	}
 
 	if (panic) 
@@ -3494,9 +3419,19 @@ skip_stage:
 	if (ur_rip && ur_rsp) {
         	*rip = ur_rip;
 		*rsp = ur_rsp;
+		return;
+	}
+
+	if (halt_rip && halt_rsp) {
+        	*rip = halt_rip;
+		*rsp = halt_rsp;
+		return;
 	}
 
-        console("x86_64_get_dumpfile_stack_frame: cannot find anything useful\n");
+	if (CRASHDEBUG(1)) 
+        	error(INFO, 
+		    "x86_64_get_dumpfile_stack_frame: cannot find anything useful (task: %lx)\n",
+			bt->task);
 
 	bt->flags &= ~(ulonglong)BT_DUMPFILE_SEARCH;
 
@@ -4220,7 +4155,7 @@ x86_64_calc_phys_base(void)
 
 	machdep->machspec->phys_base = 0;   /* default/traditional */
 
-	if (!symbol_exists("phys_base"))
+	if (!kernel_symbol_exists("phys_base"))
 		return;
 
 	if (!symbol_exists("_text"))
@@ -4340,7 +4275,7 @@ x86_64_xen_kdump_p2m_create(struct xen_k
 	    "xen kdump p2m mfn page", RETURN_ON_ERROR))
 		error(FATAL, "cannot read xen kdump p2m mfn page\n");
 
-	if (CRASHDEBUG(1))
+	if (CRASHDEBUG(2))
 		x86_64_debug_dump_page(fp, xkd->page, "pfn_to_mfn_frame_list");
 
 	for (i = 0, up = (ulong *)xkd->page; i < MAX_X86_64_FRAMES; i++, up++)
@@ -4381,8 +4316,14 @@ x86_64_xen_kdump_p2m_create(struct xen_k
 		frames -= mfns[i];
 	}
 
+	if (CRASHDEBUG(2)) {
+		for (i = 0; i < xkd->p2m_frames; i++)
+		    	fprintf(fp, "%lx ", xkd->p2m_mfn_frame_list[i]);
+		fprintf(fp, "\n");
+	}
+
         pc->readmem = read_kdump;
-	return FALSE;
+	return TRUE;
 
 use_cr3:
 
@@ -4906,4 +4847,265 @@ generic:
                 }
 	}
 }
+
+/* for XEN Hypervisor analysis */
+
+static int 
+x86_64_is_kvaddr_hyper(ulong addr)
+{
+        return (addr >= HYPERVISOR_VIRT_START && addr < HYPERVISOR_VIRT_END); 
+}
+
+static ulong
+x86_64_get_stackbase_hyper(ulong task)
+{
+	ulong init_tss, rsp0, base;
+	char *buf;
+
+	/* task means pcpu here */
+	if (task < 0 || task >= xht->pcpus) {
+		error(FATAL, "invalid pcpu number\n");
+	}
+        init_tss = symbol_value("init_tss");
+        buf = GETBUF(XEN_HYPER_SIZE(tss_struct));
+	init_tss += XEN_HYPER_SIZE(tss_struct) * task;
+	if (!readmem(init_tss, KVADDR, buf,
+		     XEN_HYPER_SIZE(tss_struct), "init_tss", RETURN_ON_ERROR)) {
+		error(FATAL, "cannot read init_tss.\n");
+	}
+	rsp0 = ULONG(buf + XEN_HYPER_OFFSET(tss_struct_rsp0));
+        FREEBUF(buf);
+
+	base = rsp0 & (~(STACKSIZE() - 1));
+	return base;
+}
+
+static ulong
+x86_64_get_stacktop_hyper(ulong task)
+{
+	return x86_64_get_stackbase_hyper(task) + STACKSIZE();
+}
+
+static void
+x86_64_get_stack_frame_hyper(struct bt_info *bt, ulong *pcp, ulong *spp)
+{
+        int pcpu;
+        ulong *regs;
+	ulong rsp, rip;
+
+	/* task means pcpu here */
+        pcpu = bt->task;
+	if (pcpu < 0 || pcpu >= xht->pcpus) {
+		error(FATAL, "invalid pcpu number\n");
+	}
+
+	if (bt->flags & BT_TEXT_SYMBOLS_ALL) {
+		if (spp)
+			*spp = x86_64_get_stackbase_hyper(pcpu);
+		if (pcp)
+			*pcp = 0;
+		bt->flags &= ~BT_TEXT_SYMBOLS_ALL;
+		return;
+	}
+
+	regs = (ulong *)xhdit->context[pcpu].pr_reg_ptr;
+	rsp = XEN_HYPER_X86_64_NOTE_RSP(regs);
+	rip = XEN_HYPER_X86_64_NOTE_RIP(regs);
+
+	if (spp) {
+		if (rsp < x86_64_get_stackbase_hyper(pcpu) ||
+			rsp >= x86_64_get_stacktop_hyper(pcpu))
+			*spp = x86_64_get_stackbase_hyper(pcpu);
+		else
+			*spp = rsp;
+	}
+	if (pcp) {
+		if (is_kernel_text(rip))
+			*pcp = rip;
+		else
+			*pcp = 0;
+	}
+}
+
+static int
+x86_64_print_stack_entry_hyper(struct bt_info *bt, FILE *ofp, int level, 
+	int stkindex, ulong text)
+{
+	ulong rsp, offset;
+	struct syment *sp;
+	char *name;
+	int result; 
+	char buf[BUFSIZE];
+
+	offset = 0;
+	sp = value_search(text, &offset);
+	if (!sp)
+		return BACKTRACE_ENTRY_IGNORED;
+
+	name = sp->name;
+
+	if (STREQ(name, "syscall_enter"))
+		result = BACKTRACE_COMPLETE;
+	else
+		result = BACKTRACE_ENTRY_DISPLAYED;
+
+	rsp = bt->stackbase + (stkindex * sizeof(long));
+
+	if ((bt->flags & BT_FULL)) {
+		if (bt->frameptr) 
+			x86_64_display_full_frame(bt, rsp, ofp);
+		bt->frameptr = rsp + sizeof(ulong);
+	}
+
+        fprintf(ofp, "%s#%d [%8lx] %s at %lx\n", level < 10 ? " " : "", level,
+		rsp, name, text);
+
+        if (bt->flags & BT_LINE_NUMBERS) {
+                get_line_number(text, buf, FALSE);
+                if (strlen(buf))
+                        fprintf(ofp, "    %s\n", buf);
+	}
+
+	if (BT_REFERENCE_CHECK(bt))
+		x86_64_do_bt_reference_check(bt, text, name);
+
+	return result;
+}
+
+/*
+ *  simple back tracer for xen hypervisor
+ *  irq stack and exception stack does not exist. so relative easy.
+ */
+static void
+x86_64_simple_back_trace_cmd_hyper(struct bt_info *bt_in)
+{
+	int i, level, done;
+	ulong rsp;
+	ulong *up;
+	FILE *ofp;
+	struct bt_info bt_local, *bt;
+
+	bt = &bt_local;
+	BCOPY(bt_in, bt, sizeof(struct bt_info));
+
+	if (bt->flags & BT_FRAMESIZE_DEBUG) {
+		error(INFO, "-F not support\n");
+		return;
+	}
+
+	level = 0;
+	done = FALSE;
+	bt->call_target = NULL;
+	rsp = bt->stkptr;
+	if (!rsp) {
+		error(INFO, "cannot determine starting stack pointer\n");
+		return;
+	}
+	if (BT_REFERENCE_CHECK(bt))
+		ofp = pc->nullfp;
+	else
+		ofp = fp;
+
+        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;
+
+		switch (x86_64_print_stack_entry_hyper(bt, ofp, level, i,*up))
+		{
+		case BACKTRACE_ENTRY_DISPLAYED:
+			level++;
+			break;
+		case BACKTRACE_ENTRY_IGNORED:	
+			break;
+		case BACKTRACE_COMPLETE:
+			done = TRUE;
+			break;
+		}
+        }
+}
+
+static void
+x86_64_init_hyper(int when)
+{
+	switch (when)
+	{
+	case PRE_SYMTAB:
+		machdep->verify_symbol = x86_64_verify_symbol;
+                machdep->machspec = &x86_64_machine_specific;
+                if (pc->flags & KERNEL_DEBUG_QUERY)
+                        return;
+                machdep->pagesize = memory_page_size();
+                machdep->pageshift = ffs(machdep->pagesize) - 1;
+                machdep->pageoffset = machdep->pagesize - 1;
+                machdep->pagemask = ~((ulonglong)machdep->pageoffset);
+		machdep->stacksize = machdep->pagesize * 2;
+                if ((machdep->machspec->upml = (char *)malloc(PAGESIZE())) == NULL)
+                        error(FATAL, "cannot malloc upml space.");
+                if ((machdep->pgd = (char *)malloc(PAGESIZE())) == NULL)
+                        error(FATAL, "cannot malloc pgd space.");
+                if ((machdep->pmd = (char *)malloc(PAGESIZE())) == NULL)
+                        error(FATAL, "cannot malloc pmd space.");
+                if ((machdep->ptbl = (char *)malloc(PAGESIZE())) == NULL)
+                        error(FATAL, "cannot malloc ptbl space.");
+		if ((machdep->machspec->pml4 = 
+			(char *)malloc(PAGESIZE()*2)) == NULL)
+                        error(FATAL, "cannot malloc pml4 space.");
+                machdep->machspec->last_upml_read = 0;
+                machdep->machspec->last_pml4_read = 0;
+                machdep->last_pgd_read = 0;
+                machdep->last_pmd_read = 0;
+                machdep->last_ptbl_read = 0;
+		machdep->verify_paddr = generic_verify_paddr;
+		machdep->ptrs_per_pgd = PTRS_PER_PGD;
+                if (machdep->cmdline_arg)
+                        parse_cmdline_arg();
+		break;
+
+	case PRE_GDB:
+                machdep->machspec->page_offset = PAGE_OFFSET_XEN_HYPER;
+	        machdep->kvbase = (ulong)HYPERVISOR_VIRT_START;
+		machdep->identity_map_base = (ulong)PAGE_OFFSET_XEN_HYPER;
+                machdep->is_kvaddr = x86_64_is_kvaddr_hyper;
+                machdep->is_uvaddr = x86_64_is_uvaddr;
+	        machdep->eframe_search = x86_64_eframe_search;
+	        machdep->back_trace = x86_64_simple_back_trace_cmd_hyper;
+	        machdep->processor_speed = x86_64_processor_speed;
+	        machdep->kvtop = x86_64_kvtop;
+	        machdep->get_task_pgd = x86_64_get_task_pgd;
+		machdep->get_stack_frame = x86_64_get_stack_frame_hyper;
+		machdep->get_stackbase = x86_64_get_stackbase_hyper;
+		machdep->get_stacktop = x86_64_get_stacktop_hyper;
+		machdep->translate_pte = x86_64_translate_pte;
+		machdep->memory_size = x86_memory_size_hyper;	/* KAK add */
+		machdep->is_task_addr = x86_64_is_task_addr;
+		machdep->dis_filter = x86_64_dis_filter;
+		machdep->cmd_mach = x86_64_cmd_mach;
+		machdep->get_smp_cpus = x86_get_smp_cpus_hyper;	/* KAK add */
+		machdep->line_number_hooks = x86_64_line_number_hooks;
+		machdep->value_to_symbol = generic_machdep_value_to_symbol;
+		machdep->init_kernel_pgd = x86_64_init_kernel_pgd;
+		machdep->clear_machdep_cache = x86_64_clear_machdep_cache;
+
+		/* machdep table for Xen Hypervisor */
+		xhmachdep->pcpu_init = x86_xen_hyper_pcpu_init;
+		break;
+
+	case POST_GDB:
+		XEN_HYPER_STRUCT_SIZE_INIT(cpuinfo_x86, "cpuinfo_x86");
+		XEN_HYPER_STRUCT_SIZE_INIT(tss_struct, "tss_struct");
+		XEN_HYPER_MEMBER_OFFSET_INIT(tss_struct_rsp0, "tss_struct", "rsp0");
+/* KAK Can this be calculated? */
+		if (!machdep->hz) {
+			machdep->hz = XEN_HYPER_HZ;
+		}
+		break;
+
+	case POST_INIT:
+		break;
+	}
+}
 #endif  /* X86_64 */ 
diff -purN crash-4.0-3.9/xen_hyper.c crash-4.0-3.14/xen_hyper.c
--- crash-4.0-3.9/xen_hyper.c	1970-01-01 01:00:00.000000000 +0100
+++ crash-4.0-3.14/xen_hyper.c	2006-12-01 21:39:42.000000000 +0100
@@ -0,0 +1,1231 @@
+/*
+ *  xen_hyper.c
+ *
+ *  Portions Copyright (C) 2006 Fujitsu Limited
+ *  Portions Copyright (C) 2006 VA Linux Systems Japan K.K.
+ *
+ *  This file is part of Xencrash.
+ *
+ *  Xencrash 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 (version 2 of the License).
+ *
+ *  Xencrash 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.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Xencrash; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA.
+ */
+
+#include "defs.h"
+
+#ifdef XEN_HYPERVISOR_ARCH
+#include "xen_hyper_defs.h"
+
+/*
+ * Do initialization for Xen Hyper system here.
+ */
+void
+xen_hyper_init(void)
+{
+	char *buf;
+	long member_offset;
+
+	get_symbol_data("crashing_cpu", sizeof(xht->crashing_cpu),
+		&xht->crashing_cpu);
+	get_symbol_data("max_cpus", sizeof(xht->max_cpus), &xht->max_cpus);
+	machdep->get_smp_cpus();
+	machdep->memory_size();
+
+	if (machine_type("X86") || machine_type("X86_64")) {
+		member_offset = MEMBER_OFFSET("cpuinfo_x86", "x86_model_id");
+		buf = GETBUF(XEN_HYPER_SIZE(cpuinfo_x86));	
+		xen_hyper_fill_cpu_data_x86(0, buf);
+		strncpy(xht->utsname.machine, (char *)(buf + member_offset),
+			sizeof(xht->utsname.machine)-1);
+		FREEBUF(buf);
+	}
+
+	XEN_HYPER_STRUCT_SIZE_INIT(note_buf_t, "note_buf_t");
+	XEN_HYPER_STRUCT_SIZE_INIT(ELF_Prstatus,"ELF_Prstatus");
+	XEN_HYPER_MEMBER_OFFSET_INIT(ELF_Prstatus_pr_info, "ELF_Prstatus", "pr_info");
+	XEN_HYPER_MEMBER_OFFSET_INIT(ELF_Prstatus_pr_cursig, "ELF_Prstatus", "pr_cursig");
+	XEN_HYPER_MEMBER_OFFSET_INIT(ELF_Prstatus_pr_sigpend, "ELF_Prstatus", "pr_sigpend");
+	XEN_HYPER_MEMBER_OFFSET_INIT(ELF_Prstatus_pr_sighold, "ELF_Prstatus", "pr_sighold");
+	XEN_HYPER_MEMBER_OFFSET_INIT(ELF_Prstatus_pr_pid, "ELF_Prstatus", "pr_pid");
+	XEN_HYPER_MEMBER_OFFSET_INIT(ELF_Prstatus_pr_ppid, "ELF_Prstatus", "pr_ppid");
+	XEN_HYPER_MEMBER_OFFSET_INIT(ELF_Prstatus_pr_pgrp, "ELF_Prstatus", "pr_pgrp");
+	XEN_HYPER_MEMBER_OFFSET_INIT(ELF_Prstatus_pr_sid, "ELF_Prstatus", "pr_sid");
+	XEN_HYPER_MEMBER_OFFSET_INIT(ELF_Prstatus_pr_utime, "ELF_Prstatus", "pr_utime");
+	XEN_HYPER_MEMBER_OFFSET_INIT(ELF_Prstatus_pr_stime, "ELF_Prstatus", "pr_stime");
+	XEN_HYPER_MEMBER_OFFSET_INIT(ELF_Prstatus_pr_cutime, "ELF_Prstatus", "pr_cutime");
+	XEN_HYPER_MEMBER_OFFSET_INIT(ELF_Prstatus_pr_cstime, "ELF_Prstatus", "pr_cstime");
+	XEN_HYPER_MEMBER_OFFSET_INIT(ELF_Prstatus_pr_reg, "ELF_Prstatus", "pr_reg");
+	XEN_HYPER_MEMBER_OFFSET_INIT(ELF_Prstatus_pr_fpvalid, "ELF_Prstatus", "pr_fpvalid");
+	XEN_HYPER_MEMBER_OFFSET_INIT(ELF_Timeval_tv_sec, "ELF_Timeval", "tv_sec");
+	XEN_HYPER_MEMBER_OFFSET_INIT(ELF_Timeval_tv_usec, "ELF_Timeval", "tv_usec");
+	XEN_HYPER_STRUCT_SIZE_INIT(ELF_Signifo,"ELF_Signifo");
+	XEN_HYPER_STRUCT_SIZE_INIT(ELF_Gregset,"ELF_Gregset");
+	XEN_HYPER_STRUCT_SIZE_INIT(ELF_Timeval,"ELF_Timeval");
+	XEN_HYPER_STRUCT_SIZE_INIT(domain, "domain");
+	XEN_HYPER_STRUCT_SIZE_INIT(vcpu, "vcpu");
+	XEN_HYPER_STRUCT_SIZE_INIT(cpu_info, "cpu_info");
+	XEN_HYPER_STRUCT_SIZE_INIT(cpu_user_regs, "cpu_user_regs");
+
+	xen_hyper_dumpinfo_init();
+}
+
+/*
+ * Do initialization for Domain of Xen Hyper system here.
+ */
+void
+xen_hyper_domain_init(void)
+{
+	XEN_HYPER_MEMBER_OFFSET_INIT(domain_domain_id, "domain", "domain_id");
+	XEN_HYPER_MEMBER_OFFSET_INIT(domain_tot_pages, "domain", "tot_pages");
+	XEN_HYPER_MEMBER_OFFSET_INIT(domain_max_pages, "domain", "max_pages");
+	XEN_HYPER_MEMBER_OFFSET_INIT(domain_xenheap_pages, "domain", "xenheap_pages");
+	XEN_HYPER_MEMBER_OFFSET_INIT(domain_shared_info, "domain", "shared_info");
+	XEN_HYPER_MEMBER_OFFSET_INIT(domain_sched_priv, "domain", "sched_priv");
+	XEN_HYPER_MEMBER_OFFSET_INIT(domain_next_in_list, "domain", "next_in_list");
+	XEN_HYPER_MEMBER_OFFSET_INIT(domain_domain_flags, "domain", "domain_flags");
+	XEN_HYPER_MEMBER_OFFSET_INIT(domain_evtchn, "domain", "evtchn");
+	XEN_HYPER_MEMBER_OFFSET_INIT(domain_vcpu, "domain", "vcpu");
+
+	if((xhdt->domain_struct = malloc(XEN_HYPER_SIZE(domain))) == NULL) {
+		error(FATAL, "cannot malloc domain struct space.\n");
+	}
+	if((xhdt->domain_struct_verify = malloc(XEN_HYPER_SIZE(domain))) == NULL) {
+		error(FATAL, "cannot malloc domain struct space to verification.\n");
+	}
+	xen_hyper_refresh_domain_context_space();
+	xhdt->flags |= XEN_HYPER_DOMAIN_F_INIT;
+}
+
+/*
+ * Do initialization for vcpu of Xen Hyper system here.
+ */
+void
+xen_hyper_vcpu_init(void)
+{
+	XEN_HYPER_STRUCT_SIZE_INIT(timer, "timer");
+	XEN_HYPER_MEMBER_OFFSET_INIT(timer_expires, "timer", "expires");
+	XEN_HYPER_MEMBER_OFFSET_INIT(timer_cpu, "timer", "cpu");
+	XEN_HYPER_MEMBER_OFFSET_INIT(timer_function, "timer", "function");
+	XEN_HYPER_MEMBER_OFFSET_INIT(timer_data, "timer", "data");
+	XEN_HYPER_MEMBER_OFFSET_INIT(timer_heap_offset, "timer", "heap_offset");
+	XEN_HYPER_MEMBER_OFFSET_INIT(timer_killed, "timer", "killed");
+
+	XEN_HYPER_STRUCT_SIZE_INIT(vcpu_runstate_info, "vcpu_runstate_info");
+	XEN_HYPER_MEMBER_OFFSET_INIT(vcpu_runstate_info_state, "vcpu_runstate_info", "state");
+	XEN_HYPER_MEMBER_OFFSET_INIT(vcpu_runstate_info_state_entry_time, "vcpu_runstate_info", "state_entry_time");
+	XEN_HYPER_MEMBER_OFFSET_INIT(vcpu_runstate_info_time, "vcpu_runstate_info", "time");
+
+	XEN_HYPER_MEMBER_OFFSET_INIT(vcpu_vcpu_id, "vcpu", "vcpu_id");
+	XEN_HYPER_MEMBER_OFFSET_INIT(vcpu_processor, "vcpu", "processor");
+	XEN_HYPER_MEMBER_OFFSET_INIT(vcpu_vcpu_info, "vcpu", "vcpu_info");
+	XEN_HYPER_MEMBER_OFFSET_INIT(vcpu_domain, "vcpu", "domain");
+	XEN_HYPER_MEMBER_OFFSET_INIT(vcpu_next_in_list, "vcpu", "next_in_list");
+	XEN_HYPER_MEMBER_OFFSET_INIT(vcpu_timer, "vcpu", "timer");
+	XEN_HYPER_MEMBER_OFFSET_INIT(vcpu_sleep_tick, "vcpu", "sleep_tick");
+	XEN_HYPER_MEMBER_OFFSET_INIT(vcpu_poll_timer, "vcpu", "poll_timer");
+	XEN_HYPER_MEMBER_OFFSET_INIT(vcpu_sched_priv, "vcpu", "sched_priv");
+	XEN_HYPER_MEMBER_OFFSET_INIT(vcpu_runstate, "vcpu", "runstate");
+	XEN_HYPER_MEMBER_OFFSET_INIT(vcpu_runstate_guest, "vcpu", "runstate_guest");
+	XEN_HYPER_MEMBER_OFFSET_INIT(vcpu_vcpu_flags, "vcpu", "vcpu_flags");
+	XEN_HYPER_MEMBER_OFFSET_INIT(vcpu_pause_count, "vcpu", "pause_count");
+	XEN_HYPER_MEMBER_OFFSET_INIT(vcpu_virq_to_evtchn, "vcpu", "virq_to_evtchn");
+	XEN_HYPER_MEMBER_OFFSET_INIT(vcpu_cpu_affinity, "vcpu", "cpu_affinity");
+	XEN_HYPER_MEMBER_OFFSET_INIT(vcpu_nmi_addr, "vcpu", "nmi_addr");
+	XEN_HYPER_MEMBER_OFFSET_INIT(vcpu_vcpu_dirty_cpumask, "vcpu", "vcpu_dirty_cpumask");
+	XEN_HYPER_MEMBER_OFFSET_INIT(vcpu_arch, "vcpu", "arch");
+
+	if((xhvct->vcpu_struct = malloc(XEN_HYPER_SIZE(vcpu))) == NULL) {
+		error(FATAL, "cannot malloc vcpu struct space.\n");
+	}
+	if((xhvct->vcpu_struct_verify = malloc(XEN_HYPER_SIZE(vcpu))) == NULL) {
+		error(FATAL, "cannot malloc vcpu struct space to verification.\n");
+	}
+
+	xen_hyper_refresh_vcpu_context_space();
+	xhvct->flags |= XEN_HYPER_VCPU_F_INIT;
+	xhvct->idle_vcpu = symbol_value("idle_vcpu");
+}
+
+/*
+ * Do initialization for pcpu of Xen Hyper system here.
+ */
+void
+x86_xen_hyper_pcpu_init(void)
+{
+	long cpu_info;
+	long init_tss;
+	long sp;
+	struct xen_hyper_pcpu_context *pcc;
+	char *buf, *bp;
+	int i;
+
+	XEN_HYPER_MEMBER_OFFSET_INIT(cpu_info_guest_cpu_user_regs, "cpu_info", "guest_cpu_user_regs");
+	XEN_HYPER_MEMBER_OFFSET_INIT(cpu_info_processor_id, "cpu_info", "processor_id");
+	XEN_HYPER_MEMBER_OFFSET_INIT(cpu_info_current_vcpu, "cpu_info", "current_vcpu");
+
+	if((xhpct->pcpu_struct = malloc(XEN_HYPER_SIZE(cpu_info))) == NULL) {
+		error(FATAL, "cannot malloc pcpu struct space.\n");
+	}
+
+	/* get physical cpu context */
+	xen_hyper_alloc_pcpu_context_space(XEN_HYPER_MAX_PCPUS());
+	pcc = xhpct->context_array;
+	init_tss = symbol_value("init_tss");
+	buf = GETBUF(XEN_HYPER_SIZE(tss_struct));	
+	for (i = 0; i < xht->pcpus;
+		i++, pcc++, init_tss += XEN_HYPER_SIZE(tss_struct)) {
+		if (!readmem(init_tss, KVADDR, buf,
+			XEN_HYPER_SIZE(tss_struct), "init_tss", RETURN_ON_ERROR)) {
+			error(FATAL, "cannot read init_tss.\n");
+		}
+		if (machine_type("X86")) {
+			sp = ULONG(buf + XEN_HYPER_OFFSET(tss_struct_esp0));
+		} else if (machine_type("X86_64")) {
+			sp = ULONG(buf + XEN_HYPER_OFFSET(tss_struct_rsp0));
+		}
+		cpu_info = XEN_HYPER_GET_CPU_INFO(sp);
+		if (CRASHDEBUG(1)) {
+			fprintf(fp, "sp=%lx, cpu_info=%lx\n", sp, cpu_info);
+		}
+		if(!(bp = xen_hyper_read_pcpu(cpu_info))) {
+			error(FATAL, "cannot read cpu_info.\n");
+		}
+		xen_hyper_store_pcpu_context(pcc, cpu_info, bp);
+	}
+	FREEBUF(buf);
+}
+
+/*
+ * This should be called after all initailize process finished.
+ */
+void
+xen_hyper_post_init(void)
+{
+	/* set pcpu last */
+	if (!(xhpct->last =
+		xen_hyper_id_to_pcpu_context(xht->crashing_cpu))) {
+		xhpct->last = xhpct->context_array;
+	}
+
+	/* set vcpu last */
+	if (xhpct->last) {
+		xhvct->last =
+			xen_hyper_vcpu_to_vcpu_context(xhpct->last->current_vcpu);
+		/* set crashing vcpu */
+		xht->crashing_vcc = xhvct->last;
+	}
+	if (!xhvct->last) {
+		xhvct->last = xhvct->vcpu_context_arrays->context_array;
+	}
+
+	/* set domain last */
+	if (xhvct->last) {
+		xhdt->last =
+			xen_hyper_domain_to_domain_context(xhvct->last->domain);
+	}
+	if (!xhdt->last) {
+		xhdt->last = xhdt->context_array;
+	}
+}
+
+/*
+ * Do initialization for dump information header here.
+ */
+void
+xen_hyper_dumpinfo_init(void)
+{
+	Elf32_Nhdr *note;
+	char *bp, *np, *upp;
+	ulong addr;
+	int i, size;
+
+	addr = symbol_value("per_cpu__crash_notes");
+	for (i = 0; i < xht->pcpus; i++) {
+		xhdit->context[i].note = xen_hyper_per_cpu(addr, i);
+	}
+
+	if (XEN_HYPER_SIZE(note_buf_t) >
+		XEN_HYPER_SIZE(ELF_Prstatus) * xht->pcpus) {
+		size = XEN_HYPER_SIZE(note_buf_t);
+	} else {
+		size = XEN_HYPER_SIZE(ELF_Prstatus) * xht->pcpus;
+	}
+	if(!(xhdit->ELF_Prstatus_array = malloc(size))) {
+		error(FATAL, "cannot malloc note_buf_t struct space.\n");
+	}
+	bp = xhdit->ELF_Prstatus_array;
+	note = (Elf32_Nhdr *)bp;
+	if (!readmem(addr, KVADDR, bp,
+		XEN_HYPER_SIZE(note_buf_t), "per_cpu__crash_notes", RETURN_ON_ERROR)) {
+		error(FATAL, "cannot read per_cpu__crash_notes.\n");
+	}
+	/* cpu data */
+	np = bp + sizeof(Elf32_Nhdr);
+	upp = np + note->n_namesz;
+	upp = (char *)roundup((ulong)upp, 4);
+	xhdit->offset = (Elf_Word)((ulong)upp - (ulong)note);
+	note = (Elf32_Nhdr *)(upp + note->n_descsz);
+	/* cr3 data */
+	np = (char *)note + sizeof(Elf32_Nhdr);
+	upp = np + note->n_namesz;
+	upp = (char *)roundup((ulong)upp, 4);
+	upp = upp + note->n_descsz;
+	xhdit->size = upp - bp;
+
+	bp = xhdit->ELF_Prstatus_array;
+	BZERO(bp, size);
+	for (i = 0; i < xht->pcpus; i++, bp += XEN_HYPER_SIZE(ELF_Prstatus)) {
+		addr = xhdit->context[i].note + xhdit->offset;
+		if (!xen_hyper_fill_ELF_Prstatus(addr, bp)) {
+			error(FATAL, "cannot read ELF_Prstatus.\n");
+		}
+		xhdit->context[i].pcpu_id = i;
+		xhdit->context[i].ELF_Prstatus_ptr = bp;
+		xhdit->context[i].pr_reg_ptr = bp + XEN_HYPER_OFFSET(ELF_Prstatus_pr_reg);
+	}
+}
+
+/*
+ * Get dump information context from physical cpu id.
+ */
+struct xen_hyper_dumpinfo_context *
+xen_hyper_id_to_dumpinfo_context(uint id)
+{
+	return &xhdit->context[id];
+}
+
+/*
+ * Get dump information context from ELF Note address.
+ */
+struct xen_hyper_dumpinfo_context *
+xen_hyper_note_to_dumpinfo_context(ulong note)
+{
+	int i;
+
+	for (i = 0; i < xht->pcpus; i++) {
+		if (note == xhdit->context[i].note) {
+			return &xhdit->context[i];
+		}
+	}
+	return NULL;
+}
+
+/*
+ * Fill ELF Notes header here.
+ */
+char *
+xen_hyper_fill_elf_notes(ulong note, char *note_buf)
+{
+	if (!readmem(note, KVADDR, note_buf, XEN_HYPER_SIZE(note_buf_t),
+		"note_buf_t", RETURN_ON_ERROR)) {
+		error(WARNING, "cannot fill note_buf_t.\n");
+		return NULL;
+	}
+	return note_buf;
+}
+
+/*
+ * Fill ELF_Prstatus in ELF Notes header here.
+ */
+char *
+xen_hyper_fill_ELF_Prstatus(ulong prstatus, char *note_buf)
+{
+	if (!readmem(prstatus, KVADDR, note_buf, XEN_HYPER_SIZE(ELF_Prstatus),
+		"ELF_Prstatus", RETURN_ON_ERROR)) {
+		error(WARNING, "cannot fill ELF_Prstatus.\n");
+		return NULL;
+	}
+	return note_buf;
+}
+
+
+
+/*
+ * Get domain status.
+ */
+ulong
+xen_hyper_domain_state(struct xen_hyper_domain_context *dc)
+{
+	if (ACTIVE()) {
+		if (xen_hyper_read_domain_verify(dc->domain) == NULL) {
+			return XEN_HYPER_DOMF_ERROR;
+		}
+	}
+	return dc->domain_flags;
+}
+
+/*
+ * Allocate domain context space.
+ */
+void
+xen_hyper_refresh_domain_context_space(void)
+{
+	char *domain_struct;
+	ulong domain, next, idle_vcpu;
+	struct xen_hyper_domain_context *dc;
+	struct xen_hyper_domain_context *dom0;
+
+	if ((xhdt->flags & XEN_HYPER_DOMAIN_F_INIT) && !ACTIVE()) {
+		return;
+	}
+
+	XEN_HYPER_RUNNING_DOMAINS() = XEN_HYPER_MAX_DOMAINS() =
+		xen_hyper_get_domains();
+	xen_hyper_alloc_domain_context_space(XEN_HYPER_MAX_DOMAINS());
+
+	dc = xhdt->context_array;
+	/* restore an idle domain context. */
+	get_symbol_data("idle_vcpu", sizeof(idle_vcpu), &idle_vcpu);
+	if (!readmem(idle_vcpu + MEMBER_OFFSET("vcpu", "domain"),
+		KVADDR, &domain, sizeof(domain), "domain", RETURN_ON_ERROR)) {
+		error(WARNING, "cannot read domain member in vcpu.\n");
+	}
+	if (CRASHDEBUG(1)) {
+		fprintf(fp, "idle_vcpu=%lx, domain=%lx\n", idle_vcpu, domain);
+	}
+	if ((domain_struct = xen_hyper_read_domain(domain)) == NULL) {
+		error(FATAL, "cannot read idle domain.\n");
+	}
+	xen_hyper_store_domain_context(dc, domain, domain_struct);
+	xhdt->idle_domain = dc;
+	dc++;
+
+	/* restore domain contexts from dom0 symbol. */
+	xen_hyper_get_domain_next(XEN_HYPER_DOMAIN_READ_DOM0, &next);
+	domain = next;
+	dom0 = dc;
+	while((domain_struct =
+	xen_hyper_get_domain_next(XEN_HYPER_DOMAIN_READ_NEXT, &next)) != NULL) {
+		xen_hyper_store_domain_context(dc, domain, domain_struct);
+		domain = next;
+		dc++;
+	}
+	xhdt->dom0 = dom0;
+}
+
+/*
+ * Get number of domain.
+ */
+int
+xen_hyper_get_domains(void)
+{
+	ulong domain, next_in_list;
+	long domain_next_in_list;
+	int i;
+
+	get_symbol_data("dom0", sizeof(void *), &domain);
+	domain_next_in_list = MEMBER_OFFSET("domain", "next_in_list");
+	i = 0;
+	while (domain != 0) {
+		i++;
+		next_in_list = domain + domain_next_in_list;
+		if (!readmem(next_in_list, KVADDR, &domain, sizeof(void *),
+			"domain.next_in_list", RETURN_ON_ERROR)) {
+			error(FATAL, "cannot read domain.next_in_list.\n");
+		}
+	}
+	i++;					/* for idle domain */
+	return i;
+}
+
+/*
+ * Get next domain struct.
+ * 	mod - XEN_HYPER_DOMAIN_READ_DOM0:start from dom0 symbol
+ * 	    - XEN_HYPER_DOMAIN_READ_INIT:start from xhdt->context_array
+ * 	    - XEN_HYPER_DOMAIN_READ_NEXT:next
+ */
+char *
+xen_hyper_get_domain_next(int mod, ulong *next)
+{
+	static int idx = 0;
+
+	char *domain_struct;
+	struct xen_hyper_domain_context *dc;
+
+	switch (mod) {
+	case XEN_HYPER_DOMAIN_READ_DOM0:
+		/* Case of search from dom0 symbol. */
+		idx = 0;
+		if (xhdt->dom0) {
+			*next = xhdt->dom0->domain;
+		} else {
+			get_symbol_data("dom0", sizeof(void *), next);
+		}
+		return xhdt->domain_struct;
+		break;
+	case XEN_HYPER_DOMAIN_READ_INIT:
+		/* Case of search from context_array. */
+		if (xhdt->context_array && xhdt->context_array->domain) {
+			idx = 1; 		/* this has a next index. */
+			*next = xhdt->context_array->domain;
+		} else {
+			idx = 0;
+			*next = 0;
+			return NULL;
+		}
+		return xhdt->domain_struct;
+		break;
+	case XEN_HYPER_DOMAIN_READ_NEXT:
+		break;
+	default :
+		error(FATAL, "xen_hyper_get_domain_next mod error: %d\n", mod);
+		return NULL;
+	}
+
+	/* Finished search */
+	if (!*next) {
+		return NULL;
+	}
+
+	domain_struct = NULL;
+	/* Is domain context array valid? */
+	if (idx) {
+		if ((domain_struct =
+			xen_hyper_read_domain(*next)) == NULL) {
+			error(FATAL, "cannot get next domain from domain context array.\n");
+		}
+		if (idx > XEN_HYPER_MAX_DOMAINS()) {
+			*next = 0;
+		} else {
+			dc = xhdt->context_array;
+			dc += idx;
+			*next = dc->domain;
+			idx++;
+		}
+		return domain_struct;
+	}
+
+	/* Search from dom0 symbol. */
+	if ((domain_struct =
+		xen_hyper_read_domain(*next)) == NULL) {
+		error(FATAL, "cannot get next domain from dom0 symbol.\n");
+	}
+	*next = ULONG(domain_struct + XEN_HYPER_OFFSET(domain_next_in_list));
+	return domain_struct;
+}
+
+/*
+ * from domain address to id.
+ */
+domid_t
+xen_hyper_domain_to_id(ulong domain)
+{
+	struct xen_hyper_domain_context *dc;
+
+	/* Is domain context array valid? */
+	if (xhdt->context_array && xhdt->context_array->domain) {
+		if ((dc = xen_hyper_domain_to_domain_context(domain)) == NULL) {
+			return XEN_HYPER_DOMAIN_ID_INVALID;
+		} else {
+			return dc->domain_id;
+		}
+	} else {
+		return XEN_HYPER_DOMAIN_ID_INVALID;
+	}
+}
+
+/*
+ * Get domain struct from id.
+ */
+char *
+xen_hyper_id_to_domain_struct(domid_t id)
+{
+	char *domain_struct;
+	struct xen_hyper_domain_context *dc;
+
+	domain_struct = NULL;
+
+	/* Is domain context array valid? */
+	if (xhdt->context_array && xhdt->context_array->domain) {
+		if ((dc = xen_hyper_id_to_domain_context(id)) == NULL) {
+			return NULL;
+		} else {
+			if ((domain_struct =
+				xen_hyper_read_domain(dc->domain)) == NULL) {
+				error(FATAL, "cannot get domain from domain context array with id.\n");
+			}
+			return domain_struct;
+		}
+	} else {
+		return NULL;
+	}
+}
+
+/*
+ * Get domain context from domain address.
+ */
+struct xen_hyper_domain_context *
+xen_hyper_domain_to_domain_context(ulong domain)
+{
+	struct xen_hyper_domain_context *dc;
+	int i;
+
+	if (xhdt->context_array == NULL ||
+		xhdt->context_array->domain == 0) {
+		return NULL;
+	}
+	if (!domain) {
+		return NULL;
+	}
+	for (i = 0, dc = xhdt->context_array; i < XEN_HYPER_MAX_DOMAINS();
+		i++, dc++) {
+		if (domain == dc->domain) {
+			return dc;
+		}
+	}
+	return NULL;
+}
+
+/*
+ * Get domain context from domain id.
+ */
+struct xen_hyper_domain_context *
+xen_hyper_id_to_domain_context(domid_t id)
+{
+	struct xen_hyper_domain_context *dc;
+	int i;
+
+	if (xhdt->context_array == NULL ||
+		xhdt->context_array->domain == 0) {
+		return NULL;
+	}
+	if (id == XEN_HYPER_DOMAIN_ID_INVALID) {
+		return NULL;
+	}
+	for (i = 0, dc = xhdt->context_array; i < XEN_HYPER_MAX_DOMAINS();
+		i++, dc++) {
+		if (id == dc->domain_id) {
+			return dc;
+		}
+	}
+	return NULL;
+}
+
+/*
+ * Store domain struct contents.
+ */
+struct xen_hyper_domain_context *
+xen_hyper_store_domain_context(struct xen_hyper_domain_context *dc,
+	       ulong domain, char *dp)
+{
+	int i;
+
+	dc->domain = domain;
+	BCOPY((char *)(dp + XEN_HYPER_OFFSET(domain_domain_id)),
+		&dc->domain_id, sizeof(domid_t));
+	dc->tot_pages = UINT(dp + XEN_HYPER_OFFSET(domain_tot_pages));
+	dc->max_pages = UINT(dp + XEN_HYPER_OFFSET(domain_max_pages));
+	dc->xenheap_pages = UINT(dp + XEN_HYPER_OFFSET(domain_xenheap_pages));
+	dc->shared_info = ULONG(dp + XEN_HYPER_OFFSET(domain_shared_info));
+	dc->sched_priv = ULONG(dp + XEN_HYPER_OFFSET(domain_sched_priv));
+	dc->next_in_list = ULONG(dp + XEN_HYPER_OFFSET(domain_next_in_list));
+	dc->domain_flags = ULONG(dp + XEN_HYPER_OFFSET(domain_domain_flags));
+	dc->evtchn = ULONG(dp + XEN_HYPER_OFFSET(domain_evtchn));
+	for (i = 0; i < XEN_HYPER_MAX_VIRT_CPUS; i++) {
+		dc->vcpu[i] = ULONG(dp + XEN_HYPER_OFFSET(domain_vcpu) + i*sizeof(void *));
+		if (dc->vcpu[i])	XEN_HYPER_MAX_VCPUS(dc)++;
+	}
+
+	return dc;
+}
+
+/*
+ * Read domain struct from domain context.
+ */
+char *
+xen_hyper_read_domain_from_context(struct xen_hyper_domain_context *dc)
+{
+	return xen_hyper_fill_domain_struct(dc->domain, xhdt->domain_struct);
+}
+
+/*
+ * Read domain struct.
+ */
+char *
+xen_hyper_read_domain(ulong domain)
+{
+	return xen_hyper_fill_domain_struct(domain, xhdt->domain_struct);
+}
+
+/*
+ * Read domain struct to verification.
+ */
+char *
+xen_hyper_read_domain_verify(ulong domain)
+{
+	return xen_hyper_fill_domain_struct(domain, xhdt->domain_struct_verify);
+}
+
+/*
+ * Fill domain struct.
+ */
+char *
+xen_hyper_fill_domain_struct(ulong domain, char *domain_struct)
+{
+	if (!readmem(domain, KVADDR, domain_struct,
+		XEN_HYPER_SIZE(domain), "fill_domain_struct",
+	       	ACTIVE() ? (RETURN_ON_ERROR|QUIET) : RETURN_ON_ERROR)) {
+		error(WARNING, "cannot fill domain struct.\n");
+		return NULL;
+	}
+	return domain_struct;
+}
+
+/*
+ * Allocate domain context space.
+ */
+void
+xen_hyper_alloc_domain_context_space(int domains)
+{
+	if (xhdt->context_array == NULL) {
+		if (!(xhdt->context_array =
+			malloc(domains * sizeof(struct xen_hyper_domain_context)))) {
+			error(FATAL, "cannot malloc context array (%d domains).",
+				domains);
+		}
+		xhdt->context_array_cnt = domains;
+	} else if (domains > xhdt->context_array_cnt) {
+		if (!(xhdt->context_array =
+			realloc(xhdt->context_array,
+				domains * sizeof(struct xen_hyper_domain_context)))) {
+			error(FATAL, "cannot realloc context array (%d domains).",
+				domains);
+		}
+		xhdt->context_array_cnt = domains;
+	}
+	BZERO(xhdt->context_array,
+		domains * sizeof(struct xen_hyper_domain_context));
+}
+
+
+
+/*
+ * Get vcpu status.
+ */
+int
+xen_hyper_vcpu_state(struct xen_hyper_vcpu_context *vcc)
+{
+	if (ACTIVE()) {
+		if (xen_hyper_read_vcpu_verify(vcc->vcpu) == NULL) {
+			return XEN_HYPER_RUNSTATE_ERROR;
+		}
+	}
+	return vcc->state;
+}
+
+/*
+ * Allocate vcpu context space.
+ */
+void
+xen_hyper_refresh_vcpu_context_space(void)
+{
+	struct xen_hyper_domain_context *dc;
+	struct xen_hyper_vcpu_context_array *vcca;
+	struct xen_hyper_vcpu_context *vcc;
+	int i, j;
+
+	if ((xhvct->flags & XEN_HYPER_VCPU_F_INIT) && !ACTIVE()) {
+		return;
+	}
+
+	xen_hyper_alloc_vcpu_context_arrays_space(XEN_HYPER_MAX_DOMAINS());
+	for (i = 0, xht->vcpus = 0, dc = xhdt->context_array,
+	vcca = xhvct->vcpu_context_arrays;
+	i < XEN_HYPER_MAX_DOMAINS(); i++, dc++, vcca++) {
+		dc->vcpu_context_array = vcca;
+		xen_hyper_alloc_vcpu_context_space(vcca,
+			XEN_HYPER_MAX_VCPUS(dc));
+		for (j = 0, vcc = vcca->context_array;
+		j < XEN_HYPER_MAX_VCPUS(dc); j++, vcc++) {
+			xen_hyper_read_vcpu(dc->vcpu[j]);
+			xen_hyper_store_vcpu_context(vcc, dc->vcpu[j],
+				xhvct->vcpu_struct);	
+		}
+		if (dc == xhdt->idle_domain) {
+			xhvct->idle_vcpu_context_array = vcca;
+		}
+		xht->vcpus += vcca->context_array_cnt;
+	}
+}
+
+/*
+ * Get vcpu context from vcpu address.
+ */
+struct xen_hyper_vcpu_context *
+xen_hyper_vcpu_to_vcpu_context(ulong vcpu)
+{
+	struct xen_hyper_vcpu_context_array *vcca;
+	struct xen_hyper_vcpu_context *vcc;
+	int i, j;
+
+	if (!vcpu) {
+		return NULL;
+	}
+	for (i = 0, vcca = xhvct->vcpu_context_arrays;
+		i < xhvct->vcpu_context_arrays_cnt; i++, vcca++) {
+		for (j = 0, vcc = vcca->context_array;
+			j < vcca->context_array_cnt; j++, vcc++) {
+			if (vcpu == vcc->vcpu) {
+				return vcc;
+			}
+		}
+	}
+	return NULL;
+}
+
+/*
+ * Get vcpu context.
+ */
+struct xen_hyper_vcpu_context *
+xen_hyper_id_to_vcpu_context(ulong domain, domid_t did, int vcid)
+{
+	struct xen_hyper_vcpu_context_array *vcca;
+	struct xen_hyper_vcpu_context *vcc;
+	int i;
+
+	if (vcid == XEN_HYPER_VCPU_ID_INVALID) {
+		return NULL;
+	}
+	if ((vcca = xen_hyper_domain_to_vcpu_context_array(domain))) {
+		;
+	} else if (!(vcca = xen_hyper_domid_to_vcpu_context_array(did))) {
+		return NULL;
+	}
+	for (i = 0, vcc = vcca->context_array;
+		i < vcca->context_array_cnt; i++, vcc++) {
+		if (vcid == vcc->vcpu_id) {
+			return vcc;
+		}
+	}
+	return NULL;
+}
+
+/*
+ * Get pointer of a vcpu context array from domain address.
+ */
+struct xen_hyper_vcpu_context_array *
+xen_hyper_domain_to_vcpu_context_array(ulong domain)
+{
+	struct xen_hyper_domain_context *dc;
+
+	if(!(dc = xen_hyper_domain_to_domain_context(domain))) {
+		return NULL;
+	}
+	return dc->vcpu_context_array;
+}
+
+/*
+ * Get pointer of a vcpu context array from domain id.
+ */
+struct xen_hyper_vcpu_context_array *
+xen_hyper_domid_to_vcpu_context_array(domid_t id)
+{
+	struct xen_hyper_domain_context *dc;
+
+	if (!(dc = xen_hyper_id_to_domain_context(id))) {
+		return NULL;
+	}
+	return dc->vcpu_context_array;
+}
+
+/*
+ * Store vcpu struct contents.
+ */
+struct xen_hyper_vcpu_context *
+xen_hyper_store_vcpu_context(struct xen_hyper_vcpu_context *vcc,
+       ulong vcpu, char *vcp)
+{
+	vcc->vcpu = vcpu;
+	vcc->vcpu_id = INT(vcp + XEN_HYPER_OFFSET(vcpu_vcpu_id));
+	vcc->processor = INT(vcp + XEN_HYPER_OFFSET(vcpu_processor));
+	vcc->vcpu_info = ULONG(vcp + XEN_HYPER_OFFSET(vcpu_vcpu_info));
+	vcc->domain = ULONG(vcp + XEN_HYPER_OFFSET(vcpu_domain));
+	vcc->next_in_list = ULONG(vcp + XEN_HYPER_OFFSET(vcpu_next_in_list));
+	vcc->sleep_tick = ULONG(vcp + XEN_HYPER_OFFSET(vcpu_sleep_tick));
+	vcc->sched_priv = ULONG(vcp + XEN_HYPER_OFFSET(vcpu_sched_priv));
+	vcc->state = INT(vcp + XEN_HYPER_OFFSET(vcpu_runstate) +
+		XEN_HYPER_OFFSET(vcpu_runstate_info_state));
+	vcc->state_entry_time = ULONGLONG(vcp +
+		XEN_HYPER_OFFSET(vcpu_runstate) +
+		XEN_HYPER_OFFSET(vcpu_runstate_info_state_entry_time));
+	vcc->runstate_guest = ULONG(vcp + XEN_HYPER_OFFSET(vcpu_runstate_guest));
+	vcc->vcpu_flags = ULONG(vcp + XEN_HYPER_OFFSET(vcpu_vcpu_flags));
+	return vcc;
+}
+
+/*
+ * Read vcpu struct from vcpu context.
+ */
+char *
+xen_hyper_read_vcpu_from_context(struct xen_hyper_vcpu_context *vcc)
+{
+	return xen_hyper_fill_vcpu_struct(vcc->vcpu, xhvct->vcpu_struct);
+}
+
+/*
+ * Read vcpu struct.
+ */
+char *
+xen_hyper_read_vcpu(ulong vcpu)
+{
+	return xen_hyper_fill_vcpu_struct(vcpu, xhvct->vcpu_struct);
+}
+
+/*
+ * Read vcpu struct to verification.
+ */
+char *
+xen_hyper_read_vcpu_verify(ulong vcpu)
+{
+	return xen_hyper_fill_vcpu_struct(vcpu, xhvct->vcpu_struct_verify);
+}
+
+/*
+ * Fill vcpu struct.
+ */
+char *
+xen_hyper_fill_vcpu_struct(ulong vcpu, char *vcpu_struct)
+{
+	if (!readmem(vcpu, KVADDR, vcpu_struct,
+		XEN_HYPER_SIZE(vcpu), "fill_vcpu_struct",
+	       	ACTIVE() ? (RETURN_ON_ERROR|QUIET) : RETURN_ON_ERROR)) {
+		error(WARNING, "cannot fill vcpu struct.\n");
+		return NULL;
+	}
+	return vcpu_struct;
+}
+
+/*
+ * Allocate vcpu context arrays space.
+ */
+void
+xen_hyper_alloc_vcpu_context_arrays_space(int domains)
+{
+	struct xen_hyper_vcpu_context_array *vcca;
+
+	if (xhvct->vcpu_context_arrays == NULL) {
+		if (!(xhvct->vcpu_context_arrays =
+			malloc(domains * sizeof(struct xen_hyper_vcpu_context_array)))) {
+			error(FATAL, "cannot malloc context arrays (%d domains).",
+				domains);
+		}
+		xhvct->vcpu_context_arrays_cnt = domains;
+		BZERO(xhvct->vcpu_context_arrays, domains * sizeof(struct xen_hyper_vcpu_context_array));
+	} else if (domains > xhvct->vcpu_context_arrays_cnt) {
+		if (!(xhvct->vcpu_context_arrays =
+			realloc(xhvct->vcpu_context_arrays,
+				domains * sizeof(struct xen_hyper_vcpu_context_array)))) {
+			error(FATAL, "cannot realloc context arrays (%d domains).",
+				domains);
+		}
+		vcca = xhvct->vcpu_context_arrays + domains;
+		BZERO(vcca, (domains - xhvct->vcpu_context_arrays_cnt) *
+			sizeof(struct xen_hyper_vcpu_context_array));
+		xhvct->vcpu_context_arrays_cnt = domains;
+	}
+}
+
+/*
+ * Allocate vcpu context space.
+ */
+void
+xen_hyper_alloc_vcpu_context_space(struct xen_hyper_vcpu_context_array *vcca, int vcpus)
+{
+	if (vcca->context_array == NULL) {
+		if (!(vcca->context_array =
+			malloc(vcpus * sizeof(struct xen_hyper_vcpu_context)))) {
+			error(FATAL, "cannot malloc context array (%d vcpus).",
+				vcpus);
+		}
+		vcca->context_array_cnt = vcpus;
+	} else if (vcpus > vcca->context_array_cnt) {
+		if (!(vcca->context_array =
+			realloc(vcca->context_array,
+				vcpus * sizeof(struct xen_hyper_vcpu_context_array)))) {
+			error(FATAL, "cannot realloc context array (%d vcpus).",
+				vcpus);
+		}
+		vcca->context_array_cnt = vcpus;
+	}
+	vcca->context_array_valid = vcpus;
+	BZERO(vcca->context_array, vcpus * sizeof(struct xen_hyper_vcpu_context));
+}
+
+
+
+/*
+ * Get pcpu context from pcpu id.
+ */
+struct xen_hyper_pcpu_context *
+xen_hyper_id_to_pcpu_context(uint id)
+{
+	struct xen_hyper_pcpu_context *pcc;
+	int i;
+
+	if (xhpct->context_array == NULL) {
+		return NULL;
+	}
+	if (id == XEN_HYPER_PCPU_ID_INVALID) {
+		return NULL;
+	}
+	for (i = 0, pcc = xhpct->context_array; i < XEN_HYPER_MAX_PCPUS();
+		i++, pcc++) {
+		if (id == pcc->processor_id) {
+			return pcc;
+		}
+	}
+	return NULL;
+}
+
+/*
+ * Get pcpu context from pcpu address.
+ */
+struct xen_hyper_pcpu_context *
+xen_hyper_pcpu_to_pcpu_context(ulong pcpu)
+{
+	struct xen_hyper_pcpu_context *pcc;
+	int i;
+
+	if (xhpct->context_array == NULL) {
+		return NULL;
+	}
+	if (!pcpu) {
+		return NULL;
+	}
+	for (i = 0, pcc = xhpct->context_array; i < XEN_HYPER_MAX_PCPUS();
+		i++, pcc++) {
+		if (pcpu == pcc->pcpu) {
+			return pcc;
+		}
+	}
+	return NULL;
+}
+
+/*
+ * Store pcpu struct contents.
+ */
+struct xen_hyper_pcpu_context *
+xen_hyper_store_pcpu_context(struct xen_hyper_pcpu_context *pcc,
+       ulong pcpu, char *pcp)
+{
+	pcc->pcpu = pcpu;
+	pcc->processor_id =
+		UINT(pcp + XEN_HYPER_OFFSET(cpu_info_processor_id));
+	pcc->guest_cpu_user_regs = (ulong)(pcpu +
+			XEN_HYPER_OFFSET(cpu_info_guest_cpu_user_regs));
+	pcc->current_vcpu =
+		ULONG(pcp + XEN_HYPER_OFFSET(cpu_info_current_vcpu));
+	return pcc;
+}
+
+/*
+ * Read pcpu struct.
+ */
+char *
+xen_hyper_read_pcpu(ulong pcpu)
+{
+	return xen_hyper_fill_pcpu_struct(pcpu, xhpct->pcpu_struct);
+}
+
+/*
+ * Fill pcpu struct.
+ */
+char *
+xen_hyper_fill_pcpu_struct(ulong pcpu, char *pcpu_struct)
+{
+	if (!readmem(pcpu, KVADDR, pcpu_struct,
+		XEN_HYPER_SIZE(cpu_info), "fill_pcpu_struct",
+	       	ACTIVE() ? (RETURN_ON_ERROR|QUIET) : RETURN_ON_ERROR)) {
+		error(WARNING, "cannot fill pcpu_struct.\n");
+		return NULL;
+	}
+	return pcpu_struct;
+}
+
+/*
+ * Allocate pcpu context space.
+ */
+void
+xen_hyper_alloc_pcpu_context_space(int pcpus)
+{
+	if (xhpct->context_array == NULL) {
+		if (!(xhpct->context_array =
+			malloc(pcpus * sizeof(struct xen_hyper_pcpu_context)))) {
+			error(FATAL, "cannot malloc context array (%d pcpus).",
+				pcpus);
+		}
+	}
+	BZERO(xhpct->context_array, pcpus * sizeof(struct xen_hyper_pcpu_context));
+}
+
+
+
+/*
+ * Fill cpu_data.
+ * ia64 has difference cpu_data format.
+ */
+char *
+xen_hyper_fill_cpu_data_x86(int idx, char *cpuinfo_x86)
+{
+	ulong cpu_data_base, cpu_data;
+
+	cpu_data_base = symbol_value("cpu_data");
+	cpu_data = cpu_data_base + XEN_HYPER_SIZE(cpuinfo_x86) *idx;
+	if (!readmem(cpu_data, KVADDR, cpuinfo_x86, XEN_HYPER_SIZE(cpuinfo_x86),
+		"cpu_data", RETURN_ON_ERROR)) {
+		error(WARNING, "cannot read cpu_data.\n");
+		return NULL;
+	}
+	return cpuinfo_x86;
+}
+
+/*
+ * Return whether vcpu is crashing.
+ */
+int
+is_xen_hyper_vcpu_crash(struct xen_hyper_vcpu_context *vcc)
+{
+	if (vcc == xht->crashing_vcc)
+		return TRUE;
+	return FALSE;
+}
+
+
+
+/*
+ *  Calculate and return the uptime.
+ */
+ulonglong
+get_uptime_hyper(void)
+{
+	ulong jiffies, tmp1, tmp2;
+	ulonglong jiffies_64, wrapped;
+
+	if (symbol_exists("jiffies_64")) {
+		get_symbol_data("jiffies_64", sizeof(ulonglong), &jiffies_64);
+		wrapped = (jiffies_64 & 0xffffffff00000000ULL);
+		if (wrapped) {
+			wrapped -= 0x100000000ULL;
+			jiffies_64 &= 0x00000000ffffffffULL;
+			jiffies_64 |= wrapped;
+               		jiffies_64 += (ulonglong)(300*machdep->hz);
+		} else {
+			tmp1 = (ulong)(uint)(-300*machdep->hz);
+			tmp2 = (ulong)jiffies_64;
+			jiffies_64 = (ulonglong)(tmp2 - tmp1);
+		}
+	} else {
+		get_symbol_data("jiffies", sizeof(long), &jiffies);
+		jiffies_64 = (ulonglong)jiffies;
+	}
+
+	return jiffies_64;
+}
+
+/*
+ * Calculate a number of physical cpu.
+ */
+int
+x86_get_smp_cpus_hyper(void)
+{
+	ulong vaddr;
+	long cpuinfo_x86_x86_max_cores;
+	long cpuinfo_x86_booted_cores;
+	int total_x86_max_cores, total_booted_cores;
+	char *cpu_data;
+	int i;
+
+	if (xht->pcpus) {
+		return xht->pcpus;
+	}
+	vaddr = symbol_value("cpu_data");
+	cpu_data = GETBUF(XEN_HYPER_SIZE(cpuinfo_x86));	
+	cpuinfo_x86_x86_max_cores = MEMBER_OFFSET("cpuinfo_x86", "x86_max_cores");
+	cpuinfo_x86_booted_cores = MEMBER_OFFSET("cpuinfo_x86", "booted_cores");
+	total_x86_max_cores = 0;
+	total_booted_cores = 0;
+	for (i = 0; i < xht->max_cpus; i++) {
+		xen_hyper_fill_cpu_data_x86(i, cpu_data);
+		total_x86_max_cores +=
+			*(cpu_data + cpuinfo_x86_x86_max_cores);
+		total_booted_cores +=
+			*(cpu_data + cpuinfo_x86_booted_cores);
+	}
+	xht->cores = total_x86_max_cores;
+	xht->pcpus = total_booted_cores;
+	FREEBUF(cpu_data);
+	return xht->pcpus;
+}
+
+/*
+ * Calculate used memory size.
+ */
+uint64_t
+x86_memory_size_hyper(void)
+{
+	ulong vaddr;
+
+	if (machdep->memsize) {
+		return machdep->memsize;
+	}
+	vaddr = symbol_value("max_page");
+	if (!readmem(vaddr, KVADDR, &xht->max_page, sizeof(xht->max_page),
+		"max_page", RETURN_ON_ERROR)) {
+		error(WARNING, "cannot read max_page.\n");
+	}
+	machdep->memsize = (uint64_t)(xht->max_page) * (uint64_t)(machdep->pagesize);
+	return machdep->memsize;
+}
+
+
+
+/*
+ * Print with aligned string in specified length.
+ */
+void
+xen_hyper_fpr_indent(FILE *fp, int len, char *str1, char *str2, int flag)
+{
+	char buf[XEN_HYPER_CMD_BUFSIZE];
+	int sl, r;
+	char *s1, *s2;
+
+	sl = strlen(str1);
+	if (sl > len) {
+		r = 0;
+	} else {
+		r = len - sl;
+	}
+
+	memset(buf, ' ', sizeof(buf));
+	buf[r] =  '\0';
+	if (flag == XEN_HYPER_PRI_L) {
+		s1 = str1;
+		s2 = buf;
+	} else {
+		s1 = buf;
+		s2 = str1;
+	}
+	if (str2) {
+		fprintf(fp, "%s%s%s", s1, s2, str2);
+	} else {
+		fprintf(fp, "%s%s", s1, s2);
+	}
+}
+
+void
+print_pcpu_header_hyper(FILE *out, int pcpu, int newline)
+{
+	if (newline)
+		fprintf(out, "\n");
+	fprintf(out, "PCPU: %2d\n", pcpu);
+}
+#endif
diff -purN crash-4.0-3.9/xen_hyper_command.c crash-4.0-3.14/xen_hyper_command.c
--- crash-4.0-3.9/xen_hyper_command.c	1970-01-01 01:00:00.000000000 +0100
+++ crash-4.0-3.14/xen_hyper_command.c	2006-12-01 21:39:42.000000000 +0100
@@ -0,0 +1,1584 @@
+/*
+ *  xen_hyper_command.c
+ *
+ *  Portions Copyright (C) 2006 Fujitsu Limited
+ *  Portions Copyright (C) 2006 VA Linux Systems Japan K.K.
+ *
+ *  This file is part of Xencrash.
+ *
+ *  Xencrash 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 (version 2 of the License).
+ *
+ *  Xencrash 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.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Xencrash; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA.
+ */
+
+#include "defs.h"
+
+#ifdef XEN_HYPERVISOR_ARCH
+#include "xen_hyper_defs.h"
+
+#ifdef X86
+char *xhregt[] = {
+	"ebx", "ecx", "edx", "esi", "edi", "ebp", "eax", "ds", "es",
+	"fs", "gs", "orig_eax", "eip", "cs", "eflags", "esp", "ss",
+	NULL
+};
+#endif
+
+#ifdef X86_64
+char *xhregt[] = {
+	"r15", "r14", "r13", "r12", "rbp", "rbx", "r11", "r10", "r9",
+	"r8", "rax", "rcx", "rdx", "rsi", "rdi", "rip", "cs", "eflags",
+	"rsp", "ss", "fs", "gs", "ds", "es", "fs", "gs",
+	NULL
+};
+#endif
+
+static void do_xen_hyper_domain(struct domain_args *da);
+static void do_xen_hyper_doms(struct domain_args *da);
+static void show_xen_hyper_doms(struct xen_hyper_domain_context *dc);
+static void do_xen_hyper_dumpinfo(ulong flag, struct dumpinfo_args *ena);
+static void show_xen_hyper_dumpinfo(ulong flag,
+	struct xen_hyper_dumpinfo_context *enc);
+static void do_xen_hyper_pcpus(ulong flag, struct pcpu_args *pca);
+static void show_xen_hyper_pcpus(ulong flag, struct xen_hyper_pcpu_context *pcc);
+static void do_xen_hyper_vcpu(struct vcpu_args *vca);
+static void do_xen_hyper_vcpus(struct vcpu_args *vca);
+static void show_xen_hyper_vcpus(struct xen_hyper_vcpu_context *vcc);
+static char *xen_hyper_domain_to_type(ulong domain, int *type, char *buf, int verbose);
+static char *xen_hyper_domain_context_to_type(
+	struct xen_hyper_domain_context *dc, int *type, char *buf, int verbose);
+static int xen_hyper_str_to_domain_context(char *string, ulong *value,
+	struct xen_hyper_domain_context **dcp);
+static int xen_hyper_str_to_dumpinfo_context(char *string, ulong *value, struct xen_hyper_dumpinfo_context **encp);
+static int xen_hyper_strvcpu_to_vcpu_context(char *string, ulong *value,
+	struct xen_hyper_vcpu_context **vccp);
+static int
+xen_hyper_strid_to_vcpu_context(char *strdom, char *strvc, ulong *valdom,
+	ulong *valvc, struct xen_hyper_vcpu_context **vccp);
+static int xen_hyper_str_to_pcpu_context(char *string, ulong *value,
+	struct xen_hyper_pcpu_context **pccp);
+
+/*
+ *  Display domain struct.
+ */
+void
+cmd_xen_hyper_domain(void)
+{
+	struct xen_hyper_domain_context *dc;
+	struct domain_args da;
+	ulong val;
+        int c, cnt, type, bogus;
+
+	BZERO(&da, sizeof(struct domain_args));
+        while ((c = getopt(argcnt, args, "")) != EOF) {
+                switch(c)
+                {
+                default:
+                        argerrs++;
+                        break;
+                }
+        }
+
+        if (argerrs)
+                cmd_usage(pc->curcmd, SYNOPSIS);
+
+	cnt = bogus = 0;
+        while (args[optind]) {
+		if (IS_A_NUMBER(args[optind])) {
+			type = xen_hyper_str_to_domain_context(args[optind], &val, &dc);
+			switch (type) {
+			case XEN_HYPER_STR_DID:
+			case XEN_HYPER_STR_DOMAIN:
+				da.value[cnt] = val;
+				da.type[cnt] = type;
+				da.domain[cnt] = dc->domain;
+				da.dc[cnt] = dc;
+				cnt++;
+				break;
+			case XEN_HYPER_STR_INVALID:
+				error(INFO, "invalid domain or id value: %s\n\n",
+					args[optind]);
+				bogus++;
+			}
+		} else {
+			error(FATAL, "invalid address: %s\n",
+				args[optind]);
+		}
+		optind++;
+	}
+	da.cnt = cnt;
+	if (bogus && !cnt) {
+		return;
+	}
+	
+	do_xen_hyper_domain(&da);
+}
+
+/*
+ *  Do the work requested by cmd_xen_hyper_dom().
+ */
+static void
+do_xen_hyper_domain(struct domain_args *da)
+{
+	int i;
+
+	if (da->cnt) {
+		if (da->cnt == 1) {
+			xhdt->last = da->dc[0];
+		}
+		for (i = 0; i < da->cnt; i++) {
+			dump_struct("domain", da->domain[i], 0);
+		}
+	} else {
+		dump_struct("domain", xhdt->last->domain, 0);
+	}
+}
+
+/*
+ *  Display domain status.
+ */
+void
+cmd_xen_hyper_doms(void)
+{
+	struct xen_hyper_domain_context *dc;
+	struct domain_args da;
+	ulong val;
+        int c, cnt, type, bogus;
+
+	BZERO(&da, sizeof(struct domain_args));
+        while ((c = getopt(argcnt, args, "")) != EOF) {
+                switch(c)
+                {
+                default:
+                        argerrs++;
+                        break;
+                }
+        }
+
+        if (argerrs)
+                cmd_usage(pc->curcmd, SYNOPSIS);
+
+	cnt = bogus = 0;
+        while (args[optind]) {
+		if (IS_A_NUMBER(args[optind])) {
+			type = xen_hyper_str_to_domain_context(args[optind], &val, &dc);
+			switch (type) {
+			case XEN_HYPER_STR_DID:
+			case XEN_HYPER_STR_DOMAIN:
+				da.value[cnt] = val;
+				da.type[cnt] = type;
+				da.domain[cnt] = dc->domain;
+				da.dc[cnt] = dc;
+				cnt++;
+				break;
+			case XEN_HYPER_STR_INVALID:
+				error(INFO, "invalid domain or id value: %s\n\n",
+					args[optind]);
+				bogus++;
+			}
+		} else {
+			error(FATAL, "invalid address: %s\n",
+				args[optind]);
+		}
+		optind++;
+	}
+	da.cnt = cnt;
+	if (bogus && !cnt) {
+		return;
+	}
+	
+	do_xen_hyper_doms(&da);
+}
+
+/*
+ *  Do the work requested by cmd_xen_hyper_doms().
+ */
+static void
+do_xen_hyper_doms(struct domain_args *da)
+{
+	struct xen_hyper_domain_context *dca;
+	char buf1[XEN_HYPER_CMD_BUFSIZE];
+	int i;
+
+	fprintf(fp,
+		"   DID  %s ST T %%MMEM %%TMEM VCPU\n",
+		mkstring(buf1, VADDR_PRLEN, CENTER|RJUST, "DOMAIN"));
+	if (da->cnt) {
+		for (i = 0; i < da->cnt; i++) {
+			show_xen_hyper_doms(da->dc[i]);
+		}
+	} else {
+		for (i = 0, dca=xhdt->context_array; i < XEN_HYPER_MAX_DOMAINS();
+			i++, dca++) {
+			show_xen_hyper_doms(dca);
+		}
+	}
+}
+
+static void
+show_xen_hyper_doms(struct xen_hyper_domain_context *dc)
+{
+	double mmem, tmem;
+	char *act, *crash;
+	int type, i, j;
+	struct xen_hyper_pcpu_context *pcc;
+	char buf1[XEN_HYPER_CMD_BUFSIZE];
+	char buf2[XEN_HYPER_CMD_BUFSIZE];
+
+	if (!(dc->domain)) {
+		return;
+	}
+
+	act = NULL;
+	for (i = 0, pcc = xhpct->context_array; i < xht->pcpus; i++, pcc++) {
+		for (j = 0; j < dc->vcpu_cnt; j++) {
+			if (pcc->current_vcpu == dc->vcpu[j]) {
+				act = ">";
+				break;
+			}
+		}
+		if (act)	break;
+	}
+	if (act == NULL)	act = " ";
+	if (xht->crashing_vcc && dc->domain == xht->crashing_vcc->domain) {
+		crash = "*";
+	} else {
+		crash = " ";
+	}
+	if (dc->max_pages == -1) {
+		mmem = 100;
+	} else {
+		mmem = (double)(dc->max_pages) /
+			(double)(xht->max_page) * (double)100;
+	}
+	tmem = (double)(dc->tot_pages) /
+		(double)(xht->max_page) * (double)100;
+	sprintf(buf1, "%s%s%5d ", act, crash, dc->domain_id);
+	mkstring(&buf1[strlen(buf1)], VADDR_PRLEN, CENTER|LONG_HEX|RJUST, (char *)(dc->domain));
+	strncat(buf1, " ", XEN_HYPER_CMD_BUFSIZE-strlen(buf1)-1);
+	sprintf(&buf1[strlen(buf1)], "%s ",
+		xen_hyper_domain_state_string(dc, buf2, !VERBOSE));
+	sprintf(&buf1[strlen(buf1)], "%s ",
+		xen_hyper_domain_context_to_type(dc, &type, buf2, !VERBOSE));
+
+	sprintf(buf2, "%3.1f", mmem);
+	mkstring(&buf1[strlen(buf1)], 5, RJUST, buf2);
+	strncat(buf1, " ", XEN_HYPER_CMD_BUFSIZE-strlen(buf1)-1);
+
+	sprintf(buf2, "%3.1f", tmem);
+	mkstring(&buf1[strlen(buf1)], 5, RJUST, buf2);
+
+	fprintf(fp, "%s %3d\n", buf1, dc->vcpu_cnt);
+}
+
+/*
+ * Display ELF Notes information.
+ */
+void
+cmd_xen_hyper_dumpinfo(void)
+{
+	struct dumpinfo_args ena;
+	ulong flag;
+	ulong val;
+	struct xen_hyper_dumpinfo_context *enc;
+	int c, cnt, type, bogus;
+
+	BZERO(&ena, sizeof(struct cmd_args));
+	flag= 0;
+        while ((c = getopt(argcnt, args, "rt")) != EOF) {
+                switch(c)
+                {
+		case 't':
+			flag |= XEN_HYPER_DUMPINFO_TIME;
+                        break;
+		case 'r':
+			flag |= XEN_HYPER_DUMPINFO_REGS;
+                        break;
+                default:
+                        argerrs++;
+                        break;
+                }
+        }
+
+        if (argerrs)
+                cmd_usage(pc->curcmd, SYNOPSIS);
+
+	cnt = bogus = 0;
+        while (args[optind]) {
+		if (IS_A_NUMBER(args[optind])) {
+			type = xen_hyper_str_to_dumpinfo_context(args[optind], &val, &enc);
+			switch (type)
+			{
+			case XEN_HYPER_STR_PCID:
+			case XEN_HYPER_STR_ADDR:
+				ena.value[cnt] = val;
+				ena.type[cnt] = type;
+				ena.enc[cnt] = enc;
+				cnt++;
+				break;
+
+			case XEN_HYPER_STR_INVALID:
+				error(INFO, "invalid note address or id "
+					"value: %s\n\n", args[optind]);
+				bogus++;
+				break;
+			}
+		} else {
+			error(INFO, "invalid note address or id "
+				"value: %s\n\n", args[optind]);
+		}
+		optind++;
+	}
+	ena.cnt = cnt;
+	if (!cnt && bogus) {
+		return;
+	}
+	
+	do_xen_hyper_dumpinfo(flag, &ena);
+}
+
+/*
+ * Do the work requested by cmd_xen_hyper_dumpinfo().
+ */
+static void
+do_xen_hyper_dumpinfo(ulong flag, struct dumpinfo_args *ena)
+{
+	struct xen_hyper_dumpinfo_context *enc;
+	char buf[XEN_HYPER_CMD_BUFSIZE];
+	int i, cnt;
+
+	if (ena->cnt) {
+		cnt = ena->cnt;
+	} else {
+		cnt = xht->pcpus;
+	}
+	for (i = 0; i < cnt; i++) {
+		if (i == 0 || flag & XEN_HYPER_DUMPINFO_REGS ||
+			flag & XEN_HYPER_DUMPINFO_TIME) {
+			if (i) {
+				fprintf(fp, "\n");
+			}
+			sprintf(buf, " PCID ");
+			mkstring(&buf[strlen(buf)], VADDR_PRLEN, CENTER|RJUST, "ENOTE");
+			sprintf(&buf[strlen(buf)], "  PID   PPID  PGRP  SID");
+			fprintf(fp, "%s\n", buf);
+		}
+		if (ena->cnt) {
+			enc = ena->enc[i];
+		} else {
+			enc = &xhdit->context[i];
+		}
+		show_xen_hyper_dumpinfo(flag, enc);
+	}
+}
+
+static void
+show_xen_hyper_dumpinfo(ulong flag, struct xen_hyper_dumpinfo_context *enc)
+{
+	char buf[XEN_HYPER_CMD_BUFSIZE];
+	char *note_buf;
+	ulong addr;
+	ulong *regs;
+	long tv_sec, tv_usec;
+	int pid, i, regcnt;
+
+	if (!enc->note) {
+		return;
+	}
+
+	note_buf = enc->ELF_Prstatus_ptr;
+	sprintf(buf, "%5d ", enc->pcpu_id);
+	mkstring(&buf[strlen(buf)], VADDR_PRLEN, CENTER|LONG_HEX|RJUST,
+		(char *)(enc->note));
+
+	pid = INT(note_buf + XEN_HYPER_OFFSET(ELF_Prstatus_pr_pid));
+	sprintf(&buf[strlen(buf)], " %5d ", pid);
+	pid = INT(note_buf + XEN_HYPER_OFFSET(ELF_Prstatus_pr_ppid));
+	sprintf(&buf[strlen(buf)], "%5d ", pid);
+	pid = INT(note_buf + XEN_HYPER_OFFSET(ELF_Prstatus_pr_pgrp));
+	sprintf(&buf[strlen(buf)], "%5d ", pid);
+	pid = INT(note_buf + XEN_HYPER_OFFSET(ELF_Prstatus_pr_sid));
+	sprintf(&buf[strlen(buf)], "%5d", pid);
+
+	fprintf(fp, "%s\n", buf);
+
+	if (flag & XEN_HYPER_DUMPINFO_TIME) {
+		sprintf(buf, "             ");
+		mkstring(&buf[strlen(buf)], VADDR_PRLEN, CENTER|RJUST, "tv_sec");
+		strncat(buf, " ", XEN_HYPER_CMD_BUFSIZE-strlen(buf)-1);
+		mkstring(&buf[strlen(buf)], VADDR_PRLEN, CENTER|RJUST, "tv_usec");
+		fprintf(fp, "%s\n", buf);
+
+		addr = (ulong)note_buf +
+			XEN_HYPER_OFFSET(ELF_Prstatus_pr_utime);
+		for (i = 0; i < 4; i++, addr+XEN_HYPER_SIZE(ELF_Timeval)) {
+			switch (i)
+			{
+			case 0: 
+				sprintf(buf, "  pr_utime   ");
+				break;
+			case 1: 
+				sprintf(buf, "  pr_stime   ");
+				break;
+			case 2: 
+				sprintf(buf, "  pr_cutime  ");
+				break;
+			case 3: 
+				sprintf(buf, "  pr_cstime  ");
+				break;
+			}
+			tv_sec = LONG(addr +
+				XEN_HYPER_OFFSET(ELF_Timeval_tv_sec));
+			tv_usec = LONG(addr +
+				XEN_HYPER_OFFSET(ELF_Timeval_tv_sec) +
+				XEN_HYPER_OFFSET(ELF_Timeval_tv_usec));
+			mkstring(&buf[strlen(buf)], VADDR_PRLEN, CENTER|LONG_HEX|RJUST,
+				(char *)(tv_sec));
+			strncat(buf, " ", XEN_HYPER_CMD_BUFSIZE-strlen(buf)-1);
+			mkstring(&buf[strlen(buf)], VADDR_PRLEN, CENTER|LONG_HEX|RJUST,
+				(char *)(tv_sec));
+			fprintf(fp, "%s\n", buf);
+		}
+	}
+
+	if (flag & XEN_HYPER_DUMPINFO_REGS) {
+		regcnt = XEN_HYPER_SIZE(ELF_Gregset) / sizeof(long);
+		addr = (ulong)note_buf +
+			XEN_HYPER_OFFSET(ELF_Prstatus_pr_reg);
+		regs = (ulong *)addr;
+		fprintf(fp, "Register information:\n");
+		for (i = 0; i < regcnt; i++, regs++) {
+			if (xhregt[i] == NULL) {
+				break;
+			}
+			fprintf(fp, "  %s = ", xhregt[i]);
+			fprintf(fp, "0x%s\n",
+				mkstring(buf, VADDR_PRLEN, LONG_HEX|LJUST, (char *)(*regs)));
+		}
+	}
+}
+
+/*
+ * Dump the Xen conring in chronological order.
+ */
+void
+cmd_xen_hyper_log(void)
+{
+	int c;
+
+        while ((c = getopt(argcnt, args, "")) != EOF) {
+                switch(c)
+                {
+                default:
+                        argerrs++;
+                        break;
+                }
+        }
+
+        if (argerrs)
+                cmd_usage(pc->curcmd, SYNOPSIS);
+	
+	dump_xen_hyper_log();
+}
+
+void
+dump_xen_hyper_log(void)
+{
+	uint conringc, conringp;
+	uint warp, start, len, idx, i;
+	ulong conring;
+	char *buf;
+	char last;
+
+	conring = symbol_value("conring");
+	get_symbol_data("conringc", sizeof(uint), &conringc);
+	get_symbol_data("conringp", sizeof(uint), &conringp);
+	warp = FALSE;
+	if (conringp >= XEN_HYPER_CONRING_SIZE) {
+		if ((start = conringp & (XEN_HYPER_CONRING_SIZE - 1))) {
+			warp = TRUE;
+		}
+	} else {
+		start = 0;
+	}
+
+	buf = GETBUF(XEN_HYPER_CONRING_SIZE);
+	readmem(conring, KVADDR, buf, XEN_HYPER_CONRING_SIZE,
+		"conring contents", FAULT_ON_ERROR);
+	idx = start;
+	len = XEN_HYPER_CONRING_SIZE;
+
+wrap_around:
+	for (i = idx; i < len; i++) {
+		if (buf[i]) {
+			fputc(ascii(buf[i]) ? buf[i] : '.', fp);
+			last = buf[i];
+		}
+	}
+	if (warp) {
+		len = idx;
+		idx = 0;
+		warp = FALSE;
+		goto wrap_around;
+	}
+	if (last != '\n') {
+		fprintf(fp, "\n");
+	}
+	FREEBUF(buf);
+}
+
+/*
+ *  Display physical cpu information.
+ */
+void
+cmd_xen_hyper_pcpus(void)
+{
+	struct xen_hyper_pcpu_context *pcc;
+	struct pcpu_args pca;
+	ulong flag;
+	ulong val;
+        int c, cnt, type, bogus;
+
+	BZERO(&pca, sizeof(struct pcpu_args));
+	flag= 0;
+        while ((c = getopt(argcnt, args, "r")) != EOF) {
+                switch(c)
+                {
+		case 'r':
+			flag |= XEN_HYPER_PCPUS_REGS;
+			break;
+                default:
+                        argerrs++;
+                        break;
+                }
+        }
+
+        if (argerrs)
+                cmd_usage(pc->curcmd, SYNOPSIS);
+
+	cnt = bogus = 0;
+        while (args[optind]) {
+		if (IS_A_NUMBER(args[optind])) {
+			type = xen_hyper_str_to_pcpu_context(args[optind], &val, &pcc);
+			switch (type) {
+			case XEN_HYPER_STR_PCID:
+			case XEN_HYPER_STR_PCPU:
+				pca.value[cnt] = val;
+				pca.type[cnt] = type;
+				pca.pcpu[cnt] = pcc->pcpu;
+				pca.pcc[cnt] = pcc;
+				cnt++;
+				break;
+			case XEN_HYPER_STR_INVALID:
+				error(INFO, "invalid pcpu or id value: %s\n\n",
+					args[optind]);
+				bogus++;
+			}
+		} else {
+			error(FATAL, "invalid address: %s\n",
+				args[optind]);
+		}
+		optind++;
+	}
+	pca.cnt = cnt;
+	if (bogus && !cnt) {
+		return;
+	}
+	
+	do_xen_hyper_pcpus(flag, &pca);
+}
+
+/*
+ *  Do the work requested by cmd_xen_hyper_pcpu().
+ */
+static void
+do_xen_hyper_pcpus(ulong flag, struct pcpu_args *pca)
+{
+	struct xen_hyper_pcpu_context *pcca;
+	int i;
+
+	if (pca->cnt) {
+		for (i = 0; i < pca->cnt; i++) {
+			show_xen_hyper_pcpus(flag, pca->pcc[i]);
+			flag |= XEN_HYPER_PCPUS_1STCALL;
+		}
+	} else {
+		for (i = 0, pcca=xhpct->context_array; i < XEN_HYPER_MAX_PCPUS();
+			i++, pcca++) {
+			show_xen_hyper_pcpus(flag, pcca);
+			flag |= XEN_HYPER_PCPUS_1STCALL;
+		}
+	}
+}
+
+static void
+show_xen_hyper_pcpus(ulong flag, struct xen_hyper_pcpu_context *pcc)
+{
+	char *act = "  ";
+	char buf[XEN_HYPER_CMD_BUFSIZE];
+
+	if (!(pcc->pcpu)) {
+		return;
+	}
+	if (xht->crashing_cpu == pcc->processor_id) {
+		act = " *";
+	}
+	if ((flag & XEN_HYPER_PCPUS_REGS) ||
+	(!(flag & XEN_HYPER_PCPUS_REGS) && !(flag & XEN_HYPER_PCPUS_1STCALL))) {
+		sprintf(buf, "   PCID ");
+		mkstring(&buf[strlen(buf)], VADDR_PRLEN, CENTER|RJUST, "PCPU");
+		strncat(buf, " ", XEN_HYPER_CMD_BUFSIZE-strlen(buf)-1);
+		mkstring(&buf[strlen(buf)], VADDR_PRLEN, CENTER|RJUST, "CUR-VCPU");
+		fprintf(fp, "%s\n", buf);
+	}
+
+	sprintf(buf, "%s%5d ", act, pcc->processor_id);
+	mkstring(&buf[strlen(buf)], VADDR_PRLEN, CENTER|LONG_HEX|RJUST, (char *)(pcc->pcpu));
+	strncat(buf, " ", XEN_HYPER_CMD_BUFSIZE-strlen(buf)-1);
+	mkstring(&buf[strlen(buf)], VADDR_PRLEN, CENTER|LONG_HEX|RJUST,
+		(char *)(pcc->current_vcpu));
+	fprintf(fp, "%s\n", buf);
+	if (flag & XEN_HYPER_PCPUS_REGS) {
+		fprintf(fp, "\nRegister information:\n");
+		dump_struct("cpu_user_regs", pcc->guest_cpu_user_regs, 0);
+	}
+}
+
+/*
+ *  Display general system info.
+ */
+void
+cmd_xen_hyper_sys(void)
+{
+        int c;
+	ulong sflag;
+
+	sflag = FALSE;
+
+        while ((c = getopt(argcnt, args, "c")) != EOF) {
+                switch(c)
+                {
+		case 'c':
+			sflag = TRUE;
+			break;
+
+                default:
+                        argerrs++;
+                        break;
+                }
+        }
+
+        if (argerrs)
+                cmd_usage(pc->curcmd, SYNOPSIS);
+
+        if (!args[optind]) {
+		if (sflag)
+			fprintf(fp, "No support argument\n");
+			/* display config info here. */
+		else
+			display_xen_hyper_sys_stats();
+		return;
+	}
+}
+
+/*
+ *  Display system stats at init-time or for the sys command.
+ */
+void
+display_xen_hyper_sys_stats(void)
+{
+        struct new_utsname *uts;
+        char buf1[XEN_HYPER_CMD_BUFSIZE];
+        char buf2[XEN_HYPER_CMD_BUFSIZE];
+	ulong mhz;
+	int len, flag;
+
+	uts = &xht->utsname;
+	len = 11;
+	flag = XEN_HYPER_PRI_R;
+
+        /*
+         *  It's now safe to unlink the remote namelist.
+         */
+        if (pc->flags & UNLINK_NAMELIST) {
+                unlink(pc->namelist);
+                pc->flags &= ~UNLINK_NAMELIST;
+                pc->flags |= NAMELIST_UNLINKED;
+        }
+
+	if (REMOTE()) {
+		switch (pc->flags & 
+			(NAMELIST_LOCAL|NAMELIST_UNLINKED|NAMELIST_SAVED))
+		{
+		case NAMELIST_UNLINKED:
+			XEN_HYPER_PRI(fp, len, "KERNEL: ", buf1, flag,
+				(buf1, "%s  (temporary)\n", pc->namelist));
+			break;
+
+		case (NAMELIST_UNLINKED|NAMELIST_SAVED):
+		case NAMELIST_LOCAL:
+			XEN_HYPER_PRI(fp, len, "KERNEL: ", buf1, flag,
+				(buf1, "%s\n", pc->namelist));
+			break;
+
+		}
+	} else {
+        	if (pc->system_map) {
+			XEN_HYPER_PRI(fp, len, "SYSTEM MAP: ", buf1, flag,
+				(buf1, "%s\n", pc->system_map));
+			XEN_HYPER_PRI(fp, len, "DEBUG KERNEL: ", buf1, flag,
+				(buf1, "%s\n", pc->namelist));
+		} else {
+			XEN_HYPER_PRI(fp, len, "KERNEL: ", buf1, flag,
+				(buf1, "%s\n", pc->namelist));
+		}
+	}
+
+	if (pc->debuginfo_file) {
+		XEN_HYPER_PRI(fp, len, "DEBUGINFO: ", buf1, flag,
+			(buf1, "%s\n", pc->debuginfo_file));
+	} else if (pc->namelist_debug) {
+		XEN_HYPER_PRI(fp, len, "DEBUG KERNEL: ", buf1, flag,
+			(buf1, "%s\n", pc->namelist_debug));
+	}
+
+	XEN_HYPER_PRI_CONS(fp, len, "DUMPFILE: ", flag);
+        if (ACTIVE()) {
+		if (REMOTE_ACTIVE()) 
+			fprintf(fp, "%s@%s  (remote live system)\n",
+			    	pc->server_memsrc, pc->server);
+		else
+                	fprintf(fp, "%s\n", pc->live_memsrc);
+	} else {
+		if (REMOTE_DUMPFILE())
+                	fprintf(fp, "%s@%s  (remote dumpfile)", 
+				pc->server_memsrc, pc->server);
+		else
+                	fprintf(fp, "%s", pc->dumpfile);
+
+		fprintf(fp, "\n");
+	}
+
+	XEN_HYPER_PRI(fp, len, "CPUS: ", buf1, flag,
+		(buf1, "%d\n", xht->pcpus));
+	XEN_HYPER_PRI(fp, len, "DOMAINS: ", buf1, flag,
+		(buf1, "%d\n", XEN_HYPER_MAX_DOMAINS()));
+	/* !!!Display a date here if it can be found. */
+	XEN_HYPER_PRI(fp, len, "UPTIME: ", buf1, flag,
+		(buf1, "%s\n", convert_time(get_uptime_hyper(), buf2)));
+	/* !!!Display a version here if it can be found. */
+	if (uts->machine) {
+		XEN_HYPER_PRI(fp, len, "MACHINE: ", buf1, flag,
+			(buf1, "%s  ", uts->machine));
+	} else {
+		XEN_HYPER_PRI_CONS(fp, len, "MACHINE: unknown  ", flag);
+	}
+	if ((mhz = machdep->processor_speed()))
+		fprintf(fp, "(%ld Mhz)\n", mhz);
+	else
+		fprintf(fp, "(unknown Mhz)\n");
+	XEN_HYPER_PRI(fp, len, "MEMORY: ", buf1, flag,
+		(buf1, "%s\n", get_memory_size(buf2)));
+	if (XENDUMP_DUMPFILE() && (kt->xen_flags & XEN_SUSPEND))
+		return;
+}
+
+/*
+ *  Display vcpu struct.
+ */
+void
+cmd_xen_hyper_vcpu(void)
+{
+	struct vcpu_args vca;
+	struct xen_hyper_vcpu_context *vcc;
+	ulong flag;
+	ulong valvc, valdom;
+        int c, cnt, type, bogus;
+
+	BZERO(&vca, sizeof(struct vcpu_args));
+	flag = 0;
+        while ((c = getopt(argcnt, args, "i")) != EOF) {
+                switch(c)
+                {
+		case 'i':
+			flag |= XEN_HYPER_VCPUS_ID;
+                        break;
+                default:
+                        argerrs++;
+                        break;
+                }
+        }
+
+        if (argerrs)
+                cmd_usage(pc->curcmd, SYNOPSIS);
+
+	cnt = bogus = 0;
+        while (args[optind]) {
+		if (IS_A_NUMBER(args[optind])) {
+			if (flag & XEN_HYPER_VCPUS_ID) {
+				type = xen_hyper_strid_to_vcpu_context(
+					args[optind], args[optind+1],
+					&valdom, &valvc, &vcc);
+			} else {
+				type = xen_hyper_strvcpu_to_vcpu_context(
+					args[optind], &valvc, &vcc);
+			}
+			switch (type) {
+			case XEN_HYPER_STR_VCID:
+			case XEN_HYPER_STR_VCPU:
+				vca.value[cnt] = valvc;
+				vca.type[cnt] = type;
+				vca.vcpu[cnt] = vcc->vcpu;
+				vca.vcc[cnt] = vcc;
+				cnt++;
+				break;
+			case XEN_HYPER_STR_INVALID:
+				error(INFO, "invalid vcpu or id value: %s\n\n",
+					args[optind]);
+				bogus++;
+			}
+		} else {
+			error(FATAL, "invalid address: %s\n",
+				args[optind]);
+		}
+		optind++;
+		if (flag & XEN_HYPER_VCPUS_ID) optind++;
+	}
+	vca.cnt = cnt;
+	if (bogus && !cnt) {
+		return;
+	}
+	
+	do_xen_hyper_vcpu(&vca);
+}
+
+/*
+ *  Do the work requested by cmd_xen_hyper_vcpu().
+ */
+static void
+do_xen_hyper_vcpu(struct vcpu_args *vca)
+{
+	int i;
+
+	if (vca->cnt) {
+		if (vca->cnt == 1) {
+			xhvct->last = vca->vcc[0];
+		}
+		for (i = 0; i < vca->cnt; i++) {
+			dump_struct("vcpu", vca->vcpu[i], 0);
+		}
+	} else {
+		dump_struct("vcpu", xhvct->last->vcpu, 0);
+	}
+}
+
+/*
+ *  Display vcpu status.
+ */
+void
+cmd_xen_hyper_vcpus(void)
+{
+	struct vcpu_args vca;
+	struct xen_hyper_vcpu_context *vcc;
+	ulong flag;
+	ulong valvc, valdom;
+        int c, cnt, type, bogus;
+
+	BZERO(&vca, sizeof(struct vcpu_args));
+	flag = 0;
+        while ((c = getopt(argcnt, args, "i")) != EOF) {
+                switch(c)
+                {
+		case 'i':
+			flag |= XEN_HYPER_VCPUS_ID;
+                        break;
+                default:
+                        argerrs++;
+                        break;
+                }
+        }
+
+        if (argerrs)
+                cmd_usage(pc->curcmd, SYNOPSIS);
+
+	cnt = bogus = 0;
+        while (args[optind]) {
+		if (IS_A_NUMBER(args[optind])) {
+			if (flag & XEN_HYPER_VCPUS_ID) {
+				type = xen_hyper_strid_to_vcpu_context(
+					args[optind], args[optind+1],
+					&valdom, &valvc, &vcc);
+			} else {
+				type = xen_hyper_strvcpu_to_vcpu_context(
+					args[optind], &valvc, &vcc);
+			}
+			switch (type) {
+			case XEN_HYPER_STR_VCID:
+			case XEN_HYPER_STR_VCPU:
+				vca.value[cnt] = valvc;
+				vca.type[cnt] = type;
+				vca.vcpu[cnt] = vcc->vcpu;
+				vca.vcc[cnt] = vcc;
+				cnt++;
+				break;
+			case XEN_HYPER_STR_INVALID:
+				error(INFO, "invalid vcpu or id value: %s\n\n",
+					args[optind]);
+				bogus++;
+			}
+		} else {
+			error(FATAL, "invalid address: %s\n",
+				args[optind]);
+		}
+		optind++;
+	}
+	vca.cnt = cnt;
+	if (bogus && !cnt) {
+		return;
+	}
+	
+	do_xen_hyper_vcpus(&vca);
+}
+
+/*
+ *  Do the work requested by cmd_xen_hyper_vcpus().
+ */
+static void
+do_xen_hyper_vcpus(struct vcpu_args *vca)
+{
+	struct xen_hyper_vcpu_context_array *vcca;
+	struct xen_hyper_vcpu_context *vcc;
+	char buf1[XEN_HYPER_CMD_BUFSIZE];
+	char buf2[XEN_HYPER_CMD_BUFSIZE];
+	int i, j;
+
+	fprintf(fp, "   VCID  PCID %s ST T DOMID %s\n",
+		mkstring(buf1, VADDR_PRLEN, CENTER|RJUST, "VCPU"),
+		mkstring(buf2, VADDR_PRLEN, CENTER|RJUST, "DOMAIN"));
+	if (vca->cnt) {
+		for (i = 0; i < vca->cnt; i++) {
+			show_xen_hyper_vcpus(vca->vcc[i]);
+		}
+	} else {
+		for (i = 0, vcca = xhvct->vcpu_context_arrays;
+			i < XEN_HYPER_MAX_DOMAINS(); i++, vcca++) {
+			for (j = 0, vcc = vcca->context_array;
+				j < vcca->context_array_valid; j++, vcc++) {
+				show_xen_hyper_vcpus(vcc);
+			}
+		}
+	}
+}
+
+static void
+show_xen_hyper_vcpus(struct xen_hyper_vcpu_context *vcc)
+{
+	int type;
+	char *act, *crash;
+	char buf[XEN_HYPER_CMD_BUFSIZE];
+	struct xen_hyper_pcpu_context *pcc;
+	domid_t domid;
+
+	if (!(vcc->vcpu)) {
+		return;
+	}
+	if((pcc = xen_hyper_id_to_pcpu_context(vcc->processor))) {
+		if (pcc->current_vcpu == vcc->vcpu) {
+			act = ">";
+		} else {
+			act = " ";
+		}
+	} else {
+		act = " ";
+	}
+	if (xht->crashing_vcc && vcc->vcpu == xht->crashing_vcc->vcpu) {
+		crash = "*";
+	} else {
+		crash = " ";
+	}
+	sprintf(buf, "%s%s%5d %5d ", act, crash, vcc->vcpu_id, vcc->processor);
+	mkstring(&buf[strlen(buf)], VADDR_PRLEN, CENTER|LONG_HEX|RJUST,
+		(char *)(vcc->vcpu));
+	strncat(buf, " ", XEN_HYPER_CMD_BUFSIZE-strlen(buf)-1);
+	xen_hyper_vcpu_state_string(vcc, &buf[strlen(buf)], !VERBOSE);
+	strncat(buf, " ", XEN_HYPER_CMD_BUFSIZE-strlen(buf)-1);
+	xen_hyper_domain_to_type(vcc->domain, &type, &buf[strlen(buf)], !VERBOSE);
+	if ((domid = xen_hyper_domain_to_id(vcc->domain)) == XEN_HYPER_DOMAIN_ID_INVALID) {
+		sprintf(&buf[strlen(buf)], " ????? ");
+	} else {
+		sprintf(&buf[strlen(buf)], " %5d ", domid);
+	}
+	mkstring(&buf[strlen(buf)], VADDR_PRLEN, CENTER|LONG_HEX|RJUST,
+		(char *)(vcc->domain));
+	fprintf(fp, "%s\n", buf);
+}
+
+
+
+/*
+ *  Get string for domain status.
+ *  - This may need some data in domain struct.
+ */
+char *
+xen_hyper_domain_state_string(struct xen_hyper_domain_context *dc,
+	char *buf, int verbose)
+{
+	ulong stat;
+
+	stat = xen_hyper_domain_state(dc);
+
+	if (stat == XEN_HYPER_DOMF_ERROR) {
+		sprintf(buf, verbose ? "(unknown)" : "??");
+	} else if (stat & XEN_HYPER_DOMF_shutdown) {
+		sprintf(buf, verbose ? "DOMAIN_SHUTDOWN" : "SH");
+	} else if (stat & XEN_HYPER_DOMF_dying) {
+		sprintf(buf, verbose ? "DOMAIN_DYING" : "DY");
+	} else if (stat & XEN_HYPER_DOMF_ctrl_pause) {
+		sprintf(buf, verbose ? "DOMAIN_CTRL_PAUSE" : "CP");
+	} else if (stat & XEN_HYPER_DOMF_polling) {
+		sprintf(buf, verbose ? "DOMAIN_POLLING" : "PO");
+	} else if (stat & XEN_HYPER_DOMF_paused) {
+		sprintf(buf, verbose ? "DOMAIN_PAUSED" : "PA");
+	} else {
+		sprintf(buf, verbose ? "DOMAIN_RUNNING" : "RU");
+	}
+
+	return buf;
+}
+
+/*
+ *  Get string for vcpu status.
+ *  - This may need some data in vcpu struct.
+ */
+char *
+xen_hyper_vcpu_state_string(struct xen_hyper_vcpu_context *vcc,
+	char *buf, int verbose)
+{
+	int stat;
+
+	stat = xen_hyper_vcpu_state(vcc);
+
+	if (stat == XEN_HYPER_RUNSTATE_ERROR) {
+		sprintf(buf, verbose ? "(unknown)" : "??");
+	} else if (stat == XEN_HYPER_RUNSTATE_running ||
+		stat == XEN_HYPER_RUNSTATE_runnable) {
+		sprintf(buf, verbose ? "VCPU_RUNNING" : "RU");
+	} else if (stat == XEN_HYPER_RUNSTATE_blocked) {
+		sprintf(buf, verbose ? "VCPU_BLOCKED" : "BL");
+	} else if (stat == XEN_HYPER_RUNSTATE_offline) {
+		sprintf(buf, verbose ? "VCPU_OFFLINE" : "OF");
+	} else {
+		sprintf(buf, verbose ? "(unknown)" : "??");
+	}
+
+	return buf;
+}
+
+/*
+ *  Get domain type from domain address.
+ */
+static char *
+xen_hyper_domain_to_type(ulong domain, int *type, char *buf, int verbose)
+{
+	struct xen_hyper_domain_context *dc;
+
+	if ((dc = xen_hyper_domain_to_domain_context(domain)) == NULL) {
+		error(WARNING, "cannot get context from domain address.\n");
+		return NULL;
+	}
+	return xen_hyper_domain_context_to_type(dc, type, buf, verbose);
+}
+
+/*
+ *  Get domain type from domain context.
+ */
+static char *
+xen_hyper_domain_context_to_type(struct xen_hyper_domain_context *dc, int *type,
+	char *buf, int verbose)
+{
+	if (!dc) {
+		*type = XEN_HYPER_DOMAIN_TYPE_INVALID;
+		return NULL;
+	} else if (dc == xhdt->idle_domain) {
+		*type = XEN_HYPER_DOMAIN_TYPE_IDLE;
+		sprintf(buf, verbose ? "idle domain" : "I");
+	} else if (dc == xhdt->dom0) {
+		*type = XEN_HYPER_DOMAIN_TYPE_DOM0;
+		sprintf(buf, verbose ? "domain 0" : "0");
+	} else {
+		*type = XEN_HYPER_DOMAIN_TYPE_GUEST;
+		sprintf(buf, verbose ? "guest domain" : "G");
+	}
+	return buf;
+}
+
+/*
+ * Check a type for value. And return domain context.
+ */
+static int
+xen_hyper_str_to_domain_context(char *string, ulong *value,
+	struct xen_hyper_domain_context **dcp)
+{
+	ulong dvalue, hvalue;
+	int found, type;
+	char *s;
+	struct xen_hyper_domain_context *dc_did, *dc_ddc, *dc_hid, *dc_hdc;
+
+	if (string == NULL) {
+		error(INFO, "received NULL string\n");
+		return STR_INVALID;
+	}
+
+	s = string;
+        dvalue = hvalue = BADADDR;
+
+        if (decimal(s, 0))
+                dvalue = dtol(s, RETURN_ON_ERROR, NULL);
+
+        if (hexadecimal(s, 0)) {
+        	if (STRNEQ(s, "0x") || STRNEQ(s, "0X"))
+                	s += 2;
+		if (strlen(s) <= MAX_HEXADDR_STRLEN) 
+                	hvalue = htol(s, RETURN_ON_ERROR, NULL);
+	}
+
+        found = 0;
+        dc_did = dc_ddc = dc_hid = dc_hdc = NULL;
+	type = XEN_HYPER_STR_INVALID;
+
+	if (dvalue != BADADDR) {
+		if ((dc_did = xen_hyper_id_to_domain_context(dvalue)))
+			found++;
+	        if ((dc_ddc = xen_hyper_domain_to_domain_context(dvalue)))
+			found++;
+	}
+
+	if ((hvalue != BADADDR) && (dvalue != hvalue)) {
+	        if ((dc_hid = xen_hyper_id_to_domain_context(hvalue)))
+			found++;
+	        if ((dc_hdc = xen_hyper_domain_to_domain_context(hvalue)))
+			found++;
+	}
+
+	switch (found) 
+	{
+	case 2: 
+		if (dc_did && dc_hid) {      
+                	*dcp = dc_did;      
+                	*value = dvalue;   
+                	type = STR_PID;
+		}
+		break;
+
+	case 1: 
+		if (dc_did) {
+			*dcp = dc_did;
+			*value = dvalue;
+			type = XEN_HYPER_STR_DID;
+		}
+
+		if (dc_ddc) {
+			*dcp = dc_ddc;
+			*value = dvalue;
+			type = XEN_HYPER_STR_DOMAIN;
+		}
+
+		if (dc_hid) {
+			*dcp = dc_hid;
+			*value = hvalue;
+			type = XEN_HYPER_STR_DID;
+		}
+
+		if (dc_hdc) {
+			*dcp = dc_hdc;
+			*value = hvalue;
+			type = XEN_HYPER_STR_DOMAIN;
+		}
+		break;
+	}
+
+	return type;
+}
+
+
+
+/*
+ *  Display a vcpu context.
+ */
+void
+show_xen_hyper_vcpu_context(struct xen_hyper_vcpu_context *vcc)
+{
+	char buf[XEN_HYPER_CMD_BUFSIZE];
+	struct xen_hyper_pcpu_context *pcc;
+	struct xen_hyper_domain_context *dc;
+	int len, flag;
+
+	len = 6;
+	len += pc->flags & RUNTIME ? 0 : 5;
+	flag = XEN_HYPER_PRI_R;
+
+	if (!(pcc = xen_hyper_id_to_pcpu_context(vcc->processor))) {
+		error(FATAL, "cannot get pcpu context vcpu belongs.\n");
+	}
+	if (!(dc = xen_hyper_domain_to_domain_context(vcc->domain))) {
+		error(FATAL, "cannot get domain context vcpu belongs.\n");
+	}
+	XEN_HYPER_PRI(fp, len, "PCPU-ID: ", buf, flag,
+		(buf, "%d\n", vcc->processor));
+	XEN_HYPER_PRI(fp, len, "PCPU: ", buf, flag,
+		(buf, "%lx\n", pcc->pcpu));
+	XEN_HYPER_PRI(fp, len, "VCPU-ID: ", buf, flag,
+		(buf, "%d\n", vcc->vcpu_id));
+	XEN_HYPER_PRI(fp, len, "VCPU: ", buf, flag,
+		(buf, "%lx  ", vcc->vcpu));
+	fprintf(fp, "(%s)\n", xen_hyper_vcpu_state_string(vcc, buf, VERBOSE));
+	XEN_HYPER_PRI(fp, len, "DOMAIN-ID: ", buf, flag,
+		(buf, "%d\n", dc->domain_id));
+	XEN_HYPER_PRI(fp, len, "DOMAIN: ", buf, flag,
+		(buf, "%lx  ", vcc->domain));
+	fprintf(fp, "(%s)\n", xen_hyper_domain_state_string(dc, buf, VERBOSE));
+	XEN_HYPER_PRI_CONS(fp, len, "STATE: ", flag);
+	if (machdep->flags & HWRESET) {
+		fprintf(fp, "HARDWARE RESET");
+	} else if (machdep->flags & INIT) {
+		fprintf(fp, "INIT");
+	} else if (is_xen_hyper_vcpu_crash(vcc)) {
+		fprintf(fp, "CRASH");
+	} else {
+		fprintf(fp, "ACTIVE");
+	}
+
+	fprintf(fp, "\n");
+}
+
+/*
+ * Check a type for value. And return dump information context address.
+ */
+static int
+xen_hyper_str_to_dumpinfo_context(char *string, ulong *value,
+	struct xen_hyper_dumpinfo_context **encp)
+{
+	ulong dvalue, hvalue;
+	struct xen_hyper_dumpinfo_context *note_did, *note_hid;
+	struct xen_hyper_dumpinfo_context *note_dad, *note_had;
+	int found, type;
+	char *s;
+
+	if (string == NULL) {
+		error(INFO, "received NULL string\n");
+		return STR_INVALID;
+	}
+
+	s = string;
+	dvalue = hvalue = BADADDR;
+
+	if (decimal(s, 0))
+		dvalue = dtol(s, RETURN_ON_ERROR, NULL);
+	if (hexadecimal(s, 0)) {
+		if (STRNEQ(s, "0x") || STRNEQ(s, "0X"))
+			s += 2;
+		if (strlen(s) <= MAX_HEXADDR_STRLEN)
+			hvalue = htol(s, RETURN_ON_ERROR, NULL);
+	}
+
+	found = 0;
+	note_did = note_hid = note_dad = note_had = 0;
+	type = XEN_HYPER_STR_INVALID;
+
+	if (dvalue != BADADDR) {
+		if (dvalue > xht->pcpus) {
+			note_dad = xen_hyper_note_to_dumpinfo_context(dvalue);
+		} else {
+			note_did = xen_hyper_id_to_dumpinfo_context(dvalue);
+		}
+		found++;
+	}
+	if ((hvalue != BADADDR)) {
+		if (hvalue > xht->pcpus) {
+			note_had = xen_hyper_note_to_dumpinfo_context(hvalue);
+		} else {
+			note_hid = xen_hyper_id_to_dumpinfo_context(hvalue);
+		}
+		found++;
+	}
+
+	switch (found)
+	{
+	case 2:
+		if (note_did && note_hid) {
+			*value = dvalue;
+			*encp = note_did;
+			type = XEN_HYPER_STR_PCID;
+		}
+		break;
+	case 1:
+		if (note_did) {
+			*value = dvalue;
+			*encp = note_did;
+			type = XEN_HYPER_STR_PCID;
+		}
+
+		if (note_hid) {
+			*value = hvalue;
+			*encp = note_hid;
+			type = XEN_HYPER_STR_PCID;
+		}
+
+		if (note_dad) {
+			*value = dvalue;
+			*encp = note_dad;
+			type = XEN_HYPER_STR_ADDR;
+		}
+
+		if (note_had) {
+			*value = hvalue;
+			*encp = note_had;
+			type = XEN_HYPER_STR_ADDR;
+		}
+		break;
+	}
+
+	return type;
+}
+
+/*
+ * Check a type for value. And return vcpu context.
+ */
+static int
+xen_hyper_strvcpu_to_vcpu_context(char *string, ulong *value,
+	struct xen_hyper_vcpu_context **vccp)
+{
+	ulong dvalue, hvalue;
+	int found, type;
+	char *s;
+	struct xen_hyper_vcpu_context *vcc_dvc, *vcc_hvc;
+
+	if (string == NULL) {
+		error(INFO, "received NULL string\n");
+		return STR_INVALID;
+	}
+
+	s = string;
+        dvalue = hvalue = BADADDR;
+
+        if (decimal(s, 0))
+                dvalue = dtol(s, RETURN_ON_ERROR, NULL);
+
+        if (hexadecimal(s, 0)) {
+        	if (STRNEQ(s, "0x") || STRNEQ(s, "0X"))
+                	s += 2;
+		if (strlen(s) <= MAX_HEXADDR_STRLEN) 
+                	hvalue = htol(s, RETURN_ON_ERROR, NULL);
+	}
+
+        found = 0;
+        vcc_dvc = vcc_hvc = NULL;
+	type = XEN_HYPER_STR_INVALID;
+
+	if (dvalue != BADADDR) {
+	        if ((vcc_dvc = xen_hyper_vcpu_to_vcpu_context(dvalue)))
+			found++;
+	}
+
+	if ((hvalue != BADADDR) && (dvalue != hvalue)) {
+	        if ((vcc_hvc = xen_hyper_vcpu_to_vcpu_context(hvalue)))
+			found++;
+	}
+
+	switch (found) 
+	{
+	case 1: 
+		if (vcc_dvc) {
+			*vccp = vcc_dvc;
+			*value = dvalue;
+			type = XEN_HYPER_STR_VCPU;
+		}
+
+		if (vcc_hvc) {
+			*vccp = vcc_hvc;
+			*value = hvalue;
+			type = XEN_HYPER_STR_VCPU;
+		}
+		break;
+	}
+
+	return type;
+}
+
+/*
+ * Check a type for id value. And return vcpu context.
+ */
+static int
+xen_hyper_strid_to_vcpu_context(char *strdom, char *strvc, ulong *valdom,
+	ulong *valvc, struct xen_hyper_vcpu_context **vccp)
+{
+	ulong dvalue, hvalue;
+	int found, type;
+	char *s;
+	struct xen_hyper_vcpu_context *vcc_did, *vcc_hid;
+	struct xen_hyper_domain_context *dc;
+
+	if (strdom == NULL || strvc == NULL) {
+		error(INFO, "received NULL string\n");
+		return STR_INVALID;
+	}
+
+	if (xen_hyper_str_to_domain_context(strdom, valdom, &dc) ==
+	XEN_HYPER_STR_INVALID) {
+		error(INFO, "invalid domain id string.\n");
+		return STR_INVALID;
+	}
+
+	s = strvc;
+        dvalue = hvalue = BADADDR;
+        if (decimal(s, 0))
+                dvalue = dtol(s, RETURN_ON_ERROR, NULL);
+
+        if (hexadecimal(s, 0)) {
+        	if (STRNEQ(s, "0x") || STRNEQ(s, "0X"))
+                	s += 2;
+		if (strlen(s) <= MAX_HEXADDR_STRLEN) 
+                	hvalue = htol(s, RETURN_ON_ERROR, NULL);
+	}
+
+        found = 0;
+        vcc_did = vcc_hid = NULL;
+	type = XEN_HYPER_STR_INVALID;
+
+	if (dvalue != BADADDR) {
+	        if ((vcc_did = xen_hyper_id_to_vcpu_context(dc->domain,
+		XEN_HYPER_DOMAIN_ID_INVALID, dvalue)))
+			found++;
+	}
+
+	if ((hvalue != BADADDR) && (dvalue != hvalue)) {
+	        if ((vcc_hid = xen_hyper_id_to_vcpu_context(dc->domain,
+		XEN_HYPER_DOMAIN_ID_INVALID, hvalue)))
+			found++;
+	}
+
+	switch (found) 
+	{
+	case 2:
+		if (vcc_did && vcc_hid) {
+			*vccp = vcc_did;
+			*valvc = dvalue;
+			type = XEN_HYPER_STR_VCID;
+		}
+		break;
+	case 1: 
+		if (vcc_did) {
+			*vccp = vcc_did;
+			*valvc = dvalue;
+			type = XEN_HYPER_STR_VCID;
+		}
+
+		if (vcc_hid) {
+			*vccp = vcc_hid;
+			*valvc = hvalue;
+			type = XEN_HYPER_STR_VCID;
+		}
+		break;
+	}
+
+	return type;
+}
+
+/*
+ * Check a type for value. And return pcpu context.
+ */
+static int
+xen_hyper_str_to_pcpu_context(char *string, ulong *value,
+	struct xen_hyper_pcpu_context **pccp)
+{
+	ulong dvalue, hvalue;
+	int found, type;
+	char *s;
+	struct xen_hyper_pcpu_context *pcc_did, *pcc_dpc, *pcc_hid, *pcc_hpc;
+
+	if (string == NULL) {
+		error(INFO, "received NULL string\n");
+		return STR_INVALID;
+	}
+
+	s = string;
+        dvalue = hvalue = BADADDR;
+
+        if (decimal(s, 0))
+                dvalue = dtol(s, RETURN_ON_ERROR, NULL);
+
+        if (hexadecimal(s, 0)) {
+        	if (STRNEQ(s, "0x") || STRNEQ(s, "0X"))
+                	s += 2;
+		if (strlen(s) <= MAX_HEXADDR_STRLEN) 
+                	hvalue = htol(s, RETURN_ON_ERROR, NULL);
+	}
+
+        found = 0;
+        pcc_did = pcc_dpc = pcc_hid = pcc_hpc = NULL;
+	type = XEN_HYPER_STR_INVALID;
+
+	if (dvalue != BADADDR) {
+		if ((pcc_did = xen_hyper_id_to_pcpu_context(dvalue)))
+			found++;
+	        if ((pcc_dpc = xen_hyper_pcpu_to_pcpu_context(dvalue)))
+			found++;
+	}
+
+	if ((hvalue != BADADDR) && (dvalue != hvalue)) {
+	        if ((pcc_hid = xen_hyper_id_to_pcpu_context(hvalue)))
+			found++;
+	        if ((pcc_hpc = xen_hyper_pcpu_to_pcpu_context(hvalue)))
+			found++;
+	}
+
+	switch (found) 
+	{
+	case 2: 
+		if (pcc_did && pcc_hid) {      
+                	*pccp = pcc_did;      
+                	*value = dvalue;   
+                	type = STR_PID;
+		}
+		break;
+
+	case 1: 
+		if (pcc_did) {
+			*pccp = pcc_did;
+			*value = dvalue;
+			type = XEN_HYPER_STR_PCID;
+		}
+
+		if (pcc_dpc) {
+			*pccp = pcc_dpc;
+			*value = dvalue;
+			type = XEN_HYPER_STR_PCPU;
+		}
+
+		if (pcc_hid) {
+			*pccp = pcc_hid;
+			*value = hvalue;
+			type = XEN_HYPER_STR_PCID;
+		}
+
+		if (pcc_hpc) {
+			*pccp = pcc_hpc;
+			*value = hvalue;
+			type = XEN_HYPER_STR_PCPU;
+		}
+		break;
+	}
+
+	return type;
+}
+
+#endif
diff -purN crash-4.0-3.9/xen_hyper_defs.h crash-4.0-3.14/xen_hyper_defs.h
--- crash-4.0-3.9/xen_hyper_defs.h	1970-01-01 01:00:00.000000000 +0100
+++ crash-4.0-3.14/xen_hyper_defs.h	2006-12-01 21:39:42.000000000 +0100
@@ -0,0 +1,708 @@
+/*
+ *  xen_hyper_defs.h
+ *
+ *  Portions Copyright (C) 2006 Fujitsu Limited
+ *  Portions Copyright (C) 2006 VA Linux Systems Japan K.K.
+ *
+ *  This file is part of Xencrash.
+ *
+ *  Xencrash 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 (version 2 of the License).
+ *
+ *  Xencrash 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.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Xencrash; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA.
+ */
+
+#ifdef XEN_HYPERVISOR_ARCH
+
+#include <sys/types.h>
+#include <elf.h>
+
+#ifdef X86
+/* Xen Hypervisor address space layout */
+#define IOREMAP_VIRT_END        (0UL)
+#define IOREMAP_VIRT_START      (0xFFC00000UL)
+#define DIRECTMAP_VIRT_END      IOREMAP_VIRT_START
+#define DIRECTMAP_VIRT_START    (0xFF000000UL)
+#define MAPCACHE_VIRT_END       DIRECTMAP_VIRT_START
+#define MAPCACHE_VIRT_START     (0xFFC00000UL)
+#define PERDOMAIN_VIRT_END      DIRECTMAP_VIRT_START
+#define PERDOMAIN_VIRT_START    (0xFE800000UL)
+#define SH_LINEAR_PT_VIRT_END   PERDOMAIN_VIRT_START
+#define SH_LINEAR_PT_VIRT_START (0xFE400000UL)
+#define SH_LINEAR_PT_VIRT_START_PAE (0xFE000000UL)
+#define LINEAR_PT_VIRT_END      SH_LINEAR_PT_VIRT_START
+#define LINEAR_PT_VIRT_START    (0xFE000000UL)
+#define LINEAR_PT_VIRT_START_PAE    (0xFD800000UL)
+#define RDWR_MPT_VIRT_END       LINEAR_PT_VIRT_START
+#define RDWR_MPT_VIRT_START     (0xFDC00000UL)
+#define RDWR_MPT_VIRT_START_PAE     (0xFC800000UL)
+#define FRAMETABLE_VIRT_END     RDWR_MPT_VIRT_START
+#define FRAMETABLE_VIRT_START   (0xFC400000UL)
+#define FRAMETABLE_VIRT_START_PAE   (0xF6800000UL)
+#define RO_MPT_VIRT_END         FRAMETABLE_VIRT_START
+#define RO_MPT_VIRT_START       (0xFC000000UL)
+#define RO_MPT_VIRT_START_PAE       (0xF5800000UL)
+
+#define HYPERVISOR_VIRT_START   RO_MPT_VIRT_START
+#define HYPERVISOR_VIRT_START_PAE   RO_MPT_VIRT_START_PAE
+#endif
+
+#ifdef X86_64
+#define HYPERVISOR_VIRT_START (0xffff800000000000)
+#define HYPERVISOR_VIRT_END   (0xffff880000000000)
+#define DIRECTMAP_VIRT_START  (0xffff830000000000)
+#define DIRECTMAP_VIRT_END    (0xffff840000000000)
+#define PAGE_OFFSET_XEN_HYPER DIRECTMAP_VIRT_START
+#endif
+
+#define DIRECTMAP_VIRT_ADDR(vaddr) \
+    (((vaddr) >= DIRECTMAP_VIRT_START) && ((vaddr) < DIRECTMAP_VIRT_END))
+
+typedef uint16_t	domid_t;
+typedef uint32_t	Elf_Word;
+
+/*
+ * Xen Hyper
+ */
+#define XEN_HYPER_SMP (0x400)
+
+#ifdef X86
+#define XEN_HYPER_MAX_VIRT_CPUS  (32)
+#define XEN_HYPER_HZ 100
+#endif
+#ifdef X86_64
+#define XEN_HYPER_MAX_VIRT_CPUS  (32)
+#define XEN_HYPER_HZ 100
+#endif
+#ifdef IA64
+#define XEN_HYPER_MAX_VIRT_CPUS  (64)
+#define XEN_HYPER_HZ 100
+#endif
+#ifndef XEN_HYPER_MAX_VIRT_CPUS
+#define XEN_HYPER_MAX_VIRT_CPUS  (1)
+#endif
+
+#define XEN_HYPER_PERCPU_SHIFT 12
+#define xen_hyper_per_cpu(var, cpu)  \
+	((ulong)var + (((ulong)(cpu))<<XEN_HYPER_PERCPU_SHIFT))
+
+#define XEN_HYPER_STACK_ORDER 2
+#if 0
+#define XEN_HYPER_STACK_SIZE (machdep->pagesize << XEN_HYPER_STACK_ORDER)
+#endif
+#define XEN_HYPER_GET_CPU_INFO(esp) \
+	((esp & ~(STACKSIZE()-1)) | \
+	(STACKSIZE() - XEN_HYPER_SIZE(cpu_info)))
+
+#define XEN_HYPER_CONRING_SIZE 16384
+
+/* system time */
+#define XEN_HYPER_NANO_TO_SEC(ns)	((ulonglong)((ns) / 1000000000ULL))
+#define XEN_HYPER_MICR_TO_SEC(us)	((ulonglong)((us) / 1000000ULL))
+#define XEN_HYPER_MILI_TO_SEC(ms)	((ulonglong)((ms) / 1000ULL))
+
+/*
+ * Domain
+ */
+/* Domain flags (domain_flags). */
+ /* Is this domain privileged? */
+#define XEN_HYPER__DOMF_privileged       0
+#define XEN_HYPER_DOMF_privileged        (1UL<<XEN_HYPER__DOMF_privileged)
+ /* Guest shut itself down for some reason. */
+#define XEN_HYPER__DOMF_shutdown         1
+#define XEN_HYPER_DOMF_shutdown          (1UL<<XEN_HYPER__DOMF_shutdown)
+ /* Death rattle. */
+#define XEN_HYPER__DOMF_dying            2
+#define XEN_HYPER_DOMF_dying             (1UL<<XEN_HYPER__DOMF_dying)
+ /* Domain is paused by controller software. */
+#define XEN_HYPER__DOMF_ctrl_pause       3
+#define XEN_HYPER_DOMF_ctrl_pause        (1UL<<XEN_HYPER__DOMF_ctrl_pause)
+ /* Domain is being debugged by controller software. */
+#define XEN_HYPER__DOMF_debugging        4
+#define XEN_HYPER_DOMF_debugging         (1UL<<XEN_HYPER__DOMF_debugging)
+ /* Are any VCPUs polling event channels (SCHEDOP_poll)? */
+#define XEN_HYPER__DOMF_polling          5
+#define XEN_HYPER_DOMF_polling           (1UL<<XEN_HYPER__DOMF_polling)
+ /* Domain is paused by the hypervisor? */
+#define XEN_HYPER__DOMF_paused           6
+#define XEN_HYPER_DOMF_paused            (1UL<<XEN_HYPER__DOMF_paused)
+ /* Domain flag error */
+#define XEN_HYPER_DOMF_ERROR            ((ulong)(-1))
+
+/*
+ * VCPU
+ */
+/* VCPU flags (vcpu_flags). */
+ /* Has the FPU been initialised? */
+#define XEN_HYPER__VCPUF_fpu_initialised 0
+#define XEN_HYPER_VCPUF_fpu_initialised  (1UL<<XEN_HYPER__VCPUF_fpu_initialised)
+ /* Has the FPU been used since it was last saved? */
+#define XEN_HYPER__VCPUF_fpu_dirtied     1
+#define XEN_HYPER_VCPUF_fpu_dirtied      (1UL<<XEN_HYPER__VCPUF_fpu_dirtied)
+ /* Domain is blocked waiting for an event. */
+#define XEN_HYPER__VCPUF_blocked         2
+#define XEN_HYPER_VCPUF_blocked          (1UL<<XEN_HYPER__VCPUF_blocked)
+ /* Currently running on a CPU? */
+#define XEN_HYPER__VCPUF_running         3
+#define XEN_HYPER_VCPUF_running          (1UL<<XEN_HYPER__VCPUF_running)
+ /* Initialization completed. */
+#define XEN_HYPER__VCPUF_initialised     4
+#define XEN_HYPER_VCPUF_initialised      (1UL<<XEN_HYPER__VCPUF_initialised)
+ /* VCPU is offline. */
+#define XEN_HYPER__VCPUF_down            5
+#define XEN_HYPER_VCPUF_down             (1UL<<XEN_HYPER__VCPUF_down)
+ /* NMI callback pending for this VCPU? */
+#define XEN_HYPER__VCPUF_nmi_pending     8
+#define XEN_HYPER_VCPUF_nmi_pending      (1UL<<XEN_HYPER__VCPUF_nmi_pending)
+ /* Avoid NMI reentry by allowing NMIs to be masked for short periods. */
+#define XEN_HYPER__VCPUF_nmi_masked      9
+#define XEN_HYPER_VCPUF_nmi_masked       (1UL<<XEN_HYPER__VCPUF_nmi_masked)
+ /* VCPU is polling a set of event channels (SCHEDOP_poll). */
+#define XEN_HYPER__VCPUF_polling         10
+#define XEN_HYPER_VCPUF_polling          (1UL<<XEN_HYPER__VCPUF_polling)
+ /* VCPU is paused by the hypervisor? */
+#define XEN_HYPER__VCPUF_paused          11
+#define XEN_HYPER_VCPUF_paused           (1UL<<XEN_HYPER__VCPUF_paused)
+/* VCPU is blocked awaiting an event to be consumed by Xen. */
+#define XEN_HYPER__VCPUF_blocked_in_xen  12
+#define XEN_HYPER_VCPUF_blocked_in_xen   (1UL<<XEN_HYPER__VCPUF_blocked_in_xen)
+ /* VCPU flag error */
+#define XEN_HYPER_VCPUF_ERROR            ((ulong)(-1))
+
+/* VCPU state (vcpu_runstate_info.state). */
+/* VCPU is currently running on a physical CPU. */
+#define XEN_HYPER_RUNSTATE_running  0
+/* VCPU is runnable, but not currently scheduled on any physical CPU. */
+#define XEN_HYPER_RUNSTATE_runnable 1
+/* VCPU is blocked (a.k.a. idle). It is therefore not runnable. */
+#define XEN_HYPER_RUNSTATE_blocked  2
+/*
+ * VCPU is not runnable, but it is not blocked.
+ * This is a 'catch all' state for things like hotplug and pauses by the
+ * system administrator (or for critical sections in the hypervisor).
+ * RUNSTATE_blocked dominates this state (it is the preferred state).
+ */
+#define XEN_HYPER_RUNSTATE_offline  3
+#define XEN_HYPER_RUNSTATE_ERROR        ((int)(-1))
+
+/*
+ * Programs constant
+ */
+#define XEN_HYPER_CMD_BUFSIZE (1024)
+
+#define XEN_HYPER_DOMAIN_ID_INVALID ((uint16_t)(-1))
+#define XEN_HYPER_VCPU_ID_INVALID ((int)(-1))
+#define XEN_HYPER_PCPU_ID_INVALID ((uint)(-1))
+
+#define XEN_HYPER_DOMAIN_READ_DOM0 0
+#define XEN_HYPER_DOMAIN_READ_INIT 1
+#define XEN_HYPER_DOMAIN_READ_NEXT 2
+
+#define XEN_HYPER_DOMAIN_FLAGS_PRIV 0
+#define XEN_HYPER_DOMAIN_FLAGS_STAT 1
+
+#define XEN_HYPER_STR_ADDR	(0x1)
+#define XEN_HYPER_STR_DID	(0x11)
+#define XEN_HYPER_STR_DOMAIN	(0x12)
+#define XEN_HYPER_STR_VCID	(0x21)
+#define XEN_HYPER_STR_VCPU	(0x22)
+#define XEN_HYPER_STR_PCID	(0x31)
+#define XEN_HYPER_STR_PCPU	(0x32)
+#define XEN_HYPER_STR_INVALID	(-1)
+
+#define XEN_HYPER_DOMAIN_TYPE_IDLE	(0x0)
+#define XEN_HYPER_DOMAIN_TYPE_DOM0	(0x1)
+#define XEN_HYPER_DOMAIN_TYPE_GUEST	(0x2)
+#define XEN_HYPER_DOMAIN_TYPE_INVALID	(-1)
+
+/*
+ * command interface structs
+ */
+#define XEN_HYPER_MAX_ARGS 100
+
+struct cmd_args {
+	int cnt;
+	ulong value[XEN_HYPER_MAX_ARGS];
+	int type[XEN_HYPER_MAX_ARGS];
+	ulong addr[XEN_HYPER_MAX_ARGS];
+};
+
+/*
+ * Domain command
+ */
+#define XEN_HYPER_MAX_DOMS_ARGS XEN_HYPER_MAX_ARGS
+
+struct domain_args {
+	int cnt;
+	ulong value[XEN_HYPER_MAX_DOMS_ARGS];
+	int type[XEN_HYPER_MAX_DOMS_ARGS];
+	ulong domain[XEN_HYPER_MAX_DOMS_ARGS];
+	struct xen_hyper_domain_context *dc[XEN_HYPER_MAX_DOMS_ARGS];
+};
+
+/*
+ * Virtual cpu command
+ */
+#define XEN_HYPER_MAX_VCPUS_ARGS XEN_HYPER_MAX_ARGS
+#define XEN_HYPER_VCPUS_ID (0x1)
+
+struct vcpu_args {
+	int cnt;
+	ulong value[XEN_HYPER_MAX_VCPUS_ARGS];
+	ulong type[XEN_HYPER_MAX_VCPUS_ARGS];
+	ulong vcpu[XEN_HYPER_MAX_VCPUS_ARGS];
+	struct xen_hyper_vcpu_context *vcc[XEN_HYPER_MAX_VCPUS_ARGS];
+};
+
+/*
+ * Physical cpu command
+ */
+#define XEN_HYPER_MAX_PCPUS_ARGS XEN_HYPER_MAX_ARGS
+#define XEN_HYPER_PCPUS_1STCALL (0x1)
+#define XEN_HYPER_PCPUS_REGS (0x2)
+
+struct pcpu_args {
+	int cnt;
+	ulong value[XEN_HYPER_MAX_PCPUS_ARGS];
+	int type[XEN_HYPER_MAX_PCPUS_ARGS];
+	ulong pcpu[XEN_HYPER_MAX_PCPUS_ARGS];
+	struct xen_hyper_pcpu_context *pcc[XEN_HYPER_MAX_PCPUS_ARGS];
+};
+
+/*
+ * dump information command
+ */
+/* options */
+#define XEN_HYPER_DUMPINFO_TIME (0x1)
+#define XEN_HYPER_DUMPINFO_REGS (0x2)
+
+struct dumpinfo_args {
+	int cnt;
+	ulong value[XEN_HYPER_MAX_ARGS];
+	int type[XEN_HYPER_MAX_ARGS];
+	struct xen_hyper_dumpinfo_context *enc[XEN_HYPER_MAX_ARGS];
+};
+
+/*
+ * table structs
+ */
+struct xen_hyper_machdep_table {
+	void (*pcpu_init)(void);
+};
+
+struct xen_hyper_table {
+	ulong flags;
+	ulong stext;
+	ulong etext;
+	struct new_utsname utsname;
+	uint cpu_curr;
+	uint max_cpus;			/* max cpu in system max */
+	int cores;			/* number of cpu core */
+	int pcpus;			/* number of physical cpu */
+	int vcpus;			/* number of virtual cpu */
+	int domains;			/* number of domain */
+	int crashing_cpu;
+	struct xen_hyper_vcpu_context *crashing_vcc;
+	ulong max_page;
+};
+
+struct xen_hyper_dumpinfo_context {
+	ulong note;			/* per_cpu__crash_notes address */
+	uint pcpu_id;
+	char *ELF_Prstatus_ptr;		/* pointer to ELF_Prstatus buf */
+	char *pr_reg_ptr;		/* pointer to pr_reg buf */
+};
+
+struct xen_hyper_dumpinfo_table {
+	char *ELF_Prstatus_array;
+	struct xen_hyper_dumpinfo_context context[NR_CPUS];
+	Elf_Word offset;
+	Elf_Word size;
+};
+
+/* domain */
+struct xen_hyper_domain_context {
+	ulong domain;			/* domain address */
+	domid_t domain_id;
+	uint tot_pages;
+	uint max_pages;
+	uint xenheap_pages;
+	ulong shared_info;
+	ulong sched_priv;
+	ulong next_in_list;
+	ulong domain_flags;
+	ulong evtchn;
+	int vcpu_cnt;
+	ulong vcpu[XEN_HYPER_MAX_VIRT_CPUS];
+	struct xen_hyper_vcpu_context_array *vcpu_context_array;
+};
+
+struct xen_hyper_domain_table {
+	uint32_t flags;
+	struct xen_hyper_domain_context *context_array;
+	int context_array_cnt;
+	ulong running_domains;
+	struct xen_hyper_domain_context *dom0;
+	struct xen_hyper_domain_context *idle_domain;
+	struct xen_hyper_domain_context *curr_domain;
+	struct xen_hyper_domain_context *last;
+	char *domain_struct;
+	char *domain_struct_verify;
+};
+
+/* vcpu */
+struct xen_hyper_vcpu_context {
+	ulong vcpu;			/* vcpu address */
+	int vcpu_id;
+	int processor;
+	ulong vcpu_info;
+	ulong domain;
+	ulong next_in_list;
+	ulong sleep_tick;
+	ulong sched_priv;
+	int state;
+	uint64_t state_entry_time;
+	ulong runstate_guest;
+	ulong vcpu_flags;
+};
+
+struct xen_hyper_vcpu_context_array {
+	struct xen_hyper_vcpu_context *context_array;
+	int context_array_cnt;
+	int context_array_valid;
+};
+
+struct xen_hyper_vcpu_table {
+	uint32_t flags;
+	struct xen_hyper_vcpu_context_array *vcpu_context_arrays;
+	int vcpu_context_arrays_cnt;
+	ulong idle_vcpu;
+	struct xen_hyper_vcpu_context_array *idle_vcpu_context_array;
+	struct xen_hyper_vcpu_context *last;
+	char *vcpu_struct;
+	char *vcpu_struct_verify;
+};
+
+/* pcpu */
+struct xen_hyper_pcpu_context {
+	ulong pcpu;			/* pcpu address */
+	uint processor_id;
+	ulong guest_cpu_user_regs;
+	ulong current_vcpu;
+};
+
+struct xen_hyper_pcpu_table {
+	struct xen_hyper_pcpu_context *context_array;
+	struct xen_hyper_pcpu_context *last;
+	char *pcpu_struct;
+};
+
+/* scheduler */
+struct xen_hyper_sched_table {
+	int type;
+	char opt_sched[10];
+};
+
+struct syment;
+
+struct xen_hyper_symbol_table_data {
+	struct syment *symtable;
+};
+
+struct xen_hyper_size_table {
+	long ELF_Prstatus;
+	long ELF_Signifo;
+	long ELF_Gregset;
+	long ELF_Timeval;
+	long cpu_info;
+	long cpu_time;
+	long cpu_user_regs;
+	long cpuinfo_x86;
+	long domain;
+	long note_buf_t;
+	long scheduler;
+	long timer;
+	long tss_struct;
+	long vcpu;
+	long vcpu_runstate_info;
+};
+
+struct xen_hyper_offset_table {
+	/* ELF */
+	long ELF_Prstatus_pr_info;
+	long ELF_Prstatus_pr_cursig;
+	long ELF_Prstatus_pr_sigpend;
+	long ELF_Prstatus_pr_sighold;
+	long ELF_Prstatus_pr_pid;
+	long ELF_Prstatus_pr_ppid;
+	long ELF_Prstatus_pr_pgrp;
+	long ELF_Prstatus_pr_sid;
+	long ELF_Prstatus_pr_utime;
+	long ELF_Prstatus_pr_stime;
+	long ELF_Prstatus_pr_cutime;
+	long ELF_Prstatus_pr_cstime;
+	long ELF_Prstatus_pr_reg;
+	long ELF_Prstatus_pr_fpvalid;
+	long ELF_Timeval_tv_sec;
+	long ELF_Timeval_tv_usec;
+	/* cpu_info */
+	long cpu_info_guest_cpu_user_regs;
+	long cpu_info_processor_id;
+	long cpu_info_current_vcpu;
+	/* cpu_time */
+	long cpu_time_local_tsc_stamp;
+	long cpu_time_stime_local_stamp;
+	long cpu_time_stime_master_stamp;
+	long cpu_time_tsc_scale;
+	long cpu_time_calibration_timer;
+	/* domain */
+	long domain_page_list;
+	long domain_xenpage_list;
+	long domain_domain_id;
+	long domain_tot_pages;
+	long domain_max_pages;
+	long domain_xenheap_pages;
+	long domain_shared_info;
+	long domain_sched_priv;
+	long domain_next_in_list;
+	long domain_domain_flags;
+	long domain_evtchn;
+	long domain_vcpu;
+	/* timer */
+	long timer_expires;
+	long timer_cpu;
+	long timer_function;
+	long timer_data;
+	long timer_heap_offset;
+	long timer_killed;
+	/* tss */
+	long tss_struct_rsp0;
+	long tss_struct_esp0;
+	/* vcpu */
+	long vcpu_vcpu_id;
+	long vcpu_processor;
+	long vcpu_vcpu_info;
+	long vcpu_domain;
+	long vcpu_next_in_list;
+	long vcpu_timer;
+	long vcpu_sleep_tick;
+	long vcpu_poll_timer;
+	long vcpu_sched_priv;
+	long vcpu_runstate;
+	long vcpu_runstate_guest;
+	long vcpu_vcpu_flags;
+	long vcpu_pause_count;
+	long vcpu_virq_to_evtchn;
+	long vcpu_cpu_affinity;
+	long vcpu_nmi_addr;
+	long vcpu_vcpu_dirty_cpumask;
+	long vcpu_arch;
+	/* vcpu_runstate_info */
+	long vcpu_runstate_info_state;
+	long vcpu_runstate_info_state_entry_time;
+	long vcpu_runstate_info_time;
+};
+
+/*
+ * offset, size
+ */
+#define XEN_HYPER_SIZE(X)		(SIZE_verify(xen_hyper_size_table.X, (char *)__FUNCTION__, __FILE__, __LINE__, #X))
+#define XEN_HYPER_OFFSET(X)		(OFFSET_verify(xen_hyper_offset_table.X, (char *)__FUNCTION__, __FILE__, __LINE__, #X))
+
+#define XEN_HYPER_ASSIGN_SIZE(X)	(xen_hyper_size_table.X)
+#define XEN_HYPER_ASSIGN_OFFSET(X)	(xen_hyper_offset_table.X)
+
+#define XEN_HYPER_STRUCT_SIZE_INIT(X, Y) (XEN_HYPER_ASSIGN_SIZE(X) = STRUCT_SIZE(Y))
+#define XEN_HYPER_MEMBER_SIZE_INIT(X, Y, Z) (XEN_HYPER_ASSIGN_SIZE(X) = MEMBER_SIZE(Y, Z))
+#define XEN_HYPER_MEMBER_OFFSET_INIT(X, Y, Z) (XEN_HYPER_ASSIGN_OFFSET(X) = MEMBER_OFFSET(Y, Z))
+
+/*
+ * Dump information
+ */
+#define XEN_HYPER_X86_NOTE_ESP(regs) (regs[15])
+#define XEN_HYPER_X86_NOTE_EIP(regs) (regs[12])
+#define XEN_HYPER_X86_64_NOTE_RSP(regs) (regs[18])
+#define XEN_HYPER_X86_64_NOTE_RIP(regs) (regs[15])
+
+/*
+ * Domain
+ */
+#define XEN_HYPER_DOMAIN_F_INIT 0x1
+
+#define XEN_HYPER_MAX_DOMAINS() (xht->domains)
+#define XEN_HYPER_RUNNING_DOMAINS() (xhdt->running_domains)
+
+/*
+ * Phisycal CPU
+ */
+#define XEN_HYPER_MAX_PCPUS() (xht->pcpus)
+
+/*
+ * VCPU
+ */
+#define XEN_HYPER_VCPU_F_INIT 0x1
+
+#define XEN_HYPER_MAX_VCPUS(domain_context) (domain_context->vcpu_cnt)
+#define XEN_HYPER_VCPU_LAST_CONTEXT()	(xhvct->last)
+
+/*
+ * tools
+ */
+#define XEN_HYPER_PRI(fp, len, str, buf, flag, args)	\
+	sprintf args;				\
+	xen_hyper_fpr_indent(fp, len, str, buf, flag);
+#define XEN_HYPER_PRI_CONS(fp, len, str, flag)	\
+	xen_hyper_fpr_indent(fp, len, str, NULL, flag);
+
+#define XEN_HYPER_PRI_L	0
+#define XEN_HYPER_PRI_R	1
+
+/*
+ * Global data
+ */
+extern struct xen_hyper_machdep_table *xhmachdep;
+extern struct xen_hyper_table *xht;
+extern struct xen_hyper_dumpinfo_table *xhdit;
+extern struct xen_hyper_domain_table *xhdt;
+extern struct xen_hyper_vcpu_table *xhvct;
+extern struct xen_hyper_pcpu_table *xhpct;
+extern struct xen_hyper_sched_table *xhscht;
+extern struct xen_hyper_symbol_table_data *xhsymt;
+
+extern struct xen_hyper_offset_table xen_hyper_offset_table;
+extern struct xen_hyper_size_table xen_hyper_size_table;
+
+extern struct command_table_entry xen_hyper_command_table[];
+extern struct task_context fake_tc;
+
+/*
+ * Xen Hyper command help
+ */
+extern char *help_xen_hyper_domain[];
+extern char *help_xen_hyper_doms[];
+extern char *help_xen_hyper_dumpinfo[];
+extern char *help_xen_hyper_log[];
+extern char *help_xen_hyper_pcpus[];
+extern char *help_xen_hyper_sys[];
+extern char *help_xen_hyper_vcpu[];
+extern char *help_xen_hyper_vcpus[];
+
+/*
+ * Prototype
+ */
+ulonglong get_uptime_hyper(void);
+
+/*
+ * x86
+ */
+int x86_get_smp_cpus_hyper(void);
+uint64_t x86_memory_size_hyper(void);
+
+/*
+ * Xen Hyper
+ */
+void xen_hyper_init(void);
+void xen_hyper_domain_init(void);
+void xen_hyper_vcpu_init(void);
+void xen_hyper_dumpinfo_init(void);
+void xen_hyper_post_init(void);
+struct xen_hyper_dumpinfo_context *xen_hyper_id_to_dumpinfo_context(uint id);
+struct xen_hyper_dumpinfo_context *xen_hyper_note_to_dumpinfo_context(ulong note);
+char *xen_hyper_fill_elf_notes(ulong note, char *note_buf);
+char *xen_hyper_fill_ELF_Prstatus(ulong prstatus, char *note_buf);
+
+/* domain */
+void xen_hyper_refresh_domain_context_space(void);
+int xen_hyper_get_domains(void);
+char *xen_hyper_get_domain_next(int mod, ulong *next);
+domid_t xen_hyper_domain_to_id(ulong domain);
+char *xen_hyper_id_to_domain_struct(domid_t id);
+struct xen_hyper_domain_context *
+xen_hyper_domain_to_domain_context(ulong domain);
+struct xen_hyper_domain_context *
+xen_hyper_id_to_domain_context(domid_t id);
+struct xen_hyper_domain_context *
+xen_hyper_store_domain_context(struct xen_hyper_domain_context *dc,
+		ulong domain, char *dp);
+char *xen_hyper_read_domain_from_context(struct xen_hyper_domain_context *dc);
+char *xen_hyper_read_domain(ulong domain);
+char *xen_hyper_read_domain_verify(ulong domain);
+char *xen_hyper_fill_domain_struct(ulong domain, char *domain_struct);
+void xen_hyper_alloc_domain_context_space(int domains);
+ulong xen_hyper_domain_state(struct xen_hyper_domain_context *dc);
+
+/* vcpu */
+void xen_hyper_refresh_vcpu_context_space(void);
+struct xen_hyper_vcpu_context *
+xen_hyper_vcpu_to_vcpu_context(ulong vcpu);
+struct xen_hyper_vcpu_context *
+xen_hyper_id_to_vcpu_context(ulong domain, domid_t did, int vcid);
+struct xen_hyper_vcpu_context_array *
+xen_hyper_domain_to_vcpu_context_array(ulong domain);
+struct xen_hyper_vcpu_context_array *
+xen_hyper_domid_to_vcpu_context_array(domid_t id);
+struct xen_hyper_vcpu_context *
+xen_hyper_store_vcpu_context(struct xen_hyper_vcpu_context *vcc,
+	ulong vcpu, char *vcp);
+char *
+xen_hyper_read_vcpu_from_context(struct xen_hyper_vcpu_context *vcc);
+char *xen_hyper_read_vcpu(ulong vcpu);
+char *xen_hyper_read_vcpu_verify(ulong vcpu);
+char *xen_hyper_fill_vcpu_struct(ulong vcpu, char *vcpu_struct);
+void xen_hyper_alloc_vcpu_context_arrays_space(int domains);
+void xen_hyper_alloc_vcpu_context_space(struct xen_hyper_vcpu_context_array *vcca, int vcpus);
+int xen_hyper_vcpu_state(struct xen_hyper_vcpu_context *vcc);
+
+/* pcpu */
+void x86_xen_hyper_pcpu_init(void);
+struct xen_hyper_pcpu_context *xen_hyper_id_to_pcpu_context(uint id);
+struct xen_hyper_pcpu_context *xen_hyper_pcpu_to_pcpu_context(ulong pcpu);
+struct xen_hyper_pcpu_context *xen_hyper_store_pcpu_context(struct xen_hyper_pcpu_context *pcc,
+	ulong pcpu, char *pcp);
+char *xen_hyper_read_pcpu(ulong pcpu);
+char *xen_hyper_fill_pcpu_struct(ulong pcpu, char *pcpu_struct);
+void xen_hyper_alloc_pcpu_context_space(int pcpus);
+
+/* others */
+char *xen_hyper_fill_cpu_data_x86(int idx, char *cpuinfo_x86);
+int is_xen_hyper_vcpu_crash(struct xen_hyper_vcpu_context *vcc);
+void print_pcpu_header_hyper(FILE *out, int pcpu, int newline);
+
+/*
+ * Xen Hyper command
+ */
+void cmd_xen_hyper_help(void);
+void cmd_xen_hyper_domain(void);
+void cmd_xen_hyper_doms(void);
+void cmd_xen_hyper_dumpinfo(void);
+void cmd_xen_hyper_log(void);
+void dump_xen_hyper_log(void);
+void cmd_xen_hyper_pcpus(void);
+void cmd_xen_hyper_sys(void);
+void cmd_xen_hyper_vcpu(void);
+void cmd_xen_hyper_vcpus(void);
+void display_xen_hyper_sys_stats(void);
+
+void show_xen_hyper_vcpu_context(struct xen_hyper_vcpu_context *vcc);
+char *xen_hyper_domain_state_string(struct xen_hyper_domain_context *dc,
+	char *buf, int verbose);
+char *xen_hyper_vcpu_state_string(struct xen_hyper_vcpu_context *vcc,
+	char *buf, int verbose);
+
+/* tools */
+void xen_hyper_fpr_indent(FILE *fp, int len, char *str1, char *str2, int flag);
+
+#else
+
+#define XEN_HYPERVISOR_NOT_SUPPORTED \
+    "Xen hypervisor mode not supported on this architecture\n"
+
+#endif
diff -purN crash-4.0-3.9/xen_hyper_dump_tables.c crash-4.0-3.14/xen_hyper_dump_tables.c
--- crash-4.0-3.9/xen_hyper_dump_tables.c	1970-01-01 01:00:00.000000000 +0100
+++ crash-4.0-3.14/xen_hyper_dump_tables.c	2006-12-01 21:39:42.000000000 +0100
@@ -0,0 +1,467 @@
+/*
+ *  xen_hyper_dump_tables.c
+ *
+ *  Portions Copyright (C) 2006 Fujitsu Limited
+ *  Portions Copyright (C) 2006 VA Linux Systems Japan K.K.
+ *
+ *  This file is part of Xencrash.
+ *
+ *  Xencrash 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 (version 2 of the License).
+ *
+ *  Xencrash 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.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Xencrash; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA.
+ */
+
+#include "defs.h"
+
+#ifdef XEN_HYPERVISOR_ARCH
+#include "xen_hyper_defs.h"
+
+static void dump_xen_hyper_table(int verbose);
+static void dump_xen_hyper_domain_table(int verbose);
+static void dump_xen_hyper_vcpu_table(int verbose);
+static void dump_xen_hyper_pcpu_table(int verbose);
+static void dump_xen_hyper_size_table(char *spec, ulong makestruct);
+static void dump_xen_hyper_offset_table(char *spec, ulong makestruct);
+
+/*
+ *  Get help for a command, to dump an internal table, or the GNU public
+ *  license copying/warranty information.
+ */
+void
+cmd_xen_hyper_help(void)
+{
+	int c;
+	int oflag;
+
+	oflag = 0;
+
+        while ((c = getopt(argcnt, args, 
+	        "aBbcDgHhMmnOopszX:")) != EOF) {
+                switch(c)
+                {
+		case 'a':
+			dump_alias_data();
+			return;
+		case 'b':
+			dump_shared_bufs();
+			return;
+		case 'B':
+			dump_build_data();
+			return;
+		case 'c':
+			dump_numargs_cache();
+			return;
+		case 'n':
+		case 'D':
+			dumpfile_memory(DUMPFILE_MEM_DUMP);
+			return;
+		case 'g':
+			dump_gdb_data();
+			return;
+		case 'H':
+			dump_hash_table(VERBOSE);
+			return;
+		case 'h':
+			dump_hash_table(!VERBOSE);
+ 			return;
+		case 'M':
+			dump_machdep_table(stol(optarg, FAULT_ON_ERROR, NULL));
+			return;
+		case 'm':
+			dump_machdep_table(0);
+			return;
+		case 'O':
+			dump_offset_table(NULL, TRUE);
+			return;
+		case 'o':
+			oflag = TRUE;
+			break;
+		case 'p':
+			dump_program_context();
+			return;
+		case 's':
+			dump_symbol_table();
+			return;
+		case 'X':
+			if (strlen(optarg) != 3) {
+				argerrs++;
+				break;
+			}
+			if (!strncmp("Xen", optarg, strlen(optarg)))
+				dump_xen_hyper_table(VERBOSE);
+			else if (!strncmp("xen", optarg, strlen(optarg)))
+				dump_xen_hyper_table(!VERBOSE);
+			else if (!strncmp("Dom", optarg, strlen(optarg)))
+				dump_xen_hyper_domain_table(VERBOSE);
+			else if (!strncmp("dom", optarg, strlen(optarg)))
+				dump_xen_hyper_domain_table(!VERBOSE);
+			else if (!strncmp("Vcp", optarg, strlen(optarg)))
+				dump_xen_hyper_vcpu_table(VERBOSE);
+			else if (!strncmp("vcp", optarg, strlen(optarg)))
+				dump_xen_hyper_vcpu_table(!VERBOSE);
+			else if (!strncmp("Pcp", optarg, strlen(optarg)))
+				dump_xen_hyper_pcpu_table(!VERBOSE);
+			else if (!strncmp("pcp", optarg, strlen(optarg)))
+				dump_xen_hyper_pcpu_table(VERBOSE);
+			else if (!strncmp("siz", optarg, strlen(optarg)))
+				dump_xen_hyper_size_table(NULL, TRUE);
+			else if (!strncmp("ofs", optarg, strlen(optarg)))
+				dump_xen_hyper_offset_table(NULL, TRUE);
+ 			return;
+		case 'z':
+			fprintf(fp, "help options:\n");
+			fprintf(fp, " -a - alias data\n");
+			fprintf(fp, " -b - shared buffer data\n");
+			fprintf(fp, " -B - build data\n");
+			fprintf(fp, " -c - numargs cache\n");
+			fprintf(fp, " -M <num> machine specific\n");
+			fprintf(fp, " -m - machdep_table\n");
+			fprintf(fp, " -s - symbol table data\n");
+			fprintf(fp, " -o - offset_table and size_table\n");
+			fprintf(fp, " -p - program_context\n");
+			fprintf(fp, " -h - hash_table data\n");
+			fprintf(fp, " -H - hash_table data (verbose)\n");
+			fprintf(fp, " -X Xen - xen table data (verbose)\n");
+			fprintf(fp, " -X xen - xen table data\n");
+			fprintf(fp, " -X Dom - domain table data (verbose)\n");
+			fprintf(fp, " -X dom - domain table data\n");
+			fprintf(fp, " -X Vcp - vcpu table data (verbose)\n");
+			fprintf(fp, " -X vcp - vcpu table data\n");
+			fprintf(fp, " -X Pcp - pcpu table data (verbose)\n");
+			fprintf(fp, " -X pcp - pcpu table data\n");
+			fprintf(fp, " -X siz - size table data\n");
+			fprintf(fp, " -X ofs - offset table data\n");
+			return;
+                default:  
+			argerrs++;
+                        break;
+                }
+        }
+
+        if (argerrs)
+                cmd_usage(pc->curcmd, COMPLETE_HELP);
+
+	if (!args[optind]) {
+		if (oflag) 
+			dump_offset_table(NULL, FALSE);
+		else 
+			display_help_screen("");
+		return;
+	}
+
+        do {
+		if (oflag) 
+			dump_offset_table(args[optind], FALSE);
+		else	
+        		cmd_usage(args[optind], COMPLETE_HELP);
+		optind++;
+        } while (args[optind]);
+}
+
+/*
+ * "help -x xen" output
+ */
+static void
+dump_xen_hyper_table(int verbose)
+{
+	char buf[XEN_HYPER_CMD_BUFSIZE];
+	int len, flag;
+
+	len = 14;
+	flag = XEN_HYPER_PRI_R;
+
+	XEN_HYPER_PRI(fp, len, "cpu_curr: ", buf, flag,
+		(buf, "%u\n", xht->cpu_curr));
+	XEN_HYPER_PRI(fp, len, "max_cpus: ", buf, flag,
+		(buf, "%u\n", xht->max_cpus));
+	XEN_HYPER_PRI(fp, len, "cores: ", buf, flag,
+		(buf, "%d\n", xht->cores));
+	XEN_HYPER_PRI(fp, len, "pcpus: ", buf, flag,
+		(buf, "%d\n", xht->pcpus));
+	XEN_HYPER_PRI(fp, len, "vcpus: ", buf, flag,
+		(buf, "%d\n", xht->vcpus));
+	XEN_HYPER_PRI(fp, len, "domains: ", buf, flag,
+		(buf, "%d\n", xht->domains));
+	XEN_HYPER_PRI(fp, len, "crashing_cpu: ", buf, flag,
+		(buf, "%d\n", xht->crashing_cpu));
+	XEN_HYPER_PRI(fp, len, "crashing_vcc: ", buf, flag,
+		(buf, "%p\n", xht->crashing_vcc));
+	XEN_HYPER_PRI(fp, len, "max_page: ", buf, flag,
+		(buf, "%lu\n", xht->max_page));
+}
+
+/*
+ * "help -x dom" output
+ */
+static void
+dump_xen_hyper_domain_table(int verbose)
+{
+	char buf[XEN_HYPER_CMD_BUFSIZE];
+	int len, flag;
+
+	len = 22;
+	flag = XEN_HYPER_PRI_R;
+
+	XEN_HYPER_PRI(fp, len, "context_array: ", buf, flag,
+		(buf, "%p\n", xhdt->context_array));
+	XEN_HYPER_PRI(fp, len, "context_array_cnt: ", buf, flag,
+		(buf, "%d\n", xhdt->context_array_cnt));
+	XEN_HYPER_PRI(fp, len, "running_domains: ", buf, flag,
+		(buf, "%lu\n", xhdt->running_domains));
+	XEN_HYPER_PRI(fp, len, "dom0: ", buf, flag,
+		(buf, "%p\n", xhdt->dom0));
+	XEN_HYPER_PRI(fp, len, "idle_domain: ", buf, flag,
+		(buf, "%p\n", xhdt->idle_domain));
+	XEN_HYPER_PRI(fp, len, "curr_domain: ", buf, flag,
+		(buf, "%p\n", xhdt->curr_domain));
+	XEN_HYPER_PRI(fp, len, "last: ", buf, flag,
+		(buf, "%p\n", xhdt->last));
+	XEN_HYPER_PRI(fp, len, "domain_struct: ", buf, flag,
+		(buf, "%p\n", xhdt->domain_struct));
+	XEN_HYPER_PRI(fp, len, "domain_struct_verify: ", buf, flag,
+		(buf, "%p\n", xhdt->domain_struct_verify));
+}
+
+/*
+ * "help -x vcp" output
+ */
+static void
+dump_xen_hyper_vcpu_table(int verbose)
+{
+	char buf[XEN_HYPER_CMD_BUFSIZE];
+	int len, flag;
+
+	len = 25;
+	flag = XEN_HYPER_PRI_R;
+
+	XEN_HYPER_PRI(fp, len, "vcpu_context_arrays: ", buf, flag,
+		(buf, "%p\n", xhvct->vcpu_context_arrays));
+	XEN_HYPER_PRI(fp, len, "vcpu_context_arrays_cnt: ", buf, flag,
+		(buf, "%d\n", xhvct->vcpu_context_arrays_cnt));
+	XEN_HYPER_PRI(fp, len, "idle_vcpu: ", buf, flag,
+		(buf, "%lx\n", xhvct->idle_vcpu));
+	XEN_HYPER_PRI(fp, len, "idle_vcpu_context_array: ", buf, flag,
+		(buf, "%p\n", xhvct->idle_vcpu_context_array));
+	XEN_HYPER_PRI(fp, len, "last: ", buf, flag,
+		(buf, "%p\n", xhvct->last));
+	XEN_HYPER_PRI(fp, len, "vcpu_struct: ", buf, flag,
+		(buf, "%p\n", xhvct->vcpu_struct));
+	XEN_HYPER_PRI(fp, len, "vcpu_struct_verify: ", buf, flag,
+		(buf, "%p\n", xhvct->vcpu_struct_verify));
+}
+
+/*
+ * "help -x pcp" output
+ */
+static void
+dump_xen_hyper_pcpu_table(int verbose)
+{
+	char buf[XEN_HYPER_CMD_BUFSIZE];
+	int len, flag;
+
+	len = 15;
+	flag = XEN_HYPER_PRI_R;
+
+	XEN_HYPER_PRI(fp, len, "context_array: ", buf, flag,
+		(buf, "%p\n", xhpct->context_array));
+	XEN_HYPER_PRI(fp, len, "last: ", buf, flag,
+		(buf, "%p\n", xhpct->last));
+	XEN_HYPER_PRI(fp, len, "pcpu_struct: ", buf, flag,
+		(buf, "%p\n", xhpct->pcpu_struct));
+}
+
+/*
+ * "help -x siz" output
+ */
+static void
+dump_xen_hyper_size_table(char *spec, ulong makestruct)
+{
+	char buf[XEN_HYPER_CMD_BUFSIZE];
+	int len, flag;
+
+	len = 20;
+	flag = XEN_HYPER_PRI_R;
+
+	XEN_HYPER_PRI(fp, len, "ELF_Prstatus: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.ELF_Prstatus));
+	XEN_HYPER_PRI(fp, len, "ELF_Signifo: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.ELF_Signifo));
+	XEN_HYPER_PRI(fp, len, "ELF_Gregset: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.ELF_Gregset));
+	XEN_HYPER_PRI(fp, len, "ELF_Timeval: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.ELF_Timeval));
+	XEN_HYPER_PRI(fp, len, "cpu_info: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.cpu_info));
+	XEN_HYPER_PRI(fp, len, "cpu_time: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.cpu_time));
+	XEN_HYPER_PRI(fp, len, "cpu_user_regs: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.cpu_user_regs));
+	XEN_HYPER_PRI(fp, len, "cpuinfo_x86: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.cpuinfo_x86));
+	XEN_HYPER_PRI(fp, len, "domain: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.domain));
+	XEN_HYPER_PRI(fp, len, "note_buf_t: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.note_buf_t));
+	XEN_HYPER_PRI(fp, len, "scheduler: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.scheduler));
+	XEN_HYPER_PRI(fp, len, "timer: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.timer));
+	XEN_HYPER_PRI(fp, len, "tss_struct: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.tss_struct));
+	XEN_HYPER_PRI(fp, len, "vcpu: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.vcpu));
+	XEN_HYPER_PRI(fp, len, "vcpu_runstate_info: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.vcpu_runstate_info));
+}
+
+/*
+ * "help -x ofs" output
+ */
+static void
+dump_xen_hyper_offset_table(char *spec, ulong makestruct)
+{
+	char buf[XEN_HYPER_CMD_BUFSIZE];
+	int len, flag;
+
+	len = 37;
+	flag = XEN_HYPER_PRI_R;
+
+	XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_info: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_info));
+	XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_cursig: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_cursig));
+	XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_sigpend: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_sigpend));
+	XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_sighold: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_sighold));
+	XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_pid: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_pid));
+	XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_ppid: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_ppid));
+	XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_pgrp: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_pgrp));
+	XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_sid: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_sid));
+	XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_stime: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_stime));
+	XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_cutime: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_cutime));
+	XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_cstime: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_cstime));
+	XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_reg: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_reg));
+	XEN_HYPER_PRI(fp, len, "ELF_Prstatus_pr_fpvalid: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.ELF_Prstatus_pr_fpvalid));
+	XEN_HYPER_PRI(fp, len, "ELF_Timeval_tv_sec: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.ELF_Timeval_tv_sec));
+	XEN_HYPER_PRI(fp, len, "ELF_Timeval_tv_usec: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.ELF_Timeval_tv_usec));
+	XEN_HYPER_PRI(fp, len, "cpu_info_guest_cpu_user_regs: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.cpu_info_guest_cpu_user_regs));
+	XEN_HYPER_PRI(fp, len, "cpu_info_processor_id: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.cpu_info_processor_id));
+	XEN_HYPER_PRI(fp, len, "cpu_info_current_vcpu: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.cpu_info_current_vcpu));
+	XEN_HYPER_PRI(fp, len, "cpu_time_local_tsc_stamp: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.cpu_time_local_tsc_stamp));
+	XEN_HYPER_PRI(fp, len, "cpu_time_stime_local_stamp: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.cpu_time_stime_local_stamp));
+	XEN_HYPER_PRI(fp, len, "cpu_time_stime_master_stamp: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.cpu_time_stime_master_stamp));
+	XEN_HYPER_PRI(fp, len, "cpu_time_tsc_scale: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.cpu_time_tsc_scale));
+	XEN_HYPER_PRI(fp, len, "cpu_time_calibration_timer: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.cpu_time_calibration_timer));
+	XEN_HYPER_PRI(fp, len, "domain_page_list: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.domain_page_list));
+	XEN_HYPER_PRI(fp, len, "domain_xenpage_list: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.domain_xenpage_list));
+	XEN_HYPER_PRI(fp, len, "domain_domain_id: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.domain_domain_id));
+	XEN_HYPER_PRI(fp, len, "domain_tot_pages: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.domain_tot_pages));
+	XEN_HYPER_PRI(fp, len, "domain_max_pages: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.domain_max_pages));
+	XEN_HYPER_PRI(fp, len, "domain_xenheap_pages: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.domain_xenheap_pages));
+	XEN_HYPER_PRI(fp, len, "domain_shared_info: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.domain_shared_info));
+	XEN_HYPER_PRI(fp, len, "domain_sched_priv: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.domain_sched_priv));
+	XEN_HYPER_PRI(fp, len, "domain_next_in_list: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.domain_next_in_list));
+	XEN_HYPER_PRI(fp, len, "domain_domain_flags: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.domain_domain_flags));
+	XEN_HYPER_PRI(fp, len, "domain_evtchn: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.domain_evtchn));
+	XEN_HYPER_PRI(fp, len, "domain_vcpu: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.domain_vcpu));
+	XEN_HYPER_PRI(fp, len, "timer_expires: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.timer_expires));
+	XEN_HYPER_PRI(fp, len, "timer_cpu: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.timer_cpu));
+	XEN_HYPER_PRI(fp, len, "timer_function: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.timer_function));
+	XEN_HYPER_PRI(fp, len, "timer_data: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.timer_data));
+	XEN_HYPER_PRI(fp, len, "timer_heap_offset: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.timer_heap_offset));
+	XEN_HYPER_PRI(fp, len, "timer_killed: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.timer_killed));
+	XEN_HYPER_PRI(fp, len, "tss_struct_rsp0: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.tss_struct_rsp0));
+	XEN_HYPER_PRI(fp, len, "tss_struct_esp0: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.tss_struct_esp0));
+	XEN_HYPER_PRI(fp, len, "vcpu_vcpu_id: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.vcpu_vcpu_id));
+	XEN_HYPER_PRI(fp, len, "vcpu_processor: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.vcpu_processor));
+	XEN_HYPER_PRI(fp, len, "vcpu_vcpu_info: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.vcpu_vcpu_info));
+	XEN_HYPER_PRI(fp, len, "vcpu_domain: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.vcpu_domain));
+	XEN_HYPER_PRI(fp, len, "vcpu_next_in_list: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.vcpu_next_in_list));
+	XEN_HYPER_PRI(fp, len, "vcpu_timer: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.vcpu_timer));
+	XEN_HYPER_PRI(fp, len, "vcpu_sleep_tick: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.vcpu_sleep_tick));
+	XEN_HYPER_PRI(fp, len, "vcpu_poll_timer: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.vcpu_poll_timer));
+	XEN_HYPER_PRI(fp, len, "vcpu_sched_priv: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.vcpu_sched_priv));
+	XEN_HYPER_PRI(fp, len, "vcpu_runstate: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.vcpu_runstate));
+	XEN_HYPER_PRI(fp, len, "vcpu_runstate_guest: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.vcpu_runstate_guest));
+	XEN_HYPER_PRI(fp, len, "vcpu_vcpu_flags: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.vcpu_vcpu_flags));
+	XEN_HYPER_PRI(fp, len, "vcpu_pause_count: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.vcpu_pause_count));
+	XEN_HYPER_PRI(fp, len, "vcpu_virq_to_evtchn: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.vcpu_virq_to_evtchn));
+	XEN_HYPER_PRI(fp, len, "vcpu_cpu_affinity: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.vcpu_cpu_affinity));
+	XEN_HYPER_PRI(fp, len, "vcpu_nmi_addr: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.vcpu_nmi_addr));
+	XEN_HYPER_PRI(fp, len, "vcpu_vcpu_dirty_cpumask: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.vcpu_vcpu_dirty_cpumask));
+	XEN_HYPER_PRI(fp, len, "vcpu_arch: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.vcpu_arch));
+	XEN_HYPER_PRI(fp, len, "vcpu_runstate_info_state: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.vcpu_runstate_info_state));
+	XEN_HYPER_PRI(fp, len, "vcpu_runstate_info_state_entry_time: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.vcpu_runstate_info_state_entry_time));
+	XEN_HYPER_PRI(fp, len, "vcpu_runstate_info_time: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.vcpu_runstate_info_time));
+}
+#endif
diff -purN crash-4.0-3.9/xen_hyper_global_data.c crash-4.0-3.14/xen_hyper_global_data.c
--- crash-4.0-3.9/xen_hyper_global_data.c	1970-01-01 01:00:00.000000000 +0100
+++ crash-4.0-3.14/xen_hyper_global_data.c	2006-12-01 21:39:42.000000000 +0100
@@ -0,0 +1,261 @@
+/*
+ *  xen_hyper_global_data.c
+ *
+ *  Portions Copyright (C) 2006 Fujitsu Limited
+ *  Portions Copyright (C) 2006 VA Linux Systems Japan K.K.
+ *
+ *  This file is part of Xencrash.
+ *
+ *  Xencrash 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 (version 2 of the License).
+ *
+ *  Xencrash 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.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Xencrash; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA.
+ */
+
+#include "defs.h"
+
+#ifdef XEN_HYPERVISOR_ARCH
+#include "xen_hyper_defs.h"
+
+/*
+ * Global data for Xen hypervisor.
+ */
+
+struct xen_hyper_machdep_table xen_hyper_machdep_table = { 0 };
+struct xen_hyper_machdep_table *xhmachdep = &xen_hyper_machdep_table;
+
+struct xen_hyper_table xen_hyper_table = { 0 };
+struct xen_hyper_table *xht = &xen_hyper_table;
+
+struct xen_hyper_dumpinfo_table xen_hyper_dumpinfo_table = { 0 };
+struct xen_hyper_dumpinfo_table *xhdit = &xen_hyper_dumpinfo_table;
+
+struct xen_hyper_domain_table xen_hyper_domain_table = { 0 };
+struct xen_hyper_domain_table *xhdt = &xen_hyper_domain_table;
+
+struct xen_hyper_vcpu_table xen_hyper_vcpu_table = { 0 };
+struct xen_hyper_vcpu_table *xhvct = &xen_hyper_vcpu_table;
+
+struct xen_hyper_pcpu_table xen_hyper_pcpu_table = { 0 };
+struct xen_hyper_pcpu_table *xhpct = &xen_hyper_pcpu_table;
+
+struct xen_hyper_sched_table xen_hyper_sched_table = { 0 };
+struct xen_hyper_sched_table *xhscht = &xen_hyper_sched_table;
+
+struct xen_hyper_symbol_table_data xen_hyper_symbol_table_data = { 0 };
+struct xen_hyper_symbol_table_data *xhsymt = &xen_hyper_symbol_table_data;
+
+/*
+ * The following commands are for Xen hypervisor.
+ */
+
+struct command_table_entry xen_hyper_command_table[] = {
+	{"*", 	    cmd_pointer, help_pointer, 0},
+	{"alias",   cmd_alias,   help_alias,   0},
+        {"ascii",   cmd_ascii,   help_ascii,   0},
+        {"bt",      cmd_bt,      help_bt,      0},
+	{"dis",     cmd_dis,     help_dis,     0},
+	{"domain",  cmd_xen_hyper_domain,   help_xen_hyper_domain,  REFRESH_TASK_TABLE},
+	{"doms",    cmd_xen_hyper_doms,     help_xen_hyper_doms,    REFRESH_TASK_TABLE},
+	{"dumpinfo",cmd_xen_hyper_dumpinfo, help_xen_hyper_dumpinfo,0},
+	{"eval",    cmd_eval,    help_eval,    0},
+	{"exit",    cmd_quit,    help_exit,    0},
+	{"extend",  cmd_extend,  help_extend,  0},
+	{"foreach", cmd_foreach, help_foreach, 0},
+	{"gdb",     cmd_gdb,     help_gdb,     0},
+        {"help",    cmd_xen_hyper_help,     help_help,              0},
+	{"list",    cmd_list,    help__list,   0},
+	{"log",     cmd_xen_hyper_log,      help_xen_hyper_log,     0},
+	{"p",       cmd_p,       help_p,       0},
+	{"pcpus",   cmd_xen_hyper_pcpus,    help_xen_hyper_pcpus,   0},
+        {"pte",     cmd_pte,     help_pte,     0},
+        {"q",       cmd_quit,    help_quit,    0},
+        {"rd",      cmd_rd,      help_rd,      0},
+	{"repeat",  cmd_repeat,  help_repeat,  0},
+        {"search",  cmd_search,  help_search,  0},
+        {"set",     cmd_set,     help_set,     0},
+        {"struct",  cmd_struct,  help_struct,  0},
+        {"sym",     cmd_sym,     help_sym,     0},
+        {"sys",     cmd_xen_hyper_sys,      help_xen_hyper_sys,     0},
+	{"test",    cmd_test,    NULL,         HIDDEN_COMMAND},
+	{"union",   cmd_union,   help_union,   0},
+	{"vcpu",    cmd_xen_hyper_vcpu,     help_xen_hyper_vcpu,    REFRESH_TASK_TABLE},
+	{"vcpus",   cmd_xen_hyper_vcpus,    help_xen_hyper_vcpus,   REFRESH_TASK_TABLE},
+	{"whatis",  cmd_whatis,  help_whatis,  0},
+	{"wr",      cmd_wr,      help_wr,      0},
+	{(char *)NULL}
+};
+
+/*
+ *
+ */
+struct xen_hyper_offset_table xen_hyper_offset_table = { 0 };
+struct xen_hyper_size_table xen_hyper_size_table = { 0 };
+
+/*
+ * help data
+ */
+
+char *help_xen_hyper_domain[] = {
+"domain",
+"display contents of domain struct",
+"[domain-id | domainp] ...",
+"  This command displays contents of domain struct for selected, or all, domains",
+"     domain-id  a domain id.",
+"       domainp  a domain pointer.",
+NULL               
+};
+
+char *help_xen_hyper_doms[] = {
+"doms",
+"display domain status information",
+"[domain-id | domainp] ...",
+"  This command displays domain status for selected, or all, domains" ,
+"     domain-id  a domain id.",
+"       domainp  a domain pointer.",
+" ",
+"    1. the DOMAIN-ID.",
+"    2. the struct domain pointer.",
+"    3. the domain state (SH, DY, CP, PO, PA, RU).",
+"    4. the TYPE of domain(I, 0, G).",
+"    5. displays percentage of page of max_pages member of domain",
+"       for max_page of system.",
+"    6. displays percentage of page of tot_pages member of domain" ,
+"       for max_page of system." ,
+"    7. a number of vcpu that domain is assigned.",
+" ",
+"  The active domain on each CPU will be highlighted by an angle ",
+"  bracket (\">\") preceding its information.",
+"  The crashing domain on each CPU will be highlighted by an aster ",
+"  (\"*\") preceding its information.",
+"\nEXAMPLES",
+"  Show the domain status of all:\n",
+"    %s> doms",
+"       DID   DOMAIN  ST T %MMEM %TMEM VCPU",
+"      32767 ffbfc080 RU I   0.0   0.0   2",
+"    >*    0 ff198080 RU 0 100.0  79.0   2",
+"          4 ffbee080 RU G   6.3   6.3   2",
+"          5 ff186080 RU G   6.3   6.3   2",
+"    %s>",
+NULL               
+};
+
+char *help_xen_hyper_dumpinfo[] = {
+"dumpinfo",
+"display Xen dump information",
+"[-t | -r] [pcpu-id | enotep] ...",
+"  This command displays Xen dump information for selected, or all, cpus" ,
+"       pcpu-id  a physical cpu id.",
+"        enotep  a ELF Note pointer.",
+"            -t  display time information.",
+"            -r  display register information.",
+NULL               
+};
+
+char *help_xen_hyper_log[] = {
+"log",
+"dump system message buffer",
+"  This command dumps the xen conring contents in chronological order." ,
+NULL               
+};
+
+char *help_xen_hyper_pcpus[] = {
+"pcpus",
+"display physical cpu information",
+"[-r] [pcpu-id | pcpup] ...",
+"  This command displays physical cpu information for selected, or all, cpus" ,
+"       pcpu-id  a physical cpu id.",
+"         pcpup  a physical cpu pointer.",
+"      cur-vcpu  a current virtual cpu pointer.",
+"            -r  display register information.",
+" ",
+"  The crashing physical cpu will be highlighted by an aster ",
+"  (\"*\") preceding its information.",
+"\nEXAMPLES",
+"  Show the physical cpu status of all:\n",
+"    %s> pcpus",
+"       PCID   PCPU   CUR-VCPU",
+"          0 ff1a3fb4 ffbf9080",
+"     *    1 ff1dbfb4 ffbf8080",
+"    %s>",
+NULL               
+};
+
+char *help_xen_hyper_sys[] = {
+"sys",
+"system data",
+"[-c [name|number]] config",
+"  This command displays system-specific data.  If no arguments are entered,\n"
+"  the same system data shown during %s invocation is shown.\n",
+"\nEXAMPLES",
+"  Display essential system information:\n",
+"    %s> sys",
+"      DEBUG KERNEL: xen-syms",
+"          DUMPFILE: vmcore",
+"              CPUS: 2",
+"           DOMAINS: 2",
+"           MACHINE: Pentium III (Coppermine)  (866 Mhz)",
+"            MEMORY: 2 GB",
+"    %s>",
+NULL               
+};
+
+char *help_xen_hyper_vcpu[] = {
+"vcpu",
+"display contents of vcpu struct",
+"[vcpup] ...",
+"  This command displays contents of vcpu struct for selected, or all, vcpus",
+"       vcpu-id  a virtual cpu id.",
+"         vcpup  a virtual cpu pointer.",
+NULL               
+};
+
+char *help_xen_hyper_vcpus[] = {
+"vcpus",
+"display vcpu status information",
+"[-i domain-id vcpu-id | vcpup] ...",
+"  This command displays vcpu status for selected, or all, vcpus" ,
+"     domain-id  a domain id.",
+"       vcpu-id  a VCPU-ID.",
+"         vcpup  a hexadecimal struct vcpu pointer.",
+"            -i  specify vcpu id as an argument.",
+" ",
+"    1. the VCPU-ID.",
+"    2. the physical CPU-ID.",
+"    3. the struct vcpu pointer.",
+"    4. the vcpu state (RU, BL, OF).",
+"    5. the TYPE of domain that vcpu is assigned(I, 0, G).",
+"    6. the DOMAIN-ID of domain that vcpu is assigned.",
+"    7. the struct domain pointer of domain that vcpu is assigned.",
+" ",
+"  The active vcpu on each CPU will be highlighted by an angle ",
+"  bracket (\">\") preceding its information.",
+"  The crashing vcpu on each CPU will be highlighted by an aster ",
+"  (\"*\") preceding its information.",
+"\nEXAMPLES",
+"  Show the vcpu status of all:\n",
+"    %s> vcpus",
+"       VCID  PCID   VCPU   ST T DOMID  DOMAIN",
+"          0     0 ffbfe080 RU I 32767 ffbfc080",
+"          1     1 ff1df080 RU I 32767 ffbfc080",
+"    >*    0     0 ff195180 RU 0     0 ff198080",
+"    >     1     1 ff190080 BL 0     0 ff198080",
+"          0     1 ff18a080 BL G     4 ffbee080",
+"          1     0 ff189080 BL G     4 ffbee080",
+"          0     1 ff1f3080 BL G     5 ff186080",
+"          1     0 ff1f2080 BL G     5 ff186080",
+"    %s>",
+NULL               
+};
+
+struct task_context fake_tc = { 0 };
+
+#endif
diff -purN crash-4.0-3.9/xendump.c crash-4.0-3.14/xendump.c
--- crash-4.0-3.9/xendump.c	2006-07-13 20:51:50.000000000 +0200
+++ crash-4.0-3.14/xendump.c	2006-12-01 21:39:42.000000000 +0100
@@ -668,6 +668,32 @@ read_xendump(int fd, void *bufptr, int c
 }
 
 int
+read_xendump_hyper(int fd, void *bufptr, int cnt, ulong addr, physaddr_t paddr)
+{
+        ulong pfn, page_index;
+        off_t offset;
+
+        pfn = (ulong)BTOP(paddr);
+
+	/* ODA: pfn == mfn !!! */
+        if ((page_index = xc_core_mfn_to_page_index(pfn)) == PFN_NOT_FOUND)
+                return READ_ERROR;
+
+        offset = (off_t)xd->xc_core.header.xch_pages_offset +
+                ((off_t)(page_index) * (off_t)xd->page_size);
+
+        if (lseek(xd->xfd, offset, SEEK_SET) == -1)
+                return SEEK_ERROR;
+
+        if (read(xd->xfd, xd->page, xd->page_size) != xd->page_size)
+                return READ_ERROR;
+
+        BCOPY(xd->page + PAGEOFFSET(paddr), bufptr, cnt);
+
+        return cnt;
+}
+
+int
 write_xendump(int fd, void *bufptr, int cnt, ulong addr, physaddr_t paddr)
 {
         return WRITE_ERROR;

Places

File crash-4.0-3.9-3.14.patch of Package crash (Revision 4e212cfae17dcbfea71a02de321cbb7f)

Places