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

Overview Repositories Revisions Requests Users Attributes Meta

File crash-4.0-3.14-3.15.patch of Package crash (Revision c1bc67168c997b363420d83149e8c6f5)

Currently displaying revision c1bc67168c997b363420d83149e8c6f5 , Show latest

diff -Nur crash-4.0-2.33/defs.h crash-4.0-3.15/defs.h
--- crash-4.0-3.14/defs.h	2006-12-20 16:41:21.000000000 +0100
+++ crash-4.0-3.15/defs.h	2006-12-20 15:57:05.000000000 +0100
@@ -791,6 +791,7 @@
             machdep->last_ptbl_read = (ulong)(PTBL); 	                    \
     }
 
+#define SETUP_ENV  (0)
 #define PRE_SYMTAB (1)
 #define PRE_GDB    (2)
 #define POST_GDB   (3)
@@ -3887,6 +3888,7 @@
 int kdump_memory_used(void);
 int kdump_memory_dump(FILE *);
 void get_kdump_regs(struct bt_info *, ulong *, ulong *);
+void xen_kdump_p2m_mfn(char *);
 
 /*
  *  diskdump.c
diff -Nur crash-4.0-2.33/extensions.c crash-4.0-3.15/extensions.c
--- crash-4.0-3.14/extensions.c	2006-07-13 20:51:50.000000000 +0200
+++ crash-4.0-3.15/extensions.c	2006-12-20 15:57:05.000000000 +0100
@@ -205,7 +205,7 @@
         *  _init() function before dlopen() returns below.
 	*/
 	pc->curext = ext;
-	ext->handle = dlopen(ext->filename, RTLD_NOW); 
+	ext->handle = dlopen(ext->filename, RTLD_NOW|RTLD_GLOBAL); 
 
 	if (!ext->handle) {
 		strcpy(buf, dlerror());
diff -Nur crash-4.0-2.33/help.c crash-4.0-3.15/help.c
--- crash-4.0-3.14/help.c	2006-12-20 16:41:21.000000000 +0100
+++ crash-4.0-3.15/help.c	2006-12-20 15:57:05.000000000 +0100
@@ -5138,7 +5138,8 @@
 "Copyright (C) 2002, 2003, 2004, 2005, 2006  Red Hat, Inc.",
 "Copyright (C) 2004, 2005, 2006  IBM Corporation", 
 "Copyright (C) 1999-2006  Hewlett-Packard Co",
-"Copyright (C) 2005  Fujitsu Limited",
+"Copyright (C) 2005, 2006  Fujitsu Limited",
+"Copyright (C) 2006  VA Linux Systems Japan K.K.",
 "Copyright (C) 2005  NEC Corporation",
 "Copyright (C) 1999, 2002  Silicon Graphics, Inc.",
 "Copyright (C) 1999, 2000, 2001, 2002  Mission Critical Linux, Inc.",
diff -Nur crash-4.0-2.33/ia64.c crash-4.0-3.15/ia64.c
--- crash-4.0-3.14/ia64.c	2006-12-20 16:41:21.000000000 +0100
+++ crash-4.0-3.15/ia64.c	2006-12-20 15:57:05.000000000 +0100
@@ -89,13 +89,16 @@
 
         switch (when)
         {
-        case PRE_SYMTAB:
+	case SETUP_ENV:
 #if defined(PR_SET_FPEMU) && defined(PR_FPEMU_NOPRINT)
 		prctl(PR_SET_FPEMU, PR_FPEMU_NOPRINT, 0, 0, 0);
 #endif
 #if defined(PR_SET_UNALIGN) && defined(PR_UNALIGN_NOPRINT)
 		prctl(PR_SET_UNALIGN, PR_UNALIGN_NOPRINT, 0, 0, 0);
 #endif
+		break;
+
+        case PRE_SYMTAB:
                 machdep->verify_symbol = ia64_verify_symbol;
 		machdep->machspec = &ia64_machine_specific;
 		if (pc->flags & KERNEL_DEBUG_QUERY)
@@ -2570,9 +2573,10 @@
             !readmem(ia64_boot_param+
 	    MEMBER_OFFSET("ia64_boot_param", "efi_memmap"),
             KVADDR, &efi_memmap, sizeof(uint64_t), "efi_memmap", 
-	    RETURN_ON_ERROR)) {
-		error(WARNING, "cannot read ia64_boot_param: " 
-			"memory verification will not be performed\n\n");
+	    QUIET|RETURN_ON_ERROR)) {
+		if (!XEN() || CRASHDEBUG(1))
+			error(WARNING, "cannot read ia64_boot_param: " 
+			    "memory verification will not be performed\n\n");
 		return;
 	}
 
@@ -3871,6 +3875,11 @@
 static int
 ia64_xendump_p2m_create(struct xendump_data *xd)
 {
+	if (!symbol_exists("phys_to_machine_mapping")) {
+		xd->flags |= XC_CORE_NO_P2MM;
+		return TRUE;
+	}
+
 	error(FATAL, "ia64_xendump_p2m_create: TBD\n");
 
 	/* dummy calls for clean "make [wW]arn" */
@@ -3926,7 +3935,8 @@
 static ulong
 ia64_xendump_panic_task(struct xendump_data *xd)
 {
-	error(INFO, "ia64_xendump_panic_task: TBD\n");
+	if (CRASHDEBUG(1))
+		error(INFO, "ia64_xendump_panic_task: TBD\n");
 
 	return NO_TASK;
 }
@@ -3934,6 +3944,12 @@
 static void
 ia64_get_xendump_regs(struct xendump_data *xd, struct bt_info *bt, ulong *rip, ulong *rsp)
 {
-	error(FATAL, "ia64_get_xendump_regs: TBD\n");
+        machdep->get_stack_frame(bt, rip, rsp);
+
+	if (is_task_active(bt->task) &&
+            !(bt->flags & (BT_TEXT_SYMBOLS_ALL|BT_TEXT_SYMBOLS)) &&
+	    STREQ(closest_symbol(*rip), "schedule"))
+		error(INFO, 
+		    "xendump: switch_stack possibly not saved -- try \"bt -t\"\n");
 }
 #endif
diff -Nur crash-4.0-2.33/kernel.c crash-4.0-3.15/kernel.c
--- crash-4.0-3.14/kernel.c	2006-12-20 16:41:21.000000000 +0100
+++ crash-4.0-3.15/kernel.c	2006-12-20 15:57:05.000000000 +0100
@@ -71,16 +71,26 @@
 	kt->end = symbol_value("_end");
 	
 	/*
-	 *  If Xen architecture, default to writable page tables; for now
-	 *  it can be overridden with the --shared_page_tables command
-	 *  line option.
+	 *  For the Xen architecture, default to writable page tables unless:
+	 *  
+	 *  (1) it's an "xm save" CANONICAL_PAGE_TABLES dumpfile,  or
+	 *  (2) the --shadow_page_tables option was explicitly entered.  
+	 *
+	 *  But if the "phys_to_maching_mapping" array does not exist, and 
+         *  it's not an "xm save" canonical dumpfile, then we have no choice 
+         *  but to presume shadow page tables.
 	 */ 
 	if (symbol_exists("xen_start_info")) {
 		kt->flags |= ARCH_XEN;
 		if (!(kt->xen_flags & (SHADOW_PAGE_TABLES|CANONICAL_PAGE_TABLES)))
 			kt->xen_flags |= WRITABLE_PAGE_TABLES;
-         	get_symbol_data("phys_to_machine_mapping", sizeof(ulong),
-                       	&kt->phys_to_machine_mapping);
+		if (symbol_exists("phys_to_machine_mapping"))
+         		get_symbol_data("phys_to_machine_mapping", sizeof(ulong),
+                       		&kt->phys_to_machine_mapping);
+		else if (!(kt->xen_flags & CANONICAL_PAGE_TABLES)) {
+			kt->xen_flags &= ~WRITABLE_PAGE_TABLES;
+			kt->xen_flags |= SHADOW_PAGE_TABLES;
+		}
 		if (machine_type("X86"))
                 	get_symbol_data("max_pfn", sizeof(ulong), &kt->p2m_table_size);
 		if (machine_type("X86_64"))
@@ -1416,7 +1426,9 @@
 #ifdef XEN_HYPERVISOR_ARCH
 		/* "task" means physical cpu id */
 		if (active) {
-			for (c = 0; c < xht->pcpus; c++) {
+			for (c = 0; c < XEN_HYPER_MAX_CPUS(); c++) {
+				if (!xen_hyper_test_pcpu_id(c))
+					continue;
 				fake_tc.task = c;
 				BT_SETUP(&fake_tc);
 				print_pcpu_header_hyper(fp, c, subsequent++);
@@ -2660,16 +2672,20 @@
 		strcpy(file, filename);
 #ifdef MODULES_IN_CWD
        else {
-                sprintf(file, "%s.o", modref);
-                if (access(file, R_OK) == 0) {
-                        retbuf = GETBUF(strlen(file)+1);
-                        strcpy(retbuf, file);
-                        if (CRASHDEBUG(1))
-                            	fprintf(fp, 
-				    "find_module_objfile: [%s] file in cwd\n",
-                                	retbuf);
-                        return retbuf;
-                }
+		char *fileext[] = { "ko", "o"};
+		int i;
+		for (i = 0; i < 2; i++) {
+			sprintf(file, "%s.%s", modref, fileext[i]);
+			if (access(file, R_OK) == 0) {
+				retbuf = GETBUF(strlen(file)+1);
+				strcpy(retbuf, file);
+				if (CRASHDEBUG(1))
+					fprintf(fp, 
+					    "find_module_objfile: [%s] file in cwd\n",
+						retbuf);
+				return retbuf;
+			}
+		}
 	}
 #else
 	else 
@@ -2688,6 +2704,8 @@
 	if ((st->flags & INSMOD_BUILTIN) && !filename) {
 		sprintf(buf, "__insmod_%s_O/", modref);
 		if (symbol_query(buf, NULL, &sp) == 1) {
+                        if (CRASHDEBUG(1))
+                                fprintf(fp, "search: INSMOD_BUILTIN %s\n", sp->name);
 			BZERO(buf, BUFSIZE);
 			p1 = strstr(sp->name, "/");
 			if ((p2 = strstr(sp->name, file)))
diff -Nur crash-4.0-2.33/lkcd_common.c crash-4.0-3.15/lkcd_common.c
--- crash-4.0-3.14/lkcd_common.c	2006-07-13 20:51:50.000000000 +0200
+++ crash-4.0-3.15/lkcd_common.c	2006-12-20 15:57:05.000000000 +0100
@@ -626,6 +626,10 @@
 {
         static int i = 0;
 
+        if (pc->flags & SILENT) {
+                return;
+        }
+
         switch (++i%4) {
         case 0:
                 lkcd_print("|\b");
diff -Nur crash-4.0-2.33/lkcd_x86_trace.c crash-4.0-3.15/lkcd_x86_trace.c
--- crash-4.0-3.14/lkcd_x86_trace.c	2006-12-20 16:41:21.000000000 +0100
+++ crash-4.0-3.15/lkcd_x86_trace.c	2006-12-20 15:57:05.000000000 +0100
@@ -1554,8 +1554,8 @@
 			bp = curframe->fp + frame_size;
 		}
 #endif
-		if ((func_name = kl_funcname(pc))
-			&& !XEN_HYPER_MODE()) {
+		func_name = kl_funcname(pc);
+		if (func_name && !XEN_HYPER_MODE()) {
 			if (strstr(func_name, "kernel_thread")) {
 				ra = 0;
 				bp = saddr - 4;
@@ -1680,6 +1680,26 @@
 				}
 			}
 		}
+		if (func_name && XEN_HYPER_MODE()) {
+			if (STREQ(func_name, "continue_nmi")) {
+				/* Interrupt frame */
+				sp = curframe->fp + 4;
+				asp = (uaddr_t*)((uaddr_t)sbp + (STACK_SIZE - 
+						(saddr - sp)));
+				bp = curframe->fp + (12 * 4);
+				curframe = alloc_sframe(trace, flags);
+				ra = *(asp + 9);
+				UPDATE_FRAME(func_name, pc, ra, sp, bp + 4, asp,
+			       	0, 0, curframe->fp - curframe->sp+4, 12 * 4);
+
+				/* contunue next frame */
+				pc = ra;
+				sp = curframe->fp + 4;
+				bp = sp + get_framesize(pc, bt);
+				func_name = kl_funcname(pc);
+				continue;
+			}
+		}
 
 		/*
 		 *  Check for hypervisor_callback from user-space.
@@ -1925,7 +1945,7 @@
 	if (kt->flags & RA_SEEK)
 		bt->flags |= BT_SPECULATE;
 
-	if (XENDUMP_DUMPFILE() && is_task_active(bt->task) && 
+	if (XENDUMP_DUMPFILE() && XEN() && is_task_active(bt->task) && 
     	    STREQ(kl_funcname(bt->instptr), "stop_this_cpu")) {
 		/*
 		 *  bt->instptr of "stop_this_cpu" is not a return
@@ -1941,7 +1961,7 @@
 				kl_funcname(bt->instptr));
 	}
 
-	if (XENDUMP_DUMPFILE() && is_idle_thread(bt->task) &&
+	if (XENDUMP_DUMPFILE() && XEN() && is_idle_thread(bt->task) &&
 	    is_task_active(bt->task) && 
 	    !(kt->xen_flags & XEN_SUSPEND) &&
     	    STREQ(kl_funcname(bt->instptr), "schedule")) {
@@ -1969,7 +1989,7 @@
 		}
 	}
 
-        if (XENDUMP_DUMPFILE() && is_idle_thread(bt->task) &&
+        if (XENDUMP_DUMPFILE() && XEN() && is_idle_thread(bt->task) &&
             is_task_active(bt->task) &&
             (kt->xen_flags & XEN_SUSPEND) &&
             STREQ(kl_funcname(bt->instptr), "schedule")) {
@@ -2006,7 +2026,7 @@
                 }
         }
 
-	if (XENDUMP_DUMPFILE() && !is_idle_thread(bt->task) &&
+	if (XENDUMP_DUMPFILE() && XEN() && !is_idle_thread(bt->task) &&
 	    is_task_active(bt->task) && 
     	    STREQ(kl_funcname(bt->instptr), "schedule")) {
 		/*
diff -Nur crash-4.0-2.33/main.c crash-4.0-3.15/main.c
--- crash-4.0-3.14/main.c	2006-12-20 16:41:21.000000000 +0100
+++ crash-4.0-3.15/main.c	2006-12-20 15:57:05.000000000 +0100
@@ -47,6 +47,7 @@
         {"cpus", 1, 0, 0},
         {"no_ikconfig", 0, 0, 0},
         {"hyper", 0, 0, 0},
+	{"p2m_mfn", 1, 0, 0},
         {0, 0, 0, 0}
 };
 
@@ -148,6 +149,9 @@
 			if (STREQ(long_options[option_index].name, "hyper"))
 				pc->flags |= XEN_HYPER;
 
+		        if (STREQ(long_options[option_index].name, "p2m_mfn")) 
+				xen_kdump_p2m_mfn(optarg);
+
 			break;
 
 		case 'f':
@@ -807,6 +811,8 @@
 
 	if (STREQ(pc->editing_mode, "no_mode"))
 		pc->editing_mode = "vi";
+
+	machdep_init(SETUP_ENV);
 }
 
 
diff -Nur crash-4.0-2.33/Makefile crash-4.0-3.15/Makefile
--- crash-4.0-3.14/Makefile	2006-12-20 16:41:21.000000000 +0100
+++ crash-4.0-3.15/Makefile	2006-12-20 15:57:05.000000000 +0100
@@ -355,13 +355,13 @@
 ppc.o: ${GENERIC_HFILES} ppc.c
 	cc -c ${CFLAGS} ppc.c ${WARNING_OPTIONS} ${WARNING_ERROR}
 
-ia64.o: ${GENERIC_HFILES} ia64.c
+ia64.o: ${GENERIC_HFILES} ${REDHAT_HFILES} ia64.c
 	cc -c ${CFLAGS} ia64.c ${WARNING_OPTIONS} ${WARNING_ERROR}
 
 ppc64.o: ${GENERIC_HFILES} ppc64.c
 	cc -c ${CFLAGS} ppc64.c ${WARNING_OPTIONS} ${WARNING_ERROR}
 
-x86_64.o: ${GENERIC_HFILES} x86_64.c
+x86_64.o: ${GENERIC_HFILES} ${REDHAT_HFILES} x86_64.c
 	cc -c ${CFLAGS} x86_64.c ${WARNING_OPTIONS} ${WARNING_ERROR}
 
 s390.o: ${GENERIC_HFILES} ${IBM_HFILES} s390.c
@@ -470,7 +470,7 @@
 # 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.14
+RELEASE=4.0-3.15
 
 release: make_configure
 	@if [ "`id --user`" != "0" ]; then \
diff -Nur crash-4.0-2.33/memory.c crash-4.0-3.15/memory.c
--- crash-4.0-3.14/memory.c	2006-12-20 16:41:21.000000000 +0100
+++ crash-4.0-3.15/memory.c	2006-12-20 15:57:05.000000000 +0100
@@ -11649,11 +11649,13 @@
 	case 'k':
 	case 'K':
 		LASTCHAR(s) = NULLCHAR;
-		if (decimal(s, 0))
-			k = 1024;
-		else 
+		if (!decimal(s, 0)) {
 			err = TRUE;
-		break;
+			break;
+		}
+		k = 1024;
+
+		/* FALLTHROUGH */
 
 	default:
         	if (decimal(s, 0))
diff -Nur crash-4.0-2.33/netdump.c crash-4.0-3.15/netdump.c
--- crash-4.0-3.14/netdump.c	2006-12-20 16:41:21.000000000 +0100
+++ crash-4.0-3.15/netdump.c	2006-12-20 15:57:05.000000000 +0100
@@ -1261,6 +1261,7 @@
         netdump_print("Elf32_Nhdr:\n");
         netdump_print("               n_namesz: %ld ", note->n_namesz);
         BZERO(buf, BUFSIZE);
+	xen_core = FALSE;
         ptr = (char *)note + sizeof(Elf32_Nhdr);
         BCOPY(ptr, buf, note->n_namesz);
         netdump_print("(\"%s\")\n", buf);
@@ -1321,11 +1322,12 @@
 		break;
 #endif
 	default:
-		xen_core = STRNEQ(buf, "XEN CORE");
+		xen_core = STRNEQ(buf, "XEN CORE") || STRNEQ(buf, "Xen");
 		if (xen_core) {
-			netdump_print("(unknown XEN CORE n_type)\n"); 
-			error(WARNING, "unknown XEN CORE n_type: %lx\n\n", 
-				note->n_type);
+			netdump_print("(unknown Xen n_type)\n"); 
+			if (store)
+				error(WARNING, "unknown Xen n_type: %lx\n\n", 
+					note->n_type);
 		} else
 			netdump_print("(?)\n");
 		break;
@@ -1334,11 +1336,14 @@
                 netdump_print("(NT_XEN_KDUMP_CR3) [obsolete]\n");
 		if (store)
 			error(WARNING, 
-			    "obsolete XEN CORE n_type: %lx (NT_XEN_KDUMP_CR3)\n\n", 
+			    "obsolete Xen n_type: %lx (NT_XEN_KDUMP_CR3)\n\n", 
 				note->n_type);
 		/* FALL THROUGH */
 
 	case XEN_ELFNOTE_CRASH_INFO:
+		/*
+		 *  x86 and x86_64: p2m mfn appended to crash_xen_info_t structure
+		 */
 		if (note->n_type == XEN_ELFNOTE_CRASH_INFO)
                 	netdump_print("(XEN_ELFNOTE_CRASH_INFO)\n");
 		xen_core = TRUE;
@@ -1363,12 +1368,19 @@
 				uptr = (ulong *)(ptr + note->n_namesz);
 				uptr = (ulong *)roundup((ulong)uptr, 4);
 				words = note->n_descsz/sizeof(ulong);
-				nd->xen_kdump_data->p2m_mfn = *(uptr+(words-1));
+				/*
+				 *  If already set, overridden with --pfm_mfn
+				 */
+				if (!nd->xen_kdump_data->p2m_mfn)
+					nd->xen_kdump_data->p2m_mfn = *(uptr+(words-1));
 			}
 		}
 		break;
 
 	case XEN_ELFNOTE_CRASH_REGS:
+      		/* 
+		 *  x86 and x86_64: cr0, cr2, cr3, cr4 
+		 */
 		xen_core = TRUE;	
                	netdump_print("(XEN_ELFNOTE_CRASH_REGS)\n");
 		break;
@@ -1425,6 +1437,7 @@
         netdump_print("               n_namesz: %ld ", note->n_namesz);
         BZERO(buf, BUFSIZE);
         ptr = (char *)note + sizeof(Elf64_Nhdr);
+	xen_core = FALSE;
         BCOPY(ptr, buf, note->n_namesz);
         netdump_print("(\"%s\")\n", buf);
 
@@ -1497,12 +1510,12 @@
                 break;
 #endif
 	default:
-                if ((xen_core = STRNEQ(buf, "XEN CORE"))) {
-                        netdump_print("(unknown XEN CORE n_type)\n");
+		xen_core = STRNEQ(buf, "XEN CORE") || STRNEQ(buf, "Xen");
+                if (xen_core) {
+                        netdump_print("(unknown Xen n_type)\n");
 			if (store)
                         	error(WARNING, 
-				    "unknown XEN CORE n_type: %lx\n\n",
-                                	note->n_type);
+				    "unknown Xen n_type: %lx\n\n", note->n_type);
                 } else
                         netdump_print("(?)\n");
                 break;
@@ -1511,11 +1524,14 @@
                 netdump_print("(NT_XEN_KDUMP_CR3) [obsolete]\n");
                	if (store)
                 	error(WARNING,
-                            "obsolete XEN CORE n_type: %lx (NT_XEN_KDUMP_CR3)\n\n",
+                            "obsolete Xen n_type: %lx (NT_XEN_KDUMP_CR3)\n\n",
                                 note->n_type);
 		/* FALL THROUGH */
 
 	case XEN_ELFNOTE_CRASH_INFO:
+		/*
+		 *  x86 and x86_64: p2m mfn appended to crash_xen_info_t structure
+		 */
 		if (note->n_type == XEN_ELFNOTE_CRASH_INFO)
                 	netdump_print("(XEN_ELFNOTE_CRASH_INFO)\n");
 		xen_core = TRUE;
@@ -1540,12 +1556,19 @@
 				up = (ulong *)(ptr + note->n_namesz);
 	                        up = (ulong *)roundup((ulong)up, 4);
 				words = note->n_descsz/sizeof(ulong);
-	                        nd->xen_kdump_data->p2m_mfn = *(up+(words-1));
+				/*
+				 *  If already set, overridden with --p2m_mfn
+				 */
+	                        if (!nd->xen_kdump_data->p2m_mfn)
+	                        	nd->xen_kdump_data->p2m_mfn = *(up+(words-1));
 			}
 		}
                 break;
 
         case XEN_ELFNOTE_CRASH_REGS:
+      		/* 
+		 *  x86 and x86_64: cr0, cr2, cr3, cr4 
+		 */
                 xen_core = TRUE;
                 netdump_print("(XEN_ELFNOTE_CRASH_REGS)\n");
                 break;
@@ -1559,17 +1582,30 @@
         if ((nd->flags & KDUMP_ELF64) && (note->n_namesz == 5))
                 uptr = (ulonglong *)(ptr + ((note->n_namesz + 3) & ~3));
 
-       if (xen_core)
+        if (xen_core)
                 uptr = (ulonglong *)roundup((ulong)uptr, 4);
 
-	for (i = lf = 0; i < note->n_descsz/sizeof(ulonglong); i++) {
-		if (((i%2)==0)) {
-			netdump_print("%s                         ", 
-				i ? "\n" : "");
-			lf++;
-		} else
-			lf = 0;
-		netdump_print("%016llx ", *uptr++);
+	if (BITS32() && (xen_core || (note->n_type == NT_PRSTATUS))) {
+		iptr = (int *)uptr;
+		for (i = lf = 0; i < note->n_descsz/sizeof(ulong); i++) {
+			if (((i%4)==0)) {
+				netdump_print("%s                         ", 
+					i ? "\n" : "");
+				lf++;
+			} else
+				lf = 0;
+			netdump_print("%08lx ", *iptr++);
+		}
+	} else {
+		for (i = lf = 0; i < note->n_descsz/sizeof(ulonglong); i++) {
+			if (((i%2)==0)) {
+				netdump_print("%s                         ", 
+					i ? "\n" : "");
+				lf++;
+			} else
+				lf = 0;
+			netdump_print("%016llx ", *uptr++);
+		}
 	}
 	if (!lf)
 		netdump_print("\n");
@@ -2056,3 +2092,25 @@
 
 	return &vmcore_data;
 }
+
+/*
+ *  Override the dom0 p2m mfn in the XEN_ELFNOTE_CRASH_INFO note
+ *  in order to initiate a crash session of a guest kernel.
+ */
+void
+xen_kdump_p2m_mfn(char *arg)
+{
+	ulong value;
+	int errflag;
+
+	errflag = 0;
+	value = htol(arg, RETURN_ON_ERROR|QUIET, &errflag);
+	if (!errflag) {
+		xen_kdump_data.p2m_mfn = value;
+		if (CRASHDEBUG(1))
+			error(INFO, 
+			    "xen_kdump_data.p2m_mfn override: %lx\n",  
+				value); 
+	} else 
+		error(WARNING, "invalid p2m_mfn argument: %s\n", arg);
+}
diff -Nur crash-4.0-2.33/README crash-4.0-3.15/README
--- crash-4.0-3.14/README	2006-12-20 16:41:21.000000000 +0100
+++ crash-4.0-3.15/README	2006-12-20 15:57:05.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.14
+  To build this utility, simply uncompress the tar file, enter the crash-4.0-3.15
   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,11 +89,12 @@
 
     $ crash
     
-    crash 4.0-3.14
+    crash 4.0-3.15
     Copyright (C) 2002, 2003, 2004, 2005, 2006  Red Hat, Inc.
     Copyright (C) 2004, 2005, 2006  IBM Corporation
     Copyright (C) 1999-2006  Hewlett-Packard Co
-    Copyright (C) 2005  Fujitsu Limited
+    Copyright (C) 2005, 2006  Fujitsu Limited
+    Copyright (C) 2006  VA Linux Systems Japan K.K.
     Copyright (C) 2005  NEC Corporation
     Copyright (C) 1999, 2002  Silicon Graphics, Inc.
     Copyright (C) 1999, 2000, 2001, 2002  Mission Critical Linux, Inc.
@@ -113,7 +114,7 @@
           KERNEL: /boot/vmlinux
         DUMPFILE: /dev/mem
             CPUS: 1
-            DATE: Fri Dec  1 15:39:42 2006
+            DATE: Wed Dec 20 09:57:04 2006
           UPTIME: 10 days, 22:55:18
     LOAD AVERAGE: 0.08, 0.03, 0.01
            TASKS: 42
@@ -141,7 +142,7 @@
     exit           log            rd             task           
     extend         mach           repeat         timer          
     
-    crash version: 4.0-3.14   gdb version: 6.1
+    crash version: 4.0-3.15   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,11 +155,12 @@
 
     $ crash vmlinux vmcore
  
-    crash 4.0-3.14
+    crash 4.0-3.15
     Copyright (C) 2002, 2003, 2004, 2005, 2006  Red Hat, Inc.
     Copyright (C) 2004, 2005, 2006  IBM Corporation
     Copyright (C) 1999-2006  Hewlett-Packard Co
-    Copyright (C) 2005  Fujitsu Limited
+    Copyright (C) 2005, 2006  Fujitsu Limited
+    Copyright (C) 2006  VA Linux Systems Japan K.K.
     Copyright (C) 2005  NEC Corporation
     Copyright (C) 1999, 2002  Silicon Graphics, Inc.
     Copyright (C) 1999, 2000, 2001, 2002  Mission Critical Linux, Inc.
@@ -200,11 +202,12 @@
 
     $ crash vmlinux.17 lcore.cr.17
 
-    crash 4.0-3.14
+    crash 4.0-3.15
     Copyright (C) 2002, 2003, 2004, 2005, 2006  Red Hat, Inc.
     Copyright (C) 2004, 2005, 2006  IBM Corporation
     Copyright (C) 1999-2006  Hewlett-Packard Co
-    Copyright (C) 2005  Fujitsu Limited
+    Copyright (C) 2005, 2006  Fujitsu Limited
+    Copyright (C) 2006  VA Linux Systems Japan K.K.
     Copyright (C) 2005  NEC Corporation
     Copyright (C) 1999, 2002  Silicon Graphics, Inc.
     Copyright (C) 1999, 2000, 2001, 2002  Mission Critical Linux, Inc.
diff -Nur crash-4.0-2.33/.rh_rpm_package crash-4.0-3.15/.rh_rpm_package
--- crash-4.0-3.14/.rh_rpm_package	2006-12-20 16:41:21.000000000 +0100
+++ crash-4.0-3.15/.rh_rpm_package	2006-12-20 15:57:05.000000000 +0100
@@ -1 +1 @@
-4.0-3.14
+4.0-3.15
diff -Nur crash-4.0-2.33/symbols.c crash-4.0-3.15/symbols.c
--- crash-4.0-3.14/symbols.c	2006-12-20 16:41:21.000000000 +0100
+++ crash-4.0-3.15/symbols.c	2006-12-20 15:57:05.000000000 +0100
@@ -2129,19 +2129,6 @@
         fprintf(fp, ")\n");
 
 	fprintf(fp, "                 bfd: %lx\n", (ulong)st->bfd);
-
-	sec = (asection **)st->sections;
-	fprintf(fp, "            sections: %s\n", sec ? "" : "(not in use)");
-	for (i = 0; sec && (i < st->bfd->section_count); i++, sec++) {
-		asection *section;
-
-		section = *sec;
-		fprintf(fp, "%25s  vma: %.*lx  size: %ld\n", 
-			section->name, VADDR_PRLEN,
-			(ulong)bfd_get_section_vma(st->bfd, section),
-			(ulong)bfd_section_size(st->bfd, section));
-	}
-
 	fprintf(fp, "            symtable: %lx\n", (ulong)st->symtable);
 	fprintf(fp, "              symend: %lx\n", (ulong)st->symend);
 	fprintf(fp, "              symcnt: %ld\n", st->symcnt);
@@ -2330,6 +2317,19 @@
 	fprintf(fp, "dwarf_eh_frame_file_offset: %llx\n", 
 		(unsigned long long)st->dwarf_eh_frame_file_offset);
         fprintf(fp, "       dwarf_eh_frame_size: %ld\n", st->dwarf_eh_frame_size);
+	fprintf(fp, "\n");
+
+	sec = (asection **)st->sections;
+	fprintf(fp, "            sections: %s\n", sec ? "" : "(not in use)");
+	for (i = 0; sec && (i < st->bfd->section_count); i++, sec++) {
+		asection *section;
+
+		section = *sec;
+		fprintf(fp, "%25s  vma: %.*lx  size: %ld\n", 
+			section->name, VADDR_PRLEN,
+			(ulong)bfd_get_section_vma(st->bfd, section),
+			(ulong)bfd_section_size(st->bfd, section));
+	}
 }
 
 
@@ -2437,7 +2437,7 @@
 			goto not_system_map;
 		if (parse_line(buf, mapitems) != 3)
                         goto not_system_map;
-		if ((strlen(mapitems[0]) != MAX_HEXADDR_STRLEN) ||
+		if ((strlen(mapitems[0]) > MAX_HEXADDR_STRLEN) ||
 		    !hexadecimal(mapitems[0], 0) || (strlen(mapitems[1]) > 1))
 			goto not_system_map;
 	}
diff -Nur crash-4.0-2.33/task.c crash-4.0-3.15/task.c
--- crash-4.0-3.14/task.c	2006-12-20 16:41:21.000000000 +0100
+++ crash-4.0-3.15/task.c	2006-12-20 15:57:05.000000000 +0100
@@ -5420,6 +5420,14 @@
 	}							\
                                                       		\
         if (panic_task && die_task) {                 		\
+		if ((panic_task > (NO_TASK+1)) &&               \
+		    (panic_task == die_task)) {                 \
+		        if (CRASHDEBUG(1))			\
+				fprintf(fp, 			\
+		    "get_active_set_panic_task: %lx (panic)\n", \
+					panic_task);		\
+			return panic_task;			\
+		}                                               \
                 error(WARNING,                        		\
      "multiple active tasks have called die and/or panic\n\n"); \
 		goto no_panic_task_found;			\
@@ -5475,6 +5483,9 @@
 			xen_panic_task = task;	        \
 			xendump_panic_hook(buf);	\
 		}					\
+                if (machine_type("IA64") && XENDUMP_DUMPFILE() && !xen_panic_task && \
+                    strstr(buf, " sysrq_handle_crashdump+")) \
+			xen_sysrq_task = task;	        \
 	}
 
 /*
@@ -5488,10 +5499,12 @@
 	char buf[BUFSIZE];
 	ulong panic_task, die_task, crash_kexec_task;
 	ulong xen_panic_task;
+	ulong xen_sysrq_task;
 	char *tp;
 	struct task_context *tc;
 
 	panic_task = die_task = crash_kexec_task = xen_panic_task = NO_TASK;
+	xen_sysrq_task = NO_TASK;
 
         for (i = 0; i < NR_CPUS; i++) {
                 if (!(task = tt->active_set[i]))
@@ -5582,6 +5595,14 @@
 		return crash_kexec_task;
 	}
 
+	if (xen_sysrq_task) {
+		if (CRASHDEBUG(1))
+			error(INFO,
+		    "get_active_set_panic_task: %lx (sysrq_handle_crashdump)\n", 
+				xen_sysrq_task);
+		return xen_sysrq_task;
+	}
+
 no_panic_task_found:
 
 	if (CRASHDEBUG(1)) 
diff -Nur crash-4.0-2.33/x86_64.c crash-4.0-3.15/x86_64.c
--- crash-4.0-3.14/x86_64.c	2006-12-20 16:41:21.000000000 +0100
+++ crash-4.0-3.15/x86_64.c	2006-12-20 15:57:05.000000000 +0100
@@ -4511,6 +4511,11 @@
 	ulong *up;
 	off_t offset; 
 
+        if (!symbol_exists("phys_to_machine_mapping")) {
+                xd->flags |= XC_CORE_NO_P2MM;
+                return TRUE;
+        }
+
 	if ((ctrlreg_offset = MEMBER_OFFSET("vcpu_guest_context", "ctrlreg")) ==
 	     INVALID_OFFSET)
 		error(FATAL, 
@@ -4863,7 +4868,7 @@
 	char *buf;
 
 	/* task means pcpu here */
-	if (task < 0 || task >= xht->pcpus) {
+	if (!xen_hyper_test_pcpu_id(task)) {
 		error(FATAL, "invalid pcpu number\n");
 	}
         init_tss = symbol_value("init_tss");
@@ -4895,7 +4900,7 @@
 
 	/* task means pcpu here */
         pcpu = bt->task;
-	if (pcpu < 0 || pcpu >= xht->pcpus) {
+	if (!xen_hyper_test_pcpu_id(pcpu)) {
 		error(FATAL, "invalid pcpu number\n");
 	}
 
@@ -4908,7 +4913,7 @@
 		return;
 	}
 
-	regs = (ulong *)xhdit->context[pcpu].pr_reg_ptr;
+	regs = (ulong *)xen_hyper_id_to_dumpinfo_context(pcpu)->pr_reg_ptr;
 	rsp = XEN_HYPER_X86_64_NOTE_RSP(regs);
 	rip = XEN_HYPER_X86_64_NOTE_RIP(regs);
 
diff -Nur crash-4.0-2.33/x86.c crash-4.0-3.15/x86.c
--- crash-4.0-3.14/x86.c	2006-12-20 16:41:21.000000000 +0100
+++ crash-4.0-3.15/x86.c	2006-12-20 15:57:05.000000000 +0100
@@ -4372,6 +4372,11 @@
 	ulonglong *ulp;
 	off_t offset; 
 
+        if (!symbol_exists("phys_to_machine_mapping")) {
+                xd->flags |= XC_CORE_NO_P2MM;
+                return TRUE;
+        }
+
 	if ((ctrlreg_offset = MEMBER_OFFSET("vcpu_guest_context", "ctrlreg")) ==
 	     INVALID_OFFSET)
 		error(FATAL, 
@@ -4724,7 +4729,7 @@
 	char *buf;
 
 	/* task means pcpu here */
-	if (task < 0 || task >= xht->pcpus) {
+	if (!xen_hyper_test_pcpu_id(task)) {
 		error(FATAL, "invalid pcpu number\n");
 	}
 	init_tss = symbol_value("init_tss");
@@ -4756,7 +4761,7 @@
 
 	/* task means pcpu here */
 	pcpu = bt->task;
-	if (pcpu < 0 || pcpu >= xht->pcpus) {
+	if (!xen_hyper_test_pcpu_id(pcpu)) {
 		error(FATAL, "invalid pcpu number\n");
 	}
 
@@ -4769,7 +4774,7 @@
 		return;
 	}
 
-	regs = (ulong *)xhdit->context[pcpu].pr_reg_ptr;
+	regs = (ulong *)xen_hyper_id_to_dumpinfo_context(pcpu)->pr_reg_ptr;
 	esp = XEN_HYPER_X86_NOTE_ESP(regs);
 	eip = XEN_HYPER_X86_NOTE_EIP(regs);
 
diff -Nur crash-4.0-2.33/xendump.c crash-4.0-3.15/xendump.c
--- crash-4.0-3.14/xendump.c	2006-12-20 16:41:21.000000000 +0100
+++ crash-4.0-3.15/xendump.c	2006-12-20 15:57:05.000000000 +0100
@@ -22,6 +22,7 @@
 static int xc_core_verify(char *);
 static int xc_save_read(void *, int, ulong, physaddr_t);
 static int xc_core_read(void *, int, ulong, physaddr_t);
+static int xc_core_mfns(ulong, FILE *);
 
 static void poc_store(ulong, off_t);
 static off_t poc_get(ulong, int *);
@@ -54,6 +55,8 @@
 
         if (machine_type("X86") || machine_type("X86_64"))
                 xd->page_size = 4096;
+	else if (machine_type("IA64") && !machdep->pagesize)
+		xd->page_size = 16384;
 	else 
                 xd->page_size = machdep->pagesize;
 
@@ -98,6 +101,9 @@
 
         xd->flags |= (XENDUMP_LOCAL | XC_CORE);
 
+	if (xc_core_mfns(XC_CORE_64BIT_HOST, stderr))
+		xd->flags |= XC_CORE_64BIT_HOST;
+
 	if (!xd->page_size)
 		error(FATAL,
 		    "unknown page size: use -p <pagesize> command line option\n");
@@ -195,6 +201,7 @@
 	int i, batch_count, done_batch, *intptr;
 	ulong flags, *ulongptr;
 	ulong batch_index, total_pages_read;
+	ulong N;
 
 	if (!STRNEQ(buf, XC_SAVE_SIGNATURE))
 		return FALSE;
@@ -268,20 +275,23 @@
 	if (CRASHDEBUG(1)) {
 		for (i = 0; i < sizeof(ulong); i++)
 			fprintf(stderr, "[%x]", buf[i] & 0xff);
-		fprintf(stderr, ": %lx (native)\n", *ulongptr);
+		fprintf(stderr, ": %lx (nr_pfns)\n", *ulongptr);
 	}
 
 	xd->xc_save.nr_pfns = *ulongptr;
 
+	if (machine_type("IA64"))
+		goto xc_save_ia64;
+
     	/* 
 	 *  Get a local copy of the live_P2M_frame_list 
 	 */
 	if (!(xd->xc_save.p2m_frame_list = (unsigned long *)malloc(P2M_FL_SIZE))) 
-        	error(FATAL, "Cannot allocate p2m_frame_list array");
+        	error(FATAL, "cannot allocate p2m_frame_list array");
 
 	if (!(xd->xc_save.batch_offsets = (off_t *)calloc((size_t)P2M_FL_ENTRIES, 
 	    sizeof(off_t))))
-        	error(FATAL, "Cannot allocate batch_offsets array");
+        	error(FATAL, "cannot allocate batch_offsets array");
 
 	xd->xc_save.batch_count = P2M_FL_ENTRIES;
 		
@@ -424,6 +434,100 @@
 
 	return TRUE;
 
+xc_save_ia64:
+
+	/*
+	 *  Completely different format for ia64:
+         *
+         *    ...
+         *    pfn #
+         *    page data
+         *    pfn #
+         *    page data
+         *    ...
+	 */
+	free(xd->poc); 
+	xd->poc = NULL;
+	free(xd->xc_save.region_pfn_type); 
+	xd->xc_save.region_pfn_type = NULL;
+
+	if (!(xd->xc_save.ia64_page_offsets = 
+	    (ulong *)calloc(xd->xc_save.nr_pfns, sizeof(off_t)))) 
+        	error(FATAL, "cannot allocate ia64_page_offsets array");
+
+        /*
+         *  version
+         */
+        if (read(xd->xfd, buf, sizeof(ulong)) != sizeof(ulong))
+                goto xc_save_bailout;
+
+	xd->xc_save.ia64_version = *((ulong *)buf);
+
+	if (CRASHDEBUG(1))
+		fprintf(stderr, "ia64 version: %lx\n", 
+			xd->xc_save.ia64_version);
+
+	/*
+	 *  xen_domctl_arch_setup structure
+	 */
+        if (read(xd->xfd, buf, sizeof(xen_domctl_arch_setup_t)) != 
+	    sizeof(xen_domctl_arch_setup_t))
+                goto xc_save_bailout;
+
+	if (CRASHDEBUG(1)) {
+		xen_domctl_arch_setup_t *setup = 
+			(xen_domctl_arch_setup_t *)buf;
+
+		fprintf(stderr, "xen_domctl_arch_setup:\n");
+		fprintf(stderr, "        flags: %lx\n", (ulong)setup->flags);
+		fprintf(stderr, "           bp: %lx\n", (ulong)setup->bp);
+		fprintf(stderr, "       maxmem: %lx\n", (ulong)setup->maxmem);
+		fprintf(stderr, "       xsi_va: %lx\n", (ulong)setup->xsi_va);
+		fprintf(stderr, "hypercall_imm: %x\n", setup->hypercall_imm);
+	}
+
+	for (i = N = 0; i < xd->xc_save.nr_pfns; i++) {
+        	if (read(xd->xfd, &N, sizeof(N)) != sizeof(N))
+                	goto xc_save_bailout;
+
+		if (N < xd->xc_save.nr_pfns)
+			xd->xc_save.ia64_page_offsets[N] = 
+				lseek(xd->xfd, 0, SEEK_CUR);
+		else
+			error(WARNING, 	
+			    "[%d]: pfn of %lx (0x%lx) in ia64 canonical page list exceeds %ld\n",	
+				i, N, N, xd->xc_save.nr_pfns);
+
+		if (CRASHDEBUG(1)) {
+			if ((i < 10) || (N >= (xd->xc_save.nr_pfns-10))) 
+				fprintf(stderr, "[%d]: %ld\n%s", i, N,
+					i == 9 ? "...\n" : "");	
+		}
+
+		if ((N+1) >= xd->xc_save.nr_pfns)
+			break;
+
+		if (lseek(xd->xfd, xd->page_size, SEEK_CUR) == -1)
+                	goto xc_save_bailout;
+	}
+
+	if (CRASHDEBUG(1)) {
+		for (i = N = 0; i < xd->xc_save.nr_pfns; i++) {
+			if (!xd->xc_save.ia64_page_offsets[i])
+				N++;
+		}
+		fprintf(stderr, "%ld out of %ld pfns not dumped\n",
+			N,  xd->xc_save.nr_pfns);
+	}
+
+	xd->flags |= (XENDUMP_LOCAL | flags | XC_SAVE_IA64);
+	kt->xen_flags |= (CANONICAL_PAGE_TABLES|XEN_SUSPEND);
+
+	if (CRASHDEBUG(1))
+		xendump_memory_dump(stderr);
+
+	return TRUE;
+
 xc_save_bailout:
 
 	error(INFO, 
@@ -467,6 +571,42 @@
 	        "xc_save_read(bufptr: %lx cnt: %d addr: %lx paddr: %llx (%ld, 0x%lx)\n",
 		    (ulong)bufptr, cnt, addr, (ulonglong)paddr, reqpfn, reqpfn);
 
+	if (xd->flags & XC_SAVE_IA64) {
+                if (reqpfn >= xd->xc_save.nr_pfns) {
+			if (CRASHDEBUG(1))
+                            	fprintf(xd->ofp,
+				    "xc_save_read: pfn %lx too large: nr_pfns: %lx\n",
+					reqpfn, xd->xc_save.nr_pfns);
+			return SEEK_ERROR;
+		}
+
+        	file_offset = xd->xc_save.ia64_page_offsets[reqpfn];
+		if (!file_offset) {
+			if (CRASHDEBUG(1))
+                            	fprintf(xd->ofp,
+				    "xc_save_read: pfn %lx not stored in xendump\n",
+					reqpfn);
+			return SEEK_ERROR;
+		}	
+
+       		if (reqpfn != xd->last_pfn) {
+	        	if (lseek(xd->xfd, file_offset, SEEK_SET) == -1)
+				return SEEK_ERROR;
+	
+			if (read(xd->xfd, xd->page, xd->page_size) != xd->page_size)
+	               		return READ_ERROR;
+		} else {
+                	xd->redundant++;
+			xd->cache_hits++;
+		}
+
+		xd->accesses++;
+		xd->last_pfn = reqpfn;
+
+                BCOPY(xd->page + PAGEOFFSET(paddr), bufptr, cnt);
+                return cnt;
+	}
+
 	if ((file_offset = poc_get(reqpfn, &redundant))) {
 		if (!redundant) {
         		if (lseek(xd->xfd, file_offset, SEEK_SET) == -1)
@@ -744,6 +884,12 @@
 		fprintf(fp, "%sXC_CORE", others++ ? "|" : "");
 	if (xd->flags & XC_CORE_P2M_INIT)
 		fprintf(fp, "%sXC_CORE_P2M_INIT", others++ ? "|" : "");
+	if (xd->flags & XC_CORE_NO_P2MM)
+		fprintf(fp, "%sXC_CORE_NO_P2MM", others++ ? "|" : "");
+	if (xd->flags & XC_SAVE_IA64)
+		fprintf(fp, "%sXC_SAVE_IA64", others++ ? "|" : "");
+	if (xd->flags & XC_CORE_64BIT_HOST)
+		fprintf(fp, "%sXC_CORE_64BIT_HOST", others++ ? "|" : "");
 	fprintf(fp, ")\n");
 	fprintf(fp, "          xfd: %d\n", xd->xfd);
 	fprintf(fp, "    page_size: %d\n", xd->page_size);
@@ -764,10 +910,13 @@
 	else
 		fprintf(fp, "\n");
 	for (i = used = 0; i < PFN_TO_OFFSET_CACHE_ENTRIES; i++) 
-		if (xd->poc[i].cnt)
+		if (xd->poc && xd->poc[i].cnt)
 			used++;
-	fprintf(fp, "    poc[%d]: %lx %s", PFN_TO_OFFSET_CACHE_ENTRIES, (ulong)xd->poc,
-		xd->poc ? "" : "(none)");
+	if (xd->poc)
+		fprintf(fp, "    poc[%d]: %lx %s", PFN_TO_OFFSET_CACHE_ENTRIES, 
+		(ulong)xd->poc, xd->poc ? "" : "(none)");
+	else
+		fprintf(fp, "       poc[0]: (unused)\n");
 	for (i = 0; i < PFN_TO_OFFSET_CACHE_ENTRIES; i++) {
 		if (!xd->poc)
 			break;
@@ -796,7 +945,7 @@
 	if (xd->flags & XC_SAVE) 
 		xen_dump_vmconfig(fp);
 	fprintf(fp, "           p2m_frame_list: %lx ", (ulong)xd->xc_save.p2m_frame_list);
-	if (xd->flags & XC_SAVE) {
+	if ((xd->flags & XC_SAVE) && xd->xc_save.p2m_frame_list) {
 		fprintf(fp, "\n");
 		ulongptr = xd->xc_save.p2m_frame_list;
 		for (i = 0; i < P2M_FL_ENTRIES; i++, ulongptr++)
@@ -827,6 +976,12 @@
 	}
 	if (linefeed)
 		fprintf(fp, "\n");
+	fprintf(fp, "             ia64_version: %ld\n", (ulong)xd->xc_save.ia64_version);
+	fprintf(fp, "        ia64_page_offsets: %lx ", (ulong)xd->xc_save.ia64_page_offsets);
+	if (xd->xc_save.ia64_page_offsets)
+		fprintf(fp, "(%ld entries)\n\n", xd->xc_save.nr_pfns);
+	else
+		fprintf(fp, "(none)\n\n");	
 
 	fprintf(fp, "      xc_core:\n");
 	fprintf(fp, "                   header:\n");
@@ -858,6 +1013,9 @@
 	}
 	fprintf(fp, xd->xc_core.p2m_frames ? "\n\n" : "\n");
 
+	if (CRASHDEBUG(3))
+		xc_core_mfns(XENDUMP_LOCAL, fp);
+
 	return 0;
 }
 
@@ -995,6 +1153,7 @@
 	int i, b, idx, done;
 	ulong tmp[MAX_BATCH_SIZE];
 	off_t offset;
+	uint nr_pages;
 
         if (lseek(xd->xfd, (off_t)xd->xc_core.header.xch_index_offset,
             SEEK_SET) == -1) {
@@ -1002,9 +1161,12 @@
 		return NULL;
 	}
 
+	nr_pages = xd->xc_core.header.xch_nr_pages;
+	if (xd->flags & XC_CORE_64BIT_HOST)
+		nr_pages *= 2;
+
         for (b = 0, idx = -1, done = FALSE; 
-	     !done && (b < xd->xc_core.header.xch_nr_pages); 
-	     b += MAX_BATCH_SIZE) {
+	     !done && (b < nr_pages); b += MAX_BATCH_SIZE) {
 
                 if (read(xd->xfd, tmp, sizeof(ulong) * MAX_BATCH_SIZE) != 
 		    (MAX_BATCH_SIZE * sizeof(ulong))) {
@@ -1013,7 +1175,7 @@
 		}
 
                 for (i = 0; i < MAX_BATCH_SIZE; i++) {
-			if ((b+i) >= xd->xc_core.header.xch_nr_pages) {
+			if ((b+i) >= nr_pages) {
 				done = TRUE;
 				break;
 			}
@@ -1064,6 +1226,7 @@
 {
         int i, b;
         ulong tmp[MAX_BATCH_SIZE];
+	uint nr_pages;
 
         if (lseek(xd->xfd, (off_t)xd->xc_core.header.xch_index_offset,
             SEEK_SET) == -1) {
@@ -1071,7 +1234,11 @@
                 return MFN_NOT_FOUND;
         }
 
-        for (b = 0; b < xd->xc_core.header.xch_nr_pages; b += MAX_BATCH_SIZE) {
+	nr_pages = xd->xc_core.header.xch_nr_pages;
+	if (xd->flags & XC_CORE_64BIT_HOST)
+                nr_pages *= 2;
+
+        for (b = 0; b < nr_pages; b += MAX_BATCH_SIZE) {
 
                 if (read(xd->xfd, tmp, sizeof(ulong) * MAX_BATCH_SIZE) != 
 		    (MAX_BATCH_SIZE * sizeof(ulong))) {
@@ -1080,7 +1247,7 @@
 		}
 
 		for (i = 0; i < MAX_BATCH_SIZE; i++) {
-			if ((b+i) >= xd->xc_core.header.xch_nr_pages)
+			if ((b+i) >= nr_pages)
 				break;
 			
                 	if (tmp[i] == mfn) {
@@ -1097,6 +1264,86 @@
 }
 
 /*
+ *  XC_CORE mfn-related utility function.
+ */
+static int
+xc_core_mfns(ulong arg, FILE *ofp)
+{
+        int i, b;
+	uint nr_pages;
+        ulong tmp[MAX_BATCH_SIZE];
+
+        if (lseek(xd->xfd, (off_t)xd->xc_core.header.xch_index_offset,
+            SEEK_SET) == -1) {
+                error(INFO, "cannot lseek to page index\n");
+		return FALSE;
+        }
+
+	switch (arg)
+	{
+	case XC_CORE_64BIT_HOST:
+		/*
+		 *  Determine whether this is a 32-bit guest xendump that
+		 *  was taken on a 64-bit xen host.
+	         */
+		if (machine_type("X86_64") || machine_type("IA64"))
+			return FALSE;
+check_next:
+	        if (read(xd->xfd, tmp, sizeof(ulong) * 4) != (4 * sizeof(ulong))) {
+			error(INFO, "cannot read index pages\n");
+			return FALSE;
+	        }
+
+		if ((tmp[0] == 0xffffffff) || (tmp[1] == 0xffffffff) ||
+		    (tmp[2] == 0xffffffff) || (tmp[3] == 0xffffffff) ||
+		    (!tmp[0] && !tmp[1]) || (!tmp[2] && !tmp[3]))
+			goto check_next;
+
+		if (CRASHDEBUG(2))
+			fprintf(ofp, "mfns: %08lx %08lx %08lx %08lx\n", 
+					tmp[0], tmp[1], tmp[2], tmp[3]);
+
+		if (tmp[0] && !tmp[1] && tmp[2] && !tmp[3])
+			return TRUE;
+		else
+			return FALSE;
+
+	case XENDUMP_LOCAL:
+		nr_pages = xd->xc_core.header.xch_nr_pages;
+		if (xd->flags & XC_CORE_64BIT_HOST)
+                	nr_pages *= 2;
+	        for (b = 0; b < nr_pages; b += MAX_BATCH_SIZE) {
+	                if (read(xd->xfd, tmp, sizeof(ulong) * MAX_BATCH_SIZE) !=
+	                    (MAX_BATCH_SIZE * sizeof(ulong))) {
+	                        error(INFO, "cannot read index page %d\n", b);
+	                        return FALSE;
+	                }
+	
+			if (b) fprintf(ofp, "\n");
+
+	                for (i = 0; i < MAX_BATCH_SIZE; i++) {
+				if ((b+i) >= nr_pages)
+					break;
+				if ((i%8) == 0) {
+					fprintf(ofp, "%s[%d]: %lx", 
+						i ? "\n" : "", b+i, tmp[i]);
+				} else {
+					fprintf(ofp, " %lx", tmp[i]);
+				}
+			}
+		}
+		fprintf(ofp, "\nxch_nr_pages: %d", xd->xc_core.header.xch_nr_pages);
+		if (xd->flags & XC_CORE_64BIT_HOST)
+			fprintf(ofp, " (64-bit host: effective pages: %d", nr_pages);
+		fprintf(ofp, "\n");
+		return TRUE;
+
+	default:
+		return FALSE;
+	}
+}
+
+/*
  *  Given a normal kernel pfn, determine the page index in the dumpfile.
  *
  *  -  First determine which of the pages making up the 
@@ -1114,6 +1361,9 @@
 	ulong *up, mfn;
 	off_t offset;
 
+	if (xd->flags & XC_CORE_NO_P2MM)
+		return pfn;
+
 	idx = pfn/PFNS_PER_PAGE;
 
 	if (idx >= xd->xc_core.p2m_frames) {
@@ -1167,6 +1417,9 @@
 	char buf[BUFSIZE];
 	ulong value, *sp;
 
+	if (machine_type("IA64"))  /* needs switch_stack address */
+		return;
+
 	strcpy(buf, stack);
 
         argc = parse_line(buf, arglist);
diff -Nur crash-4.0-2.33/xendump.h crash-4.0-3.15/xendump.h
--- crash-4.0-3.14/xendump.h	2006-07-13 20:51:50.000000000 +0200
+++ crash-4.0-3.15/xendump.h	2006-12-20 15:57:05.000000000 +0100
@@ -67,15 +67,20 @@
 		off_t *batch_offsets;
 		ulong batch_count;
 		ulong *region_pfn_type;
+		ulong ia64_version;
+		ulong *ia64_page_offsets;
 	} xc_save;
 
 	ulong panic_pc;
 	ulong panic_sp;
 };
 
-#define XC_SAVE           (XENDUMP_LOCAL << 1)
-#define XC_CORE           (XENDUMP_LOCAL << 2)
-#define XC_CORE_P2M_INIT  (XENDUMP_LOCAL << 3)
+#define XC_SAVE            (XENDUMP_LOCAL << 1)
+#define XC_CORE            (XENDUMP_LOCAL << 2)
+#define XC_CORE_P2M_INIT   (XENDUMP_LOCAL << 3)
+#define XC_CORE_NO_P2MM    (XENDUMP_LOCAL << 4)
+#define XC_SAVE_IA64       (XENDUMP_LOCAL << 5)
+#define XC_CORE_64BIT_HOST (XENDUMP_LOCAL << 6)
 
 #define MACHINE_BYTE_ORDER()  \
         (machine_type("X86") || \
@@ -95,3 +100,16 @@
 
 #define MFN_NOT_FOUND (-1)
 #define PFN_NOT_FOUND (-1)
+
+/*
+ *  ia64 "xm save" format is completely different than the others.
+ */
+typedef struct xen_domctl_arch_setup {
+    uint64_t flags;      /* XEN_DOMAINSETUP_* */
+/* #ifdef __ia64__ */
+    uint64_t bp;            /* mpaddr of boot param area */
+    uint64_t maxmem;        /* Highest memory address for MDT.  */
+    uint64_t xsi_va;        /* Xen shared_info area virtual address.  */
+    uint32_t hypercall_imm; /* Break imm for Xen hypercalls.  */
+/* #endif */
+} xen_domctl_arch_setup_t;
diff -Nur crash-4.0-2.33/xen_hyper.c crash-4.0-3.15/xen_hyper.c
--- crash-4.0-3.14/xen_hyper.c	2006-12-20 16:41:21.000000000 +0100
+++ crash-4.0-3.15/xen_hyper.c	2006-12-20 15:57:05.000000000 +0100
@@ -36,20 +36,42 @@
 
 	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);
+		xen_hyper_fill_cpu_data_x86(xht->crashing_cpu, 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(crash_note_t, "crash_note_t");
+	XEN_HYPER_MEMBER_OFFSET_INIT(crash_note_t_core, "crash_note_t", "core");
+	XEN_HYPER_MEMBER_OFFSET_INIT(crash_note_t_xen, "crash_note_t", "xen");
+	XEN_HYPER_MEMBER_OFFSET_INIT(crash_note_t_xen_regs, "crash_note_t", "xen_regs");
+	XEN_HYPER_MEMBER_OFFSET_INIT(crash_note_t_xen_info, "crash_note_t", "xen_info");
+
+	XEN_HYPER_STRUCT_SIZE_INIT(crash_note_core_t, "crash_note_core_t");
+	XEN_HYPER_MEMBER_OFFSET_INIT(crash_note_core_t_note, "crash_note_core_t", "note");
+	XEN_HYPER_MEMBER_OFFSET_INIT(crash_note_core_t_desc, "crash_note_core_t", "desc");
+
+	XEN_HYPER_STRUCT_SIZE_INIT(crash_note_xen_t, "crash_note_xen_t");
+	XEN_HYPER_MEMBER_OFFSET_INIT(crash_note_xen_t_note, "crash_note_xen_t", "note");
+	XEN_HYPER_MEMBER_OFFSET_INIT(crash_note_xen_t_desc, "crash_note_xen_t", "desc");
+	XEN_HYPER_STRUCT_SIZE_INIT(crash_note_xen_core_t, "crash_note_xen_core_t");
+	XEN_HYPER_MEMBER_OFFSET_INIT(crash_note_xen_core_t_note, "crash_note_xen_core_t", "note");
+	XEN_HYPER_MEMBER_OFFSET_INIT(crash_note_xen_core_t_desc, "crash_note_xen_core_t", "desc");
+	XEN_HYPER_STRUCT_SIZE_INIT(crash_note_xen_info_t, "crash_note_xen_info_t");
+	XEN_HYPER_MEMBER_OFFSET_INIT(crash_note_xen_info_t_note, "crash_note_xen_info_t", "note");
+	XEN_HYPER_MEMBER_OFFSET_INIT(crash_note_xen_info_t_desc, "crash_note_xen_info_t", "desc");
+	XEN_HYPER_STRUCT_SIZE_INIT(crash_xen_core_t, "crash_xen_core_t");
+	XEN_HYPER_STRUCT_SIZE_INIT(crash_xen_info_t, "crash_xen_info_t");
+	XEN_HYPER_STRUCT_SIZE_INIT(xen_crash_xen_regs_t, "xen_crash_xen_regs_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");
@@ -161,12 +183,12 @@
 void
 x86_xen_hyper_pcpu_init(void)
 {
-	long cpu_info;
-	long init_tss;
+	ulong cpu_info;
+	ulong init_tss_base, init_tss;
 	long sp;
 	struct xen_hyper_pcpu_context *pcc;
 	char *buf, *bp;
-	int i;
+	int i, cpuid;
 
 	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");
@@ -177,12 +199,12 @@
 	}
 
 	/* get physical cpu context */
-	xen_hyper_alloc_pcpu_context_space(XEN_HYPER_MAX_PCPUS());
-	pcc = xhpct->context_array;
-	init_tss = symbol_value("init_tss");
+	xen_hyper_alloc_pcpu_context_space(XEN_HYPER_MAX_CPUS());
+	init_tss_base = 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)) {
+	for_cpu_indexes(i, cpuid)
+	{
+		init_tss = init_tss_base + XEN_HYPER_SIZE(tss_struct) * cpuid;
 		if (!readmem(init_tss, KVADDR, buf,
 			XEN_HYPER_SIZE(tss_struct), "init_tss", RETURN_ON_ERROR)) {
 			error(FATAL, "cannot read init_tss.\n");
@@ -199,6 +221,7 @@
 		if(!(bp = xen_hyper_read_pcpu(cpu_info))) {
 			error(FATAL, "cannot read cpu_info.\n");
 		}
+		pcc = &xhpct->context_array[cpuid];
 		xen_hyper_store_pcpu_context(pcc, cpu_info, bp);
 	}
 	FREEBUF(buf);
@@ -213,7 +236,7 @@
 	/* set pcpu last */
 	if (!(xhpct->last =
 		xen_hyper_id_to_pcpu_context(xht->crashing_cpu))) {
-		xhpct->last = xhpct->context_array;
+		xhpct->last = &xhpct->context_array[xht->cpu_idxs[0]];
 	}
 
 	/* set vcpu last */
@@ -244,54 +267,152 @@
 xen_hyper_dumpinfo_init(void)
 {
 	Elf32_Nhdr *note;
-	char *bp, *np, *upp;
+	char *buf, *bp, *np, *upp;
 	ulong addr;
-	int i, size;
+	long size;
+	int i, cpuid;
+
+	/*
+	 * kakuma NOTE: It is not clear that what ikind of
+	 * a elf note format each one of the xen uses.
+	 * So, we decide it confirming whether a symbol exists.
+	 */
+	if (STRUCT_EXISTS("note_buf_t"))
+		xhdit->note_ver = XEN_HYPER_ELF_NOTE_V1;
+	else if (STRUCT_EXISTS("crash_note_xen_t"))
+		xhdit->note_ver = XEN_HYPER_ELF_NOTE_V2;
+	else if (STRUCT_EXISTS("crash_note_xen_core_t"))
+		xhdit->note_ver = XEN_HYPER_ELF_NOTE_V3;
+	else {
+		error(WARNING, "unsupported elf note format.\n");
+		return;
+	}
 
+	size = sizeof(struct xen_hyper_dumpinfo_context) * XEN_HYPER_MAX_CPUS();
+	if((xhdit->context_array = malloc(size)) == NULL) {
+		error(FATAL, "cannot malloc dumpinfo table context space.\n");
+	}
+	BZERO(xhdit->context_array, 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);
+	for (i = 0; i < XEN_HYPER_MAX_CPUS(); i++) {
+		xhdit->context_array[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);
+	if (xhdit->note_ver == XEN_HYPER_ELF_NOTE_V1) {
+		xhdit->note_size = XEN_HYPER_SIZE(note_buf_t);
 	} else {
-		size = XEN_HYPER_SIZE(ELF_Prstatus) * xht->pcpus;
+		xhdit->note_size = XEN_HYPER_SIZE(crash_note_t);
 	}
-	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)) {
+		
+	/* read a sample note */
+	buf = GETBUF(xhdit->note_size);
+	if (!xen_hyper_fill_elf_notes(xhdit->context_array[xht->crashing_cpu].note,
+	buf, XEN_HYPER_ELF_NOTE_FILL_T_NOTE)) {
 		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 = buf;
 
-	bp = xhdit->ELF_Prstatus_array;
+	switch (xhdit->note_ver) {
+	case XEN_HYPER_ELF_NOTE_V1:
+		/* core data */
+		note = (Elf32_Nhdr *)bp;
+		np = bp + sizeof(Elf32_Nhdr);
+		upp = np + note->n_namesz;
+		upp = (char *)roundup((ulong)upp, 4);
+		xhdit->core_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->core_size = upp - bp;
+		break;
+	case XEN_HYPER_ELF_NOTE_V2:
+		/* core data */
+		xhdit->core_offset = XEN_HYPER_OFFSET(crash_note_core_t_desc);
+		xhdit->core_size = XEN_HYPER_SIZE(crash_note_core_t);
+		/* xen core */
+		xhdit->xen_info_offset = XEN_HYPER_OFFSET(crash_note_xen_t_desc);
+		xhdit->xen_info_size = XEN_HYPER_SIZE(crash_note_xen_t);
+		if((xhdit->crash_note_xen_info_ptr =
+		malloc(xhdit->xen_info_size)) == NULL) {
+			error(FATAL, "cannot malloc dumpinfo table "
+				"crash_note_xen_info_ptr space.\n");
+		}
+		memcpy(xhdit->crash_note_xen_info_ptr,
+			bp + xhdit->core_size, xhdit->xen_info_size);
+		xhdit->context_xen_info.note =
+			xhdit->context_array[xht->crashing_cpu].note +
+			xhdit->core_size;
+		xhdit->context_xen_info.pcpu_id = xht->crashing_cpu;
+		xhdit->context_xen_info.crash_xen_info_ptr =
+			xhdit->crash_note_xen_info_ptr + xhdit->xen_info_offset;
+		break;
+	case XEN_HYPER_ELF_NOTE_V3:
+		/* core data */
+		xhdit->core_offset = XEN_HYPER_OFFSET(crash_note_core_t_desc);
+		xhdit->core_size = XEN_HYPER_SIZE(crash_note_core_t);
+		/* xen core */
+		xhdit->xen_core_offset = XEN_HYPER_OFFSET(crash_note_xen_core_t_desc);
+		xhdit->xen_core_size = XEN_HYPER_SIZE(crash_note_xen_core_t);
+		if((xhdit->crash_note_xen_core_ptr =
+		malloc(xhdit->xen_core_size)) == NULL) {
+			error(FATAL, "cannot malloc dumpinfo table "
+				"crash_note_xen_core_ptr space.\n");
+		}
+		memcpy(xhdit->crash_note_xen_core_ptr,
+			bp + xhdit->core_size, xhdit->xen_core_size);
+		xhdit->context_xen_core.note =
+			xhdit->context_array[xht->crashing_cpu].note +
+			xhdit->core_size;
+		xhdit->context_xen_core.pcpu_id = xht->crashing_cpu;
+		xhdit->context_xen_core.crash_xen_core_ptr =
+			xhdit->crash_note_xen_core_ptr + xhdit->xen_core_offset;
+		/* xen info */
+		xhdit->xen_info_offset = XEN_HYPER_OFFSET(crash_note_xen_info_t_desc);
+		xhdit->xen_info_size = XEN_HYPER_SIZE(crash_note_xen_info_t);
+		if((xhdit->crash_note_xen_info_ptr =
+		malloc(xhdit->xen_info_size)) == NULL) {
+			error(FATAL, "cannot malloc dumpinfo table "
+				"crash_note_xen_info_ptr space.\n");
+		}
+		memcpy(xhdit->crash_note_xen_info_ptr,
+			bp + xhdit->core_size + xhdit->xen_core_size,
+			xhdit->xen_info_size);
+		xhdit->context_xen_info.note =
+			xhdit->context_array[xht->crashing_cpu].note +
+			xhdit->core_size + xhdit->xen_core_size;
+		xhdit->context_xen_info.pcpu_id = xht->crashing_cpu;
+		xhdit->context_xen_info.crash_xen_info_ptr =
+			xhdit->crash_note_xen_info_ptr + xhdit->xen_info_offset;
+		break;
+	default:
+		error(FATAL, "logic error in cheking elf note format occurs.\n");
+	}
+
+	size = xhdit->core_size * XEN_HYPER_MAX_PCPUS();
+	if(!(xhdit->crash_note_core_array = malloc(size))) {
+		error(FATAL, "cannot malloc note_buf_t struct space.\n");
+	}
+	bp = xhdit->crash_note_core_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)) {
+	for_cpu_indexes(i, cpuid)
+	{
+		addr = xhdit->context_array[cpuid].note;
+		if (!xen_hyper_fill_elf_notes(addr, bp,
+		XEN_HYPER_ELF_NOTE_FILL_T_CORE)) {
 			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);
+		xhdit->context_array[cpuid].pcpu_id = cpuid;
+		xhdit->context_array[cpuid].ELF_Prstatus_ptr =
+			bp + xhdit->core_offset;
+		xhdit->context_array[cpuid].pr_reg_ptr =
+			bp + xhdit->core_offset +
+			XEN_HYPER_OFFSET(ELF_Prstatus_pr_reg);
+		bp += xhdit->core_size;
 	}
+	FREEBUF(buf);
 }
 
 /*
@@ -300,7 +421,7 @@
 struct xen_hyper_dumpinfo_context *
 xen_hyper_id_to_dumpinfo_context(uint id)
 {
-	return &xhdit->context[id];
+	return &xhdit->context_array[id];
 }
 
 /*
@@ -311,9 +432,9 @@
 {
 	int i;
 
-	for (i = 0; i < xht->pcpus; i++) {
-		if (note == xhdit->context[i].note) {
-			return &xhdit->context[i];
+	for (i = 0; i < XEN_HYPER_MAX_CPUS(); i++) {
+		if (note == xhdit->context_array[i].note) {
+			return &xhdit->context_array[i];
 		}
 	}
 	return NULL;
@@ -323,25 +444,35 @@
  * Fill ELF Notes header here.
  */
 char *
-xen_hyper_fill_elf_notes(ulong note, char *note_buf)
+xen_hyper_fill_elf_notes(ulong note, char *note_buf, int type)
 {
-	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;
-}
+	long size;
 
-/*
- * 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");
+	if (type == XEN_HYPER_ELF_NOTE_FILL_T_NOTE)
+		size = xhdit->note_size;
+	else if (type == XEN_HYPER_ELF_NOTE_FILL_T_CORE)
+		size = xhdit->core_size;
+	else if (type == XEN_HYPER_ELF_NOTE_FILL_T_XEN_CORE)
+		size = xhdit->xen_core_size;
+	else if (type == XEN_HYPER_ELF_NOTE_FILL_T_PRS)
+		size = XEN_HYPER_SIZE(ELF_Prstatus);
+	else if (type == XEN_HYPER_ELF_NOTE_FILL_T_XEN_REGS)
+		size = XEN_HYPER_SIZE(xen_crash_xen_regs_t);
+	else
+		return NULL;
+
+	if (!readmem(note, KVADDR, note_buf, size,
+		"note_buf_t or crash_note_t", RETURN_ON_ERROR)) {
+		if (type == XEN_HYPER_ELF_NOTE_FILL_T_NOTE)
+			error(WARNING, "cannot fill note_buf_t or crash_note_t.\n");
+		else if (type == XEN_HYPER_ELF_NOTE_FILL_T_CORE)
+			error(WARNING, "cannot fill note core.\n");
+		else if (type == XEN_HYPER_ELF_NOTE_FILL_T_XEN_CORE)
+			error(WARNING, "cannot fill note xen core.\n");
+		else if (type == XEN_HYPER_ELF_NOTE_FILL_T_PRS)
+			error(WARNING, "cannot fill ELF_Prstatus.\n");
+		else if (type == XEN_HYPER_ELF_NOTE_FILL_T_XEN_REGS)
+			error(WARNING, "cannot fill xen_crash_xen_regs_t.\n");
 		return NULL;
 	}
 	return note_buf;
@@ -968,22 +1099,13 @@
 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) {
+	if (!xen_hyper_test_pcpu_id(id)) {
 		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;
+	return &xhpct->context_array[id];
 }
 
 /*
@@ -994,6 +1116,7 @@
 {
 	struct xen_hyper_pcpu_context *pcc;
 	int i;
+	uint cpuid;
 
 	if (xhpct->context_array == NULL) {
 		return NULL;
@@ -1001,8 +1124,9 @@
 	if (!pcpu) {
 		return NULL;
 	}
-	for (i = 0, pcc = xhpct->context_array; i < XEN_HYPER_MAX_PCPUS();
-		i++, pcc++) {
+	for_cpu_indexes(i, cpuid)
+	{
+		pcc = &xhpct->context_array[cpuid];
 		if (pcpu == pcc->pcpu) {
 			return pcc;
 		}
@@ -1099,6 +1223,29 @@
 	return FALSE;
 }
 
+/*
+ * Test whether cpu for pcpu id exists.
+ */
+int
+xen_hyper_test_pcpu_id(uint pcpu_id)
+{
+	ulong *cpumask = xht->cpumask;
+	uint i, j;
+
+	if (pcpu_id > XEN_HYPER_MAX_CPUS()) {
+		return FALSE;
+	}
+
+	i = pcpu_id / (sizeof(ulong) * 8);
+	j = pcpu_id % (sizeof(ulong) * 8);
+	cpumask += i;
+	if (*cpumask & (1UL << j)) {
+		return TRUE;
+	} else {
+		return FALSE;
+	}
+}
+
 
 
 /*
@@ -1132,37 +1279,61 @@
 }
 
 /*
- * Calculate a number of physical cpu.
+ * Get cpu informatin around.
+ */
+void
+xen_hyper_get_cpu_info(void)
+{
+	ulong addr;
+	ulong *cpumask;
+	uint *cpu_idx;
+	int i, j, cpus;
+
+	get_symbol_data("max_cpus", sizeof(xht->max_cpus), &xht->max_cpus);
+	XEN_HYPER_STRUCT_SIZE_INIT(cpumask_t, "cpumask_t");
+	if (XEN_HYPER_SIZE(cpumask_t) * 8 > xht->max_cpus) {
+		xht->max_cpus = XEN_HYPER_SIZE(cpumask_t) * 8;
+	}
+	if (xht->cpumask) {
+		free(xht->cpumask);
+	}
+	if((xht->cpumask = malloc(XEN_HYPER_SIZE(cpumask_t))) == NULL) {
+		error(FATAL, "cannot malloc cpumask space.\n");
+	}
+	/* kakuma: It may be better to use cpu_present_map. */
+	addr = symbol_value("cpu_online_map");
+	if (!readmem(addr, KVADDR, xht->cpumask,
+		XEN_HYPER_SIZE(cpumask_t), "cpu_online_map", RETURN_ON_ERROR)) {
+		error(FATAL, "cannot read cpu_online_map.\n");
+	}
+	if (xht->cpu_idxs) {
+		free(xht->cpu_idxs);
+	}
+	if((xht->cpu_idxs = malloc(sizeof(uint) * XEN_HYPER_MAX_PCPUS())) == NULL) {
+		error(FATAL, "cannot malloc cpu_idxs space.\n");
+	}
+	for (i = cpus = 0, cpumask = xht->cpumask, cpu_idx = xht->cpu_idxs;
+	i < (XEN_HYPER_SIZE(cpumask_t)/sizeof(ulong)); i++, cpumask++) {
+		for (j = 0; j < sizeof(ulong) * 8; j++) {
+			if (*cpumask & (1UL << j)) {
+				*cpu_idx++ = i * sizeof(ulong) * 8 + j;
+				cpus++;
+			}
+		}
+	}
+	xht->pcpus = cpus;
+}
+
+/*
+ * Calculate the number of physical cpu for x86.
  */
 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);
+	xen_hyper_get_cpu_info();
 	return xht->pcpus;
 }
 
@@ -1189,7 +1360,7 @@
 
 
 /*
- * Print with aligned string in specified length.
+ * Print an aligned string with specified length.
  */
 void
 xen_hyper_fpr_indent(FILE *fp, int len, char *str1, char *str2, int flag)
@@ -1207,7 +1378,7 @@
 
 	memset(buf, ' ', sizeof(buf));
 	buf[r] =  '\0';
-	if (flag == XEN_HYPER_PRI_L) {
+	if (flag & XEN_HYPER_PRI_L) {
 		s1 = str1;
 		s2 = buf;
 	} else {
@@ -1219,6 +1390,9 @@
 	} else {
 		fprintf(fp, "%s%s", s1, s2);
 	}
+	if (flag & XEN_HYPER_PRI_LF) {
+		fprintf(fp, "\n");
+	}
 }
 
 void
diff -Nur crash-4.0-2.33/xen_hyper_command.c crash-4.0-3.15/xen_hyper_command.c
--- crash-4.0-3.14/xen_hyper_command.c	2006-12-20 16:41:21.000000000 +0100
+++ crash-4.0-3.15/xen_hyper_command.c	2006-12-20 15:57:05.000000000 +0100
@@ -35,8 +35,8 @@
 
 #ifdef X86_64
 char *xhregt[] = {
-	"r15", "r14", "r13", "r12", "rbp", "rbx", "r11", "r10", "r9",
-	"r8", "rax", "rcx", "rdx", "rsi", "rdi", "rip", "cs", "eflags",
+	"r15", "r14", "r13", "r12", "rbp", "rbx", "r11", "r10", "r9", "r8",
+	"rax", "rcx", "rdx", "rsi", "rdi", "orig_rax", "rip", "cs", "eflags",
 	"rsp", "ss", "fs", "gs", "ds", "es", "fs", "gs",
 	NULL
 };
@@ -229,6 +229,7 @@
 {
 	double mmem, tmem;
 	char *act, *crash;
+	uint cpuid;
 	int type, i, j;
 	struct xen_hyper_pcpu_context *pcc;
 	char buf1[XEN_HYPER_CMD_BUFSIZE];
@@ -239,7 +240,9 @@
 	}
 
 	act = NULL;
-	for (i = 0, pcc = xhpct->context_array; i < xht->pcpus; i++, pcc++) {
+	for_cpu_indexes(i, cpuid)
+	{
+		pcc = xen_hyper_id_to_pcpu_context(cpuid);
 		for (j = 0; j < dc->vcpu_cnt; j++) {
 			if (pcc->current_vcpu == dc->vcpu[j]) {
 				act = ">";
@@ -359,7 +362,7 @@
 	if (ena->cnt) {
 		cnt = ena->cnt;
 	} else {
-		cnt = xht->pcpus;
+		cnt = XEN_HYPER_MAX_PCPUS();
 	}
 	for (i = 0; i < cnt; i++) {
 		if (i == 0 || flag & XEN_HYPER_DUMPINFO_REGS ||
@@ -375,7 +378,7 @@
 		if (ena->cnt) {
 			enc = ena->enc[i];
 		} else {
-			enc = &xhdit->context[i];
+			enc = xen_hyper_id_to_dumpinfo_context(xht->cpu_idxs[i]);
 		}
 		show_xen_hyper_dumpinfo(flag, enc);
 	}
@@ -603,7 +606,8 @@
 static void
 do_xen_hyper_pcpus(ulong flag, struct pcpu_args *pca)
 {
-	struct xen_hyper_pcpu_context *pcca;
+	struct xen_hyper_pcpu_context *pcc;
+	uint cpuid;
 	int i;
 
 	if (pca->cnt) {
@@ -612,9 +616,10 @@
 			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);
+		for_cpu_indexes(i, cpuid)
+		{
+			pcc = xen_hyper_id_to_pcpu_context(cpuid);
+			show_xen_hyper_pcpus(flag, pcc);
 			flag |= XEN_HYPER_PCPUS_1STCALL;
 		}
 	}
@@ -634,6 +639,9 @@
 	}
 	if ((flag & XEN_HYPER_PCPUS_REGS) ||
 	(!(flag & XEN_HYPER_PCPUS_REGS) && !(flag & XEN_HYPER_PCPUS_1STCALL))) {
+		if ((flag & XEN_HYPER_PCPUS_REGS) && (flag & XEN_HYPER_PCPUS_1STCALL)) {
+			fprintf(fp, "\n");
+		}
 		sprintf(buf, "   PCID ");
 		mkstring(&buf[strlen(buf)], VADDR_PRLEN, CENTER|RJUST, "PCPU");
 		strncat(buf, " ", XEN_HYPER_CMD_BUFSIZE-strlen(buf)-1);
@@ -648,7 +656,7 @@
 		(char *)(pcc->current_vcpu));
 	fprintf(fp, "%s\n", buf);
 	if (flag & XEN_HYPER_PCPUS_REGS) {
-		fprintf(fp, "\nRegister information:\n");
+		fprintf(fp, "Register information:\n");
 		dump_struct("cpu_user_regs", pcc->guest_cpu_user_regs, 0);
 	}
 }
@@ -751,7 +759,7 @@
 			(buf1, "%s\n", pc->namelist_debug));
 	}
 
-	XEN_HYPER_PRI_CONS(fp, len, "DUMPFILE: ", flag);
+	XEN_HYPER_PRI_CONST(fp, len, "DUMPFILE: ", flag);
         if (ACTIVE()) {
 		if (REMOTE_ACTIVE()) 
 			fprintf(fp, "%s@%s  (remote live system)\n",
@@ -769,7 +777,7 @@
 	}
 
 	XEN_HYPER_PRI(fp, len, "CPUS: ", buf1, flag,
-		(buf1, "%d\n", xht->pcpus));
+		(buf1, "%d\n", XEN_HYPER_MAX_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. */
@@ -780,7 +788,7 @@
 		XEN_HYPER_PRI(fp, len, "MACHINE: ", buf1, flag,
 			(buf1, "%s  ", uts->machine));
 	} else {
-		XEN_HYPER_PRI_CONS(fp, len, "MACHINE: unknown  ", flag);
+		XEN_HYPER_PRI_CONST(fp, len, "MACHINE: unknown  ", flag);
 	}
 	if ((mhz = machdep->processor_speed()))
 		fprintf(fp, "(%ld Mhz)\n", mhz);
@@ -1227,10 +1235,12 @@
 	flag = XEN_HYPER_PRI_R;
 
 	if (!(pcc = xen_hyper_id_to_pcpu_context(vcc->processor))) {
-		error(FATAL, "cannot get pcpu context vcpu belongs.\n");
+		error(WARNING, "cannot get pcpu context vcpu belongs.\n");
+		return;
 	}
 	if (!(dc = xen_hyper_domain_to_domain_context(vcc->domain))) {
-		error(FATAL, "cannot get domain context vcpu belongs.\n");
+		error(WARNING, "cannot get domain context vcpu belongs.\n");
+		return;
 	}
 	XEN_HYPER_PRI(fp, len, "PCPU-ID: ", buf, flag,
 		(buf, "%d\n", vcc->processor));
@@ -1246,7 +1256,7 @@
 	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);
+	XEN_HYPER_PRI_CONST(fp, len, "STATE: ", flag);
 	if (machdep->flags & HWRESET) {
 		fprintf(fp, "HARDWARE RESET");
 	} else if (machdep->flags & INIT) {
@@ -1295,7 +1305,7 @@
 	type = XEN_HYPER_STR_INVALID;
 
 	if (dvalue != BADADDR) {
-		if (dvalue > xht->pcpus) {
+		if (dvalue > XEN_HYPER_MAX_CPUS()) {
 			note_dad = xen_hyper_note_to_dumpinfo_context(dvalue);
 		} else {
 			note_did = xen_hyper_id_to_dumpinfo_context(dvalue);
@@ -1303,7 +1313,7 @@
 		found++;
 	}
 	if ((hvalue != BADADDR)) {
-		if (hvalue > xht->pcpus) {
+		if (hvalue > XEN_HYPER_MAX_CPUS()) {
 			note_had = xen_hyper_note_to_dumpinfo_context(hvalue);
 		} else {
 			note_hid = xen_hyper_id_to_dumpinfo_context(hvalue);
diff -Nur crash-4.0-2.33/xen_hyper_defs.h crash-4.0-3.15/xen_hyper_defs.h
--- crash-4.0-3.14/xen_hyper_defs.h	2006-12-20 16:41:21.000000000 +0100
+++ crash-4.0-3.15/xen_hyper_defs.h	2006-12-20 15:57:05.000000000 +0100
@@ -69,6 +69,14 @@
 typedef uint16_t	domid_t;
 typedef uint32_t	Elf_Word;
 
+/* NOTE kakuma:
+ * The following defines are temporary version for elf note format
+ * which is used only in crash.
+ */
+#define XEN_HYPER_ELF_NOTE_V1	1
+#define XEN_HYPER_ELF_NOTE_V2	2
+#define XEN_HYPER_ELF_NOTE_V3	3
+
 /*
  * Xen Hyper
  */
@@ -98,8 +106,8 @@
 #if 0
 #define XEN_HYPER_STACK_SIZE (machdep->pagesize << XEN_HYPER_STACK_ORDER)
 #endif
-#define XEN_HYPER_GET_CPU_INFO(esp) \
-	((esp & ~(STACKSIZE()-1)) | \
+#define XEN_HYPER_GET_CPU_INFO(sp) \
+	((sp & ~(STACKSIZE()-1)) | \
 	(STACKSIZE() - XEN_HYPER_SIZE(cpu_info)))
 
 #define XEN_HYPER_CONRING_SIZE 16384
@@ -223,6 +231,12 @@
 #define XEN_HYPER_DOMAIN_TYPE_GUEST	(0x2)
 #define XEN_HYPER_DOMAIN_TYPE_INVALID	(-1)
 
+#define XEN_HYPER_ELF_NOTE_FILL_T_NOTE		(0)
+#define XEN_HYPER_ELF_NOTE_FILL_T_CORE		(1)
+#define XEN_HYPER_ELF_NOTE_FILL_T_XEN_CORE	(2)
+#define XEN_HYPER_ELF_NOTE_FILL_T_PRS		(3)
+#define XEN_HYPER_ELF_NOTE_FILL_T_XEN_REGS	(4)
+
 /*
  * command interface structs
  */
@@ -312,6 +326,8 @@
 	int crashing_cpu;
 	struct xen_hyper_vcpu_context *crashing_vcc;
 	ulong max_page;
+	ulong *cpumask;
+	uint *cpu_idxs;
 };
 
 struct xen_hyper_dumpinfo_context {
@@ -321,11 +337,33 @@
 	char *pr_reg_ptr;		/* pointer to pr_reg buf */
 };
 
+struct xen_hyper_dumpinfo_context_xen_core {
+	ulong note;			/* per_cpu__crash_notes v3:xen_regs address */
+	uint pcpu_id;
+	char *crash_xen_core_ptr;	/* pointer to crash_xen_core_t buf */
+};
+
+struct xen_hyper_dumpinfo_context_xen_info {
+	ulong note;			/* per_cpu__crash_notes v2:xen, v3:xen_info address */
+	uint pcpu_id;
+	char *crash_xen_info_ptr;	/* pointer to v2:xen_crash_xen_regs_t, v3:crash_xen_info_t buf */
+};
+
 struct xen_hyper_dumpinfo_table {
-	char *ELF_Prstatus_array;
-	struct xen_hyper_dumpinfo_context context[NR_CPUS];
-	Elf_Word offset;
-	Elf_Word size;
+	uint note_ver;
+	struct xen_hyper_dumpinfo_context *context_array;
+	struct xen_hyper_dumpinfo_context_xen_core context_xen_core;
+	struct xen_hyper_dumpinfo_context_xen_info context_xen_info;
+	char *crash_note_core_array;
+	char *crash_note_xen_core_ptr;
+	char *crash_note_xen_info_ptr;
+	Elf_Word note_size;
+	Elf_Word core_offset;
+	Elf_Word core_size;
+	Elf_Word xen_core_offset;
+	Elf_Word xen_core_size;
+	Elf_Word xen_info_offset;
+	Elf_Word xen_info_size;
 };
 
 /* domain */
@@ -418,21 +456,30 @@
 };
 
 struct xen_hyper_size_table {
-	long ELF_Prstatus;
+	long ELF_Prstatus;			/* elf note v1, v2, v3 */
 	long ELF_Signifo;
 	long ELF_Gregset;
 	long ELF_Timeval;
 	long cpu_info;
 	long cpu_time;
 	long cpu_user_regs;
+	long cpumask_t;
 	long cpuinfo_x86;
+	long crash_note_t;			/* elf note v2, v3 */
+	long crash_note_core_t;			/* elf note v2, v3 */
+	long crash_note_xen_t;			/* elf note v2 */
+	long crash_note_xen_core_t;		/* elf note v3 */
+	long crash_note_xen_info_t;		/* elf note v3 */
+	long crash_xen_core_t;			/* elf note v3 */
+	long crash_xen_info_t;			/* elf note v3 */
 	long domain;
-	long note_buf_t;
+	long note_buf_t;			/* elf note v1 */
 	long scheduler;
 	long timer;
 	long tss_struct;
 	long vcpu;
 	long vcpu_runstate_info;
+	long xen_crash_xen_regs_t;		/* elf note v2 */
 };
 
 struct xen_hyper_offset_table {
@@ -463,6 +510,23 @@
 	long cpu_time_stime_master_stamp;
 	long cpu_time_tsc_scale;
 	long cpu_time_calibration_timer;
+	/* crash_note_t */
+	long crash_note_t_core;			/* elf note v2, v3 */
+	long crash_note_t_xen;			/* elf note v2 */
+	long crash_note_t_xen_regs;		/* elf note v3 */
+	long crash_note_t_xen_info;		/* elf note v3 */
+	/* crash_note_core_t elf note v2, v3 */
+	long crash_note_core_t_note;
+	long crash_note_core_t_desc;
+	/* crash_note_xen_t elf note v2 */
+	long crash_note_xen_t_note;
+	long crash_note_xen_t_desc;
+	/* crash_note_xen_core_t elf note v3 */
+	long crash_note_xen_core_t_note;
+	long crash_note_xen_core_t_desc;
+	/* crash_note_xen_info_t elf note v3 */
+	long crash_note_xen_info_t_note;
+	long crash_note_xen_info_t_desc;
 	/* domain */
 	long domain_page_list;
 	long domain_xenpage_list;
@@ -516,6 +580,11 @@
  */
 #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_INVALID_MEMBER(X)	(xen_hyper_offset_table.X == INVALID_OFFSET)
+#define XEN_HYPER_INVALID_SIZE(X)	(xen_hyper_size_table.X == -1)
+#define XEN_HYPER_VALID_SIZE(X)		(xen_hyper_size_table.X >= 0)
+#define XEN_HYPER_VALID_STRUCT(X)	(xen_hyper_size_table.X >= 0)
+#define XEN_HYPER_VALID_MEMBER(X)	(xen_hyper_offset_table.X >= 0)
 
 #define XEN_HYPER_ASSIGN_SIZE(X)	(xen_hyper_size_table.X)
 #define XEN_HYPER_ASSIGN_OFFSET(X)	(xen_hyper_offset_table.X)
@@ -525,12 +594,17 @@
 #define XEN_HYPER_MEMBER_OFFSET_INIT(X, Y, Z) (XEN_HYPER_ASSIGN_OFFSET(X) = MEMBER_OFFSET(Y, Z))
 
 /*
+ * System
+ */
+#define XEN_HYPER_MAX_CPUS() (xht->max_cpus)
+
+/*
  * 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])
+#define XEN_HYPER_X86_NOTE_ESP(regs) (regs[15])
+#define XEN_HYPER_X86_64_NOTE_RIP(regs) (regs[16])
+#define XEN_HYPER_X86_64_NOTE_RSP(regs) (regs[19])
 
 /*
  * Domain
@@ -544,6 +618,10 @@
  * Phisycal CPU
  */
 #define XEN_HYPER_MAX_PCPUS() (xht->pcpus)
+#define for_cpu_indexes(i, cpuid)		\
+	for (i = 0, cpuid = xht->cpu_idxs[i];	\
+	i < XEN_HYPER_MAX_PCPUS();		\
+	cpuid = xht->cpu_idxs[++i])
 
 /*
  * VCPU
@@ -559,11 +637,12 @@
 #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)	\
+#define XEN_HYPER_PRI_CONST(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
+#define XEN_HYPER_PRI_L		(0x0)
+#define XEN_HYPER_PRI_R		(0x1)
+#define XEN_HYPER_PRI_LF	(0x2)
 
 /*
  * Global data
@@ -616,8 +695,7 @@
 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);
+char *xen_hyper_fill_elf_notes(ulong note, char *note_buf, int type);
 
 /* domain */
 void xen_hyper_refresh_domain_context_space(void);
@@ -675,6 +753,8 @@
 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);
+void xen_hyper_get_cpu_info(void);
+int xen_hyper_test_pcpu_id(uint pcpu_id);
 
 /*
  * Xen Hyper command
diff -Nur crash-4.0-2.33/xen_hyper_dump_tables.c crash-4.0-3.15/xen_hyper_dump_tables.c
--- crash-4.0-3.14/xen_hyper_dump_tables.c	2006-12-20 16:41:21.000000000 +0100
+++ crash-4.0-3.15/xen_hyper_dump_tables.c	2006-12-20 15:57:05.000000000 +0100
@@ -26,6 +26,7 @@
 #include "xen_hyper_defs.h"
 
 static void dump_xen_hyper_table(int verbose);
+static void dump_xen_hyper_dumpinfo_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);
@@ -100,6 +101,10 @@
 				dump_xen_hyper_table(VERBOSE);
 			else if (!strncmp("xen", optarg, strlen(optarg)))
 				dump_xen_hyper_table(!VERBOSE);
+			else if (!strncmp("Dmp", optarg, strlen(optarg)))
+				dump_xen_hyper_dumpinfo_table(VERBOSE);
+			else if (!strncmp("dmp", optarg, strlen(optarg)))
+				dump_xen_hyper_dumpinfo_table(!VERBOSE);
 			else if (!strncmp("Dom", optarg, strlen(optarg)))
 				dump_xen_hyper_domain_table(VERBOSE);
 			else if (!strncmp("dom", optarg, strlen(optarg)))
@@ -132,6 +137,8 @@
 			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 Dmp - dumpinfo table data (verbose)\n");
+			fprintf(fp, " -X dmp - dumpinfo 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");
@@ -174,7 +181,8 @@
 dump_xen_hyper_table(int verbose)
 {
 	char buf[XEN_HYPER_CMD_BUFSIZE];
-	int len, flag;
+	uint cpuid;
+	int len, flag, i;
 
 	len = 14;
 	flag = XEN_HYPER_PRI_R;
@@ -197,6 +205,66 @@
 		(buf, "%p\n", xht->crashing_vcc));
 	XEN_HYPER_PRI(fp, len, "max_page: ", buf, flag,
 		(buf, "%lu\n", xht->max_page));
+	XEN_HYPER_PRI(fp, len, "cpumask: ", buf, flag,
+		(buf, "%p\n", xht->cpumask));
+	XEN_HYPER_PRI(fp, len, "cpu_idxs: ", buf, flag,
+		(buf, "%p\n", xht->cpu_idxs));
+	if (verbose) {
+		for_cpu_indexes(i, cpuid)
+			fprintf(fp, "%03d : %d\n", i, cpuid);
+	}
+}
+
+/*
+ * "help -x dmp" output
+ */
+static void
+dump_xen_hyper_dumpinfo_table(int verbose)
+{
+	char buf[XEN_HYPER_CMD_BUFSIZE];
+	int len, flag;
+
+	len = 24;
+	flag = XEN_HYPER_PRI_R;
+
+	XEN_HYPER_PRI(fp, len, "note_ver: ", buf, flag,
+		(buf, "%u\n", xhdit->note_ver));
+	XEN_HYPER_PRI(fp, len, "context_array: ", buf, flag,
+		(buf, "%p\n", xhdit->context_array));
+	XEN_HYPER_PRI_CONST(fp, len, "context_xen_core: ", flag|XEN_HYPER_PRI_LF);
+	XEN_HYPER_PRI(fp, len, "note: ", buf, flag,
+		(buf, "%lx\n", xhdit->context_xen_core.note));
+	XEN_HYPER_PRI(fp, len, "pcpu_id: ", buf, flag,
+		(buf, "%u\n", xhdit->context_xen_core.pcpu_id));
+	XEN_HYPER_PRI(fp, len, "crash_xen_core_ptr: ", buf, flag,
+		(buf, "%p\n", xhdit->context_xen_core.crash_xen_core_ptr));
+	XEN_HYPER_PRI_CONST(fp, len, "context_xen_info: ", flag|XEN_HYPER_PRI_LF);
+	XEN_HYPER_PRI(fp, len, "note: ", buf, flag,
+		(buf, "%lx\n", xhdit->context_xen_info.note));
+	XEN_HYPER_PRI(fp, len, "pcpu_id: ", buf, flag,
+		(buf, "%u\n", xhdit->context_xen_info.pcpu_id));
+	XEN_HYPER_PRI(fp, len, "crash_xen_info_ptr: ", buf, flag,
+		(buf, "%p\n", xhdit->context_xen_info.crash_xen_info_ptr));
+	XEN_HYPER_PRI(fp, len, "crash_note_core_array: ", buf, flag,
+		(buf, "%p\n", xhdit->crash_note_core_array));
+	XEN_HYPER_PRI(fp, len, "crash_note_xen_core_ptr: ", buf, flag,
+		(buf, "%p\n", xhdit->crash_note_xen_core_ptr));
+	XEN_HYPER_PRI(fp, len, "crash_note_xen_info_ptr: ", buf, flag,
+		(buf, "%p\n", xhdit->crash_note_xen_info_ptr));
+	XEN_HYPER_PRI(fp, len, "note_size: ", buf, flag,
+		(buf, "%u\n", xhdit->note_size));
+	XEN_HYPER_PRI(fp, len, "core_offset: ", buf, flag,
+		(buf, "%u\n", xhdit->core_offset));
+	XEN_HYPER_PRI(fp, len, "core_size: ", buf, flag,
+		(buf, "%u\n", xhdit->core_size));
+	XEN_HYPER_PRI(fp, len, "xen_core_offset: ", buf, flag,
+		(buf, "%u\n", xhdit->xen_core_offset));
+	XEN_HYPER_PRI(fp, len, "xen_core_size: ", buf, flag,
+		(buf, "%u\n", xhdit->xen_core_size));
+	XEN_HYPER_PRI(fp, len, "xen_info_offset: ", buf, flag,
+		(buf, "%u\n", xhdit->xen_info_offset));
+	XEN_HYPER_PRI(fp, len, "xen_info_size: ", buf, flag,
+		(buf, "%u\n", xhdit->xen_info_size));
 }
 
 /*
@@ -305,8 +373,24 @@
 		(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, "cpumask_t: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.cpumask_t));
 	XEN_HYPER_PRI(fp, len, "cpuinfo_x86: ", buf, flag,
 		(buf, "%ld\n", xen_hyper_size_table.cpuinfo_x86));
+	XEN_HYPER_PRI(fp, len, "crash_note_t: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.crash_note_t));
+	XEN_HYPER_PRI(fp, len, "crash_note_core_t: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.crash_note_core_t));
+	XEN_HYPER_PRI(fp, len, "crash_note_xen_t: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.crash_note_xen_t));
+	XEN_HYPER_PRI(fp, len, "crash_note_xen_core_t: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.crash_note_xen_core_t));
+	XEN_HYPER_PRI(fp, len, "crash_note_xen_info_t: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.crash_note_xen_info_t));
+	XEN_HYPER_PRI(fp, len, "crash_xen_core_t: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.crash_xen_core_t));
+	XEN_HYPER_PRI(fp, len, "crash_xen_info_t: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.crash_xen_info_t));
 	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,
@@ -321,6 +405,8 @@
 		(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));
+	XEN_HYPER_PRI(fp, len, "xen_crash_xen_regs_t: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_size_table.xen_crash_xen_regs_t));
 }
 
 /*
@@ -381,6 +467,36 @@
 		(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, "crash_note_t_core: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.crash_note_t_core));
+	XEN_HYPER_PRI(fp, len, "crash_note_t_xen: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.crash_note_t_xen));
+	XEN_HYPER_PRI(fp, len, "crash_note_t_xen_regs: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.crash_note_t_xen_regs));
+	XEN_HYPER_PRI(fp, len, "crash_note_t_xen_info: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.crash_note_t_xen_info));
+
+	XEN_HYPER_PRI(fp, len, "crash_note_core_t_note: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.crash_note_core_t_note));
+	XEN_HYPER_PRI(fp, len, "crash_note_core_t_desc: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.crash_note_core_t_desc));
+
+	XEN_HYPER_PRI(fp, len, "crash_note_xen_t_note: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.crash_note_xen_t_note));
+	XEN_HYPER_PRI(fp, len, "crash_note_xen_t_desc: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.crash_note_xen_t_desc));
+
+	XEN_HYPER_PRI(fp, len, "crash_note_xen_core_t_note: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.crash_note_xen_core_t_note));
+	XEN_HYPER_PRI(fp, len, "crash_note_xen_core_t_desc: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.crash_note_xen_core_t_desc));
+
+	XEN_HYPER_PRI(fp, len, "crash_note_xen_info_t_note: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.crash_note_xen_info_t_note));
+	XEN_HYPER_PRI(fp, len, "crash_note_xen_info_t_desc: ", buf, flag,
+		(buf, "%ld\n", xen_hyper_offset_table.crash_note_xen_info_t_desc));
+
 	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,

Places

File crash-4.0-3.14-3.15.patch of Package crash (Revision c1bc67168c997b363420d83149e8c6f5)

Places