Merge lp:~dannf/ubuntu/trusty/crash/lp1354349 into lp:ubuntu/trusty/crash

[dann frazier]

[Colin Watson (cjwatson)]

Effectively merged by the 7.0.3-3ubuntu4 upload.

=== added directory '.pc'
=== added file '.pc/.version'
--- .pc/.version	1970-01-01 00:00:00 +0000
+++ .pc/.version	2014-09-09 15:21:10 +0000
@@ -0,0 +1,1 @@
+2

=== added directory '.pc/Updated-the-ARM64-implementation-to-support-Linux-3..patch'
=== added file '.pc/Updated-the-ARM64-implementation-to-support-Linux-3..patch/arm64.c'
--- .pc/Updated-the-ARM64-implementation-to-support-Linux-3..patch/arm64.c	1970-01-01 00:00:00 +0000
+++ .pc/Updated-the-ARM64-implementation-to-support-Linux-3..patch/arm64.c	2014-09-09 15:21:10 +0000
@@ -0,0 +1,1351 @@
+/*
+ * arm64.c - core analysis suite
+ *
+ * Copyright (C) 2012,2013 David Anderson
+ * Copyright (C) 2012,2013 Red Hat, Inc. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifdef ARM64
+
+#include "defs.h"
+#include <elf.h>
+
+#define NOT_IMPLEMENTED(X) error((X), "%s: function not implemented\n", __func__)
+
+static struct machine_specific arm64_machine_specific = { 0 };
+static int arm64_verify_symbol(const char *, ulong, char);
+static void arm64_parse_cmdline_args(void);
+static void arm64_calc_phys_offset(void);
+static int arm64_kdump_phys_base(ulong *);
+static ulong arm64_processor_speed(void);
+static void arm64_init_kernel_pgd(void);
+static int arm64_kvtop(struct task_context *, ulong, physaddr_t *, int);
+static int arm64_uvtop(struct task_context *, ulong, physaddr_t *, int);
+static int arm64_vtop_2level_64k(ulong, ulong, physaddr_t *, int);
+static int arm64_vtop_3level_4k(ulong, ulong, physaddr_t *, int);
+static ulong arm64_get_task_pgd(ulong);
+static void arm64_stackframe_init(void);
+static int arm64_eframe_search(struct bt_info *);
+static int arm64_in_exception_text(ulong);
+static void arm64_back_trace_cmd(struct bt_info *);
+static void arm64_print_stackframe_entry(struct bt_info *, int, struct arm64_stackframe *);
+static int arm64_unwind_frame(struct bt_info *, struct arm64_stackframe *);
+static int arm64_get_dumpfile_stackframe(struct bt_info *, struct arm64_stackframe *);
+static int arm64_get_stackframe(struct bt_info *, struct arm64_stackframe *);
+static void arm64_get_stack_frame(struct bt_info *, ulong *, ulong *);
+static int arm64_translate_pte(ulong, void *, ulonglong);
+static ulong arm64_vmalloc_start(void);
+static int arm64_is_task_addr(ulong);
+static int arm64_dis_filter(ulong, char *, unsigned int);
+static void arm64_cmd_mach(void);
+static void arm64_display_machine_stats(void);
+static int arm64_get_smp_cpus(void);
+static void arm64_clear_machdep_cache(void);
+static int arm64_in_alternate_stack(int, ulong);
+static int arm64_get_kvaddr_ranges(struct vaddr_range *);
+static int arm64_get_crash_notes(void);
+
+/*
+ * Do all necessary machine-specific setup here. This is called several times
+ * during initialization.
+ */
+void
+arm64_init(int when)
+{
+	ulong value;
+
+#if defined(__x86_64__)
+	if (ACTIVE())
+		error(FATAL, "compiled for the ARM64 architecture\n");
+#endif
+
+	switch (when) {
+	case PRE_SYMTAB:
+		machdep->machspec = &arm64_machine_specific;
+		machdep->process_elf_notes = process_elf64_notes;
+		if (pc->flags & KERNEL_DEBUG_QUERY)
+			return;
+		machdep->verify_paddr = generic_verify_paddr;
+		machdep->verify_symbol = arm64_verify_symbol;
+		if (machdep->cmdline_args[0])
+			arm64_parse_cmdline_args();
+		break;
+
+	case PRE_GDB:
+		if (kernel_symbol_exists("swapper_pg_dir") &&
+		    kernel_symbol_exists("idmap_pg_dir")) {
+			value = symbol_value("swapper_pg_dir") -
+				symbol_value("idmap_pg_dir");
+			machdep->pagesize = value / 2;
+		} else
+			machdep->pagesize = memory_page_size();   /* host */
+		machdep->pageshift = ffs(machdep->pagesize) - 1;
+		machdep->pageoffset = machdep->pagesize - 1;
+		machdep->pagemask = ~((ulonglong)machdep->pageoffset);
+		switch (machdep->pagesize)
+		{
+		case 4096:
+			machdep->flags |= VM_L3_4K;
+			machdep->ptrs_per_pgd = PTRS_PER_PGD_L3_4K;
+			if ((machdep->pgd = 
+			    (char *)malloc(PTRS_PER_PGD_L3_4K * 8)) == NULL)
+				error(FATAL, "cannot malloc pgd space.");
+			if ((machdep->pmd = 
+			    (char *)malloc(PTRS_PER_PMD_L3_4K * 8)) == NULL)
+				error(FATAL, "cannot malloc pmd space.");
+			if ((machdep->ptbl = 
+			    (char *)malloc(PTRS_PER_PTE_L3_4K * 8)) == NULL)
+				error(FATAL, "cannot malloc ptbl space.");
+			machdep->pud = NULL;  /* not used */
+			break;
+
+		case 65536:
+			machdep->flags |= VM_L2_64K;
+			machdep->ptrs_per_pgd = PTRS_PER_PGD_L2_64K;
+			if ((machdep->pgd = 
+			    (char *)malloc(PTRS_PER_PGD_L2_64K * 8)) == NULL)
+				error(FATAL, "cannot malloc pgd space.");
+			if ((machdep->ptbl = 
+			    (char *)malloc(PTRS_PER_PTE_L2_64K * 8)) == NULL)
+				error(FATAL, "cannot malloc ptbl space.");
+			machdep->pmd = NULL;  /* not used */
+			machdep->pud = NULL;  /* not used */
+			break;
+
+		default:
+			error(FATAL, "invalid/unknown page size: %d\n", 
+				machdep->pagesize);
+		}
+		machdep->last_pud_read = 0;  /* not used */
+		machdep->last_pgd_read = 0;
+		machdep->last_pmd_read = 0;
+		machdep->last_ptbl_read = 0;
+		machdep->clear_machdep_cache = arm64_clear_machdep_cache;
+
+		machdep->stacksize = ARM64_STACK_SIZE;
+		machdep->machspec->userspace_top = ARM64_USERSPACE_TOP;
+		machdep->machspec->page_offset = ARM64_PAGE_OFFSET;
+		machdep->machspec->vmalloc_start_addr = ARM64_VMALLOC_START;
+		machdep->machspec->vmalloc_end = ARM64_VMALLOC_END;
+		machdep->machspec->vmemmap_vaddr = ARM64_VMEMMAP_VADDR;
+		machdep->machspec->vmemmap_end = ARM64_VMEMMAP_END;
+		machdep->machspec->modules_vaddr = ARM64_MODULES_VADDR;
+		machdep->machspec->modules_end = ARM64_MODULES_END;
+
+		machdep->kvbase = ARM64_VMALLOC_START;
+		machdep->identity_map_base = ARM64_PAGE_OFFSET; 
+
+		arm64_calc_phys_offset();
+		
+		machdep->uvtop = arm64_uvtop;
+		machdep->kvtop = arm64_kvtop;
+		machdep->is_kvaddr = generic_is_kvaddr;
+		machdep->is_uvaddr = generic_is_uvaddr;
+		machdep->eframe_search = arm64_eframe_search;
+		machdep->back_trace = arm64_back_trace_cmd;
+		machdep->in_alternate_stack = arm64_in_alternate_stack;
+		machdep->processor_speed = arm64_processor_speed;
+		machdep->get_task_pgd = arm64_get_task_pgd;
+		machdep->get_stack_frame = arm64_get_stack_frame;
+		machdep->get_stackbase = generic_get_stackbase;
+		machdep->get_stacktop = generic_get_stacktop;
+		machdep->translate_pte = arm64_translate_pte;
+		machdep->memory_size = generic_memory_size;
+		machdep->vmalloc_start = arm64_vmalloc_start;
+		machdep->get_kvaddr_ranges = arm64_get_kvaddr_ranges;
+		machdep->is_task_addr = arm64_is_task_addr;
+		machdep->dis_filter = arm64_dis_filter;
+		machdep->cmd_mach = arm64_cmd_mach;
+		machdep->get_smp_cpus = arm64_get_smp_cpus;
+		machdep->line_number_hooks = NULL;
+		machdep->value_to_symbol = generic_machdep_value_to_symbol;
+		machdep->dump_irq = generic_dump_irq;
+		machdep->show_interrupts = generic_show_interrupts;
+		machdep->get_irq_affinity = generic_get_irq_affinity;
+		machdep->dumpfile_init = NULL;
+		machdep->verify_line_number = NULL;
+		machdep->init_kernel_pgd = arm64_init_kernel_pgd;
+		break;
+
+	case POST_GDB:
+		machdep->section_size_bits = _SECTION_SIZE_BITS;
+		machdep->max_physmem_bits = _MAX_PHYSMEM_BITS;
+		if (THIS_KERNEL_VERSION >= LINUX(3,10,0)) {
+			machdep->machspec->pte_protnone = PTE_PROT_NONE_3_10;
+			machdep->machspec->pte_file = PTE_FILE_3_10;
+		} else {
+			machdep->machspec->pte_protnone = PTE_PROT_NONE;
+			machdep->machspec->pte_file = PTE_FILE;
+		}
+
+		if (symbol_exists("irq_desc"))
+			ARRAY_LENGTH_INIT(machdep->nr_irqs, irq_desc,
+				  "irq_desc", NULL, 0);
+		else if (kernel_symbol_exists("nr_irqs"))
+			get_symbol_data("nr_irqs", sizeof(unsigned int),
+				&machdep->nr_irqs);
+
+		if (!machdep->hz)
+			machdep->hz = 100;
+
+		arm64_stackframe_init();
+		break;
+
+	case POST_VM:
+		/*
+		 * crash_notes contains machine specific information about the
+		 * crash. In particular, it contains CPU registers at the time
+		 * of the crash. We need this information to extract correct
+		 * backtraces from the panic task.
+		 */
+		if (!ACTIVE() && !arm64_get_crash_notes())
+			error(WARNING, "could not retrieve crash_notes\n");
+
+		break;
+
+	case LOG_ONLY:
+		machdep->machspec = &arm64_machine_specific;
+		machdep->identity_map_base = ARM64_PAGE_OFFSET;
+		arm64_calc_phys_offset();
+		break;
+	}
+}
+
+/*
+ * Accept or reject a symbol from the kernel namelist.
+ */
+static int
+arm64_verify_symbol(const char *name, ulong value, char type)
+{
+//	if (STREQ(name, "swapper_pg_dir"))
+//		machdep->flags |= KSYMS_START;
+//
+//	if (!name || !strlen(name) || !(machdep->flags & KSYMS_START))
+//		return FALSE;
+//
+//	if (STREQ(name, "$a") || STREQ(name, "$n") || STREQ(name, "$d"))
+//		return FALSE;
+//
+//	if (STREQ(name, "PRRR") || STREQ(name, "NMRR"))
+//		return FALSE;
+//
+//	if ((type == 'A') && STRNEQ(name, "__crc_"))
+//		return FALSE;
+//
+//	if (CRASHDEBUG(8) && name && strlen(name))
+//		fprintf(fp, "%08lx %s\n", value, name);
+//
+	NOT_IMPLEMENTED(WARNING);
+	return TRUE;
+}
+
+
+void
+arm64_dump_machdep_table(ulong arg)
+{
+	const struct machine_specific *ms;
+	int others, i;
+
+	others = 0;
+	fprintf(fp, "               flags: %lx (", machdep->flags);
+	if (machdep->flags & KSYMS_START)
+		fprintf(fp, "%sKSYMS_START", others++ ? "|" : "");
+	if (machdep->flags & PHYS_OFFSET)
+		fprintf(fp, "%sPHYS_OFFSET", others++ ? "|" : "");
+	if (machdep->flags & VM_L2_64K)
+		fprintf(fp, "%sVM_L2_64K", others++ ? "|" : "");
+	if (machdep->flags & VM_L3_4K)
+		fprintf(fp, "%sVM_L3_4K", others++ ? "|" : "");
+	fprintf(fp, ")\n");
+
+	fprintf(fp, "              kvbase: %lx\n", machdep->kvbase);
+	fprintf(fp, "   identity_map_base: %lx\n", machdep->kvbase);
+	fprintf(fp, "            pagesize: %d\n", machdep->pagesize);
+	fprintf(fp, "           pageshift: %d\n", machdep->pageshift);
+	fprintf(fp, "            pagemask: %lx\n", (ulong)machdep->pagemask);
+	fprintf(fp, "          pageoffset: %lx\n", machdep->pageoffset);
+	fprintf(fp, "           stacksize: %ld\n", machdep->stacksize);
+	fprintf(fp, "                  hz: %d\n", machdep->hz);
+	fprintf(fp, "                 mhz: %ld\n", machdep->mhz);
+	fprintf(fp, "             memsize: %lld (0x%llx)\n",
+		(ulonglong)machdep->memsize, (ulonglong)machdep->memsize);
+	fprintf(fp, "                bits: %d\n", machdep->bits);
+	fprintf(fp, "             nr_irqs: %d\n", machdep->nr_irqs);
+	fprintf(fp, "       eframe_search: arm64_eframe_search()\n");
+	fprintf(fp, "          back_trace: arm64_back_trace_cmd()\n");
+	fprintf(fp, "  in_alternate_stack: arm64_in_alternate_stack()\n");
+	fprintf(fp, "     processor_speed: arm64_processor_speed()\n");
+	fprintf(fp, "               uvtop: arm64_uvtop()->%s()\n",
+		machdep->flags & VM_L3_4K ? 
+		"arm64_vtop_3level_4k" : "arm64_vtop_2level_64k");
+	fprintf(fp, "               kvtop: arm64_kvtop()->%s()\n",
+		machdep->flags & VM_L3_4K ? 
+		"arm64_vtop_3level_4k" : "arm64_vtop_2level_64k");
+	fprintf(fp, "        get_task_pgd: arm64_get_task_pgd()\n");
+	fprintf(fp, "            dump_irq: generic_dump_irq()\n");
+	fprintf(fp, "     get_stack_frame: arm64_get_stack_frame()\n");
+	fprintf(fp, "       get_stackbase: generic_get_stackbase()\n");
+	fprintf(fp, "        get_stacktop: generic_get_stacktop()\n");
+	fprintf(fp, "       translate_pte: arm64_translate_pte()\n");
+	fprintf(fp, "         memory_size: generic_memory_size()\n");
+	fprintf(fp, "       vmalloc_start: arm64_vmalloc_start()\n");
+	fprintf(fp, "   get_kvaddr_ranges: arm64_get_kvaddr_ranges()\n");
+	fprintf(fp, "        is_task_addr: arm64_is_task_addr()\n");
+	fprintf(fp, "       verify_symbol: arm64_verify_symbol()\n");
+	fprintf(fp, "          dis_filter: arm64_dis_filter()\n");
+	fprintf(fp, "            cmd_mach: arm64_cmd_mach()\n");
+	fprintf(fp, "        get_smp_cpus: arm64_get_smp_cpus()\n");
+	fprintf(fp, "           is_kvaddr: generic_is_kvaddr()\n");
+	fprintf(fp, "           is_uvaddr: generic_is_uvaddr()\n");
+	fprintf(fp, "     value_to_symbol: generic_machdep_value_to_symbol()\n");
+	fprintf(fp, "     init_kernel_pgd: arm64_init_kernel_pgd\n");
+	fprintf(fp, "        verify_paddr: generic_verify_paddr()\n");
+	fprintf(fp, "     show_interrupts: generic_show_interrupts()\n");
+	fprintf(fp, "    get_irq_affinity: generic_get_irq_affinity()\n");
+	fprintf(fp, "       dumpfile_init: (not used)\n");
+	fprintf(fp, "   process_elf_notes: process_elf64_notes()\n");
+	fprintf(fp, "  verify_line_number: (not used)\n");
+
+	fprintf(fp, "  xendump_p2m_create: (n/a)\n");
+	fprintf(fp, "xen_kdump_p2m_create: (n/a)\n");
+        fprintf(fp, "  xendump_panic_task: (n/a)\n");
+        fprintf(fp, "    get_xendump_regs: (n/a)\n");
+	fprintf(fp, "   line_number_hooks: (not used)\n");
+	fprintf(fp, "       last_pud_read: (not used)\n");
+	fprintf(fp, "       last_pgd_read: %lx\n", machdep->last_pgd_read);
+	fprintf(fp, "       last_pmd_read: ");
+	if (PAGESIZE() == 65536)
+		fprintf(fp, "(not used)\n");
+	else
+		fprintf(fp, "%lx\n", machdep->last_pmd_read);
+	fprintf(fp, "      last_ptbl_read: %lx\n", machdep->last_ptbl_read);
+	fprintf(fp, " clear_machdep_cache: arm64_clear_machdep_cache()\n");
+	fprintf(fp, "                 pgd: %lx\n", (ulong)machdep->pgd);
+	fprintf(fp, "                 pmd: %lx\n", (ulong)machdep->pmd);
+	fprintf(fp, "                ptbl: %lx\n", (ulong)machdep->ptbl);
+	fprintf(fp, "        ptrs_per_pgd: %d\n", machdep->ptrs_per_pgd);
+	fprintf(fp, "   section_size_bits: %ld\n", machdep->section_size_bits);
+	fprintf(fp, "    max_physmem_bits: %ld\n", machdep->max_physmem_bits);
+	fprintf(fp, "   sections_per_root: %ld\n", machdep->sections_per_root);
+
+	for (i = 0; i < MAX_MACHDEP_ARGS; i++) {
+		fprintf(fp, "     cmdline_args[%d]: %s\n",
+			i, machdep->cmdline_args[i] ?
+			machdep->cmdline_args[i] : "(unused)");
+	}
+
+	ms = machdep->machspec;
+
+	fprintf(fp, "            machspec: %lx\n", (ulong)ms);
+	fprintf(fp, "         userspace_top: %016lx\n", ms->userspace_top);
+	fprintf(fp, "           page_offset: %016lx\n", ms->page_offset);
+	fprintf(fp, "    vmalloc_start_addr: %016lx\n", ms->vmalloc_start_addr);
+	fprintf(fp, "           vmalloc_end: %016lx\n", ms->vmalloc_end);
+	fprintf(fp, "         modules_vaddr: %016lx\n", ms->modules_vaddr);
+	fprintf(fp, "           modules_end: %016lx\n", ms->modules_end);
+	fprintf(fp, "         vmemmap_vaddr: %016lx\n", ms->vmemmap_vaddr);
+	fprintf(fp, "           phys_offset: %lx\n", ms->phys_offset);
+	fprintf(fp, "__exception_text_start: %lx\n", ms->__exception_text_start);
+	fprintf(fp, "  __exception_text_end: %lx\n", ms->__exception_text_end);
+	fprintf(fp, "       panic_task_regs: %lx\n", (ulong)ms->panic_task_regs);
+	fprintf(fp, "          pte_protnone: %lx\n", ms->pte_protnone);
+	fprintf(fp, "              pte_file: %lx\n", ms->pte_file);
+}
+
+
+/*
+ * Parse machine dependent command line arguments.
+ *
+ * Force the phys_offset address via:
+ *
+ *  --machdep phys_offset=<address>
+ */
+static void
+arm64_parse_cmdline_args(void)
+{
+	int index, i, c, err;
+	char *arglist[MAXARGS];
+	char buf[BUFSIZE];
+	char *p;
+	ulong value = 0;
+
+	for (index = 0; index < MAX_MACHDEP_ARGS; index++) {
+		if (!machdep->cmdline_args[index])
+			break;
+
+		if (!strstr(machdep->cmdline_args[index], "=")) {
+			error(WARNING, "ignoring --machdep option: %x\n",
+				machdep->cmdline_args[index]);
+			continue;
+		}
+
+		strcpy(buf, machdep->cmdline_args[index]);
+
+		for (p = buf; *p; p++) {
+			if (*p == ',')
+				*p = ' ';
+		}
+
+		c = parse_line(buf, arglist);
+
+		for (i = 0; i < c; i++) {
+			err = 0;
+
+			if (STRNEQ(arglist[i], "phys_offset=")) {
+				int megabytes = FALSE;
+				int flags = RETURN_ON_ERROR | QUIET;
+
+				if ((LASTCHAR(arglist[i]) == 'm') ||
+				    (LASTCHAR(arglist[i]) == 'M')) {
+					LASTCHAR(arglist[i]) = NULLCHAR;
+					megabytes = TRUE;
+				}
+
+				p = arglist[i] + strlen("phys_offset=");
+				if (strlen(p)) {
+					if (megabytes)
+						value = dtol(p, flags, &err);
+					else
+						value = htol(p, flags, &err);
+				}
+
+				if (!err) {
+					if (megabytes)
+						value = MEGABYTES(value);
+
+					machdep->machspec->phys_offset = value;
+
+					error(NOTE,
+						"setting phys_offset to: 0x%lx\n",
+						machdep->machspec->phys_offset);
+
+					machdep->flags |= PHYS_OFFSET;
+					continue;
+				}
+			}
+
+			error(WARNING, "ignoring --machdep option: %s\n",
+				arglist[i]);
+		}
+	}
+}
+
+
+static void
+arm64_calc_phys_offset(void)
+{
+	struct machine_specific *ms = machdep->machspec;
+	ulong phys_offset;
+
+	if (machdep->flags & PHYS_OFFSET) /* --machdep override */
+		return;
+
+	/*
+	 * Next determine suitable value for phys_offset. User can override this
+	 * by passing valid '--machdep phys_offset=<addr>' option.
+	 */
+	ms->phys_offset = 0;
+
+	if (ACTIVE()) {
+		char buf[BUFSIZE];
+		char *p1;
+		int errflag;
+		FILE *fp;
+
+		if ((fp = fopen("/proc/iomem", "r")) == NULL)
+			return;
+
+		/*
+		 * Memory regions are sorted in ascending order. We take the
+		 * first region which should be correct for most uses.
+		 */
+		errflag = 1;
+		while (fgets(buf, BUFSIZE, fp)) {
+			if (strstr(buf, ": System RAM")) {
+				clean_line(buf);
+				errflag = 0;
+				break;
+			}
+		}
+		fclose(fp);
+
+		if (errflag)
+			return;
+
+		if (!(p1 = strstr(buf, "-")))
+			return;
+
+		*p1 = NULLCHAR;
+
+		phys_offset = htol(buf, RETURN_ON_ERROR | QUIET, &errflag);
+		if (errflag)
+			return;
+
+		ms->phys_offset = phys_offset;
+	} else if (DISKDUMP_DUMPFILE() && diskdump_phys_base(&phys_offset)) {
+		ms->phys_offset = phys_offset;
+	} else if (KDUMP_DUMPFILE() && arm64_kdump_phys_base(&phys_offset)) {
+		ms->phys_offset = phys_offset;
+	} else {
+		error(WARNING,
+			"phys_offset cannot be determined from the dumpfile.\n");
+		error(CONT,
+			"Using default value of 0.  If this is not correct, then try\n");
+		error(CONT,
+			"using the command line option: --machdep phys_offset=<addr>\n");
+	}
+
+	if (CRASHDEBUG(1))
+		fprintf(fp, "using %lx as phys_offset\n", ms->phys_offset);
+}
+
+
+/*
+ *  Borrow the 32-bit ARM functionality.
+ */
+static int
+arm64_kdump_phys_base(ulong *phys_offset)
+{
+	return arm_kdump_phys_base(phys_offset);
+}
+
+static void
+arm64_init_kernel_pgd(void)
+{
+	int i;
+	ulong value;
+
+	if (!kernel_symbol_exists("init_mm") ||
+	    !readmem(symbol_value("init_mm") + OFFSET(mm_struct_pgd), KVADDR,
+	    &value, sizeof(void *), "init_mm.pgd", RETURN_ON_ERROR)) {
+		if (kernel_symbol_exists("swapper_pg_dir"))
+			value = symbol_value("swapper_pg_dir");
+		else {
+			error(WARNING, "cannot determine kernel pgd location\n");
+			return;
+		}
+	}
+
+        for (i = 0; i < NR_CPUS; i++)
+                vt->kernel_pgd[i] = value;
+}
+
+static int
+arm64_kvtop(struct task_context *tc, ulong kvaddr, physaddr_t *paddr, int verbose)
+{
+	ulong kernel_pgd;
+
+	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)
+			return TRUE;
+	}
+
+	kernel_pgd = vt->kernel_pgd[0];
+
+	switch (machdep->flags & (VM_L2_64K|VM_L3_4K))
+	{
+	case VM_L2_64K:
+		return arm64_vtop_2level_64k(kernel_pgd, kvaddr, paddr, verbose);
+	case VM_L3_4K:
+		return arm64_vtop_3level_4k(kernel_pgd, kvaddr, paddr, verbose);
+	default:
+		return FALSE;
+	}
+}
+
+static int
+arm64_uvtop(struct task_context *tc, ulong uvaddr, physaddr_t *paddr, int verbose)
+{
+        ulong user_pgd;
+
+        readmem(tc->mm_struct + OFFSET(mm_struct_pgd), KVADDR,
+                &user_pgd, sizeof(long), "user pgd", FAULT_ON_ERROR);
+
+	switch (machdep->flags & (VM_L2_64K|VM_L3_4K))
+	{
+	case VM_L2_64K:
+		return arm64_vtop_2level_64k(user_pgd, uvaddr, paddr, verbose);
+	case VM_L3_4K:
+		return arm64_vtop_3level_4k(user_pgd, uvaddr, paddr, verbose);
+	default:
+		return FALSE;
+	}
+}
+
+static int 
+arm64_vtop_2level_64k(ulong pgd, ulong vaddr, physaddr_t *paddr, int verbose)
+{
+	ulong *pgd_base, *pgd_ptr, pgd_val;
+	ulong *pte_base, *pte_ptr, pte_val;
+
+        if (verbose)
+                fprintf(fp, "PAGE DIRECTORY: %lx\n", pgd);
+
+	pgd_base = (ulong *)pgd;
+	FILL_PGD(pgd_base, KVADDR, PTRS_PER_PGD_L2_64K * sizeof(ulong));
+	pgd_ptr = pgd_base + (((vaddr) >> PGDIR_SHIFT_L2_64K) & (PTRS_PER_PGD_L2_64K - 1));
+        pgd_val = ULONG(machdep->pgd + PAGEOFFSET(pgd_ptr));
+        if (verbose) 
+                fprintf(fp, "   PGD: %lx => %lx\n", (ulong)pgd_ptr, pgd_val);
+	if (!pgd_val)
+		goto no_page;
+
+	/* 
+	 * #define __PAGETABLE_PUD_FOLDED 
+	 * #define __PAGETABLE_PMD_FOLDED 
+	 */
+
+	pte_base = (ulong *)PTOV(pgd_val & PHYS_MASK & (s32)machdep->pagemask);
+	FILL_PTBL(pte_base, KVADDR, PTRS_PER_PTE_L2_64K * sizeof(ulong));
+	pte_ptr = pte_base + (((vaddr) >> machdep->pageshift) & (PTRS_PER_PTE_L2_64K - 1));
+        pte_val = ULONG(machdep->ptbl + PAGEOFFSET(pte_ptr));
+        if (verbose) 
+                fprintf(fp, "   PTE: %lx => %lx\n", (ulong)pte_ptr, pte_val);
+	if (!pte_val)
+		goto no_page;
+
+	if (pte_val & PTE_VALID) {
+		*paddr = (PAGEBASE(pte_val) & PHYS_MASK) + PAGEOFFSET(vaddr);
+		if (verbose) {
+			fprintf(fp, "  PAGE: %lx\n\n", PAGEBASE(*paddr));
+			arm64_translate_pte(pte_val, 0, 0);
+		}
+	} else {
+		if (verbose) {
+			fprintf(fp, "\n");
+			arm64_translate_pte(pte_val, 0, 0);
+		}
+		goto no_page;
+	}
+
+	return TRUE;
+no_page:
+	return FALSE;
+}
+
+static int 
+arm64_vtop_3level_4k(ulong pgd, ulong vaddr, physaddr_t *paddr, int verbose)
+{
+	ulong *pgd_base, *pgd_ptr, pgd_val;
+	ulong *pmd_base, *pmd_ptr, pmd_val;
+	ulong *pte_base, *pte_ptr, pte_val;
+
+        if (verbose)
+                fprintf(fp, "PAGE DIRECTORY: %lx\n", pgd);
+
+	pgd_base = (ulong *)pgd;
+	FILL_PGD(pgd_base, KVADDR, PTRS_PER_PGD_L3_4K * sizeof(ulong));
+	pgd_ptr = pgd_base + (((vaddr) >> PGDIR_SHIFT_L3_4K) & (PTRS_PER_PGD_L3_4K - 1));
+        pgd_val = ULONG(machdep->pgd + PAGEOFFSET(pgd_ptr));
+        if (verbose) 
+                fprintf(fp, "   PGD: %lx => %lx\n", (ulong)pgd_ptr, pgd_val);
+	if (!pgd_val)
+		goto no_page;
+
+	/* 
+	 * #define __PAGETABLE_PUD_FOLDED 
+	 */
+
+	pmd_base = (ulong *)PTOV(pgd_val & PHYS_MASK & (s32)machdep->pagemask);
+	FILL_PMD(pmd_base, KVADDR, PTRS_PER_PMD_L3_4K * sizeof(ulong));
+	pmd_ptr = pmd_base + (((vaddr) >> PMD_SHIFT_L3_4K) & (PTRS_PER_PMD_L3_4K - 1));
+        pmd_val = ULONG(machdep->pmd + PAGEOFFSET(pmd_ptr));
+        if (verbose) 
+                fprintf(fp, "   PMD: %lx => %lx\n", (ulong)pmd_ptr, pmd_val);
+	if (!pmd_val)
+		goto no_page;
+
+	pte_base = (ulong *)PTOV(pmd_val & PHYS_MASK & (s32)machdep->pagemask);
+	FILL_PTBL(pte_base, KVADDR, PTRS_PER_PTE_L3_4K * sizeof(ulong));
+	pte_ptr = pte_base + (((vaddr) >> machdep->pageshift) & (PTRS_PER_PTE_L3_4K - 1));
+        pte_val = ULONG(machdep->ptbl + PAGEOFFSET(pte_ptr));
+        if (verbose) 
+                fprintf(fp, "   PTE: %lx => %lx\n", (ulong)pte_ptr, pte_val);
+	if (!pte_val)
+		goto no_page;
+
+	if (pte_val & PTE_VALID) {
+		*paddr = (PAGEBASE(pte_val) & PHYS_MASK) + PAGEOFFSET(vaddr);
+		if (verbose) {
+			fprintf(fp, "  PAGE: %lx\n\n", PAGEBASE(*paddr));
+			arm64_translate_pte(pte_val, 0, 0);
+		}
+	} else {
+		if (verbose) {
+			fprintf(fp, "\n");
+			arm64_translate_pte(pte_val, 0, 0);
+		}
+		goto no_page;
+	}
+
+	return TRUE;
+no_page:
+	return FALSE;
+}
+
+static ulong 
+arm64_get_task_pgd(ulong task)
+{
+	struct task_context *tc;
+	ulong pgd;
+
+	if ((tc = task_to_context(task)) &&
+	    readmem(tc->mm_struct + OFFSET(mm_struct_pgd), KVADDR,
+	    &pgd, sizeof(long), "user pgd", RETURN_ON_ERROR))
+		return pgd;
+	else
+		return NO_TASK;
+}
+
+static ulong 
+arm64_processor_speed(void) 
+{
+	return 0;
+};
+
+
+/*
+ *  Gather and verify all of the backtrace requirements.
+ */
+static void
+arm64_stackframe_init(void)
+{
+	long task_struct_thread;
+	long thread_struct_context;
+	long context_sp, context_pc, context_fp;
+
+	STRUCT_SIZE_INIT(note_buf, "note_buf_t");
+	STRUCT_SIZE_INIT(elf_prstatus, "elf_prstatus");
+	MEMBER_OFFSET_INIT(elf_prstatus_pr_pid, "elf_prstatus", "pr_pid");
+	MEMBER_OFFSET_INIT(elf_prstatus_pr_reg, "elf_prstatus", "pr_reg");
+
+	machdep->machspec->__exception_text_start = 
+		symbol_value("__exception_text_start");
+	machdep->machspec->__exception_text_end = 
+		symbol_value("__exception_text_end");
+
+	task_struct_thread = MEMBER_OFFSET("task_struct", "thread");
+	thread_struct_context = MEMBER_OFFSET("thread_struct", "context");
+
+	if ((task_struct_thread == INVALID_OFFSET) ||
+	    (thread_struct_context == INVALID_OFFSET)) {
+		error(INFO, 
+		    "cannot determine task_struct.thread.context offset\n");
+		return;
+	}
+
+	/*
+	 *  Pay for the convenience of using a hardcopy of a kernel structure.
+	 */
+	if (offsetof(struct arm64_stackframe, sp) != 
+	    MEMBER_OFFSET("stackframe", "sp")) {
+		error(INFO, "builtin stackframe.sp offset incorrect!\n");
+		return;
+	}
+	if (offsetof(struct arm64_stackframe, fp) != 
+	    MEMBER_OFFSET("stackframe", "fp")) {
+		error(INFO, "builtin stackframe.fp offset incorrect!\n");
+		return;
+	}
+	if (offsetof(struct arm64_stackframe, pc) != 
+	    MEMBER_OFFSET("stackframe", "pc")) {
+		error(INFO, "builtin stackframe.pc offset incorrect!\n");
+		return;
+	}
+
+	context_sp = MEMBER_OFFSET("cpu_context", "sp");
+	context_fp = MEMBER_OFFSET("cpu_context", "fp");
+	context_pc = MEMBER_OFFSET("cpu_context", "pc");
+	if (context_sp == INVALID_OFFSET) {
+		error(INFO, "cannot determine cpu_context.sp offset\n");
+		return;
+	}
+	if (context_fp == INVALID_OFFSET) {
+		error(INFO, "cannot determine cpu_context.fp offset\n");
+		return;
+	}
+	if (context_pc == INVALID_OFFSET) {
+		error(INFO, "cannot determine cpu_context.pc offset\n");
+		return;
+	}
+	ASSIGN_OFFSET(task_struct_thread_context_sp) =
+		task_struct_thread + thread_struct_context + context_sp;
+	ASSIGN_OFFSET(task_struct_thread_context_fp) =
+		task_struct_thread + thread_struct_context + context_fp;
+	ASSIGN_OFFSET(task_struct_thread_context_pc) =
+		task_struct_thread + thread_struct_context + context_pc;
+}
+
+static int arm64_eframe_search(struct bt_info *bt)
+{
+	return (NOT_IMPLEMENTED(FATAL));
+}
+
+static int
+arm64_in_exception_text(ulong ptr)
+{
+	struct machine_specific *ms = machdep->machspec;
+
+        return((ptr >= ms->__exception_text_start) &&
+               (ptr < ms->__exception_text_end));
+}
+
+static void 
+arm64_print_stackframe_entry(struct bt_info *bt, int level, struct arm64_stackframe *frame)
+{
+	char *name, *name_plus_offset;
+	ulong symbol_offset;
+	struct syment *sp;
+	struct load_module *lm;
+	char buf[BUFSIZE];
+
+        name = closest_symbol(frame->pc);
+        name_plus_offset = NULL;
+
+        if (bt->flags & BT_SYMBOL_OFFSET) {
+                sp = value_search(frame->pc, &symbol_offset);
+                if (sp && symbol_offset)
+                        name_plus_offset =
+                                value_to_symstr(frame->pc, buf, bt->radix);
+        }
+
+        fprintf(fp, "%s#%d [%8lx] %s at %lx", level < 10 ? " " : "", level,
+                frame->sp, name_plus_offset ? name_plus_offset : name, frame->pc);
+
+	if (module_symbol(frame->pc, NULL, &lm, NULL, 0))
+		fprintf(fp, " [%s]", lm->mod_name);
+
+	fprintf(fp, "\n");
+}
+
+static int arm64_unwind_frame(struct bt_info *bt, struct arm64_stackframe *frame)
+{
+        unsigned long high, low, fp;
+	unsigned long stack_mask;
+	
+	stack_mask = (unsigned long)(ARM64_STACK_SIZE) - 1;
+	fp = frame->fp;
+
+        low  = frame->sp;
+	high = (low + stack_mask) & ~(stack_mask);
+
+        if (fp < low || fp > high || fp & 0xf)
+                return FALSE;
+
+        frame->sp = fp + 0x10;
+        frame->fp = *(unsigned long *)(fp);
+        frame->pc = *(unsigned long *)(fp + 8);
+
+        return TRUE;
+}
+
+static void arm64_back_trace_cmd(struct bt_info *bt)
+{
+	struct arm64_stackframe stackframe;
+	int level;
+
+	if (BT_REFERENCE_CHECK(bt))
+		option_not_supported('R');
+
+	if (bt->flags & BT_USER_SPACE) {
+		fprintf(fp, "#0 [user space]\n");
+		return;
+	}
+
+	stackframe.sp = bt->stkptr;
+	stackframe.pc = bt->instptr;
+	stackframe.fp = bt->frameptr;
+
+	level = 0;
+        while (1) {
+		bt->instptr = stackframe.pc;
+
+		arm64_print_stackframe_entry(bt, level, &stackframe);
+
+                if (!arm64_unwind_frame(bt, &stackframe))
+                        break;
+
+        	if (arm64_in_exception_text(bt->instptr))
+			fprintf(fp, "TBD: dump exception frame: pt_regs @ stackframe.sp\n");
+
+		level++;
+        }
+}
+
+static int
+arm64_get_dumpfile_stackframe(struct bt_info *bt, struct arm64_stackframe *frame)
+{
+	struct machine_specific *ms = machdep->machspec;
+	struct arm64_pt_regs *ptregs;
+
+	if (!ms->panic_task_regs)
+		return FALSE;
+
+	ptregs = &ms->panic_task_regs[bt->tc->processor];
+	frame->sp = ptregs->sp;
+	frame->pc = ptregs->pc;
+	frame->fp = ptregs->regs[29];
+
+	if (!is_kernel_text(frame->pc) && 
+	    in_user_stack(bt->tc->task, frame->sp))
+		bt->flags |= BT_USER_SPACE;
+
+	return TRUE;
+}
+
+static int
+arm64_get_stackframe(struct bt_info *bt, struct arm64_stackframe *frame) 
+{
+	if (!fill_task_struct(bt->task))
+		return FALSE;
+
+	frame->sp = ULONG(tt->task_struct + OFFSET(task_struct_thread_context_sp));
+	frame->pc = ULONG(tt->task_struct + OFFSET(task_struct_thread_context_pc));
+	frame->fp = ULONG(tt->task_struct + OFFSET(task_struct_thread_context_fp));
+
+	return TRUE;
+}
+
+static void
+arm64_get_stack_frame(struct bt_info *bt, ulong *pcp, ulong *spp)
+{
+	int ret;
+	struct arm64_stackframe stackframe;
+
+	if (DUMPFILE() && is_task_active(bt->task))
+		ret = arm64_get_dumpfile_stackframe(bt, &stackframe);
+	else
+		ret = arm64_get_stackframe(bt, &stackframe);
+
+	if (!ret) {
+		error(WARNING, 
+			"cannot get stackframe for task %lx\n", bt->task);
+		return;
+	}
+
+	bt->frameptr = stackframe.fp;
+	if (pcp)
+		*pcp = stackframe.pc;
+	if (spp)
+		*spp = stackframe.sp;
+}
+
+/*
+ *  Translate a PTE, returning TRUE if the page is present.
+ *  If a physaddr pointer is passed in, don't print anything.
+ */
+static int
+arm64_translate_pte(ulong pte, void *physaddr, ulonglong unused)
+{
+	int c, others, len1, len2, len3;
+	ulong paddr;
+	char buf1[BUFSIZE];
+        char buf2[BUFSIZE];
+        char buf3[BUFSIZE];
+	char ptebuf[BUFSIZE];
+	char physbuf[BUFSIZE];
+        char *arglist[MAXARGS];
+	int page_present;
+
+	paddr = pte & PHYS_MASK & (s32)machdep->pagemask;
+       	page_present = pte & (PTE_VALID | machdep->machspec->pte_protnone);
+
+        if (physaddr) {
+		*((ulong *)physaddr) = paddr;
+		return page_present;
+	}
+        
+	sprintf(ptebuf, "%lx", pte);
+	len1 = MAX(strlen(ptebuf), strlen("PTE"));
+	fprintf(fp, "%s  ", mkstring(buf1, len1, CENTER|LJUST, "PTE"));
+
+        if (!page_present && (pte & PTE_FILE)) {
+                swap_location(pte, buf1);
+                if ((c = parse_line(buf1, arglist)) != 3)
+                        error(FATAL, "cannot determine swap location\n");
+
+                len2 = MAX(strlen(arglist[0]), strlen("SWAP"));
+                len3 = MAX(strlen(arglist[2]), strlen("OFFSET"));
+
+                fprintf(fp, "%s  %s\n",
+                        mkstring(buf2, len2, CENTER|LJUST, "SWAP"),
+                        mkstring(buf3, len3, CENTER|LJUST, "OFFSET"));
+
+                strcpy(buf2, arglist[0]);
+                strcpy(buf3, arglist[2]);
+                fprintf(fp, "%s  %s  %s\n",
+                        mkstring(ptebuf, len1, CENTER|RJUST, NULL),
+                        mkstring(buf2, len2, CENTER|RJUST, NULL),
+                        mkstring(buf3, len3, CENTER|RJUST, NULL));
+
+                return page_present;
+        }
+
+        sprintf(physbuf, "%lx", paddr);
+        len2 = MAX(strlen(physbuf), strlen("PHYSICAL"));
+        fprintf(fp, "%s  ", mkstring(buf1, len2, CENTER|LJUST, "PHYSICAL"));
+
+        fprintf(fp, "FLAGS\n");
+
+        fprintf(fp, "%s  %s  ",
+                mkstring(ptebuf, len1, CENTER|RJUST, NULL),
+                mkstring(physbuf, len2, CENTER|RJUST, NULL));
+        fprintf(fp, "(");
+        others = 0;
+
+	if (pte) {
+		if (pte & PTE_VALID)
+			fprintf(fp, "%sVALID", others++ ? "|" : "");
+		if (THIS_KERNEL_VERSION >= LINUX(3,10,0)) {
+			if (pte & machdep->machspec->pte_file)
+				fprintf(fp, "%sFILE", others++ ? "|" : "");
+			if (pte & machdep->machspec->pte_protnone)
+				fprintf(fp, "%sPROTNONE", others++ ? "|" : "");
+		} else {
+			if (pte & machdep->machspec->pte_protnone)
+				fprintf(fp, "%sPROTNONE", others++ ? "|" : "");
+			if (pte & machdep->machspec->pte_file)
+				fprintf(fp, "%sFILE", others++ ? "|" : "");
+		} 
+		if (pte & PTE_USER)
+			fprintf(fp, "%sUSER", others++ ? "|" : "");
+		if (pte & PTE_RDONLY)
+			fprintf(fp, "%sRDONLY", others++ ? "|" : "");
+		if (pte & PTE_SHARED)
+			fprintf(fp, "%sSHARED", others++ ? "|" : "");
+		if (pte & PTE_AF)
+			fprintf(fp, "%sAF", others++ ? "|" : "");
+		if (pte & PTE_NG)
+			fprintf(fp, "%sNG", others++ ? "|" : "");
+		if (pte & PTE_PXN)
+			fprintf(fp, "%sPXN", others++ ? "|" : "");
+		if (pte & PTE_UXN)
+			fprintf(fp, "%sUXN", others++ ? "|" : "");
+		if (pte & PTE_DIRTY)
+			fprintf(fp, "%sDIRTY", others++ ? "|" : "");
+		if (pte & PTE_SPECIAL)
+			fprintf(fp, "%sSPECIAL", others++ ? "|" : "");
+	} else {
+                fprintf(fp, "no mapping");
+        }
+
+        fprintf(fp, ")\n");
+
+	return (page_present);
+}
+
+static ulong
+arm64_vmalloc_start(void)
+{
+	return ARM64_VMALLOC_START;
+}
+
+/*
+ *  Not so accurate since thread_info introduction.
+ */
+static int
+arm64_is_task_addr(ulong task)
+{
+	if (tt->flags & THREAD_INFO)
+		return IS_KVADDR(task);
+	else
+		return (IS_KVADDR(task) && (ALIGNED_STACK_OFFSET(task) == 0));
+}
+
+/*
+ * Filter dissassembly output if the output radix is not gdb's default 10
+ */
+static int
+arm64_dis_filter(ulong vaddr, char *inbuf, unsigned int output_radix)
+{
+	char buf1[BUFSIZE];
+	char buf2[BUFSIZE];
+	char *colon, *p1;
+	int argc;
+	char *argv[MAXARGS];
+	ulong value;
+
+	if (!inbuf)
+		return TRUE;
+
+	console("IN: %s", inbuf);
+
+	colon = strstr(inbuf, ":");
+
+	if (colon) {
+		sprintf(buf1, "0x%lx <%s>", vaddr,
+			value_to_symstr(vaddr, buf2, output_radix));
+		sprintf(buf2, "%s%s", buf1, colon);
+		strcpy(inbuf, buf2);
+	}
+
+	strcpy(buf1, inbuf);
+	argc = parse_line(buf1, argv);
+
+	if ((FIRSTCHAR(argv[argc-1]) == '<') &&
+	    (LASTCHAR(argv[argc-1]) == '>')) {
+		p1 = rindex(inbuf, '<');
+		while ((p1 > inbuf) && !STRNEQ(p1, " 0x"))
+			p1--;
+
+		if (!STRNEQ(p1, " 0x"))
+			return FALSE;
+		p1++;
+
+		if (!extract_hex(p1, &value, NULLCHAR, TRUE))
+			return FALSE;
+
+		sprintf(buf1, "0x%lx <%s>\n", value,
+			value_to_symstr(value, buf2, output_radix));
+
+		sprintf(p1, "%s", buf1);
+	}
+
+	console("    %s", inbuf);
+
+	return TRUE;
+}
+
+/*
+ * Machine dependent command.
+ */
+static void
+arm64_cmd_mach(void)
+{
+	int c;
+
+	while ((c = getopt(argcnt, args, "cm")) != -1) {
+		switch (c) {
+		case 'c':
+		case 'm':
+			option_not_supported(c);
+			break;
+
+		default:
+			argerrs++;
+			break;
+		}
+	}
+
+	if (argerrs)
+		cmd_usage(pc->curcmd, SYNOPSIS);
+
+	arm64_display_machine_stats();
+}
+
+static void
+arm64_display_machine_stats(void)
+{
+	struct new_utsname *uts;
+	char buf[BUFSIZE];
+	ulong mhz;
+
+	uts = &kt->utsname;
+
+	fprintf(fp, "       MACHINE TYPE: %s\n", uts->machine);
+	fprintf(fp, "        MEMORY SIZE: %s\n", get_memory_size(buf));
+	fprintf(fp, "               CPUS: %d\n", get_cpus_to_display());
+	if ((mhz = machdep->processor_speed()))
+		fprintf(fp, "    PROCESSOR SPEED: %ld Mhz\n", mhz);
+	fprintf(fp, "                 HZ: %d\n", machdep->hz);
+	fprintf(fp, "          PAGE SIZE: %d\n", PAGESIZE());
+	fprintf(fp, "KERNEL VIRTUAL BASE: %lx\n", ARM64_PAGE_OFFSET);
+	fprintf(fp, "KERNEL VMALLOC BASE: %lx\n", ARM64_VMALLOC_START);
+	fprintf(fp, "KERNEL MODULES BASE: %lx\n", ARM64_MODULES_VADDR);
+	fprintf(fp, "  KERNEL STACK SIZE: %ld\n", STACKSIZE());
+}
+
+static int
+arm64_get_smp_cpus(void)
+{
+	return MAX(get_cpus_online(), get_highest_cpu_online()+1);
+}
+
+
+/*
+ * Retrieve task registers for the time of the crash.
+ */
+static int
+arm64_get_crash_notes(void)
+{
+	struct machine_specific *ms = machdep->machspec;
+	ulong crash_notes;
+	Elf64_Nhdr *note;
+	ulong offset;
+	char *buf, *p;
+	ulong *notes_ptrs;
+	ulong i;
+
+	if (!symbol_exists("crash_notes"))
+		return FALSE;
+
+	crash_notes = symbol_value("crash_notes");
+
+	notes_ptrs = (ulong *)GETBUF(kt->cpus*sizeof(notes_ptrs[0]));
+
+	/*
+	 * Read crash_notes for the first CPU. crash_notes are in standard ELF
+	 * note format.
+	 */
+	if (!readmem(crash_notes, KVADDR, &notes_ptrs[kt->cpus-1], 
+	    sizeof(notes_ptrs[kt->cpus-1]), "crash_notes", RETURN_ON_ERROR)) {
+		error(WARNING, "cannot read crash_notes\n");
+		FREEBUF(notes_ptrs);
+		return FALSE;
+	}
+
+	if (symbol_exists("__per_cpu_offset")) {
+		/* 
+		 * Add __per_cpu_offset for each cpu to form the notes pointer.
+		 */
+		for (i = 0; i<kt->cpus; i++)
+			notes_ptrs[i] = notes_ptrs[kt->cpus-1] + kt->__per_cpu_offset[i];	
+	}
+
+	buf = GETBUF(SIZE(note_buf));
+
+	if (!(ms->panic_task_regs = malloc(kt->cpus * sizeof(struct arm64_pt_regs))))
+		error(FATAL, "cannot malloc panic_task_regs space\n");
+	
+	for  (i = 0; i < kt->cpus; i++) {
+
+		if (!readmem(notes_ptrs[i], KVADDR, buf, SIZE(note_buf), 
+		    "note_buf_t", RETURN_ON_ERROR)) {
+			error(WARNING, "failed to read note_buf_t\n");
+			goto fail;
+		}
+
+		/*
+		 * Do some sanity checks for this note before reading registers from it.
+		 */
+		note = (Elf64_Nhdr *)buf;
+		p = buf + sizeof(Elf64_Nhdr);
+
+		if (note->n_type != NT_PRSTATUS) {
+			error(WARNING, "invalid note (n_type != NT_PRSTATUS)\n");
+			goto fail;
+		}
+		if (p[0] != 'C' || p[1] != 'O' || p[2] != 'R' || p[3] != 'E') {
+			error(WARNING, "invalid note (name != \"CORE\"\n");
+			goto fail;
+		}
+
+		/*
+		 * Find correct location of note data. This contains elf_prstatus
+		 * structure which has registers etc. for the crashed task.
+		 */
+		offset = sizeof(Elf64_Nhdr);
+		offset = roundup(offset + note->n_namesz, 4);
+		p = buf + offset; /* start of elf_prstatus */
+
+		BCOPY(p + OFFSET(elf_prstatus_pr_reg), &ms->panic_task_regs[i],
+		      sizeof(struct arm64_pt_regs));
+	}
+
+	FREEBUF(buf);
+	FREEBUF(notes_ptrs);
+	return TRUE;
+
+fail:
+	FREEBUF(buf);
+	FREEBUF(notes_ptrs);
+	free(ms->panic_task_regs);
+	ms->panic_task_regs = NULL;
+	return FALSE;
+}
+
+static void
+arm64_clear_machdep_cache(void) {
+	/*
+	 * TBD: probably not necessary...
+	 */
+	return;
+}
+
+static int
+arm64_in_alternate_stack(int cpu, ulong stkptr)
+{
+	NOT_IMPLEMENTED(INFO);
+	return FALSE;
+}
+
+
+static int
+compare_kvaddr(const void *v1, const void *v2)
+{
+        struct vaddr_range *r1, *r2;
+
+        r1 = (struct vaddr_range *)v1;
+        r2 = (struct vaddr_range *)v2;
+
+        return (r1->start < r2->start ? -1 :
+                r1->start == r2->start ? 0 : 1);
+}
+
+static int
+arm64_get_kvaddr_ranges(struct vaddr_range *vrp)
+{
+	int cnt;
+
+	cnt = 0;
+
+	vrp[cnt].type = KVADDR_UNITY_MAP;
+	vrp[cnt].start = machdep->machspec->page_offset;
+	vrp[cnt++].end = vt->high_memory;
+
+	vrp[cnt].type = KVADDR_VMALLOC;
+	vrp[cnt].start = machdep->machspec->vmalloc_start_addr;
+	vrp[cnt++].end = last_vmalloc_address();
+
+	if (st->mods_installed) {
+		vrp[cnt].type = KVADDR_MODULES;
+		vrp[cnt].start = lowest_module_address();
+		vrp[cnt++].end = roundup(highest_module_address(), 
+			PAGESIZE());
+	}
+
+	if (machdep->flags & VMEMMAP) {
+		vrp[cnt].type = KVADDR_VMEMMAP;
+		vrp[cnt].start = machdep->machspec->vmemmap_vaddr;
+		vrp[cnt++].end = vt->node_table[vt->numnodes-1].mem_map +
+			(vt->node_table[vt->numnodes-1].size * SIZE(page));
+	}
+
+	qsort(vrp, cnt, sizeof(struct vaddr_range), compare_kvaddr);
+
+	return cnt;
+}
+
+/*
+ *  Include both vmalloc'd, module and vmemmap address space as VMALLOC space.
+ */
+int
+arm64_IS_VMALLOC_ADDR(ulong vaddr)
+{
+        return ((vaddr >= ARM64_VMALLOC_START && vaddr <= ARM64_VMALLOC_END) ||
+                ((machdep->flags & VMEMMAP) &&
+                 (vaddr >= ARM64_VMEMMAP_VADDR && vaddr <= ARM64_VMEMMAP_END)) ||
+                (vaddr >= ARM64_MODULES_VADDR && vaddr <= ARM64_MODULES_END));
+}
+
+#endif  /* ARM64 */
+

=== added file '.pc/Updated-the-ARM64-implementation-to-support-Linux-3..patch/defs.h'
--- .pc/Updated-the-ARM64-implementation-to-support-Linux-3..patch/defs.h	1970-01-01 00:00:00 +0000
+++ .pc/Updated-the-ARM64-implementation-to-support-Linux-3..patch/defs.h	2014-09-09 15:21:10 +0000
@@ -0,0 +1,5946 @@
+/* defs.h - core analysis suite
+ *
+ * Copyright (C) 1999, 2000, 2001, 2002 Mission Critical Linux, Inc.
+ * Copyright (C) 2002-2013 David Anderson
+ * Copyright (C) 2002-2013 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2002 Silicon Graphics, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details. 
+ */
+
+#ifndef GDB_COMMON
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <termios.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <setjmp.h>
+#undef basename
+#if !defined(__USE_GNU)
+#define __USE_GNU
+#include <string.h>
+#undef __USE_GNU
+#else
+#include <string.h>
+#endif
+#include <fcntl.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <assert.h>
+#include <errno.h>
+#include <dirent.h>
+#include <time.h>
+#include <zlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/param.h>
+#include <sys/wait.h>
+#include <sys/time.h>
+#include <execinfo.h> /* backtrace() */
+#include <regex.h>
+#ifdef LZO
+#include <lzo/lzo1x.h>
+#endif
+#ifdef SNAPPY
+#include <snappy-c.h>
+#endif
+
+#ifndef ATTRIBUTE_UNUSED
+#define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
+#endif
+
+#define BASELEVEL_REVISION  "7.0.3"
+
+#undef TRUE
+#undef FALSE
+
+#define TRUE  (1)
+#define FALSE (0)
+#define STR(x)	#x
+#ifndef offsetof
+#  define offsetof(TYPE, MEMBER) ((ulong)&((TYPE *)0)->MEMBER)
+#endif
+
+#if !defined(X86) && !defined(X86_64) && !defined(ALPHA) && !defined(PPC) && \
+    !defined(IA64) && !defined(PPC64) && !defined(S390) && !defined(S390X) && \
+    !defined(ARM) && !defined(ARM64)
+#ifdef __alpha__
+#define ALPHA
+#endif
+#ifdef __i386__
+#define X86
+#endif
+#ifdef __powerpc__
+#define PPC
+#endif
+#ifdef __ia64__
+#define IA64
+#endif
+#ifdef __s390__
+#define S390
+#endif
+#ifdef __s390x__
+#define S390X
+#endif
+#ifdef __powerpc64__
+#define PPC64
+#endif
+#ifdef __x86_64__
+#define X86_64
+#endif
+#ifdef __arm__
+#define ARM
+#endif
+#ifdef __aarch64__
+#define ARM64
+#endif
+#endif
+
+#ifdef X86
+#define NR_CPUS  (256)
+#endif
+#ifdef X86_64
+#define NR_CPUS  (5120)
+#endif
+#ifdef ALPHA
+#define NR_CPUS  (64)
+#endif
+#ifdef PPC
+#define NR_CPUS  (32)
+#endif
+#ifdef IA64
+#define NR_CPUS  (4096)
+#endif
+#ifdef PPC64
+#define NR_CPUS  (2048)
+#endif
+#ifdef S390
+#define NR_CPUS  (64)
+#endif
+#ifdef S390X
+#define NR_CPUS  (64)
+#endif
+#ifdef ARM
+#define NR_CPUS  (4)
+#endif
+#ifdef ARM64
+#define NR_CPUS  (4096)   /* TBD */
+#endif
+
+#define BUFSIZE  (1500)
+#define NULLCHAR ('\0')
+
+#define MAXARGS    (100)   /* max number of arguments to one function */
+#define MAXARGLEN  (40)   /* max length of argument */
+
+#define HIST_BLKSIZE  (4096)
+
+static inline int string_exists(char *s) { return (s ? TRUE : FALSE); }
+#define STREQ(A, B)      (string_exists((char *)A) && string_exists((char *)B) && \
+	(strcmp((char *)(A), (char *)(B)) == 0))
+#define STRNEQ(A, B)     (string_exists((char *)A) && string_exists((char *)B) && \
+        (strncmp((char *)(A), (char *)(B), strlen((char *)(B))) == 0))
+#define BZERO(S, N)      (memset(S, NULLCHAR, N))
+#define BCOPY(S, D, C)   (memcpy(D, S, C))
+#define BNEG(S, N)       (memset(S, 0xff, N))
+#define BEEP()           fprintf(stderr, "%c", 0x7)
+#define LASTCHAR(s)      (s[strlen(s)-1])
+#define FIRSTCHAR(s)     (s[0])
+#define QUOTED_STRING(s) ((FIRSTCHAR(s) == '"') && (LASTCHAR(s) == '"'))
+#define SINGLE_QUOTED_STRING(s) ((FIRSTCHAR(s) == '\'') && (LASTCHAR(s) == '\''))
+#define PATHEQ(A, B)     ((A) && (B) && (pathcmp((char *)(A), (char *)(B)) == 0))
+
+#ifdef roundup
+#undef roundup
+#endif
+#define roundup(x, y)  ((((x)+((y)-1))/(y))*(y))
+
+typedef uint64_t physaddr_t;
+
+#define PADDR_NOT_AVAILABLE (0x1ULL)
+
+typedef unsigned long long int ulonglong;
+struct number_option {
+        ulong num;
+        ulonglong ll_num;
+	ulong retflags;
+};
+
+/*
+ *  program_context flags
+ */
+#define LIVE_SYSTEM                 (0x1ULL)
+#define TTY                         (0x2ULL)
+#define RUNTIME                     (0x4ULL)
+#define IN_FOREACH                  (0x8ULL)
+#define MCLXCD                     (0x10ULL)
+#define CMDLINE_IFILE              (0x20ULL)
+#define MFD_RDWR                   (0x40ULL)
+#define KVMDUMP                    (0x80ULL)
+#define SILENT                    (0x100ULL)
+#define SADUMP                    (0x200ULL)
+#define HASH                      (0x400ULL)
+#define SCROLL                    (0x800ULL)
+#define NO_CONSOLE               (0x1000ULL)
+#define RUNTIME_IFILE            (0x2000ULL)
+#define DROP_CORE                (0x4000ULL)
+#define LKCD                     (0x8000ULL)
+#define GDB_INIT                (0x10000ULL)
+#define IN_GDB                  (0x20000ULL)
+#define RCLOCAL_IFILE           (0x40000ULL)
+#define RCHOME_IFILE            (0x80000ULL)
+#define GET_TIMESTAMP          (0x100000ULL)
+#define READLINE               (0x200000ULL) 
+#define _SIGINT_               (0x400000ULL)
+#define IN_RESTART             (0x800000ULL)
+#define KERNEL_DEBUG_QUERY    (0x1000000ULL)
+#define DEVMEM                (0x2000000ULL)
+#define REM_LIVE_SYSTEM       (0x4000000ULL)
+#define NAMELIST_LOCAL        (0x8000000ULL)
+#define MEMSRC_LOCAL         (0x10000000ULL)
+#define NAMELIST_SAVED       (0x20000000ULL)
+#define DUMPFILE_SAVED       (0x40000000ULL)
+#define UNLINK_NAMELIST      (0x80000000ULL) 
+#define NAMELIST_UNLINKED   (0x100000000ULL)
+#define REM_MCLXCD          (0x200000000ULL)
+#define REM_LKCD            (0x400000000ULL)
+#define NAMELIST_NO_GZIP    (0x800000000ULL)
+#define UNLINK_MODULES     (0x1000000000ULL)
+#define S390D              (0x2000000000ULL)
+#define REM_S390D          (0x4000000000ULL)
+#define SYSRQ              (0x8000000000ULL)
+#define KDUMP             (0x10000000000ULL)
+#define NETDUMP           (0x20000000000ULL)
+#define REM_NETDUMP       (0x40000000000ULL)
+#define SYSMAP            (0x80000000000ULL)
+#define SYSMAP_ARG       (0x100000000000ULL)
+#define MEMMOD           (0x200000000000ULL)
+#define MODPRELOAD       (0x400000000000ULL)
+#define DISKDUMP         (0x800000000000ULL)
+#define DATADEBUG       (0x1000000000000ULL)
+#define FINDKERNEL      (0x2000000000000ULL)
+#define VERSION_QUERY   (0x4000000000000ULL)
+#define READNOW         (0x8000000000000ULL)
+#define NOCRASHRC      (0x10000000000000ULL)
+#define INIT_IFILE     (0x20000000000000ULL)
+#define XENDUMP        (0x40000000000000ULL)
+#define XEN_HYPER      (0x80000000000000ULL)
+#define XEN_CORE      (0x100000000000000ULL)
+#define PLEASE_WAIT   (0x200000000000000ULL)
+#define IFILE_ERROR   (0x400000000000000ULL)
+#define KERNTYPES     (0x800000000000000ULL)
+#define MINIMAL_MODE (0x1000000000000000ULL)
+#define CRASHBUILTIN (0x2000000000000000ULL)
+#define PRELOAD_EXTENSIONS \
+		     (0x4000000000000000ULL)
+#define PROC_KCORE   (0x8000000000000000ULL)
+
+#define ACTIVE()            (pc->flags & LIVE_SYSTEM)
+#define DUMPFILE()          (!(pc->flags & LIVE_SYSTEM))
+#define LIVE()              (pc->flags2 & LIVE_DUMP || pc->flags & LIVE_SYSTEM)
+#define MEMORY_SOURCES (NETDUMP|KDUMP|MCLXCD|LKCD|DEVMEM|S390D|MEMMOD|DISKDUMP|XENDUMP|CRASHBUILTIN|KVMDUMP|PROC_KCORE|SADUMP)
+#define DUMPFILE_TYPES      (DISKDUMP|NETDUMP|KDUMP|MCLXCD|LKCD|S390D|XENDUMP|KVMDUMP|SADUMP)
+#define REMOTE()            (pc->flags2 & REMOTE_DAEMON)
+#define REMOTE_ACTIVE()     (pc->flags & REM_LIVE_SYSTEM) 
+#define REMOTE_DUMPFILE() \
+	   (pc->flags & (REM_NETDUMP|REM_MCLXCD|REM_LKCD|REM_S390D))
+#define REMOTE_MEMSRC()     (REMOTE_ACTIVE() || REMOTE_DUMPFILE())
+#define LKCD_DUMPFILE()     (pc->flags & (LKCD|REM_LKCD))
+#define NETDUMP_DUMPFILE()  (pc->flags & (NETDUMP|REM_NETDUMP))
+#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 LKCD_KERNTYPES()    (pc->flags & KERNTYPES)
+#define KVMDUMP_DUMPFILE()  (pc->flags & KVMDUMP)
+#define SADUMP_DUMPFILE()  (pc->flags & SADUMP)
+
+#define NETDUMP_LOCAL    (0x1)  /* netdump_data flags */
+#define NETDUMP_REMOTE   (0x2)  
+#define VMCORE_VALID()   (nd->flags & (NETDUMP_LOCAL|NETDUMP_REMOTE|KDUMP_LOCAL))
+#define NETDUMP_ELF32    (0x4)
+#define NETDUMP_ELF64    (0x8)
+#define PARTIAL_DUMP    (0x10)  /* netdump or diskdump */
+#define KDUMP_ELF32     (0x20)
+#define KDUMP_ELF64     (0x40)
+#define KDUMP_LOCAL     (0x80)  
+#define KCORE_LOCAL    (0x100)     
+#define KCORE_ELF32    (0x200)
+#define KCORE_ELF64    (0x400)
+#define QEMU_MEM_DUMP_KDUMP_BACKUP \
+                       (0x800)
+#define KVMDUMP_LOCAL    (0x1)
+#define KVMDUMP_VALID()  (kvm->flags & (KVMDUMP_LOCAL))
+
+#define DUMPFILE_FORMAT(flags) ((flags) & \
+		        (NETDUMP_ELF32|NETDUMP_ELF64|KDUMP_ELF32|KDUMP_ELF64))
+
+#define DISKDUMP_LOCAL      (0x1)
+#define KDUMP_CMPRS_LOCAL   (0x2)
+#define ERROR_EXCLUDED      (0x4)
+#define ZERO_EXCLUDED       (0x8)
+#define DUMPFILE_SPLIT      (0x10)
+#define NO_ELF_NOTES        (0x20)
+#define LZO_SUPPORTED       (0x40)
+#define SNAPPY_SUPPORTED    (0x80)
+#define DISKDUMP_VALID()    (dd->flags & DISKDUMP_LOCAL)
+#define KDUMP_CMPRS_VALID() (dd->flags & KDUMP_CMPRS_LOCAL)
+#define KDUMP_SPLIT()       (dd->flags & DUMPFILE_SPLIT)
+
+#define XENDUMP_LOCAL    (0x1)
+#define XENDUMP_VALID()  (xd->flags & XENDUMP_LOCAL)
+
+#define SADUMP_LOCAL   (0x1)
+#define SADUMP_DISKSET (0x2)
+#define SADUMP_MEDIA   (0x4)
+#define SADUMP_ZERO_EXCLUDED (0x8)
+#define SADUMP_KDUMP_BACKUP  (0x10)
+#define SADUMP_VALID() (sd->flags & SADUMP_LOCAL)
+
+#define CRASHDEBUG(x) (pc->debug >= (x))
+
+#define CRASHDEBUG_SUSPEND(X) { pc->debug_save = pc->debug; pc->debug = X; }
+#define CRASHDEBUG_RESTORE()  { pc->debug = pc->debug_save; }
+
+#define VERBOSE (0x1)
+#define ADDRESS_SPECIFIED (0x2)
+
+#define FAULT_ON_ERROR   (0x1)
+#define RETURN_ON_ERROR  (0x2)
+#define QUIET            (0x4)
+#define HEX_BIAS         (0x8)
+#define LONG_LONG       (0x10)
+#define RETURN_PARTIAL  (0x20)
+
+#define SEEK_ERROR       (-1)
+#define READ_ERROR       (-2)
+#define WRITE_ERROR      (-3)
+#define PAGE_EXCLUDED    (-4)
+
+#define RESTART()         (longjmp(pc->main_loop_env, 1))
+#define RESUME_FOREACH()  (longjmp(pc->foreach_loop_env, 1))
+
+#define INFO           (1)
+#define FATAL          (2)
+#define FATAL_RESTART  (3)
+#define WARNING        (4)
+#define NOTE           (5)
+#define CONT           (6)
+#define FATAL_ERROR(x) (((x) == FATAL) || ((x) == FATAL_RESTART))
+
+#define CONSOLE_OFF(x) ((x) = console_off())
+#define CONSOLE_ON(x)  (console_on(x))
+
+#define RADIX(X)   (X)
+
+#define NUM_HEX  (0x1)
+#define NUM_DEC  (0x2)
+#define NUM_EXPR (0x4)
+#define NUM_ANY  (NUM_HEX|NUM_DEC|NUM_EXPR)
+
+/*
+ *  program context redirect flags 
+ */
+#define FROM_COMMAND_LINE        (0x1)
+#define FROM_INPUT_FILE          (0x2)
+#define REDIRECT_NOT_DONE        (0x4)
+#define REDIRECT_TO_PIPE         (0x8)
+#define REDIRECT_TO_STDPIPE     (0x10)
+#define REDIRECT_TO_FILE        (0x20)
+#define REDIRECT_FAILURE        (0x40)
+#define REDIRECT_SHELL_ESCAPE   (0x80)
+#define REDIRECT_SHELL_COMMAND (0x100)
+#define REDIRECT_PID_KNOWN     (0x200)
+#define REDIRECT_MULTI_PIPE    (0x400)
+
+#define PIPE_OPTIONS (FROM_COMMAND_LINE | FROM_INPUT_FILE | REDIRECT_TO_PIPE | \
+                      REDIRECT_TO_STDPIPE | REDIRECT_TO_FILE)
+
+#define DEFAULT_REDHAT_DEBUG_LOCATION  "/usr/lib/debug/lib/modules"
+
+#define MEMORY_DRIVER_MODULE        "crash"
+#define MEMORY_DRIVER_DEVICE        "/dev/crash"
+#define MEMORY_DRIVER_DEVICE_MODE   (S_IFCHR|S_IRUSR)
+
+/*
+ *  structure definitions
+ */
+struct program_context {
+	char *program_name;             /* this program's name */
+	char *program_path;             /* unadulterated argv[0] */
+	char *program_version;          /* this program's version */
+	char *gdb_version;              /* embedded gdb version */
+	char *prompt;                   /* this program's prompt */
+	unsigned long long flags;       /* flags from above */
+	char *namelist;         	/* linux namelist */
+	char *dumpfile;         	/* dumpfile or /dev/kmem */ 
+	char *live_memsrc;              /* live memory driver */
+	char *system_map;               /* get symbol values from System.map */
+	char *namelist_debug;         	/* namelist containing debug data  */
+	char *debuginfo_file;           /* separate debuginfo file */
+	char *memory_module;            /* alternative to mem.c driver */
+	char *memory_device;	        /* alternative to /dev/[k]mem device */
+	char *machine_type;             /* machine's processor type */
+	char *editing_mode;             /* readline vi or emacs */
+	char *server;                   /* network daemon */
+	char *server_memsrc;            /* memory source on server */
+	char *server_namelist;          /* kernel namelist on server */
+	int nfd;             		/* linux namelist fd */
+	int mfd;			/* /dev/mem fd */
+	int kfd;			/* /dev/kmem fd */
+	int dfd;			/* dumpfile fd */
+	int confd;			/* console fd */
+	int sockfd;                     /* network daemon socket */
+	ushort port;                    /* network daemon port */
+	int rmfd;                       /* remote server memory source fd */
+	int rkfd;                       /* remote server /dev/kmem fd */
+	ulong program_pid;              /* program pid */
+	ulong server_pid;               /* server pid */
+	ulong rcvbufsize;               /* client-side receive buffer size */
+	char *home;                     /* user's home directory */
+	char command_line[BUFSIZE];     /* possibly parsed input command line */
+	char orig_line[BUFSIZE];        /* original input line */
+	char *readline;                 /* pointer to last readline() return */
+	char my_tty[10];                /* real tty name (shown by ps -ef) */
+	ulong debug;                    /* level of debug */
+	ulong debug_save;               /* saved level for debug-suspend */
+	char *console;                  /* current debug console device */
+        char *redhat_debug_loc;         /* location of matching debug objects */
+	int pipefd[2];                  /* output pipe file descriptors */
+	FILE *nullfp;                   /* bitbucket */
+	FILE *stdpipe;                  /* standard pipe for output */
+	FILE *pipe;                     /* command line specified pipe */
+	FILE *ofile;                    /* command line specified output file */
+	FILE *ifile;                    /* command line specified input file */
+	FILE *ifile_pipe;               /* output pipe specified from file */
+	FILE *ifile_ofile;              /* output file specified from file */
+	FILE *symfile;                  /* symbol table data file */
+	FILE *symfile2;                 /* alternate access to above */
+	FILE *tmpfile;                  /* tmpfile for selective data output */
+	FILE *saved_fp;                 /* for printing while parsing tmpfile */
+	FILE *tmp_fp;                   /* stored tmpfile pointer */
+	char *input_file;               /* input file specified at invocation */
+	FILE *tmpfile2;                 /* tmpfile2 does not use save_fp! */
+	int eoc_index;                  /* end of redirected command index */
+	int scroll_command;             /* default scroll command for output */
+#define SCROLL_NONE 0
+#define SCROLL_LESS 1
+#define SCROLL_MORE 2
+#define SCROLL_CRASHPAGER 3
+	ulong redirect;			/* per-cmd origin and output flags */
+	pid_t stdpipe_pid;              /* per-cmd standard output pipe's pid */
+	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 */
+	ulong curcmd_flags;		/* general purpose per-command flag */
+#define XEN_MACHINE_ADDR    (0x1)
+#define REPEAT              (0x2)
+#define IDLE_TASK_SHOWN     (0x4)
+#define TASK_SPECIFIED      (0x8)
+#define MEMTYPE_UVADDR     (0x10)
+#define MEMTYPE_FILEADDR   (0x20)
+#define HEADER_PRINTED     (0x40)
+#define BAD_INSTRUCTION    (0x80)
+#define UD2A_INSTRUCTION  (0x100)
+#define IRQ_IN_USE        (0x200)
+#define NO_MODIFY         (0x400)
+#define IGNORE_ERRORS     (0x800)
+#define FROM_RCFILE      (0x1000)
+#define MEMTYPE_KVADDR   (0x2000)
+#define MOD_SECTIONS     (0x4000)
+#define MOD_READNOW      (0x8000)
+	ulonglong curcmd_private;	/* general purpose per-command info */
+	int cur_gdb_cmd;                /* current gdb command */
+	int last_gdb_cmd;               /* previously-executed gdb command */
+	int sigint_cnt;                 /* number of ignored SIGINTs */
+	struct gnu_request *cur_req;    /* current gdb gnu_request */
+	struct sigaction sigaction;     /* general usage sigaction. */
+	struct sigaction gdb_sigaction; /* gdb's SIGINT sigaction. */
+	jmp_buf main_loop_env;          /* longjmp target default */
+	jmp_buf foreach_loop_env;       /* longjmp target within foreach */
+        jmp_buf gdb_interface_env;      /* longjmp target for gdb error catch */
+	struct termios termios_orig;    /* non-raw settings */
+	struct termios termios_raw;     /* while gathering command input */
+	int ncmds;                      /* number of commands in menu */
+	char **cmdlist;                 /* current list of available commands */
+	int cmdlistsz;                  /* space available in cmdlist */
+	unsigned output_radix;          /* current gdb output_radix */
+	void *sbrk;                     /* current sbrk value */
+	struct extension_table *curext; /* extension being loaded */
+        int (*readmem)(int, void *, int, ulong, physaddr_t); /* memory access */
+        int (*writemem)(int, void *, int, ulong, physaddr_t);/* memory access */
+	ulong ifile_in_progress;        /* original xxx_IFILE flags */
+	off_t ifile_offset;             /* current offset into input file */
+	char *runtime_ifile_cmd;        /* runtime command using input file */
+	char *kvmdump_mapfile;          /* storage of physical to file offsets */
+	ulonglong flags2;               /* flags overrun */
+#define FLAT           (0x01ULL)
+#define ELF_NOTES      (0x02ULL)
+#define GET_OSRELEASE  (0x04ULL)
+#define REMOTE_DAEMON  (0x08ULL)
+#define ERASEINFO_DATA (0x10ULL)
+#define GDB_CMD_MODE   (0x20ULL)
+#define LIVE_DUMP      (0x40ULL)
+#define FLAT_FORMAT() (pc->flags2 & FLAT)
+#define ELF_NOTES_VALID() (pc->flags2 & ELF_NOTES)
+#define RADIX_OVERRIDE (0x80ULL)
+#define QEMU_MEM_DUMP (0x100ULL)
+#define GET_LOG       (0x200ULL)
+#define VMCOREINFO    (0x400ULL)
+#define ALLOW_FP      (0x800ULL)
+	char *cleanup;
+	char *namelist_orig;
+	char *namelist_debug_orig;
+	FILE *args_ifile;		/* per-command args input file */
+        void (*cmd_cleanup)(void *);    /* per-command cleanup function */
+	void *cmd_cleanup_arg;          /* optional cleanup function argument */
+	ulong scope;			/* optional text context address */
+};
+
+#define READMEM  pc->readmem
+
+typedef void (*cmd_func_t)(void);
+
+struct command_table_entry {               /* one for each command in menu */
+	char *name;
+	cmd_func_t func;
+	char **help_data;
+	ulong flags;
+};
+
+struct args_input_file {
+	int index;
+	int args_used;
+	int is_gdb_cmd;
+	int in_expression;
+	int start;
+	int resume;
+	char *fileptr;
+};
+
+#define REFRESH_TASK_TABLE (0x1)           /* command_table_entry flags */
+#define HIDDEN_COMMAND     (0x2)
+#define CLEANUP            (0x4)           /* for extensions only */
+#define MINIMAL            (0x8)
+
+/*
+ *  A linked list of extension table structures keeps track of the current
+ *  set of shared library extensions.
+ */
+struct extension_table {
+	void *handle;				    /* handle from dlopen() */
+	char *filename;				    /* name of shared library */
+	struct command_table_entry *command_table;  /* list of commands */
+	ulong flags;                                /* registration flags */
+	struct extension_table *next, *prev;        /* bookkeeping */
+};
+
+#define REGISTERED              (0x1)      /* extension_table flags */
+#define DUPLICATE_COMMAND_NAME  (0x2)
+#define NO_MINIMAL_COMMANDS     (0x4)
+
+struct new_utsname {
+        char sysname[65];
+        char nodename[65];
+        char release[65];
+        char version[65];
+        char machine[65];
+        char domainname[65];
+};
+
+#define NO_MODULE_ACCESS (0x1)
+#define TVEC_BASES_V1    (0x2)
+#define GCC_3_2          (0x4)
+#define GCC_3_2_3        (0x8)
+#define GCC_2_96        (0x10)
+#define RA_SEEK         (0x20)
+#define NO_RA_SEEK      (0x40)
+#define KALLSYMS_V1     (0x80)
+#define NO_KALLSYMS    (0x100)
+#define PER_CPU_OFF    (0x200)
+#define SMP            (0x400)
+#define GCC_3_3_2      (0x800)
+#define KMOD_V1       (0x1000)
+#define KMOD_V2       (0x2000)
+#define KALLSYMS_V2   (0x2000)
+#define TVEC_BASES_V2 (0x4000)
+#define GCC_3_3_3     (0x8000)
+#define USE_OLD_BT   (0x10000)
+#define ARCH_XEN     (0x20000)
+#define NO_IKCONFIG  (0x40000)
+#define DWARF_UNWIND (0x80000)
+#define NO_DWARF_UNWIND       (0x100000)
+#define DWARF_UNWIND_MEMORY   (0x200000)
+#define DWARF_UNWIND_EH_FRAME (0x400000)
+#define DWARF_UNWIND_CAPABLE  (DWARF_UNWIND_MEMORY|DWARF_UNWIND_EH_FRAME)
+#define DWARF_UNWIND_MODULES  (0x800000)
+#define BUGVERBOSE_OFF       (0x1000000)
+#define RELOC_SET            (0x2000000)
+#define RELOC_FORCE          (0x4000000)
+#define ARCH_OPENVZ          (0x8000000)
+#define ARCH_PVOPS          (0x10000000)
+#define PRE_KERNEL_INIT     (0x20000000)
+#define ARCH_PVOPS_XEN      (0x40000000)
+#define IRQ_DESC_TREE       (0x80000000)
+
+#define GCC_VERSION_DEPRECATED (GCC_3_2|GCC_3_2_3|GCC_2_96|GCC_3_3_2|GCC_3_3_3)
+
+#define XEN()       (kt->flags & ARCH_XEN)
+#define OPENVZ()    (kt->flags & ARCH_OPENVZ)
+#define PVOPS()     (kt->flags & ARCH_PVOPS)
+#define PVOPS_XEN() (kt->flags & ARCH_PVOPS_XEN)
+
+#define XEN_MACHINE_TO_MFN(m)    ((ulonglong)(m) >> PAGESHIFT())
+#define XEN_PFN_TO_PSEUDO(p)     ((ulonglong)(p) << PAGESHIFT())
+
+#define XEN_MFN_NOT_FOUND        (~0UL)
+#define XEN_PFNS_PER_PAGE        (PAGESIZE()/sizeof(ulong))
+#define XEN_FOREIGN_FRAME        (1UL << (BITS()-1))
+
+#define XEN_MACHADDR_NOT_FOUND   (~0ULL) 
+
+#define XEN_P2M_PER_PAGE	(PAGESIZE() / sizeof(unsigned long))
+#define XEN_P2M_MID_PER_PAGE	(PAGESIZE() / sizeof(unsigned long *))
+#define XEN_P2M_TOP_PER_PAGE	(PAGESIZE() / sizeof(unsigned long **))
+
+struct kernel_table {                   /* kernel data */
+	ulong flags;
+	ulong stext;
+	ulong etext;
+	ulong stext_init;
+	ulong etext_init;
+	ulong init_begin;
+	ulong init_end;
+	ulong end;
+	int cpus;
+	char *cpus_override;
+	void (*display_bh)(void);
+        ulong module_list;
+        ulong kernel_module;
+	int mods_installed;
+	struct timespec date;
+	char proc_version[BUFSIZE];
+	struct new_utsname utsname;
+	uint kernel_version[3];
+	uint gcc_version[3];
+	int runq_siblings;
+	int kernel_NR_CPUS;
+	long __per_cpu_offset[NR_CPUS];
+	long *__rq_idx;
+	long *__cpu_idx;
+	ulong *cpu_flags;
+#define POSSIBLE  (0x1)
+#define PRESENT   (0x2)
+#define ONLINE    (0x4)
+#define NMI       (0x8)
+	int BUG_bytes;
+	ulong xen_flags;
+#define WRITABLE_PAGE_TABLES    (0x1)
+#define SHADOW_PAGE_TABLES      (0x2)
+#define CANONICAL_PAGE_TABLES   (0x4)
+#define XEN_SUSPEND             (0x8)
+	char *m2p_page;
+	ulong phys_to_machine_mapping;
+	ulong p2m_table_size;
+#define P2M_MAPPING_CACHE    (512)
+	struct p2m_mapping_cache {
+		ulong mapping;
+		ulong pfn;
+		ulong start;
+		ulong end;
+	} p2m_mapping_cache[P2M_MAPPING_CACHE];
+#define P2M_MAPPING_PAGE_PFN(c) \
+   (PVOPS_XEN() ? kt->p2m_mapping_cache[c].pfn : \
+    (((kt->p2m_mapping_cache[c].mapping - kt->phys_to_machine_mapping)/PAGESIZE()) \
+    * XEN_PFNS_PER_PAGE))
+	ulong last_mapping_read;
+	ulong p2m_cache_index;
+	ulong p2m_pages_searched;
+	ulong p2m_mfn_cache_hits;
+	ulong p2m_page_cache_hits;
+	ulong relocate;
+	char *module_tree;
+	struct pvops_xen_info {
+		int p2m_top_entries;
+		ulong p2m_top;
+		ulong p2m_mid_missing;
+		ulong p2m_missing;
+	} pvops_xen;
+	int highest_irq;
+#define IKCONFIG_AVAIL	0x1	/* kernel contains ikconfig data */
+#define IKCONFIG_LOADED	0x2	/* ikconfig data is currently loaded */
+	int ikconfig_flags;
+	int ikconfig_ents;
+	char *hypervisor;
+	struct vmcoreinfo_data {
+		ulong log_buf_SYMBOL;
+		ulong log_end_SYMBOL;
+		ulong log_buf_len_SYMBOL;
+		ulong logged_chars_SYMBOL;
+		ulong log_first_idx_SYMBOL;
+		ulong log_next_idx_SYMBOL;
+		long log_SIZE;
+		long log_ts_nsec_OFFSET;
+		long log_len_OFFSET;
+		long log_text_len_OFFSET;
+		long log_dict_len_OFFSET;
+		ulong phys_base_SYMBOL;
+		ulong _stext_SYMBOL;
+	} vmcoreinfo;
+};
+
+/*
+ * Aid for the two versions of the kernel's module list linkage.
+ */
+#define NEXT_MODULE(next_module, modbuf)                             \
+{                                                                    \
+        switch (kt->flags & (KMOD_V1|KMOD_V2))                       \
+        {                                                            \
+        case KMOD_V1:                                                \
+                next_module = ULONG(modbuf + OFFSET(module_next));   \
+                break;                                               \
+        case KMOD_V2:                                                \
+                next_module = ULONG(modbuf + OFFSET(module_list));   \
+                if (next_module != kt->kernel_module)                \
+                        next_module -= OFFSET(module_list);          \
+                break;                                               \
+        }                                                            \
+}
+
+#define THIS_KERNEL_VERSION ((kt->kernel_version[0] << 16) + \
+			     (kt->kernel_version[1] << 8) + \
+			     (kt->kernel_version[2]))
+#define LINUX(x,y,z) (((uint)(x) << 16) + ((uint)(y) << 8) + (uint)(z))
+
+#define THIS_GCC_VERSION    ((kt->gcc_version[0] << 16) + \
+                             (kt->gcc_version[1] << 8) + \
+                             (kt->gcc_version[2]))
+#define GCC(x,y,z) (((uint)(x) << 16) + ((uint)(y) << 8) + (uint)(z))
+
+#define IS_KERNEL_STATIC_TEXT(x) (((ulong)(x) >= kt->stext) && \
+		  	          ((ulong)(x) < kt->etext))
+
+#define TASK_COMM_LEN 16     /* task command name length including NULL */
+
+struct task_context {                     /* context stored for each task */
+        ulong task;
+	ulong thread_info;
+        ulong pid;
+        char comm[TASK_COMM_LEN+1];
+	int processor;
+	ulong ptask;
+	ulong mm_struct;
+	struct task_context *tc_next;
+};
+
+struct task_table {                      /* kernel/local task table data */
+	struct task_context *current;
+	struct task_context *context_array;
+	void (*refresh_task_table)(void);
+	ulong flags;
+        ulong task_start;
+	ulong task_end;
+	void *task_local;
+        int max_tasks;
+	int nr_threads;
+	ulong running_tasks;
+	ulong retries;
+        ulong panicmsg;
+        int panic_processor;
+        ulong *idle_threads;
+        ulong *panic_threads;
+	ulong *active_set;
+	ulong *panic_ksp;
+	ulong *hardirq_ctx;
+	ulong *hardirq_tasks;
+	ulong *softirq_ctx;
+	ulong *softirq_tasks;
+        ulong panic_task;
+	ulong this_task;
+	int pidhash_len;
+	ulong pidhash_addr;
+	ulong last_task_read;
+	ulong last_thread_info_read;
+	ulong last_mm_read;
+	char *task_struct;
+	char *thread_info;
+	char *mm_struct;
+	ulong init_pid_ns;
+};
+
+#define TASK_INIT_DONE       (0x1)
+#define TASK_ARRAY_EXISTS    (0x2)
+#define PANIC_TASK_NOT_FOUND (0x4)
+#define TASK_REFRESH         (0x8)
+#define TASK_REFRESH_OFF    (0x10)
+#define PANIC_KSP           (0x20)
+#define ACTIVE_SET          (0x40)
+#define POPULATE_PANIC      (0x80)
+#define PIDHASH            (0x100)
+#define PID_HASH           (0x200)
+#define THREAD_INFO        (0x400)
+#define IRQSTACKS          (0x800)
+#define TIMESPEC          (0x1000)
+#define NO_TIMESPEC       (0x2000)
+#define ACTIVE_ONLY       (0x4000)
+
+#define TASK_SLUSH (20)
+
+#define NO_PROC_ID 0xFF       /* No processor magic marker (from kernel) */
+
+/*
+ *  Global "tt" points to task_table
+ */
+#define CURRENT_CONTEXT() (tt->current)
+#define CURRENT_TASK()    (tt->current->task)
+#define CURRENT_PID()     (tt->current->pid)
+#define CURRENT_COMM()    (tt->current->comm)
+#define RUNNING_TASKS()   (tt->running_tasks)
+#define FIRST_CONTEXT()   (tt->context_array)
+
+#define NO_PID   ((ulong)-1)
+#define NO_TASK  (0)
+
+#define IS_TASK_ADDR(X)    (machdep->is_task_addr(X))
+#define GET_STACKBASE(X)   (machdep->get_stackbase(X))
+#define GET_STACKTOP(X)    (machdep->get_stacktop(X))
+#define STACKSIZE()        (machdep->stacksize)
+#define LONGS_PER_STACK    (machdep->stacksize/sizeof(ulong))
+
+#define INSTACK(X,BT) \
+        (((ulong)(X) >= (BT)->stackbase) && ((ulong)(X) < (BT)->stacktop))
+
+#define ALIGNED_STACK_OFFSET(task)  ((ulong)(task) & (STACKSIZE()-1))
+
+#define BITS()		   (machdep->bits)
+#define BITS32()           (machdep->bits == 32)
+#define BITS64()           (machdep->bits == 64)
+#define IS_KVADDR(X)       (machdep->is_kvaddr(X))
+#define IS_UVADDR(X,C)     (machdep->is_uvaddr(X,C))
+
+#define PID_ALIVE(x) (kill(x, 0) == 0)
+
+struct kernel_list_head {
+        struct kernel_list_head *next, *prev;
+};
+
+struct stack_hook {
+        ulong esp;
+        ulong eip;
+};
+
+struct bt_info {
+        ulong task;
+        ulonglong flags;
+        ulong instptr;
+        ulong stkptr;
+	ulong bptr;
+	ulong stackbase;
+	ulong stacktop;
+	char *stackbuf;
+	struct task_context *tc;
+        struct stack_hook *hp;
+        struct stack_hook *textlist;
+        struct reference *ref;
+	ulong frameptr;
+	char *call_target;
+	void *machdep;
+        ulong debug;
+	ulong eframe_ip;
+	ulong radix;
+};
+
+#define STACK_OFFSET_TYPE(OFF) \
+  (((ulong)(OFF) > STACKSIZE()) ? \
+  (ulong)((ulong)(OFF) - (ulong)(bt->stackbase)) : (ulong)(OFF)) 
+
+#define GET_STACK_ULONG(OFF) \
+ *((ulong *)((char *)(&bt->stackbuf[(ulong)(STACK_OFFSET_TYPE(OFF))])))
+
+#define GET_STACK_DATA(OFF, LOC, SZ) memcpy((void *)(LOC), \
+    (void *)(&bt->stackbuf[(ulong)STACK_OFFSET_TYPE(OFF)]), (size_t)(SZ))
+
+struct machine_specific;  /* uniquely defined below each machine's area */
+struct xendump_data;
+struct xen_kdump_data;
+
+struct vaddr_range {
+	ulong start;
+	ulong end;
+	ulong type;
+#define KVADDR_UNITY_MAP  (1) 
+#define KVADDR_VMALLOC    (2)
+#define KVADDR_VMEMMAP    (3)
+#define KVADDR_START_MAP  (4)
+#define KVADDR_MODULES    (5)
+#define MAX_KVADDR_RANGES KVADDR_MODULES
+};
+
+#define MAX_MACHDEP_ARGS 5  /* for --machdep/-m machine-specific args */
+
+struct machdep_table {
+	ulong flags;
+	ulong kvbase;
+	ulong identity_map_base;
+	uint pagesize;
+	uint pageshift;
+	ulonglong pagemask;
+	ulong pageoffset;
+	ulong stacksize;
+	uint hz;
+	ulong mhz;
+	int bits;
+	int nr_irqs;
+	uint64_t memsize;
+        int (*eframe_search)(struct bt_info *);
+        void (*back_trace)(struct bt_info *);
+        ulong (*processor_speed)(void);
+        int (*uvtop)(struct task_context *, ulong, physaddr_t *, int);
+        int (*kvtop)(struct task_context *, ulong, physaddr_t *, int);
+        ulong (*get_task_pgd)(ulong);
+	void (*dump_irq)(int);
+	void (*get_stack_frame)(struct bt_info *, ulong *, ulong *);
+	ulong (*get_stackbase)(ulong);
+	ulong (*get_stacktop)(ulong);
+	int (*translate_pte)(ulong, void *, ulonglong);
+	uint64_t (*memory_size)(void);
+	ulong (*vmalloc_start)(void);
+        int (*is_task_addr)(ulong);
+	int (*verify_symbol)(const char *, ulong, char);
+	int (*dis_filter)(ulong, char *, unsigned int);
+	int (*get_smp_cpus)(void);
+        int (*is_kvaddr)(ulong);
+        int (*is_uvaddr)(ulong, struct task_context *);
+	int (*verify_paddr)(uint64_t);
+	void (*cmd_mach)(void);
+	void (*init_kernel_pgd)(void);
+	struct syment *(*value_to_symbol)(ulong, ulong *);
+ 	struct line_number_hook {
+        	char *func;
+        	char **file;
+	} *line_number_hooks;
+	ulong last_pgd_read;
+	ulong last_pud_read;
+	ulong last_pmd_read;
+	ulong last_ptbl_read;
+	char *pgd;
+	char *pud;
+ 	char *pmd;	
+	char *ptbl;
+	int ptrs_per_pgd;
+	char *cmdline_args[MAX_MACHDEP_ARGS];
+	struct machine_specific *machspec;
+	ulong section_size_bits;
+	ulong max_physmem_bits;
+	ulong sections_per_root;
+	int (*xendump_p2m_create)(struct xendump_data *);
+	ulong (*xendump_panic_task)(struct xendump_data *);
+	void (*get_xendump_regs)(struct xendump_data *, struct bt_info *, ulong *, ulong *);
+	void (*clear_machdep_cache)(void);
+	int (*xen_kdump_p2m_create)(struct xen_kdump_data *);
+	int (*in_alternate_stack)(int, ulong);
+	void (*dumpfile_init)(int, void *);
+	void (*process_elf_notes)(void *, unsigned long);
+	int (*get_kvaddr_ranges)(struct vaddr_range *);
+        int (*verify_line_number)(ulong, ulong, ulong);
+        void (*get_irq_affinity)(int);
+        void (*show_interrupts)(int, ulong *);
+};
+
+/*
+ *  Processor-common flags;  processor-specific flags use the lower bits
+ *  as defined in their processor-specific files below. (see KSYMS_START defs).
+ */
+#define HWRESET         (0x80000000)
+#define OMIT_FRAME_PTR  (0x40000000)
+#define FRAMESIZE_DEBUG (0x20000000)
+#define MACHDEP_BT_TEXT (0x10000000)
+#define DEVMEMRD         (0x8000000)
+#define INIT             (0x4000000)
+#define VM_4_LEVEL       (0x2000000)
+#define MCA              (0x1000000)
+#define PAE               (0x800000)
+#define VMEMMAP           (0x400000)
+
+extern struct machdep_table *machdep;
+
+#ifndef HZ
+#define HZ sysconf(_SC_CLK_TCK)
+#endif
+
+#define IS_LAST_PGD_READ(pgd)     ((ulong)(pgd) == machdep->last_pgd_read)
+#define IS_LAST_PMD_READ(pmd)     ((ulong)(pmd) == machdep->last_pmd_read)
+#define IS_LAST_PTBL_READ(ptbl)   ((ulong)(ptbl) == machdep->last_ptbl_read)
+#define IS_LAST_PUD_READ(pud)     ((ulong)(pud) == machdep->last_pud_read)
+
+#define FILL_PGD(PGD, TYPE, SIZE) 					    \
+    if (!IS_LAST_PGD_READ(PGD)) {                                           \
+            readmem((ulonglong)((ulong)(PGD)), TYPE, machdep->pgd,          \
+                    SIZE, "pgd page", FAULT_ON_ERROR);                      \
+            machdep->last_pgd_read = (ulong)(PGD);                          \
+    }								            
+
+#define FILL_PUD(PUD, TYPE, SIZE) 					    \
+    if (!IS_LAST_PUD_READ(PUD)) {                                           \
+            readmem((ulonglong)((ulong)(PUD)), TYPE, machdep->pud,          \
+                    SIZE, "pud page", FAULT_ON_ERROR);                      \
+            machdep->last_pud_read = (ulong)(PUD);                          \
+    }
+
+#define FILL_PMD(PMD, TYPE, SIZE)			                    \
+    if (!IS_LAST_PMD_READ(PMD)) {                                           \
+            readmem((ulonglong)(PMD), TYPE, machdep->pmd,                   \
+	            SIZE, "pmd page", FAULT_ON_ERROR);                      \
+            machdep->last_pmd_read = (ulong)(PMD);                          \
+    }					                                    
+
+#define FILL_PTBL(PTBL, TYPE, SIZE)			           	    \
+    if (!IS_LAST_PTBL_READ(PTBL)) {                                         \
+    	    readmem((ulonglong)(PTBL), TYPE, machdep->ptbl,                 \
+	            SIZE, "page table", FAULT_ON_ERROR);                    \
+            machdep->last_ptbl_read = (ulong)(PTBL); 	                    \
+    }
+
+#define SETUP_ENV  (0)
+#define PRE_SYMTAB (1)
+#define PRE_GDB    (2)
+#define POST_GDB   (3)
+#define POST_INIT  (4)
+#define POST_VM    (5)
+#define LOG_ONLY   (6)
+
+#define FOREACH_BT     (1)
+#define FOREACH_VM     (2)
+#define FOREACH_TASK   (3)
+#define FOREACH_SET    (4)
+#define FOREACH_FILES  (5)
+#define FOREACH_NET    (6)
+#define FOREACH_TEST   (7)
+#define FOREACH_VTOP   (8)
+#define FOREACH_SIG    (9)
+#define FOREACH_PS    (10)
+
+#define MAX_FOREACH_KEYWORDS (10)
+#define MAX_FOREACH_TASKS    (50)
+#define MAX_FOREACH_PIDS     (50)
+#define MAX_FOREACH_COMMS    (50)
+#define MAX_FOREACH_ARGS     (50)
+#define MAX_REGEX_ARGS       (10)
+
+#define FOREACH_CMD          (0x1)
+#define FOREACH_r_FLAG       (0x2)
+#define FOREACH_s_FLAG       (0x4)
+#define FOREACH_S_FLAG       (0x8)
+#define FOREACH_i_FLAG      (0x10)
+#define FOREACH_e_FLAG      (0x20)
+#define FOREACH_g_FLAG      (0x40)
+#define FOREACH_l_FLAG      (0x80)
+#define FOREACH_p_FLAG     (0x100)
+#define FOREACH_t_FLAG     (0x200)
+#define FOREACH_u_FLAG     (0x400)
+#define FOREACH_m_FLAG     (0x800)
+#define FOREACH_v_FLAG    (0x1000)
+#define FOREACH_KERNEL    (0x2000)
+#define FOREACH_USER      (0x4000)
+#define FOREACH_SPECIFIED (0x8000)
+#define FOREACH_ACTIVE   (0x10000)
+#define FOREACH_k_FLAG   (0x20000)
+#define FOREACH_c_FLAG   (0x40000)
+#define FOREACH_f_FLAG   (0x80000)
+#define FOREACH_o_FLAG  (0x100000)
+#define FOREACH_T_FLAG  (0x200000)
+#define FOREACH_F_FLAG  (0x400000)
+#define FOREACH_x_FLAG  (0x800000)
+#define FOREACH_d_FLAG (0x1000000)
+#define FOREACH_STATE  (0x2000000)
+#define FOREACH_a_FLAG (0x4000000)
+#define FOREACH_G_FLAG (0x8000000)
+
+#define FOREACH_PS_EXCLUSIVE \
+  (FOREACH_g_FLAG|FOREACH_a_FLAG|FOREACH_t_FLAG|FOREACH_c_FLAG|FOREACH_p_FLAG|FOREACH_l_FLAG|FOREACH_r_FLAG)
+
+struct foreach_data {
+	ulong flags;
+        int keyword_array[MAX_FOREACH_KEYWORDS];
+        ulong task_array[MAX_FOREACH_TASKS];
+        char *comm_array[MAX_FOREACH_COMMS];
+        ulong pid_array[MAX_FOREACH_PIDS];
+	ulong arg_array[MAX_FOREACH_ARGS];
+	struct regex_info {
+		char *pattern;
+		regex_t regex;
+	} regex_info[MAX_REGEX_ARGS];
+	ulong state;
+	char *reference;
+	int keys;
+	int pids;
+	int tasks;
+	int comms;
+	int args;
+	int regexs;
+};
+
+struct reference {       
+        char *str;       
+        ulong cmdflags;  
+        ulong hexval;     
+        ulong decval;     
+        ulong ref1;
+        ulong ref2;
+	void *refp;
+};
+
+struct offset_table {                    /* stash of commonly-used offsets */
+	long list_head_next;             /* add new entries to end of table */
+	long list_head_prev;
+	long task_struct_pid;
+	long task_struct_state;
+	long task_struct_comm;
+	long task_struct_mm;
+	long task_struct_tss;
+	long task_struct_thread;
+	long task_struct_active_mm;
+	long task_struct_tss_eip;
+	long task_struct_tss_esp;
+	long task_struct_tss_ksp;
+	long task_struct_processor;
+	long task_struct_p_pptr;
+	long task_struct_parent;
+	long task_struct_has_cpu;
+	long task_struct_cpus_runnable;
+	long task_struct_thread_eip;
+	long task_struct_thread_esp;
+	long task_struct_thread_ksp;
+	long task_struct_next_task;
+	long task_struct_files;
+	long task_struct_fs;
+	long task_struct_pidhash_next;
+	long task_struct_next_run;
+	long task_struct_flags;
+	long task_struct_sig;
+	long task_struct_signal;
+	long task_struct_blocked;
+	long task_struct_sigpending;
+	long task_struct_pending;
+	long task_struct_sigqueue;
+	long task_struct_sighand;
+	long task_struct_start_time;
+	long task_struct_times;
+	long task_struct_utime;
+	long task_struct_stime;
+	long task_struct_cpu;
+	long task_struct_run_list;
+        long task_struct_pgrp;
+        long task_struct_tgid;
+	long task_struct_namespace;
+	long task_struct_pids;
+	long task_struct_last_run;
+	long task_struct_timestamp;
+	long task_struct_thread_info;
+	long task_struct_nsproxy;
+	long task_struct_rlim;
+	long thread_info_task;
+	long thread_info_cpu;
+	long thread_info_previous_esp;
+	long thread_info_flags;
+	long nsproxy_mnt_ns;
+	long mnt_namespace_root;
+	long mnt_namespace_list;
+	long pid_link_pid;
+	long pid_hash_chain;
+	long hlist_node_next;
+	long hlist_node_pprev;
+	long pid_pid_chain;
+	long thread_struct_eip;
+	long thread_struct_esp;
+	long thread_struct_ksp;
+	long thread_struct_fph;
+	long thread_struct_rip;
+	long thread_struct_rsp;
+	long thread_struct_rsp0;
+	long tms_tms_utime;
+	long tms_tms_stime;
+	long signal_struct_count;
+	long signal_struct_action;
+	long signal_struct_shared_pending;
+	long signal_struct_rlim;
+	long k_sigaction_sa;
+	long sigaction_sa_handler;
+	long sigaction_sa_flags;
+	long sigaction_sa_mask;
+	long sigpending_head;
+	long sigpending_list;
+	long sigpending_signal;
+	long signal_queue_next;
+	long signal_queue_info;
+	long sigqueue_next;
+	long sigqueue_list;
+	long sigqueue_info;
+	long sighand_struct_action;
+	long siginfo_si_signo;
+	long thread_struct_cr3;
+	long thread_struct_ptbr;
+	long thread_struct_pg_tables;
+	long switch_stack_r26;
+	long switch_stack_b0;
+	long switch_stack_ar_bspstore;
+	long switch_stack_ar_pfs;
+	long switch_stack_ar_rnat;
+	long switch_stack_pr;
+	long cpuinfo_ia64_proc_freq;
+	long cpuinfo_ia64_unimpl_va_mask;
+	long cpuinfo_ia64_unimpl_pa_mask;
+	long device_node_type;
+	long device_node_allnext;
+	long device_node_properties;
+	long property_name;
+	long property_value;
+	long property_next;
+	long machdep_calls_setup_residual;
+	long RESIDUAL_VitalProductData;
+	long VPD_ProcessorHz;
+	long bd_info_bi_intfreq;
+	long hwrpb_struct_cycle_freq;
+	long hwrpb_struct_processor_offset;
+	long hwrpb_struct_processor_size;
+	long percpu_struct_halt_PC;
+	long percpu_struct_halt_ra;
+	long percpu_struct_halt_pv;
+	long mm_struct_mmap;
+	long mm_struct_pgd;
+	long mm_struct_rss;
+	long mm_struct_anon_rss;
+	long mm_struct_file_rss;
+	long mm_struct_total_vm;
+	long mm_struct_start_code;
+	long mm_struct_arg_start;
+	long mm_struct_arg_end;
+	long mm_struct_env_start;
+	long mm_struct_env_end;
+        long vm_area_struct_vm_mm;
+        long vm_area_struct_vm_next;
+        long vm_area_struct_vm_end;
+        long vm_area_struct_vm_start; 
+	long vm_area_struct_vm_flags;
+	long vm_area_struct_vm_file;
+	long vm_area_struct_vm_offset;
+	long vm_area_struct_vm_pgoff;
+        long vm_struct_addr;
+        long vm_struct_size;
+        long vm_struct_next;
+	long module_size_of_struct;
+	long module_next;
+	long module_size;
+	long module_name;
+	long module_nsyms;
+	long module_syms;
+	long module_flags;
+	long module_num_syms;
+	long module_list;
+	long module_gpl_syms;
+	long module_num_gpl_syms;
+	long module_module_core;
+	long module_core_size;
+	long module_core_text_size;
+	long module_num_symtab;
+	long module_symtab;
+	long module_strtab;
+
+	long module_kallsyms_start;
+	long kallsyms_header_sections;
+	long kallsyms_header_section_off;
+	long kallsyms_header_symbols;
+	long kallsyms_header_symbol_off;
+	long kallsyms_header_string_off;
+	long kallsyms_symbol_section_off;
+	long kallsyms_symbol_symbol_addr;
+	long kallsyms_symbol_name_off;
+	long kallsyms_section_start;
+	long kallsyms_section_size;
+	long kallsyms_section_name_off;
+
+	long page_next;
+	long page_prev;
+	long page_next_hash;
+	long page_list;
+	long page_list_next;
+	long page_list_prev;
+	long page_inode;
+	long page_offset;
+	long page_count;
+	long page_flags;
+	long page_mapping;
+	long page_index;
+	long page_buffers;
+	long page_lru;
+	long page_pte;
+	long swap_info_struct_swap_file;
+	long swap_info_struct_swap_vfsmnt;
+	long swap_info_struct_flags;
+	long swap_info_struct_swap_map;
+	long swap_info_struct_swap_device;
+	long swap_info_struct_prio;
+	long swap_info_struct_max;
+	long swap_info_struct_pages;
+	long swap_info_struct_old_block_size;
+	long block_device_bd_inode;
+	long block_device_bd_list;
+	long block_device_bd_disk;
+	long irq_desc_t_status;
+	long irq_desc_t_handler;
+	long irq_desc_t_chip;
+	long irq_desc_t_action;
+	long irq_desc_t_depth;
+	long irqdesc_action;
+	long irqdesc_ctl;
+	long irqdesc_level;
+	long irqaction_handler;
+	long irqaction_flags;
+	long irqaction_mask;
+	long irqaction_name;
+	long irqaction_dev_id;
+	long irqaction_next;
+	long hw_interrupt_type_typename;
+	long hw_interrupt_type_startup;
+	long hw_interrupt_type_shutdown;
+	long hw_interrupt_type_handle;
+	long hw_interrupt_type_enable;
+	long hw_interrupt_type_disable;
+	long hw_interrupt_type_ack;
+	long hw_interrupt_type_end;
+	long hw_interrupt_type_set_affinity;
+	long irq_chip_typename;
+	long irq_chip_startup;
+	long irq_chip_shutdown;
+	long irq_chip_enable;
+	long irq_chip_disable;
+	long irq_chip_ack;
+	long irq_chip_end;
+	long irq_chip_set_affinity;
+	long irq_chip_mask;
+	long irq_chip_mask_ack;
+	long irq_chip_unmask;
+	long irq_chip_eoi;
+	long irq_chip_retrigger;
+	long irq_chip_set_type;
+	long irq_chip_set_wake;
+	long irq_cpustat_t___softirq_active;
+	long irq_cpustat_t___softirq_mask;
+	long fdtable_max_fds;
+	long fdtable_max_fdset;
+	long fdtable_open_fds;
+	long fdtable_fd;
+	long files_struct_fdt;
+        long files_struct_max_fds;
+        long files_struct_max_fdset;
+        long files_struct_open_fds;
+        long files_struct_fd;
+	long files_struct_open_fds_init;
+        long file_f_dentry;
+        long file_f_vfsmnt;
+        long file_f_count;
+	long file_f_path;
+	long path_mnt;
+	long path_dentry;
+        long fs_struct_root;
+        long fs_struct_pwd;
+        long fs_struct_rootmnt;
+        long fs_struct_pwdmnt;
+        long dentry_d_inode;
+        long dentry_d_parent;
+        long dentry_d_name;
+	long dentry_d_covers;
+	long dentry_d_iname;
+        long qstr_len;
+        long qstr_name;
+        long inode_i_mode;
+        long inode_i_op;
+        long inode_i_sb;
+	long inode_u;
+	long inode_i_flock;
+	long inode_i_fop;
+	long inode_i_mapping;
+	long address_space_nrpages;
+	long vfsmount_mnt_next;
+	long vfsmount_mnt_devname;
+	long vfsmount_mnt_dirname;
+	long vfsmount_mnt_sb;
+	long vfsmount_mnt_list;
+	long vfsmount_mnt_mountpoint;
+	long vfsmount_mnt_parent;
+	long namespace_root;
+	long namespace_list;
+	long super_block_s_dirty;
+	long super_block_s_type;
+	long super_block_s_files;
+	long file_system_type_name;
+	long nlm_file_f_file;
+	long file_lock_fl_owner;
+	long nlm_host_h_exportent;
+	long svc_client_cl_ident;
+	long kmem_cache_s_c_nextp;
+	long kmem_cache_s_c_name;
+	long kmem_cache_s_c_num;
+	long kmem_cache_s_c_org_size;
+	long kmem_cache_s_c_flags;
+	long kmem_cache_s_c_offset;
+	long kmem_cache_s_c_firstp;
+	long kmem_cache_s_c_gfporder;
+	long kmem_cache_s_c_magic;
+	long kmem_cache_s_num;
+	long kmem_cache_s_next;
+	long kmem_cache_s_name;
+	long kmem_cache_s_objsize;
+	long kmem_cache_s_flags;
+	long kmem_cache_s_gfporder;
+	long kmem_cache_s_slabs;
+	long kmem_cache_s_slabs_full;
+	long kmem_cache_s_slabs_partial;
+	long kmem_cache_s_slabs_free;
+	long kmem_cache_s_cpudata;
+	long kmem_cache_s_c_align;
+	long kmem_cache_s_colour_off;
+	long cpucache_s_avail;
+	long cpucache_s_limit;
+	long kmem_cache_s_array;
+	long array_cache_avail;
+	long array_cache_limit;
+	long kmem_cache_s_lists;
+	long kmem_list3_slabs_partial;
+	long kmem_list3_slabs_full;
+	long kmem_list3_slabs_free;
+	long kmem_list3_free_objects;
+	long kmem_list3_shared;
+	long kmem_slab_s_s_nextp;
+	long kmem_slab_s_s_freep;
+	long kmem_slab_s_s_inuse;
+	long kmem_slab_s_s_mem;
+	long kmem_slab_s_s_index;
+	long kmem_slab_s_s_offset;
+	long kmem_slab_s_s_magic;
+	long slab_s_list;
+	long slab_s_s_mem;
+	long slab_s_inuse;
+	long slab_s_free;
+        long slab_list;
+        long slab_s_mem;
+        long slab_inuse;
+        long slab_free;
+	long net_device_next;
+	long net_device_name;
+	long net_device_type;
+	long net_device_addr_len;
+	long net_device_ip_ptr;
+	long net_device_dev_list;
+	long net_dev_base_head;
+	long device_next;
+	long device_name;
+	long device_type;
+	long device_ip_ptr;
+	long device_addr_len;
+	long socket_sk;
+	long sock_daddr;
+	long sock_rcv_saddr;
+	long sock_dport;
+	long sock_sport;
+	long sock_num;
+	long sock_type;
+	long sock_family;
+	long sock_common_skc_family;
+	long sock_sk_type;
+	long inet_sock_inet;
+	long inet_opt_daddr;
+	long inet_opt_rcv_saddr;
+	long inet_opt_dport;
+	long inet_opt_sport;
+	long inet_opt_num;
+	long ipv6_pinfo_rcv_saddr;
+	long ipv6_pinfo_daddr;
+	long timer_list_list;
+	long timer_list_next;
+	long timer_list_entry;
+	long timer_list_expires;
+	long timer_list_function;
+	long timer_vec_root_vec;
+	long timer_vec_vec;
+	long tvec_root_s_vec;
+	long tvec_s_vec;
+	long tvec_t_base_s_tv1;
+ 	long wait_queue_task;
+ 	long wait_queue_next;
+ 	long __wait_queue_task;
+	long __wait_queue_head_task_list;
+ 	long __wait_queue_task_list;
+	long pglist_data_node_zones;
+	long pglist_data_node_mem_map;
+	long pglist_data_node_start_paddr;
+        long pglist_data_node_start_mapnr;
+        long pglist_data_node_size;
+        long pglist_data_node_id;
+        long pglist_data_node_next;
+	long pglist_data_nr_zones;
+	long pglist_data_node_start_pfn;
+	long pglist_data_pgdat_next;
+	long pglist_data_node_present_pages;
+	long pglist_data_node_spanned_pages;
+	long pglist_data_bdata;
+	long page_cache_bucket_chain;
+        long zone_struct_free_pages;
+        long zone_struct_free_area;
+        long zone_struct_zone_pgdat;
+        long zone_struct_name;
+        long zone_struct_size;
+	long zone_struct_memsize;
+	long zone_struct_zone_start_pfn;
+        long zone_struct_zone_start_paddr;
+        long zone_struct_zone_start_mapnr;
+        long zone_struct_zone_mem_map;
+	long zone_struct_inactive_clean_pages;
+	long zone_struct_inactive_clean_list;
+	long zone_struct_inactive_dirty_pages;
+	long zone_struct_active_pages;
+	long zone_struct_pages_min;
+	long zone_struct_pages_low;
+	long zone_struct_pages_high;
+	long zone_free_pages;
+	long zone_free_area;
+        long zone_zone_pgdat;
+	long zone_zone_mem_map;
+        long zone_name;
+	long zone_spanned_pages;
+	long zone_zone_start_pfn;
+	long zone_pages_min;
+	long zone_pages_low;
+	long zone_pages_high;
+	long zone_vm_stat;
+        long neighbour_next;
+        long neighbour_primary_key;
+        long neighbour_ha;
+        long neighbour_dev;
+        long neighbour_nud_state;
+	long neigh_table_hash_buckets;
+	long neigh_table_key_len;
+        long in_device_ifa_list;
+        long in_ifaddr_ifa_next;
+        long in_ifaddr_ifa_address;
+	long pci_dev_global_list;
+	long pci_dev_next;
+	long pci_dev_bus;
+	long pci_dev_devfn;
+	long pci_dev_class;
+	long pci_dev_device;
+	long pci_dev_vendor;
+	long pci_bus_number;
+        long resource_entry_t_from;
+        long resource_entry_t_num;
+        long resource_entry_t_name; 
+        long resource_entry_t_next;
+        long resource_name;
+        long resource_start;
+        long resource_end;
+        long resource_sibling;
+        long resource_child;
+	long runqueue_curr;
+	long runqueue_idle;
+	long runqueue_active;
+	long runqueue_expired;
+	long runqueue_arrays;
+	long runqueue_cpu;
+	long cpu_s_idle;
+	long cpu_s_curr;
+	long prio_array_nr_active;
+	long prio_array_queue;
+	long user_regs_struct_ebp;
+	long user_regs_struct_esp;
+	long user_regs_struct_rip;
+	long user_regs_struct_cs;
+	long user_regs_struct_eflags;
+	long user_regs_struct_rsp;
+	long user_regs_struct_ss;
+	long e820map_nr_map;
+	long e820entry_addr;	
+	long e820entry_size;	
+	long e820entry_type;	
+	long char_device_struct_next;
+	long char_device_struct_name;
+	long char_device_struct_fops;
+	long char_device_struct_major;
+	long gendisk_major;
+	long gendisk_disk_name;
+	long gendisk_fops;
+	long blk_major_name_next;
+	long blk_major_name_major;
+	long blk_major_name_name;
+	long radix_tree_root_height;
+	long radix_tree_root_rnode;
+	long x8664_pda_pcurrent;
+	long x8664_pda_data_offset;
+	long x8664_pda_kernelstack;
+	long x8664_pda_irqrsp;
+	long x8664_pda_irqstackptr;
+	long x8664_pda_level4_pgt;
+	long x8664_pda_cpunumber;
+	long x8664_pda_me;
+	long tss_struct_ist;
+	long mem_section_section_mem_map;
+	long vcpu_guest_context_user_regs;
+	long cpu_user_regs_eip;
+	long cpu_user_regs_esp;
+	long cpu_user_regs_rip;
+	long cpu_user_regs_rsp;
+        long unwind_table_core;
+        long unwind_table_init;
+        long unwind_table_address;
+        long unwind_table_size;
+        long unwind_table_link;
+        long unwind_table_name;
+	long rq_cfs;
+	long rq_rt;
+	long rq_nr_running;
+	long cfs_rq_rb_leftmost;
+	long cfs_rq_nr_running;
+	long cfs_rq_tasks_timeline;
+	long task_struct_se;
+	long sched_entity_run_node;
+	long rt_rq_active;
+	long kmem_cache_size;
+	long kmem_cache_objsize;
+	long kmem_cache_offset;
+	long kmem_cache_order;
+	long kmem_cache_local_node;
+	long kmem_cache_objects;
+	long kmem_cache_inuse;
+	long kmem_cache_align;
+	long kmem_cache_name;
+	long kmem_cache_list;
+	long kmem_cache_node;
+	long kmem_cache_cpu_slab;
+	long page_inuse;
+/*	long page_offset;  use "old" page->offset */
+	long page_slab;
+	long page_first_page;
+	long page_freelist;
+	long kmem_cache_node_nr_partial;
+	long kmem_cache_node_nr_slabs;
+	long kmem_cache_node_partial;
+	long kmem_cache_node_full;
+	long pid_numbers;
+	long upid_nr;
+	long upid_ns;
+	long upid_pid_chain;
+	long pid_tasks;
+        long kmem_cache_cpu_freelist;
+        long kmem_cache_cpu_page;
+        long kmem_cache_cpu_node;
+	long kmem_cache_flags;
+	long zone_nr_active;
+	long zone_nr_inactive;
+	long zone_all_unreclaimable;
+	long zone_present_pages;
+	long zone_flags;
+	long zone_pages_scanned;
+	long pcpu_info_vcpu;
+	long pcpu_info_idle;
+	long vcpu_struct_rq;
+	long task_struct_sched_info;
+	long sched_info_last_arrival;
+	long page_objects;
+	long kmem_cache_oo;
+	long char_device_struct_cdev;
+	long char_device_struct_baseminor;
+	long cdev_ops;
+	long probe_next;
+	long probe_dev;
+	long probe_data;
+	long kobj_map_probes;
+	long task_struct_prio;
+	long zone_watermark;
+	long module_sect_attrs;
+	long module_sect_attrs_attrs;
+	long module_sect_attrs_nsections;
+	long module_sect_attr_mattr;
+	long module_sect_attr_name;
+	long module_sect_attr_address;
+	long module_attribute_attr;
+	long attribute_owner;
+	long module_sect_attr_attr;
+	long module_sections_attrs;
+	long swap_info_struct_inuse_pages;
+	long s390_lowcore_psw_save_area;
+	long mm_struct_rss_stat;
+	long mm_rss_stat_count;
+	long module_module_init;
+	long module_init_text_size;
+	long cpu_context_save_fp;
+	long cpu_context_save_sp;
+	long cpu_context_save_pc;
+	long elf_prstatus_pr_pid;
+	long elf_prstatus_pr_reg;
+	long irq_desc_t_name;
+	long thread_info_cpu_context;
+	long unwind_table_list;
+	long unwind_table_start;
+	long unwind_table_stop;
+	long unwind_table_begin_addr;
+	long unwind_table_end_addr;
+	long unwind_idx_addr;
+	long unwind_idx_insn;
+	long signal_struct_nr_threads;
+	long module_init_size;
+	long module_percpu;
+	long radix_tree_node_slots;
+	long s390_stack_frame_back_chain;
+	long s390_stack_frame_r14;
+	long user_regs_struct_eip;
+	long user_regs_struct_rax;
+	long user_regs_struct_eax;
+	long user_regs_struct_rbx;
+	long user_regs_struct_ebx;
+	long user_regs_struct_rcx;
+	long user_regs_struct_ecx;
+	long user_regs_struct_rdx;
+	long user_regs_struct_edx;
+	long user_regs_struct_rsi;
+	long user_regs_struct_esi;
+	long user_regs_struct_rdi;
+	long user_regs_struct_edi;
+	long user_regs_struct_ds;
+	long user_regs_struct_es;
+	long user_regs_struct_fs;
+	long user_regs_struct_gs;
+	long user_regs_struct_rbp;
+	long user_regs_struct_r8;
+	long user_regs_struct_r9;
+	long user_regs_struct_r10;
+	long user_regs_struct_r11;
+	long user_regs_struct_r12;
+	long user_regs_struct_r13;
+	long user_regs_struct_r14;
+	long user_regs_struct_r15;
+	long sched_entity_cfs_rq;
+	long sched_entity_my_q;
+	long sched_entity_on_rq;
+	long task_struct_on_rq;
+	long cfs_rq_curr;
+	long irq_desc_t_irq_data;
+	long irq_desc_t_kstat_irqs;
+	long irq_desc_t_affinity;
+	long irq_data_chip;
+	long irq_data_affinity;
+	long kernel_stat_irqs;
+	long socket_alloc_vfs_inode;
+	long class_devices;
+	long class_p;
+	long class_private_devices;
+	long device_knode_class;
+	long device_node;
+	long gendisk_dev;
+	long gendisk_kobj;
+	long gendisk_part0;
+	long gendisk_queue;
+	long hd_struct_dev;
+	long klist_k_list;
+	long klist_node_n_klist;
+	long klist_node_n_node;
+	long kobject_entry;
+	long kset_list;
+	long request_list_count;
+	long request_queue_in_flight;
+	long request_queue_rq;
+	long subsys_private_klist_devices;
+	long subsystem_kset;
+	long mount_mnt_parent;
+	long mount_mnt_mountpoint;
+	long mount_mnt_list;
+	long mount_mnt_devname;
+	long mount_mnt;
+	long task_struct_exit_state;
+	long timekeeper_xtime;
+	long file_f_op;
+	long file_private_data;
+	long hstate_order;
+	long hugetlbfs_sb_info_hstate;
+	long idr_layer_ary;
+	long idr_layer_layer;
+	long idr_layers;
+	long idr_top;
+	long ipc_id_ary_p;
+	long ipc_ids_entries;
+	long ipc_ids_max_id;
+	long ipc_ids_ipcs_idr;
+	long ipc_ids_in_use;
+	long ipc_namespace_ids;
+	long kern_ipc_perm_deleted;
+	long kern_ipc_perm_key;
+	long kern_ipc_perm_mode;
+	long kern_ipc_perm_uid;
+	long kern_ipc_perm_id;
+	long kern_ipc_perm_seq;
+	long nsproxy_ipc_ns;
+	long shmem_inode_info_swapped;
+	long shmem_inode_info_vfs_inode;
+	long shm_file_data_file;
+	long shmid_kernel_shm_file;
+	long shmid_kernel_shm_nattch;
+	long shmid_kernel_shm_perm;
+	long shmid_kernel_shm_segsz;
+	long shmid_kernel_id;
+	long sem_array_sem_perm;
+	long sem_array_sem_id;
+	long sem_array_sem_nsems;
+	long msg_queue_q_perm;
+	long msg_queue_q_id;
+	long msg_queue_q_cbytes;
+	long msg_queue_q_qnum;
+	long super_block_s_fs_info;
+	long rq_timestamp;
+	long radix_tree_node_height;
+	long rb_root_rb_node;
+	long rb_node_rb_left;
+	long rb_node_rb_right;
+	long rt_prio_array_queue;
+	long task_struct_rt;
+	long sched_rt_entity_run_list;
+	long log_ts_nsec;
+	long log_len;
+	long log_text_len;
+	long log_dict_len;
+	long log_level;
+	long log_flags_level;
+	long timekeeper_xtime_sec;
+	long neigh_table_hash_mask;
+	long sched_rt_entity_my_q;
+	long neigh_table_hash_shift;
+	long neigh_table_nht_ptr;
+	long task_group_parent;
+	long task_group_css;
+	long cgroup_subsys_state_cgroup;
+	long cgroup_dentry;
+	long task_group_rt_rq;
+	long rt_rq_tg;
+	long task_group_cfs_rq;
+	long cfs_rq_tg;
+	long task_group_siblings;
+	long task_group_children;
+	long task_group_cfs_bandwidth;
+	long cfs_rq_throttled;
+	long task_group_rt_bandwidth;
+	long rt_rq_rt_throttled;
+	long rt_rq_highest_prio;
+	long rt_rq_rt_nr_running;
+	long vmap_area_va_start;
+	long vmap_area_va_end;
+	long vmap_area_list;
+	long vmap_area_flags;
+	long vmap_area_vm;
+	long hrtimer_cpu_base_clock_base;
+	long hrtimer_clock_base_offset;
+	long hrtimer_clock_base_active;
+	long hrtimer_clock_base_first;
+	long hrtimer_clock_base_get_time;
+	long hrtimer_base_first;
+	long hrtimer_base_pending;
+	long hrtimer_base_get_time;
+	long hrtimer_node;
+	long hrtimer_list;
+	long hrtimer_softexpires;
+	long hrtimer_expires;
+	long hrtimer_function;
+	long timerqueue_head_next;
+	long timerqueue_node_expires;
+	long timerqueue_node_node;
+	long ktime_t_tv64;
+	long ktime_t_sec;
+	long ktime_t_nsec;
+	long module_taints;
+	long module_gpgsig_ok;
+	long module_license_gplok;
+	long tnt_bit;
+	long tnt_true;
+	long tnt_false;
+	long task_struct_thread_context_fp;
+	long task_struct_thread_context_sp;
+	long task_struct_thread_context_pc;
+	long page_slab_page;
+	long trace_print_flags_mask;
+	long trace_print_flags_name;
+};
+
+struct size_table {         /* stash of commonly-used sizes */
+	long page;
+	long free_area_struct;
+	long zone_struct;
+	long free_area;
+	long zone;
+	long kmem_slab_s;
+	long kmem_cache_s;
+	long kmem_bufctl_t;
+	long slab_s;
+	long slab;
+	long cpucache_s;
+	long array_cache;
+	long swap_info_struct;
+	long mm_struct;
+	long vm_area_struct;
+	long pglist_data;
+	long page_cache_bucket;
+	long pt_regs;
+	long task_struct;
+	long thread_info;
+	long softirq_state;
+	long desc_struct;
+	long umode_t;
+	long dentry;
+	long files_struct;
+	long fdtable;
+	long fs_struct;
+	long file;
+	long inode;
+	long vfsmount;
+	long super_block;
+        long irqdesc;
+	long module;
+	long list_head;
+	long hlist_node;
+	long hlist_head;
+	long irq_cpustat_t;
+	long cpuinfo_x86;
+	long cpuinfo_ia64;
+	long timer_list;
+	long timer_vec_root;
+	long timer_vec;
+	long tvec_root_s;
+	long tvec_s;
+	long tvec_t_base_s;
+	long wait_queue;
+	long __wait_queue;
+	long device;
+	long net_device;
+	long sock;
+	long signal_struct;
+	long sigpending_signal;
+	long signal_queue;
+	long sighand_struct;
+	long sigqueue;
+	long k_sigaction;
+	long resource_entry_t;
+	long resource;
+	long runqueue;
+	long irq_desc_t;
+	long task_union;
+	long thread_union;
+	long prio_array;
+	long user_regs_struct;
+	long switch_stack;
+	long vm_area_struct_vm_flags;
+	long e820map;
+	long e820entry;
+	long cpu_s;
+	long pgd_t;
+	long kallsyms_header;
+	long kallsyms_symbol;
+	long kallsyms_section;
+	long irq_ctx;
+	long block_device;
+	long blk_major_name;
+	long gendisk;
+	long address_space;
+	long char_device_struct;
+	long inet_sock;
+	long in6_addr;
+	long socket;
+	long spinlock_t;
+	long radix_tree_root;
+	long radix_tree_node;
+	long x8664_pda;
+	long ppc64_paca;
+	long gate_struct;
+	long tss_struct;
+	long task_struct_start_time;
+	long cputime_t;
+	long mem_section;
+	long pid_link;
+	long unwind_table;
+	long rlimit;
+	long kmem_cache;
+	long kmem_cache_node;
+	long upid;
+	long kmem_cache_cpu;
+	long cfs_rq;
+	long pcpu_info;
+	long vcpu_struct;
+	long cdev;
+	long probe;
+	long kobj_map;
+	long page_flags;
+	long module_sect_attr;
+	long task_struct_utime;
+	long task_struct_stime;
+	long cpu_context_save;
+	long elf_prstatus;
+	long note_buf;
+	long unwind_idx;
+	long softirq_action;
+	long irq_data;
+	long s390_stack_frame;
+	long percpu_data;
+	long sched_entity;
+	long kernel_stat;
+	long subsystem;
+	long class_private;
+	long rq_in_flight;
+	long class_private_devices;
+	long mount;
+	long hstate;
+	long ipc_ids;
+	long shmid_kernel;
+	long sem_array;
+	long msg_queue;
+	long log;
+	long log_level;
+	long rt_rq;
+	long task_group;
+	long vmap_area;
+	long hrtimer_clock_base;
+	long hrtimer_base;
+	long tnt;
+	long trace_print_flags;
+};
+
+struct array_table {
+	int kmem_cache_s_name;
+	int kmem_cache_s_c_name;
+	int kmem_cache_s_array;
+	int kmem_cache_s_cpudata;
+	int irq_desc;
+	int irq_action;
+	int log_buf;
+	int timer_vec_vec;
+	int timer_vec_root_vec;
+	int tvec_s_vec;
+	int tvec_root_s_vec;
+	int page_hash_table;
+	int net_device_name;
+	int neigh_table_hash_buckets;
+	int neighbour_ha;
+	int swap_info;
+        int pglist_data_node_zones;
+        int zone_struct_free_area;
+        int zone_free_area;
+	int free_area;
+	int free_area_DIMENSION;
+	int prio_array_queue;
+	int height_to_maxindex;
+	int pid_hash;
+	int kmem_cache_node;
+	int kmem_cache_cpu_slab;
+	int rt_prio_array_queue;
+};
+
+/*
+ *  The following set of macros use gdb to determine structure, union,
+ *  or member sizes/offsets.  They should be used only during initialization
+ *  of the offset_table or size_table, or with data structures whose names
+ *  or members are only known/specified during runtime.
+ */
+#define MEMBER_SIZE_REQUEST ((struct datatype_member *)(-1))
+#define ANON_MEMBER_OFFSET_REQUEST ((struct datatype_member *)(-2))
+#define MEMBER_TYPE_REQUEST ((struct datatype_member *)(-3))
+#define STRUCT_SIZE_REQUEST ((struct datatype_member *)(-4))
+
+#define STRUCT_SIZE(X)      datatype_info((X), NULL, STRUCT_SIZE_REQUEST)
+#define UNION_SIZE(X)       datatype_info((X), NULL, STRUCT_SIZE_REQUEST)
+#define STRUCT_EXISTS(X)    (datatype_info((X), NULL, STRUCT_SIZE_REQUEST) >= 0)
+#define DATATYPE_SIZE(X)    datatype_info((X)->name, NULL, (X))
+#define MEMBER_OFFSET(X,Y)  datatype_info((X), (Y), NULL)
+#define MEMBER_EXISTS(X,Y)  (datatype_info((X), (Y), NULL) >= 0)
+#define MEMBER_SIZE(X,Y)    datatype_info((X), (Y), MEMBER_SIZE_REQUEST)
+#define MEMBER_TYPE(X,Y)    datatype_info((X), (Y), MEMBER_TYPE_REQUEST)
+#define ANON_MEMBER_OFFSET(X,Y)    datatype_info((X), (Y), ANON_MEMBER_OFFSET_REQUEST)
+
+/*
+ *  The following set of macros can only be used with pre-intialized fields
+ *  in the offset table, size table or array_table.
+ */
+#define OFFSET(X)	   (OFFSET_verify(offset_table.X, (char *)__FUNCTION__, __FILE__, __LINE__, #X))
+#define SIZE(X)            (SIZE_verify(size_table.X, (char *)__FUNCTION__, __FILE__, __LINE__, #X))
+#define INVALID_OFFSET     (-1)
+#define INVALID_MEMBER(X)  (offset_table.X == INVALID_OFFSET)
+#define INVALID_SIZE(X)    (size_table.X == -1)
+#define VALID_SIZE(X)      (size_table.X >= 0)
+#define VALID_STRUCT(X)    (size_table.X >= 0)
+#define VALID_MEMBER(X)    (offset_table.X >= 0)
+#define ARRAY_LENGTH(X)    (array_table.X)
+#define ASSIGN_OFFSET(X)   (offset_table.X)
+#define ASSIGN_SIZE(X)     (size_table.X)
+#define OFFSET_OPTION(X,Y) (OFFSET_option(offset_table.X, offset_table.Y, (char *)__FUNCTION__, __FILE__, __LINE__, #X, #Y))
+#define SIZE_OPTION(X,Y)   (SIZE_option(size_table.X, size_table.Y, (char *)__FUNCTION__, __FILE__, __LINE__, #X, #Y))
+
+#define MEMBER_OFFSET_INIT(X, Y, Z) (ASSIGN_OFFSET(X) = MEMBER_OFFSET(Y, Z))
+#define STRUCT_SIZE_INIT(X, Y) (ASSIGN_SIZE(X) = STRUCT_SIZE(Y))
+#define ARRAY_LENGTH_INIT(A, B, C, D, E) ((A) = get_array_length(C, D, E))
+#define ARRAY_LENGTH_INIT_ALT(A, B, C, D, E) ((A) = get_array_length_alt(B, C, D, E))
+#define MEMBER_SIZE_INIT(X, Y, Z) (ASSIGN_SIZE(X) = MEMBER_SIZE(Y, Z))
+#define ANON_MEMBER_OFFSET_INIT(X, Y, Z) (ASSIGN_OFFSET(X) = ANON_MEMBER_OFFSET(Y, Z))
+
+/*
+ *  For use with non-debug kernels.
+ */
+struct builtin_debug_table {
+        char *release;
+	char *machine_type;
+        struct offset_table *offset_table;
+        struct size_table *size_table;
+        struct array_table *array_table;
+};
+
+/*
+ *  Facilitators for pulling correctly-sized data out of a buffer at a
+ *  known address. 
+ */
+#define INT(ADDR)       *((int *)((char *)(ADDR)))
+#define UINT(ADDR)      *((uint *)((char *)(ADDR)))
+#define LONG(ADDR)      *((long *)((char *)(ADDR)))
+#define ULONG(ADDR)     *((ulong *)((char *)(ADDR)))
+#define ULONGLONG(ADDR) *((ulonglong *)((char *)(ADDR)))
+#define ULONG_PTR(ADDR) *((ulong **)((char *)(ADDR)))
+#define USHORT(ADDR)    *((ushort *)((char *)(ADDR)))
+#define SHORT(ADDR)     *((short *)((char *)(ADDR)))
+#define UCHAR(ADDR)     *((unsigned char *)((char *)(ADDR)))
+#define VOID_PTR(ADDR)  *((void **)((char *)(ADDR)))
+
+struct node_table {
+	int node_id;
+	ulong pgdat;
+	ulong mem_map;
+	ulong size;
+	ulong present;
+	ulonglong start_paddr;
+	ulong start_mapnr;
+};
+
+struct meminfo;
+struct slab_data;
+
+#define VMA_CACHE   (20)
+
+struct vm_table {                /* kernel VM-related data */
+	ulong flags;
+	ulong kernel_pgd[NR_CPUS];
+	ulong high_memory;
+	ulong vmalloc_start;
+	ulong mem_map;
+	long total_pages;
+	ulong totalram_pages;
+	ulong totalhigh_pages;
+	ulong num_physpages;
+	ulong max_mapnr;
+	ulong kmem_max_c_num;
+	ulong kmem_max_limit;
+	ulong kmem_max_cpus;
+	ulong kmem_cache_count;
+	ulong kmem_cache_len_nodes;
+	ulong PG_reserved;
+	ulong PG_slab;
+	ulong PG_head_tail_mask;
+	int kmem_cache_namelen;
+	ulong page_hash_table;
+	int page_hash_table_len;
+	int paddr_prlen;
+	int numnodes;
+	int nr_zones;
+	int nr_free_areas;
+	struct node_table *node_table;
+        void (*dump_free_pages)(struct meminfo *);
+	void (*dump_kmem_cache)(struct meminfo *);
+	struct slab_data *slab_data;
+	uint nr_swapfiles;
+	ulong last_swap_read;
+	char *swap_info_struct;
+        char *vma_cache;
+        ulong cached_vma[VMA_CACHE];
+        ulong cached_vma_hits[VMA_CACHE];
+        int vma_cache_index;
+        ulong vma_cache_fills;
+	void *mem_sec;
+	char *mem_section;
+	int ZONE_HIGHMEM;
+	ulong *node_online_map;
+	int node_online_map_len;
+	int nr_vm_stat_items;
+	char **vm_stat_items;
+	int cpu_slab_type;
+	int nr_vm_event_items;
+	char **vm_event_items;
+	int nr_bad_slab_caches;
+	ulong *bad_slab_caches;
+	int nr_pageflags;
+	struct pageflags_data {
+		ulong mask;
+		char *name;
+	} *pageflags_data;
+};
+
+#define NODES                       (0x1)
+#define ZONES                       (0x2)
+#define PERCPU_KMALLOC_V1           (0x4)
+#define COMMON_VADDR                (0x8)
+#define KMEM_CACHE_INIT            (0x10)
+#define V_MEM_MAP                  (0x20)
+#define PERCPU_KMALLOC_V2          (0x40)
+#define KMEM_CACHE_UNAVAIL         (0x80)
+#define FLATMEM			  (0x100)
+#define DISCONTIGMEM		  (0x200)
+#define SPARSEMEM		  (0x400)
+#define SPARSEMEM_EX		  (0x800)
+#define PERCPU_KMALLOC_V2_NODES  (0x1000)
+#define KMEM_CACHE_DELAY         (0x2000)
+#define NODES_ONLINE             (0x4000)
+#define VM_STAT                  (0x8000)
+#define KMALLOC_SLUB            (0x10000)
+#define CONFIG_NUMA             (0x20000)
+#define VM_EVENT                (0x40000)
+#define PGCNT_ADJ               (0x80000)
+#define VM_INIT                (0x100000)
+#define SWAPINFO_V1            (0x200000)
+#define SWAPINFO_V2            (0x400000)
+#define NODELISTS_IS_PTR       (0x800000)
+#define KMALLOC_COMMON        (0x1000000)
+#define USE_VMAP_AREA         (0x2000000)
+#define PAGEFLAGS             (0x4000000)
+
+#define IS_FLATMEM()		(vt->flags & FLATMEM)
+#define IS_DISCONTIGMEM()	(vt->flags & DISCONTIGMEM)
+#define IS_SPARSEMEM()		(vt->flags & SPARSEMEM)
+#define IS_SPARSEMEM_EX()	(vt->flags & SPARSEMEM_EX)
+
+#define COMMON_VADDR_SPACE() (vt->flags & COMMON_VADDR)
+#define PADDR_PRLEN          (vt->paddr_prlen)
+
+struct datatype_member {        /* minimal definition of a structure/union */
+	char *name;             /* and possibly a member within it */
+	char *member;
+	ulong type;
+	long size;
+	long member_offset;
+	long member_size;
+	int member_typecode;
+	ulong flags;
+	char *tagname;         /* tagname and value for enums */
+	long value;
+	ulong vaddr;
+};
+
+#define union_name struct_name
+
+struct list_data {             /* generic structure used by do_list() to walk */
+        ulong flags;           /* through linked lists in the kernel */
+        ulong start;
+        long member_offset;
+	long list_head_offset;
+        ulong end;
+	ulong searchfor;
+	char **structname;
+	int structname_args;
+	char *header;
+};
+#define LIST_OFFSET_ENTERED  (VERBOSE << 1)
+#define LIST_START_ENTERED   (VERBOSE << 2)
+#define LIST_HEAD_FORMAT     (VERBOSE << 3)
+#define LIST_HEAD_POINTER    (VERBOSE << 4)
+#define RETURN_ON_DUPLICATE  (VERBOSE << 5)
+#define RETURN_ON_LIST_ERROR (VERBOSE << 6)
+#define LIST_STRUCT_RADIX_10 (VERBOSE << 7)
+#define LIST_STRUCT_RADIX_16 (VERBOSE << 8)
+#define LIST_HEAD_REVERSE    (VERBOSE << 9)
+
+struct tree_data {
+	ulong flags;
+	ulong start;
+	long node_member_offset;
+	char **structname;
+	int structname_args;
+	int count;
+};
+
+#define TREE_ROOT_OFFSET_ENTERED  (VERBOSE << 1)
+#define TREE_NODE_OFFSET_ENTERED  (VERBOSE << 2)
+#define TREE_NODE_POINTER         (VERBOSE << 3)
+#define TREE_POSITION_DISPLAY     (VERBOSE << 4)
+#define TREE_STRUCT_RADIX_10      (VERBOSE << 5)
+#define TREE_STRUCT_RADIX_16      (VERBOSE << 6)
+
+#define ALIAS_RUNTIME  (1)
+#define ALIAS_RCLOCAL  (2)
+#define ALIAS_RCHOME   (3)
+#define ALIAS_BUILTIN  (4)
+
+struct alias_data {                 /* command alias storage */
+	struct alias_data *next;
+	char *alias;
+	int argcnt;
+	int size;
+	int origin;
+	char *args[MAXARGS];
+	char argbuf[1];
+};
+
+struct rb_node
+{
+        unsigned long  rb_parent_color;
+#define RB_RED          0
+#define RB_BLACK        1
+        struct rb_node *rb_right;
+        struct rb_node *rb_left;
+};
+
+struct rb_root
+{
+        struct rb_node *rb_node;
+};
+
+#define NUMBER_STACKFRAMES 4
+
+#define SAVE_RETURN_ADDRESS(retaddr) \
+{ 									\
+	int i; 								\
+	int saved_stacks; 						\
+									\
+	saved_stacks = backtrace((void **)retaddr, NUMBER_STACKFRAMES); \
+									\
+	/* explicitely zero out the invalid addresses */		\
+	for (i = saved_stacks; i < NUMBER_STACKFRAMES; i++)		\
+		retaddr[i] = 0;						\
+}
+
+#endif /* !GDB_COMMON */
+
+
+#define SYMBOL_NAME_USED (0x1)
+#define MODULE_SYMBOL    (0x2)
+#define IS_MODULE_SYMBOL(SYM)  ((SYM)->flags & MODULE_SYMBOL)
+
+struct syment {
+        ulong value;
+        char *name;
+	struct syment *val_hash_next;
+	struct syment *name_hash_next;
+	char type;
+	unsigned char cnt;
+	unsigned char flags;
+	unsigned char pad2;
+};
+
+#define NAMESPACE_INIT     (1)
+#define NAMESPACE_REUSE    (2)
+#define NAMESPACE_FREE     (3)
+#define NAMESPACE_INSTALL  (4)
+#define NAMESPACE_COMPLETE (5)
+
+struct symbol_namespace {
+	char *address;
+	size_t size;
+	long index;
+	long cnt;
+};
+
+#define SYMVAL_HASH (512)
+#define SYMVAL_HASH_INDEX(vaddr) \
+        (((vaddr) >> machdep->pageshift) % SYMVAL_HASH)
+
+#define SYMNAME_HASH (512)
+#define SYMNAME_HASH_INDEX(name) \
+ ((name[0] ^ (name[strlen(name)-1] * name[strlen(name)/2])) % SYMNAME_HASH)
+
+#define PATCH_KERNEL_SYMBOLS_START  ((char *)(1))
+#define PATCH_KERNEL_SYMBOLS_STOP   ((char *)(2))
+
+#ifndef GDB_COMMON
+
+struct symbol_table_data {
+	ulong flags;
+#ifdef GDB_5_3
+	struct _bfd *bfd;
+#else
+	struct bfd *bfd;
+#endif
+	struct sec *sections;
+	struct syment *symtable;
+	struct syment *symend;
+	long symcnt;
+	ulong syment_size;
+        struct symval_hash_chain {
+                struct syment *val_hash_head;
+                struct syment *val_hash_last;
+        } symval_hash[SYMVAL_HASH];
+        double val_hash_searches;
+        double val_hash_iterations;
+        struct syment *symname_hash[SYMNAME_HASH];
+	struct symbol_namespace kernel_namespace;
+	struct syment *ext_module_symtable;
+	struct syment *ext_module_symend;
+	long ext_module_symcnt;
+	struct symbol_namespace ext_module_namespace;
+	int mods_installed;
+	struct load_module *current;
+	struct load_module *load_modules;
+	off_t dwarf_eh_frame_file_offset;
+	ulong dwarf_eh_frame_size;
+	ulong first_ksymbol;
+	ulong __per_cpu_start;
+	ulong __per_cpu_end;
+	off_t dwarf_debug_frame_file_offset;
+	ulong dwarf_debug_frame_size;
+};
+
+/* flags for st */
+#define KERNEL_SYMS        (0x1)
+#define MODULE_SYMS        (0x2)
+#define LOAD_MODULE_SYMS   (0x4)
+#define INSMOD_BUILTIN     (0x8)
+#define GDB_SYMS_PATCHED  (0x10)
+#define GDB_PATCHED()     (st->flags & GDB_SYMS_PATCHED)
+#define NO_SEC_LOAD       (0x20)
+#define NO_SEC_CONTENTS   (0x40)
+#define FORCE_DEBUGINFO   (0x80)
+#define CRC_MATCHES      (0x100)
+#define ADD_SYMBOL_FILE  (0x200)
+#define USE_OLD_ADD_SYM  (0x400)
+#define PERCPU_SYMS      (0x800)
+#define MODSECT_UNKNOWN (0x1000)
+#define MODSECT_V1      (0x2000)
+#define MODSECT_V2      (0x4000)
+#define MODSECT_V3      (0x8000)
+#define MODSECT_VMASK   (MODSECT_V1|MODSECT_V2|MODSECT_V3)
+#define NO_STRIP       (0x10000)
+
+#endif /* !GDB_COMMON */
+
+#define ALL_MODULES      (0)
+
+#define MAX_MOD_NAMELIST (256)
+#define MAX_MOD_NAME     (64)
+#define MAX_MOD_SEC_NAME (64)
+
+#define MOD_EXT_SYMS    (0x1)
+#define MOD_LOAD_SYMS   (0x2)
+#define MOD_REMOTE      (0x4)
+#define MOD_KALLSYMS    (0x8)
+#define MOD_INITRD     (0x10)
+#define MOD_NOPATCH    (0x20)
+#define MOD_INIT       (0x40)
+#define MOD_DO_READNOW (0x80)
+
+#define SEC_FOUND       (0x10000)
+
+struct mod_section_data {
+#if defined(GDB_5_3) || defined(GDB_6_0)
+        struct sec *section;
+#else
+        struct bfd_section *section;
+#endif
+        char name[MAX_MOD_SEC_NAME];
+        ulong offset;
+        ulong size;
+        int priority;
+        int flags;
+};
+
+struct load_module {
+        ulong mod_base;
+	ulong module_struct;
+        long mod_size;
+        char mod_namelist[MAX_MOD_NAMELIST];
+        char mod_name[MAX_MOD_NAME];
+        ulong mod_flags;
+	struct syment *mod_symtable;
+	struct syment *mod_symend;
+        long mod_ext_symcnt;
+	struct syment *mod_ext_symtable;
+	struct syment *mod_ext_symend;
+        long mod_load_symcnt;
+        struct syment *mod_load_symtable;
+        struct syment *mod_load_symend;
+        long mod_symalloc;
+	struct symbol_namespace mod_load_namespace;
+	ulong mod_size_of_struct;
+        ulong mod_text_start;
+	ulong mod_etext_guess;
+	ulong mod_rodata_start;
+        ulong mod_data_start;
+	ulong mod_bss_start;
+	int mod_sections;
+	struct mod_section_data *mod_section_data;
+        ulong mod_init_text_size;
+        ulong mod_init_module_ptr;
+	ulong mod_init_size;
+	struct syment *mod_init_symtable;
+	struct syment *mod_init_symend;
+	ulong mod_percpu;
+	ulong mod_percpu_size;
+};
+
+#define IN_MODULE(A,L) \
+ (((ulong)(A) >= (L)->mod_base) && ((ulong)(A) < ((L)->mod_base+(L)->mod_size)))
+
+#define IN_MODULE_INIT(A,L) \
+ (((ulong)(A) >= (L)->mod_init_module_ptr) && ((ulong)(A) < ((L)->mod_init_module_ptr+(L)->mod_init_size)))
+
+#define IN_MODULE_PERCPU(A,L) \
+ (((ulong)(A) >= (L)->mod_percpu) && ((ulong)(A) < ((L)->mod_percpu+(L)->mod_percpu_size)))
+
+#define MODULE_PERCPU_SYMS_LOADED(L) ((L)->mod_percpu && (L)->mod_percpu_size)
+
+#ifndef GDB_COMMON
+
+#define KVADDR             (0x1)
+#define UVADDR             (0x2)
+#define PHYSADDR           (0x4)
+#define XENMACHADDR        (0x8)
+#define FILEADDR          (0x10)
+#define AMBIGUOUS          (~0)
+
+#define USE_USER_PGD       (UVADDR << 2)
+
+#define VERIFY_ADDR        (0x8)   /* vm_area_dump() flags -- must follow */
+#define PRINT_INODES      (0x10)   /* KVADDR, UVADDR, and PHYSADDR */
+#define PRINT_MM_STRUCT   (0x20)
+#define PRINT_VMA_STRUCTS (0x40)
+#define PRINT_SINGLE_VMA  (0x80)
+#define PRINT_RADIX_10   (0x100)
+#define PRINT_RADIX_16   (0x200)
+
+#define MIN_PAGE_SIZE  (4096)
+
+#define PTOB(X)       ((ulonglong)(X) << machdep->pageshift)
+#define BTOP(X)       ((ulonglong)(X) >> machdep->pageshift)
+
+#define PAGESIZE()    (machdep->pagesize)
+#define PAGESHIFT()   (machdep->pageshift)
+
+#define PAGEOFFSET(X) (((ulong)(X)) & machdep->pageoffset)
+#define VIRTPAGEBASE(X)  (((ulong)(X)) & (ulong)machdep->pagemask)
+#define PHYSPAGEBASE(X)  (((physaddr_t)(X)) & (physaddr_t)machdep->pagemask)
+
+/* 
+ * Sparse memory stuff
+ *  These must follow the definitions in the kernel mmzone.h
+ */
+#define SECTION_SIZE_BITS()	(machdep->section_size_bits)
+#define MAX_PHYSMEM_BITS()	(machdep->max_physmem_bits)
+#define SECTIONS_SHIFT()	(MAX_PHYSMEM_BITS() - SECTION_SIZE_BITS())
+#define PA_SECTION_SHIFT()	(SECTION_SIZE_BITS())
+#define PFN_SECTION_SHIFT()	(SECTION_SIZE_BITS() - PAGESHIFT())
+#define NR_MEM_SECTIONS()	(1UL << SECTIONS_SHIFT())
+#define PAGES_PER_SECTION()	(1UL << PFN_SECTION_SHIFT())
+#define PAGE_SECTION_MASK()	(~(PAGES_PER_SECTION()-1))
+
+#define pfn_to_section_nr(pfn) ((pfn) >> PFN_SECTION_SHIFT())
+#define section_nr_to_pfn(sec) ((sec) << PFN_SECTION_SHIFT())
+
+#define SECTIONS_PER_ROOT()	(machdep->sections_per_root)
+
+/* CONFIG_SPARSEMEM_EXTREME */
+#define _SECTIONS_PER_ROOT_EXTREME()	(PAGESIZE() / SIZE(mem_section))
+/* !CONFIG_SPARSEMEM_EXTREME */
+#define _SECTIONS_PER_ROOT()	(1)
+
+#define SECTION_NR_TO_ROOT(sec)	((sec) / SECTIONS_PER_ROOT())
+#define DIV_ROUND_UP(n,d)	(((n) + (d) - 1) / (d))
+#define NR_SECTION_ROOTS()	(DIV_ROUND_UP(NR_MEM_SECTIONS(), SECTIONS_PER_ROOT()))
+#define SECTION_ROOT_MASK()	(SECTIONS_PER_ROOT() - 1)
+
+/*
+ *  Machine specific stuff
+ */
+
+#ifdef ARM
+#define _32BIT_
+#define MACHINE_TYPE		"ARM"
+
+#define PAGEBASE(X)		(((ulong)(X)) & (ulong)machdep->pagemask)
+
+#define PTOV(X) \
+	((unsigned long)(X)-(machdep->machspec->phys_base)+(machdep->kvbase))
+#define VTOP(X) \
+	((unsigned long)(X)-(machdep->kvbase)+(machdep->machspec->phys_base))
+
+#define IS_VMALLOC_ADDR(X) 	arm_is_vmalloc_addr((ulong)(X))
+
+#define DEFAULT_MODULES_VADDR	(machdep->kvbase - 16 * 1024 * 1024)
+#define MODULES_VADDR   	(machdep->machspec->modules_vaddr)
+#define MODULES_END     	(machdep->machspec->modules_end)
+#define VMALLOC_START   	(machdep->machspec->vmalloc_start_addr)
+#define VMALLOC_END     	(machdep->machspec->vmalloc_end)
+
+#define PGDIR_SHIFT   		(21)
+#define PTRS_PER_PTE		(512)
+#define PTRS_PER_PGD		(2048)
+
+#define PGD_OFFSET(vaddr)       ((vaddr) >> PGDIR_SHIFT)
+#define PTE_OFFSET(vaddr)       (((vaddr) >> PAGESHIFT()) & (PTRS_PER_PTE - 1))
+
+#define __SWP_TYPE_SHIFT	3
+#define __SWP_TYPE_BITS		6
+#define __SWP_TYPE_MASK		((1 << __SWP_TYPE_BITS) - 1)
+#define __SWP_OFFSET_SHIFT	(__SWP_TYPE_BITS + __SWP_TYPE_SHIFT)
+
+#define SWP_TYPE(entry)		(((entry) >> __SWP_TYPE_SHIFT) & __SWP_TYPE_MASK)
+#define SWP_OFFSET(entry)	((entry) >> __SWP_OFFSET_SHIFT)
+
+#define __swp_type(entry)	SWP_TYPE(entry)
+#define __swp_offset(entry)	SWP_OFFSET(entry)
+
+#define TIF_SIGPENDING		(2)
+
+#define _SECTION_SIZE_BITS	28
+#define _MAX_PHYSMEM_BITS	32
+
+#endif  /* ARM */
+
+#ifndef EM_AARCH64
+#define EM_AARCH64              183
+#endif
+
+#ifdef ARM64
+#define _64BIT_
+#define MACHINE_TYPE       "ARM64"    
+
+#define PTOV(X) \
+	((unsigned long)(X)-(machdep->machspec->phys_offset)+(machdep->kvbase))
+#define VTOP(X) \
+	((unsigned long)(X)-(machdep->kvbase)+(machdep->machspec->phys_offset))
+
+#define USERSPACE_TOP   (machdep->machspec->userspace_top)
+#define PAGE_OFFSET     (machdep->machspec->page_offset)
+#define VMALLOC_START   (machdep->machspec->vmalloc_start_addr)
+#define VMALLOC_END     (machdep->machspec->vmalloc_end)
+#define VMEMMAP_VADDR   (machdep->machspec->vmemmap_vaddr)
+#define VMEMMAP_END     (machdep->machspec->vmemmap_end)
+#define MODULES_VADDR   (machdep->machspec->modules_vaddr)
+#define MODULES_END     (machdep->machspec->modules_end)
+
+#define IS_VMALLOC_ADDR(X)    arm64_IS_VMALLOC_ADDR((ulong)(X))
+
+#define PAGEBASE(X)     (((ulong)(X)) & (ulong)machdep->pagemask)
+
+/*
+ * 40-bit physical address supported.  (512GB)
+ */
+#define PHYS_MASK_SHIFT   (40)
+#define PHYS_MASK         (((1UL) << PHYS_MASK_SHIFT) - 1)
+
+typedef signed int s32;
+
+/* 
+ * 3-levels / 4K pages
+ */
+#define PTRS_PER_PGD_L3_4K   (512)
+#define PTRS_PER_PMD_L3_4K   (512)
+#define PTRS_PER_PTE_L3_4K   (512)
+#define PGDIR_SHIFT_L3_4K    (30)
+#define PGDIR_SIZE_L3_4K     ((1UL) << PGDIR_SHIFT_L3_4K)
+#define PGDIR_MASK_L3 4K     (~(PGDIR_SIZE_L3_4K-1))
+#define PMD_SHIFT_L3_4K      (21)
+#define PMD_SIZE_L3_4K       (1UL << PMD_SHIFT_4K)
+#define PMD_MASK_L3 4K       (~(PMD_SIZE_4K-1))
+
+/*
+ * 2-levels / 64K pages
+ */
+#define PTRS_PER_PGD_L2_64K  (1024)
+#define PTRS_PER_PTE_L2_64K  (8192)
+#define PGDIR_SHIFT_L2_64K   (29)
+#define PGDIR_SIZE_L2_64K    ((1UL) << PGDIR_SHIFT_L2_64K)
+#define PGDIR_MASK_L2_64K    (~(PGDIR_SIZE_L2_64K-1))
+
+/*
+ * Software defined PTE bits definition.
+ * (arch/arm64/include/asm/pgtable.h)
+ */
+#define PTE_VALID       (1UL << 0)
+#define PTE_PROT_NONE   (1UL << 1) /* only when !PTE_VALID */
+#define PTE_FILE        (1UL << 2) /* only when !pte_present() */
+#define PTE_DIRTY       (1UL << 55)
+#define PTE_SPECIAL     (1UL << 56)
+
+/*
+ * HugeTLB/THP 3.10 support proposal swaps PTE_PROT_NONE
+ * and PTE_FILE bit positions:
+ */
+#define PTE_FILE_3_10       (1UL << 1)
+#define PTE_PROT_NONE_3_10  (1UL << 2)
+
+/*
+ * Level 3 descriptor (PTE).
+ * (arch/arm64/include/asm/pgtable-hwdef.h)
+ */
+#define PTE_TYPE_MASK   (3UL << 0)
+#define PTE_TYPE_FAULT  (0UL << 0)
+#define PTE_TYPE_PAGE   (3UL << 0)
+#define PTE_USER        (1UL << 6)         /* AP[1] */
+#define PTE_RDONLY      (1UL << 7)         /* AP[2] */
+#define PTE_SHARED      (3UL << 8)         /* SH[1:0], inner shareable */
+#define PTE_AF          (1UL << 10)        /* Access Flag */
+#define PTE_NG          (1UL << 11)        /* nG */
+#define PTE_PXN         (1UL << 53)        /* Privileged XN */
+#define PTE_UXN         (1UL << 54)        /* User XN */
+
+/*
+ * swap entry:
+ *      bits 0-1:       present (must be zero)
+ *      bit  2:         PTE_FILE
+ *      bits 3-8:       swap type
+ *      bits 9-63:      swap offset
+ *
+ * HugeTLB/THP 3.10 support proposal swaps PTE_PROT_NONE 
+ * and PTE_FILE bit positions:
+ *
+ *      bits 0, 2:	present (must both be zero)
+ *	bit  1:		PTE_FILE
+ *      bits 3-8:       swap type
+ *      bits 9-63:      swap offset
+ */
+#define __SWP_TYPE_SHIFT    3
+#define __SWP_TYPE_BITS     6
+#define __SWP_TYPE_MASK     ((1 << __SWP_TYPE_BITS) - 1)
+#define __SWP_OFFSET_SHIFT  (__SWP_TYPE_BITS + __SWP_TYPE_SHIFT)
+
+#define __swp_type(x)       (((x) >> __SWP_TYPE_SHIFT) & __SWP_TYPE_MASK)
+#define __swp_offset(x)     ((x) >> __SWP_OFFSET_SHIFT)
+#define SWP_TYPE(x)         __swp_type(x)
+#define SWP_OFFSET(x)       __swp_offset(x)
+
+#define KSYMS_START   (0x1)
+#define PHYS_OFFSET   (0x2)
+#define VM_L2_64K     (0x4)
+#define VM_L3_4K      (0x8)
+
+/* 
+ * source: Documentation/arm64/memory.txt 
+ */
+#define ARM64_USERSPACE_TOP  (0x0000007fffffffffUL)
+#define ARM64_VMALLOC_START  (0xffffff8000000000UL)
+#define ARM64_VMALLOC_END    (0xffffffbbfffeffffUL)
+#define ARM64_VMEMMAP_VADDR  (0xffffffbc00000000UL)
+#define ARM64_VMEMMAP_END    (0xffffffbffbbfffffUL)
+#define ARM64_MODULES_VADDR  (0xffffffbffc000000UL)
+#define ARM64_MODULES_END    (0xffffffbfffffffffUL)
+#define ARM64_PAGE_OFFSET    (0xffffffc000000000UL)
+
+#define ARM64_STACK_SIZE   (8192)
+
+#define _SECTION_SIZE_BITS      30
+#define _MAX_PHYSMEM_BITS       40
+
+typedef unsigned long long __u64;
+typedef unsigned long long u64;
+
+struct arm64_user_pt_regs {
+        __u64           regs[31];
+        __u64           sp;
+        __u64           pc;
+        __u64           pstate;
+};
+
+struct arm64_pt_regs {
+        union {
+                struct arm64_user_pt_regs user_regs;
+                struct {
+                        u64 regs[31];
+                        u64 sp;
+                        u64 pc;
+                        u64 pstate;
+                };
+        };
+        u64 orig_x0;
+        u64 syscallno;
+};
+
+#define TIF_SIGPENDING  (0)
+#define display_idt_table() \
+        error(FATAL, "-d option is not applicable to ARM64 architecture\n")
+
+struct machine_specific {
+	ulong flags;
+	ulong userspace_top;
+	ulong page_offset;
+	ulong vmalloc_start_addr;
+	ulong vmalloc_end;
+	ulong vmemmap_vaddr;
+	ulong vmemmap_end;
+	ulong modules_vaddr;
+	ulong modules_end;
+	ulong phys_offset;
+	ulong __exception_text_start;
+	ulong __exception_text_end;
+	struct arm64_pt_regs *panic_task_regs;
+	ulong pte_protnone;
+	ulong pte_file;
+};
+
+struct arm64_stackframe {
+        unsigned long fp;
+        unsigned long sp;
+        unsigned long pc;
+};
+
+#endif  /* ARM64 */
+
+#ifdef X86
+#define _32BIT_
+#define MACHINE_TYPE       "X86"
+#define PTOV(X)            ((unsigned long)(X)+(machdep->kvbase))
+#define VTOP(X)            ((unsigned long)(X)-(machdep->kvbase))
+#define IS_VMALLOC_ADDR(X) (vt->vmalloc_start && (ulong)(X) >= vt->vmalloc_start)
+#define KVBASE_MASK        (0x1ffffff)
+
+#define PGDIR_SHIFT_2LEVEL   (22)
+#define PTRS_PER_PTE_2LEVEL  (1024)
+#define PTRS_PER_PGD_2LEVEL  (1024)
+
+#define PGDIR_SHIFT_3LEVEL   (30)
+#define PTRS_PER_PTE_3LEVEL  (512)
+#define PTRS_PER_PGD_3LEVEL  (4)
+#define PMD_SHIFT            (21)    /* only used by PAE translators */
+#define PTRS_PER_PMD         (512)   /* only used by PAE translators */
+
+#define _PAGE_PRESENT   0x001
+#define _PAGE_RW        0x002
+#define _PAGE_USER      0x004
+#define _PAGE_PWT       0x008
+#define _PAGE_PCD       0x010
+#define _PAGE_ACCESSED  0x020
+#define _PAGE_DIRTY     0x040
+#define _PAGE_4M        0x080   /* 4 MB page, Pentium+, if present.. */
+#define _PAGE_PSE       0x080   /* 4 MB (or 2MB) page, Pentium+, if present.. */
+#define _PAGE_GLOBAL    0x100   /* Global TLB entry PPro+ */
+#define _PAGE_PROTNONE  (machdep->machspec->page_protnone)
+#define _PAGE_NX        (0x8000000000000000ULL)
+
+#define NONPAE_PAGEBASE(X)   (((unsigned long)(X)) & (unsigned long)machdep->pagemask)
+#define NX_BIT_MASK          (0x7fffffffffffffffULL)
+#define PAE_PAGEBASE(X)      (((unsigned long long)(X)) & ((unsigned long long)machdep->pagemask) & NX_BIT_MASK)
+
+#define SWP_TYPE(entry) (((entry) >> 1) & 0x3f)
+#define SWP_OFFSET(entry) ((entry) >> 8)
+#define __swp_type_PAE(entry)      (((entry) >> 32) & 0x1f)
+#define __swp_type_nonPAE(entry)   (((entry) >> 1) & 0x1f)
+#define __swp_offset_PAE(entry)    (((entry) >> 32) >> 5)
+#define __swp_offset_nonPAE(entry) ((entry) >> 8)
+#define __swp_type(entry)          (machdep->flags & PAE ? \
+				    __swp_type_PAE(entry) : __swp_type_nonPAE(entry))
+#define __swp_offset(entry)        (machdep->flags & PAE ? \
+				    __swp_offset_PAE(entry) : __swp_offset_nonPAE(entry))
+
+#define TIF_SIGPENDING  (2)
+
+// CONFIG_X86_PAE 
+#define _SECTION_SIZE_BITS_PAE_ORIG	30
+#define _SECTION_SIZE_BITS_PAE_2_6_26	29
+#define _MAX_PHYSMEM_BITS_PAE	36
+
+// !CONFIG_X86_PAE   
+#define _SECTION_SIZE_BITS	26
+#define _MAX_PHYSMEM_BITS	32
+
+#define IS_LAST_PMD_READ_PAE(pmd)     ((ulong)(pmd) == machdep->machspec->last_pmd_read_PAE)
+#define IS_LAST_PTBL_READ_PAE(ptbl)   ((ulong)(ptbl) == machdep->machspec->last_ptbl_read_PAE)
+
+#define FILL_PMD_PAE(PMD, TYPE, SIZE)			                    \
+    if (!IS_LAST_PMD_READ_PAE(PMD)) {                                       \
+            readmem((ulonglong)(PMD), TYPE, machdep->pmd,                   \
+	            SIZE, "pmd page", FAULT_ON_ERROR);                      \
+            machdep->machspec->last_pmd_read_PAE = (ulonglong)(PMD);        \
+    }					                                    
+
+#define FILL_PTBL_PAE(PTBL, TYPE, SIZE)			           	    \
+    if (!IS_LAST_PTBL_READ_PAE(PTBL)) {                                     \
+    	    readmem((ulonglong)(PTBL), TYPE, machdep->ptbl,                 \
+	            SIZE, "page table", FAULT_ON_ERROR);                    \
+            machdep->machspec->last_ptbl_read_PAE = (ulonglong)(PTBL); 	    \
+    }
+
+#endif  /* X86 */
+
+#ifdef X86_64 
+#define _64BIT_
+#define MACHINE_TYPE       "X86_64"
+
+#define USERSPACE_TOP   (machdep->machspec->userspace_top)
+#define PAGE_OFFSET     (machdep->machspec->page_offset)
+#define VMALLOC_START   (machdep->machspec->vmalloc_start_addr)
+#define VMALLOC_END     (machdep->machspec->vmalloc_end)
+#define VMEMMAP_VADDR   (machdep->machspec->vmemmap_vaddr)
+#define VMEMMAP_END     (machdep->machspec->vmemmap_end)
+#define MODULES_VADDR   (machdep->machspec->modules_vaddr)
+#define MODULES_END     (machdep->machspec->modules_end)
+
+#define __START_KERNEL_map    0xffffffff80000000UL
+#define MODULES_LEN     (MODULES_END - MODULES_VADDR)
+
+#define USERSPACE_TOP_ORIG         0x0000008000000000
+#define PAGE_OFFSET_ORIG           0x0000010000000000
+#define VMALLOC_START_ADDR_ORIG    0xffffff0000000000
+#define VMALLOC_END_ORIG           0xffffff7fffffffff
+#define MODULES_VADDR_ORIG         0xffffffffa0000000
+#define MODULES_END_ORIG           0xffffffffafffffff
+ 
+#define USERSPACE_TOP_2_6_11       0x0000800000000000
+#define PAGE_OFFSET_2_6_11         0xffff810000000000
+#define VMALLOC_START_ADDR_2_6_11  0xffffc20000000000
+#define VMALLOC_END_2_6_11         0xffffe1ffffffffff
+#define MODULES_VADDR_2_6_11       0xffffffff88000000
+#define MODULES_END_2_6_11         0xfffffffffff00000
+
+#define VMEMMAP_VADDR_2_6_24       0xffffe20000000000
+#define VMEMMAP_END_2_6_24         0xffffe2ffffffffff
+
+#define MODULES_VADDR_2_6_26       0xffffffffa0000000
+
+#define PAGE_OFFSET_2_6_27         0xffff880000000000
+#define MODULES_END_2_6_27         0xffffffffff000000
+
+#define USERSPACE_TOP_XEN          0x0000800000000000
+#define PAGE_OFFSET_XEN            0xffff880000000000
+#define VMALLOC_START_ADDR_XEN     0xffffc20000000000
+#define VMALLOC_END_XEN            0xffffe1ffffffffff
+#define MODULES_VADDR_XEN          0xffffffff88000000
+#define MODULES_END_XEN            0xfffffffffff00000
+
+#define USERSPACE_TOP_XEN_RHEL4       0x0000008000000000
+#define PAGE_OFFSET_XEN_RHEL4         0xffffff8000000000
+#define VMALLOC_START_ADDR_XEN_RHEL4  0xffffff0000000000
+#define VMALLOC_END_XEN_RHEL4         0xffffff7fffffffff
+#define MODULES_VADDR_XEN_RHEL4       0xffffffffa0000000
+#define MODULES_END_XEN_RHEL4         0xffffffffafffffff
+
+#define VMALLOC_START_ADDR_2_6_31  0xffffc90000000000
+#define VMALLOC_END_2_6_31         0xffffe8ffffffffff
+#define VMEMMAP_VADDR_2_6_31       0xffffea0000000000
+#define VMEMMAP_END_2_6_31         0xffffeaffffffffff
+#define MODULES_VADDR_2_6_31       0xffffffffa0000000
+#define MODULES_END_2_6_31         0xffffffffff000000
+
+#define PTOV(X)               ((unsigned long)(X)+(machdep->kvbase))
+#define VTOP(X)               x86_64_VTOP((ulong)(X))
+#define IS_VMALLOC_ADDR(X)    x86_64_IS_VMALLOC_ADDR((ulong)(X))
+
+#define PML4_SHIFT      39
+#define PTRS_PER_PML4   512
+#define PGDIR_SHIFT     30
+#define PTRS_PER_PGD    512
+#define PMD_SHIFT       21
+#define PTRS_PER_PMD    512
+#define PTRS_PER_PTE    512
+
+#define pml4_index(address) (((address) >> PML4_SHIFT) & (PTRS_PER_PML4-1))
+#define pgd_index(address)  (((address) >> PGDIR_SHIFT) & (PTRS_PER_PGD-1))
+#define pmd_index(address)  (((address) >> PMD_SHIFT) & (PTRS_PER_PMD-1))
+#define pte_index(address)  (((address) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1))
+
+#define IS_LAST_PML4_READ(pml4) ((ulong)(pml4) == machdep->machspec->last_pml4_read)
+
+#define FILL_PML4() { \
+	if (!(pc->flags & RUNTIME) || ACTIVE()) \
+		if (!IS_LAST_PML4_READ(vt->kernel_pgd[0])) \
+                    readmem(vt->kernel_pgd[0], KVADDR, machdep->machspec->pml4, \
+                        PAGESIZE(), "init_level4_pgt", FAULT_ON_ERROR); \
+                machdep->machspec->last_pml4_read = (ulong)(vt->kernel_pgd[0]); \
+	}
+
+#define FILL_PML4_HYPER() { \
+	if (!machdep->machspec->last_pml4_read) { \
+		unsigned long idle_pg_table = \
+		    symbol_exists("idle_pg_table_4") ? symbol_value("idle_pg_table_4") : \
+			symbol_value("idle_pg_table"); \
+		readmem(idle_pg_table, KVADDR, \
+			machdep->machspec->pml4, PAGESIZE(), "idle_pg_table", \
+			FAULT_ON_ERROR); \
+		machdep->machspec->last_pml4_read = idle_pg_table; \
+	}\
+}
+
+#define IS_LAST_UPML_READ(pml) ((ulong)(pml) == machdep->machspec->last_upml_read)
+
+#define FILL_UPML(PML, TYPE, SIZE) 					      \
+    if (!IS_LAST_UPML_READ(PML)) {                                             \
+            readmem((ulonglong)((ulong)(PML)), TYPE, machdep->machspec->upml, \
+                    SIZE, "pml page", FAULT_ON_ERROR);                        \
+            machdep->machspec->last_upml_read = (ulong)(PML);                 \
+    }								            
+
+/* 
+ *  PHYSICAL_PAGE_MASK changed (enlarged) between 2.4 and 2.6, so
+ *  for safety, use the 2.6 values to generate it.
+ */ 
+#define __PHYSICAL_MASK_SHIFT  40
+#define __PHYSICAL_MASK        ((1UL << __PHYSICAL_MASK_SHIFT) - 1)
+#define __VIRTUAL_MASK_SHIFT   48
+#define __VIRTUAL_MASK         ((1UL << __VIRTUAL_MASK_SHIFT) - 1)
+#define PAGE_SHIFT             12
+#define PAGE_SIZE              (1UL << PAGE_SHIFT)
+#define PHYSICAL_PAGE_MASK    (~(PAGE_SIZE-1) & (__PHYSICAL_MASK << PAGE_SHIFT))
+
+#define _PAGE_BIT_NX    63
+#define _PAGE_PRESENT   0x001
+#define _PAGE_RW        0x002
+#define _PAGE_USER      0x004
+#define _PAGE_PWT       0x008
+#define _PAGE_PCD       0x010
+#define _PAGE_ACCESSED  0x020
+#define _PAGE_DIRTY     0x040
+#define _PAGE_PSE       0x080   /* 2MB page */
+#define _PAGE_FILE      0x040   /* set:pagecache, unset:swap */
+#define _PAGE_GLOBAL    0x100   /* Global TLB entry */
+#define _PAGE_PROTNONE  (machdep->machspec->page_protnone)
+#define _PAGE_NX        (1UL<<_PAGE_BIT_NX)
+
+#define SWP_TYPE(entry) (((entry) >> 1) & 0x3f)
+#define SWP_OFFSET(entry) ((entry) >> 8)
+#define __swp_type(entry)   SWP_TYPE(entry)
+#define __swp_offset(entry) SWP_OFFSET(entry)
+
+#define TIF_SIGPENDING  (2)
+
+#define PAGEBASE(X)           (((ulong)(X)) & (ulong)machdep->pagemask)
+
+#define _CPU_PDA_READ2(CPU, BUFFER) \
+ 	((readmem(symbol_value("_cpu_pda"),				\
+		 KVADDR, &cpu_pda_addr, sizeof(unsigned long),		\
+		 "_cpu_pda addr", RETURN_ON_ERROR)) &&			\
+ 	(readmem(cpu_pda_addr + ((CPU) * sizeof(void *)),		\
+		 KVADDR, &cpu_pda_addr, sizeof(unsigned long),		\
+		 "_cpu_pda addr", RETURN_ON_ERROR)) &&			\
+	(cpu_pda_addr) &&						\
+	(readmem(cpu_pda_addr, KVADDR, (BUFFER), SIZE(x8664_pda),	\
+		 "cpu_pda entry", RETURN_ON_ERROR)))
+
+#define _CPU_PDA_READ(CPU, BUFFER) \
+	((STRNEQ("_cpu_pda", closest_symbol((symbol_value("_cpu_pda") +	\
+	     ((CPU) * sizeof(unsigned long)))))) &&			\
+ 	(readmem(symbol_value("_cpu_pda") + ((CPU) * sizeof(void *)),   \
+		 KVADDR, &cpu_pda_addr, sizeof(unsigned long),          \
+		 "_cpu_pda addr", RETURN_ON_ERROR)) &&	   	        \
+	(readmem(cpu_pda_addr, KVADDR, (BUFFER), SIZE(x8664_pda),       \
+		 "cpu_pda entry", RETURN_ON_ERROR)))
+
+#define CPU_PDA_READ(CPU, BUFFER) \
+	(STRNEQ("cpu_pda", closest_symbol((symbol_value("cpu_pda") +	\
+	     ((CPU) * SIZE(x8664_pda))))) &&				\
+        readmem(symbol_value("cpu_pda") + ((CPU) * SIZE(x8664_pda)),	\
+             KVADDR, (BUFFER), SIZE(x8664_pda), "cpu_pda entry",	\
+             RETURN_ON_ERROR))
+
+#define VALID_LEVEL4_PGT_ADDR(X) \
+	(((X) == VIRTPAGEBASE(X)) && IS_KVADDR(X) && !IS_VMALLOC_ADDR(X))
+
+#define _SECTION_SIZE_BITS	  27
+#define _MAX_PHYSMEM_BITS	  40
+#define _MAX_PHYSMEM_BITS_2_6_26  44
+#define _MAX_PHYSMEM_BITS_2_6_31  46
+
+#endif  /* X86_64 */
+
+#ifdef ALPHA
+#define _64BIT_
+#define MACHINE_TYPE       "ALPHA"
+
+#define PAGEBASE(X)  (((unsigned long)(X)) & (unsigned long)machdep->pagemask)
+
+#define PTOV(X)            ((unsigned long)(X)+(machdep->kvbase))
+#define VTOP(X)            ((unsigned long)(X)-(machdep->kvbase))
+#define IS_VMALLOC_ADDR(X) (vt->vmalloc_start && (ulong)(X) >= vt->vmalloc_start)
+#define KSEG_BASE_48_BIT   (0xffff800000000000)
+#define KSEG_BASE          (0xfffffc0000000000)
+#define _PFN_MASK          (0xFFFFFFFF00000000)
+#define VMALLOC_START      (0xFFFFFE0000000000)
+#define MIN_SYMBOL_VALUE   (KSEG_BASE_48_BIT)
+
+#define PGDIR_SHIFT     (PAGESHIFT() + 2*(PAGESHIFT()-3))
+#define PMD_SHIFT       (PAGESHIFT() + (PAGESHIFT()-3))
+#define PTRS_PER_PAGE   (1024)
+
+#define PTRS_PER_PGD    (1UL << (PAGESHIFT()-3))
+
+/*
+ * OSF/1 PAL-code-imposed page table bits
+ */
+#define _PAGE_VALID     0x0001
+#define _PAGE_FOR       0x0002  /* used for page protection (fault on read) */
+#define _PAGE_FOW       0x0004  /* used for page protection (fault on write) */
+#define _PAGE_FOE       0x0008  /* used for page protection (fault on exec) */
+#define _PAGE_ASM       0x0010
+#define _PAGE_KRE       0x0100  /* xxx - see below on the "accessed" bit */
+#define _PAGE_URE       0x0200  /* xxx */
+#define _PAGE_KWE       0x1000  /* used to do the dirty bit in software */
+#define _PAGE_UWE       0x2000  /* used to do the dirty bit in software */
+
+/* .. and these are ours ... */
+#define _PAGE_DIRTY     0x20000
+#define _PAGE_ACCESSED  0x40000
+
+#define SWP_TYPE(entry) (((entry) >> 32) & 0xff)
+#define SWP_OFFSET(entry) ((entry) >> 40)
+#define __swp_type(entry)   SWP_TYPE(entry)
+#define __swp_offset(entry) SWP_OFFSET(entry)
+
+#define TIF_SIGPENDING (2)
+
+#endif  /* ALPHA */
+
+#ifdef PPC
+#define _32BIT_
+#define MACHINE_TYPE       "PPC"
+
+#define PAGEBASE(X) 		((X) & machdep->pagemask)
+
+#define PTOV(X)            ((unsigned long)(X)+(machdep->kvbase))
+#define VTOP(X)            ((unsigned long)(X)-(machdep->kvbase))
+#define IS_VMALLOC_ADDR(X) (vt->vmalloc_start && (ulong)(X) >= vt->vmalloc_start)
+
+/* Holds the platform specific info for page translation */
+struct machine_specific {
+	char *platform;
+
+	/* page address translation bits */
+	int pte_size;
+	int pte_rpn_shift;
+
+	/* page flags */
+	ulong _page_present;
+	ulong _page_user;
+	ulong _page_rw;
+	ulong _page_guarded;
+	ulong _page_coherent;
+	ulong _page_no_cache;
+	ulong _page_writethru;
+	ulong _page_dirty;
+	ulong _page_accessed;
+	ulong _page_hwwrite;
+	ulong _page_shared;
+	ulong _page_k_rw;
+
+	/* platform special vtop */
+	int (*vtop_special)(ulong vaddr, physaddr_t *paddr, int verbose);
+	void *mmu_special;
+};
+
+/* machdep flags for ppc32 specific */
+#define IS_PAE()		(machdep->flags & PAE)
+#define IS_BOOKE()		(machdep->flags & CPU_BOOKE)
+/* Page translation bits */
+#define PPC_PLATFORM		(machdep->machspec->platform)
+#define PTE_SIZE		(machdep->machspec->pte_size)
+#define PTE_RPN_SHIFT		(machdep->machspec->pte_rpn_shift)
+#define PAGE_SHIFT		(12)
+#define PTE_T_LOG2		(ffs(PTE_SIZE) - 1)
+#define PTE_SHIFT		(PAGE_SHIFT - PTE_T_LOG2)
+#define PGDIR_SHIFT		(PAGE_SHIFT + PTE_SHIFT)
+#define PTRS_PER_PGD		(1 << (32 - PGDIR_SHIFT))
+#define PTRS_PER_PTE		(1 << PTE_SHIFT)
+/* special vtop */
+#define VTOP_SPECIAL		(machdep->machspec->vtop_special)
+#define MMU_SPECIAL		(machdep->machspec->mmu_special)
+
+/* PFN shifts */
+#define BOOKE3E_PTE_RPN_SHIFT	(24)
+
+/* PAGE flags */
+#define _PAGE_PRESENT   (machdep->machspec->_page_present)	/* software: pte contains a translation */
+#define _PAGE_USER      (machdep->machspec->_page_user)		/* matches one of the PP bits */
+#define _PAGE_RW        (machdep->machspec->_page_rw)		/* software: user write access allowed */
+#define _PAGE_GUARDED   (machdep->machspec->_page_guarded)
+#define _PAGE_COHERENT  (machdep->machspec->_page_coherent	/* M: enforce memory coherence (SMP systems) */)
+#define _PAGE_NO_CACHE  (machdep->machspec->_page_no_cache)	/* I: cache inhibit */
+#define _PAGE_WRITETHRU (machdep->machspec->_page_writethru)	/* W: cache write-through */
+#define _PAGE_DIRTY     (machdep->machspec->_page_dirty)	/* C: page changed */
+#define _PAGE_ACCESSED  (machdep->machspec->_page_accessed)	/* R: page referenced */
+#define _PAGE_HWWRITE   (machdep->machspec->_page_hwwrite)	/* software: _PAGE_RW & _PAGE_DIRTY */
+#define _PAGE_SHARED    (machdep->machspec->_page_shared)
+#define _PAGE_K_RW	(machdep->machspec->_page_k_rw)		/* privilege only write access allowed */
+
+/* Default values for PAGE flags */
+#define DEFAULT_PAGE_PRESENT   0x001
+#define DEFAULT_PAGE_USER      0x002
+#define DEFAULT_PAGE_RW        0x004
+#define DEFAULT_PAGE_GUARDED   0x008
+#define DEFAULT_PAGE_COHERENT  0x010
+#define DEFAULT_PAGE_NO_CACHE  0x020
+#define DEFAULT_PAGE_WRITETHRU 0x040
+#define DEFAULT_PAGE_DIRTY     0x080
+#define DEFAULT_PAGE_ACCESSED  0x100
+#define DEFAULT_PAGE_HWWRITE   0x200
+#define DEFAULT_PAGE_SHARED    0
+
+/* PPC44x PAGE flags: Values from kernel asm/pte-44x.h */
+#define PPC44x_PAGE_PRESENT	0x001
+#define PPC44x_PAGE_RW		0x002
+#define PPC44x_PAGE_ACCESSED	0x008
+#define PPC44x_PAGE_DIRTY	0x010
+#define PPC44x_PAGE_USER	0x040
+#define PPC44x_PAGE_GUARDED	0x100
+#define PPC44x_PAGE_COHERENT	0x200
+#define PPC44x_PAGE_NO_CACHE	0x400
+#define PPC44x_PAGE_WRITETHRU	0x800
+#define PPC44x_PAGE_HWWRITE	0
+#define PPC44x_PAGE_SHARED	0
+
+/* BOOK3E */
+#define BOOK3E_PAGE_PRESENT	0x000001
+#define BOOK3E_PAGE_BAP_SR	0x000004
+#define BOOK3E_PAGE_BAP_UR	0x000008 /* User Readable */
+#define BOOK3E_PAGE_BAP_SW	0x000010
+#define BOOK3E_PAGE_BAP_UW	0x000020 /* User Writable */
+#define BOOK3E_PAGE_DIRTY	0x001000
+#define BOOK3E_PAGE_ACCESSED	0x040000
+#define BOOK3E_PAGE_GUARDED	0x100000
+#define BOOK3E_PAGE_COHERENT	0x200000
+#define BOOK3E_PAGE_NO_CACHE	0x400000
+#define BOOK3E_PAGE_WRITETHRU	0x800000
+#define BOOK3E_PAGE_HWWRITE	0
+#define BOOK3E_PAGE_SHARED	0
+#define BOOK3E_PAGE_USER	(BOOK3E_PAGE_BAP_SR | BOOK3E_PAGE_BAP_UR)
+#define BOOK3E_PAGE_RW		(BOOK3E_PAGE_BAP_SW | BOOK3E_PAGE_BAP_UW)
+#define BOOK3E_PAGE_KERNEL_RW	(BOOK3E_PAGE_BAP_SW | BOOK3E_PAGE_BAP_SR | BOOK3E_PAGE_DIRTY)
+
+/* FSL BOOKE */
+#define FSL_BOOKE_PAGE_PRESENT	0x00001
+#define FSL_BOOKE_PAGE_USER	0x00002
+#define FSL_BOOKE_PAGE_RW	0x00004
+#define FSL_BOOKE_PAGE_DIRTY	0x00008
+#define FSL_BOOKE_PAGE_ACCESSED	0x00020
+#define FSL_BOOKE_PAGE_GUARDED	0x00080
+#define FSL_BOOKE_PAGE_COHERENT	0x00100
+#define FSL_BOOKE_PAGE_NO_CACHE	0x00200
+#define FSL_BOOKE_PAGE_WRITETHRU	0x00400
+#define FSL_BOOKE_PAGE_HWWRITE	0
+#define FSL_BOOKE_PAGE_SHARED	0
+
+#define SWP_TYPE(entry) (((entry) >> 1) & 0x7f)
+#define SWP_OFFSET(entry) ((entry) >> 8)
+#define __swp_type(entry)   SWP_TYPE(entry)
+#define __swp_offset(entry) SWP_OFFSET(entry)
+
+#define TIF_SIGPENDING (2)
+
+#define _SECTION_SIZE_BITS	24
+#define _MAX_PHYSMEM_BITS	44
+
+#define STACK_FRAME_OVERHEAD	16
+#define STACK_FRAME_LR_SAVE	(sizeof(ulong))
+#define STACK_FRAME_MARKER	(2 * sizeof(ulong))
+#define STACK_FRAME_REGS_MARKER	0x72656773
+#define PPC_STACK_SIZE		8192
+
+#endif  /* PPC */
+
+#ifdef IA64
+#define _64BIT_
+#define MACHINE_TYPE          "IA64"
+
+#define PAGEBASE(X)  (((unsigned long)(X)) & (unsigned long)machdep->pagemask)
+
+#define REGION_SHIFT           (61)
+#define VADDR_REGION(X)        ((ulong)(X) >> REGION_SHIFT)
+
+#define KERNEL_CACHED_REGION   (7)
+#define KERNEL_UNCACHED_REGION (6)
+#define KERNEL_VMALLOC_REGION  (5)
+#define USER_STACK_REGION      (4)
+#define USER_DATA_REGION       (3)
+#define USER_TEXT_REGION       (2)
+#define USER_SHMEM_REGION      (1)
+#define USER_IA32_EMUL_REGION  (0)
+
+#define KERNEL_VMALLOC_BASE   ((ulong)KERNEL_VMALLOC_REGION << REGION_SHIFT)
+#define KERNEL_UNCACHED_BASE  ((ulong)KERNEL_UNCACHED_REGION << REGION_SHIFT)
+#define KERNEL_CACHED_BASE    ((ulong)KERNEL_CACHED_REGION << REGION_SHIFT)
+
+#define _SECTION_SIZE_BITS    30
+#define _MAX_PHYSMEM_BITS     50
+
+/*
+ *  As of 2.6, these are no longer straight forward.
+ */
+#define PTOV(X)               ia64_PTOV((ulong)(X))
+#define VTOP(X)		      ia64_VTOP((ulong)(X))
+#define IS_VMALLOC_ADDR(X)    ia64_IS_VMALLOC_ADDR((ulong)(X))
+
+#define SWITCH_STACK_ADDR(X)  (ia64_get_switch_stack((ulong)(X)))
+
+#define __IA64_UL(x)           ((unsigned long)(x))
+#define IA64_MAX_PHYS_BITS  (50)  /* max # of phys address bits (architected) */
+
+/*
+ * How many pointers will a page table level hold expressed in shift 
+ */
+#define PTRS_PER_PTD_SHIFT	(PAGESHIFT()-3)
+
+/*
+ * Definitions for fourth level:
+ */
+#define PTRS_PER_PTE	(__IA64_UL(1) << (PTRS_PER_PTD_SHIFT))
+
+/*
+ * Definitions for third level:
+ *
+ * PMD_SHIFT determines the size of the area a third-level page table
+ * can map.
+ */
+#define PMD_SHIFT	(PAGESHIFT() + (PTRS_PER_PTD_SHIFT))
+#define PMD_SIZE	(1UL << PMD_SHIFT)
+#define PMD_MASK	(~(PMD_SIZE-1))
+#define PTRS_PER_PMD	(1UL << (PTRS_PER_PTD_SHIFT))
+
+/*
+ * PUD_SHIFT determines the size of the area a second-level page table
+ * can map
+ */
+#define PUD_SHIFT	(PMD_SHIFT + (PTRS_PER_PTD_SHIFT))
+#define PUD_SIZE	(1UL << PUD_SHIFT)
+#define PUD_MASK	(~(PUD_SIZE-1))
+#define PTRS_PER_PUD	(1UL << (PTRS_PER_PTD_SHIFT))
+
+/*
+ * Definitions for first level:
+ *
+ * PGDIR_SHIFT determines what a first-level page table entry can map.
+ */
+
+#define PGDIR_SHIFT_4L		(PUD_SHIFT + (PTRS_PER_PTD_SHIFT))
+#define PGDIR_SHIFT_3L		(PMD_SHIFT + (PTRS_PER_PTD_SHIFT))
+/* Turns out 4L & 3L PGDIR_SHIFT are the same (for now) */
+#define PGDIR_SHIFT		PGDIR_SHIFT_4L
+#define PGDIR_SIZE		(__IA64_UL(1) << PGDIR_SHIFT)
+#define PGDIR_MASK		(~(PGDIR_SIZE-1))
+#define PTRS_PER_PGD_SHIFT	PTRS_PER_PTD_SHIFT
+#define PTRS_PER_PGD		(1UL << PTRS_PER_PGD_SHIFT)
+#define USER_PTRS_PER_PGD	(5*PTRS_PER_PGD/8)	/* regions 0-4 are user regions */
+#define FIRST_USER_ADDRESS	0
+
+/*
+ * First, define the various bits in a PTE.  Note that the PTE format
+ * matches the VHPT short format, the firt doubleword of the VHPD long
+ * format, and the first doubleword of the TLB insertion format.
+ */
+#define _PAGE_P			(1 <<  0)       /* page present bit */
+#define _PAGE_MA_WB		(0x0 <<  2)	/* write back memory attribute */
+#define _PAGE_MA_UC		(0x4 <<  2)	/* uncacheable memory attribute */
+#define _PAGE_MA_UCE		(0x5 <<  2)	/* UC exported attribute */
+#define _PAGE_MA_WC		(0x6 <<  2)	/* write coalescing memory attribute */
+#define _PAGE_MA_NAT		(0x7 <<  2)	/* not-a-thing attribute */
+#define _PAGE_MA_MASK		(0x7 <<  2)
+#define _PAGE_PL_0		(0 <<  7)	/* privilege level 0 (kernel) */
+#define _PAGE_PL_1		(1 <<  7)	/* privilege level 1 (unused) */
+#define _PAGE_PL_2		(2 <<  7)	/* privilege level 2 (unused) */
+#define _PAGE_PL_3		(3 <<  7)	/* privilege level 3 (user) */
+#define _PAGE_PL_MASK		(3 <<  7)
+#define _PAGE_AR_R		(0 <<  9)	/* read only */
+#define _PAGE_AR_RX		(1 <<  9)	/* read & execute */
+#define _PAGE_AR_RW		(2 <<  9)	/* read & write */
+#define _PAGE_AR_RWX		(3 <<  9)	/* read, write & execute */
+#define _PAGE_AR_R_RW		(4 <<  9)	/* read / read & write */
+#define _PAGE_AR_RX_RWX		(5 <<  9)	/* read & exec / read, write & exec */
+#define _PAGE_AR_RWX_RW		(6 <<  9)	/* read, write & exec / read & write */
+#define _PAGE_AR_X_RX		(7 <<  9)	/* exec & promote / read & exec */
+#define _PAGE_AR_MASK		(7 <<  9)
+#define _PAGE_AR_SHIFT		9
+#define _PAGE_A			(1 <<  5)	/* page accessed bit */
+#define _PAGE_D			(1 <<  6)	/* page dirty bit */
+#define _PAGE_PPN_MASK		(((__IA64_UL(1) << IA64_MAX_PHYS_BITS) - 1) & ~0xfffUL)
+#define _PAGE_ED		(__IA64_UL(1) << 52)	/* exception deferral */
+#define _PAGE_PROTNONE		(__IA64_UL(1) << 63)
+
+#define _PFN_MASK		_PAGE_PPN_MASK
+#define _PAGE_CHG_MASK		(_PFN_MASK | _PAGE_A | _PAGE_D)
+
+#define _PAGE_SIZE_4K	12
+#define _PAGE_SIZE_8K	13
+#define _PAGE_SIZE_16K	14
+#define _PAGE_SIZE_64K	16
+#define _PAGE_SIZE_256K	18
+#define _PAGE_SIZE_1M	20
+#define _PAGE_SIZE_4M	22
+#define _PAGE_SIZE_16M	24
+#define _PAGE_SIZE_64M	26
+#define _PAGE_SIZE_256M	28
+
+#define __ACCESS_BITS		_PAGE_ED | _PAGE_A | _PAGE_P | _PAGE_MA_WB
+#define __DIRTY_BITS_NO_ED	_PAGE_A | _PAGE_P | _PAGE_D | _PAGE_MA_WB
+#define __DIRTY_BITS		_PAGE_ED | __DIRTY_BITS_NO_ED
+
+#define EFI_PAGE_SHIFT  (12)
+
+/*
+ * NOTE: #include'ing <asm/efi.h> creates too many compiler problems, so
+ * this stuff is hardwired here; it's probably etched in stone somewhere.
+ */
+struct efi_memory_desc_t {
+        uint32_t type;
+        uint32_t pad;
+        uint64_t phys_addr;
+        uint64_t virt_addr;
+        uint64_t num_pages;
+        uint64_t attribute;
+} desc;
+
+/* Memory types: */
+#define EFI_RESERVED_TYPE                0
+#define EFI_LOADER_CODE                  1
+#define EFI_LOADER_DATA                  2
+#define EFI_BOOT_SERVICES_CODE           3
+#define EFI_BOOT_SERVICES_DATA           4
+#define EFI_RUNTIME_SERVICES_CODE        5
+#define EFI_RUNTIME_SERVICES_DATA        6
+#define EFI_CONVENTIONAL_MEMORY          7
+#define EFI_UNUSABLE_MEMORY              8
+#define EFI_ACPI_RECLAIM_MEMORY          9
+#define EFI_ACPI_MEMORY_NVS             10
+#define EFI_MEMORY_MAPPED_IO            11
+#define EFI_MEMORY_MAPPED_IO_PORT_SPACE 12
+#define EFI_PAL_CODE                    13
+#define EFI_MAX_MEMORY_TYPE             14
+
+/* Attribute values: */
+#define EFI_MEMORY_UC           0x0000000000000001      /* uncached */
+#define EFI_MEMORY_WC           0x0000000000000002      /* write-coalescing */
+#define EFI_MEMORY_WT           0x0000000000000004      /* write-through */
+#define EFI_MEMORY_WB           0x0000000000000008      /* write-back */
+#define EFI_MEMORY_WP           0x0000000000001000      /* write-protect */
+#define EFI_MEMORY_RP           0x0000000000002000      /* read-protect */
+#define EFI_MEMORY_XP           0x0000000000004000      /* execute-protect */
+#define EFI_MEMORY_RUNTIME      0x8000000000000000      /* range requires runtime mapping */
+
+#define SWP_TYPE(entry)    (((entry) >> 1) & 0xff)
+#define SWP_OFFSET(entry)  ((entry) >> 9)
+#define __swp_type(entry)    ((entry >> 2) & 0x7f)
+#define __swp_offset(entry)  ((entry << 1) >> 10)
+
+#define TIF_SIGPENDING (1)
+
+#define KERNEL_TR_PAGE_SIZE (1 << _PAGE_SIZE_64M)
+#define KERNEL_TR_PAGE_MASK (~(KERNEL_TR_PAGE_SIZE - 1))
+
+#define UNKNOWN_PHYS_START ((ulong)(-1))
+#define DEFAULT_PHYS_START (KERNEL_TR_PAGE_SIZE * 1)
+
+#define IA64_GET_STACK_ULONG(OFF) \
+        ((INSTACK(OFF,bt)) ? (GET_STACK_ULONG(OFF)) : get_init_stack_ulong((unsigned long)OFF))
+
+#endif  /* IA64 */
+
+#ifdef PPC64
+#define _64BIT_
+#define MACHINE_TYPE       "PPC64"
+
+#define PPC64_64K_PAGE_SIZE  65536
+#define PPC64_STACK_SIZE     16384
+
+#define PAGEBASE(X)  (((ulong)(X)) & (ulong)machdep->pagemask)
+
+#define PTOV(X)            ((unsigned long)(X)+(machdep->identity_map_base))
+#define VTOP(X)            ((unsigned long)(X)-(machdep->identity_map_base))
+#define BOOK3E_VMBASE 0x8000000000000000
+#define IS_VMALLOC_ADDR(X) machdep->machspec->is_vmaddr(X)
+#define KERNELBASE      machdep->pageoffset
+
+#define PGDIR_SHIFT     (machdep->pageshift + (machdep->pageshift -3) + (machdep->pageshift - 2))
+#define PMD_SHIFT       (machdep->pageshift + (machdep->pageshift - 3))
+
+#define PGD_MASK        (~((1UL << PGDIR_SHIFT) - 1))
+#define PMD_MASK        (~((1UL << PMD_SHIFT) - 1))
+
+/* shift to put page number into pte */
+#define PTE_SHIFT 16
+#define PMD_TO_PTEPAGE_SHIFT 2  /* Used for 2.6 or later */
+
+#define PTE_INDEX_SIZE  9
+#define PMD_INDEX_SIZE  10
+#define PGD_INDEX_SIZE  10
+
+#define PTRS_PER_PTE    (1 << PTE_INDEX_SIZE)
+#define PTRS_PER_PMD    (1 << PMD_INDEX_SIZE)
+#define PTRS_PER_PGD    (1 << PGD_INDEX_SIZE)
+
+#define PGD_OFFSET_24(vaddr)    ((vaddr >> PGDIR_SHIFT) & (PTRS_PER_PGD - 1))
+#define PGD_OFFSET(vaddr)       ((vaddr >> PGDIR_SHIFT) & 0x7ff)
+#define PMD_OFFSET(vaddr)       ((vaddr >> PMD_SHIFT) & (PTRS_PER_PMD - 1))
+
+/* 4-level page table support */
+
+/* 4K pagesize */
+#define PTE_INDEX_SIZE_L4_4K  9
+#define PMD_INDEX_SIZE_L4_4K  7
+#define PUD_INDEX_SIZE_L4_4K  7
+#define PGD_INDEX_SIZE_L4_4K  9
+#define PTE_SHIFT_L4_4K  17
+#define PMD_MASKED_BITS_4K  0
+
+/* 64K pagesize */
+#define PTE_INDEX_SIZE_L4_64K  12
+#define PMD_INDEX_SIZE_L4_64K  12
+#define PUD_INDEX_SIZE_L4_64K  0
+#define PGD_INDEX_SIZE_L4_64K  4
+#define PTE_INDEX_SIZE_L4_64K_3_10  8
+#define PMD_INDEX_SIZE_L4_64K_3_10  10
+#define PGD_INDEX_SIZE_L4_64K_3_10  12
+#define PTE_SHIFT_L4_64K_V1  32
+#define PTE_SHIFT_L4_64K_V2  30
+#define PTE_SHIFT_L4_BOOK3E_64K 28
+#define PTE_SHIFT_L4_BOOK3E_4K 24
+#define PMD_MASKED_BITS_64K  0x1ff
+
+#define PD_HUGE           0x8000000000000000
+#define HUGE_PTE_MASK     0x03
+#define HUGEPD_SHIFT_MASK 0x3f
+#define L4_MASK           (THIS_KERNEL_VERSION >= LINUX(3,10,0) ? 0xfff : 0x1ff)
+#define L4_OFFSET(vaddr)  ((vaddr >> (machdep->machspec->l4_shift)) & L4_MASK)
+
+#define PGD_OFFSET_L4(vaddr)	\
+	((vaddr >> (machdep->machspec->l3_shift)) & (machdep->machspec->ptrs_per_l3 - 1))
+
+#define PMD_OFFSET_L4(vaddr)	\
+	((vaddr >> (machdep->machspec->l2_shift)) & (machdep->machspec->ptrs_per_l2 - 1))
+
+#define _PAGE_PRESENT   (machdep->machspec->_page_present)      /* software: pte contains a translation */
+#define _PAGE_USER      (machdep->machspec->_page_user)         /* matches one of the PP bits */
+#define _PAGE_RW        (machdep->machspec->_page_rw)           /* software: user write access allowed */
+#define _PAGE_GUARDED   (machdep->machspec->_page_guarded)
+#define _PAGE_COHERENT  (machdep->machspec->_page_coherent      /* M: enforce memory coherence (SMP systems) */)
+#define _PAGE_NO_CACHE  (machdep->machspec->_page_no_cache)     /* I: cache inhibit */
+#define _PAGE_WRITETHRU (machdep->machspec->_page_writethru)    /* W: cache write-through */
+#define _PAGE_DIRTY     (machdep->machspec->_page_dirty)        /* C: page changed */
+#define _PAGE_ACCESSED  (machdep->machspec->_page_accessed)     /* R: page referenced */
+
+#define TIF_SIGPENDING (2)
+
+#define SWP_TYPE(entry) (((entry) >> 1) & 0x7f)
+#define SWP_OFFSET(entry) ((entry) >> 8)
+#define __swp_type(entry)   SWP_TYPE(entry)
+#define __swp_offset(entry) SWP_OFFSET(entry)
+
+#define MSR_PR_LG	14	/* Problem State / Privilege Level */
+				/* Used to find the user or kernel-mode frame*/
+
+#define STACK_FRAME_OVERHEAD            112
+#define EXCP_FRAME_MARKER               0x7265677368657265
+
+#define _SECTION_SIZE_BITS	24
+#define _MAX_PHYSMEM_BITS	44
+#define _MAX_PHYSMEM_BITS_3_7   46
+
+#endif /* PPC64 */
+
+#ifdef S390
+#define _32BIT_
+#define MACHINE_TYPE       "S390"
+
+#define PTOV(X)            ((unsigned long)(X)+(machdep->kvbase))
+#define VTOP(X)            ((unsigned long)(X)-(machdep->kvbase))
+#define IS_VMALLOC_ADDR(X) (vt->vmalloc_start && (ulong)(X) >= vt->vmalloc_start)
+
+#define PTRS_PER_PTE    1024
+#define PTRS_PER_PMD    1
+#define PTRS_PER_PGD    512
+#define SEGMENT_TABLE_SIZE  ((sizeof(ulong)*4) * PTRS_PER_PGD)  
+
+#define SWP_TYPE(entry) (((entry) >> 2) & 0x1f)
+#define SWP_OFFSET(entry) ((((entry) >> 11) & 0xfffffffe) | \
+                           (((entry) >> 7) & 0x1))
+#define __swp_type(entry)   SWP_TYPE(entry)
+#define __swp_offset(entry) SWP_OFFSET(entry)
+
+#define TIF_SIGPENDING (2)
+
+#define _SECTION_SIZE_BITS	25
+#define _MAX_PHYSMEM_BITS	31
+
+#endif  /* S390 */
+
+#ifdef S390X
+#define _64BIT_
+#define MACHINE_TYPE       "S390X"
+
+#define PTOV(X)            ((unsigned long)(X)+(machdep->kvbase))
+#define VTOP(X)            ((unsigned long)(X)-(machdep->kvbase))
+#define IS_VMALLOC_ADDR(X) (vt->vmalloc_start && (ulong)(X) >= vt->vmalloc_start)
+#define PTRS_PER_PTE    512
+#define PTRS_PER_PMD    1024
+#define PTRS_PER_PGD    2048
+#define SEGMENT_TABLE_SIZE    ((sizeof(ulong)*2) * PTRS_PER_PMD)
+
+#define SWP_TYPE(entry)   (((entry) >> 2) & 0x1f)
+#define SWP_OFFSET(entry) ((((entry) >> 11) & 0xfffffffffffffffe) | \
+                           (((entry) >> 7) & 0x1)) 
+#define __swp_type(entry)  SWP_TYPE(entry)
+#define __swp_offset(entry) SWP_OFFSET(entry)
+
+#define TIF_SIGPENDING (2)
+
+#define _SECTION_SIZE_BITS	28
+#define _MAX_PHYSMEM_BITS_OLD	42
+#define _MAX_PHYSMEM_BITS_NEW	46
+
+#endif  /* S390X */
+
+#ifdef PLATFORM
+
+#define SWP_TYPE(entry)   (error("PLATFORM_SWP_TYPE: TBD\n"))
+#define SWP_OFFSET(entry) (error("PLATFORM_SWP_OFFSET: TBD\n"))
+#define __swp_type(entry)   SWP_TYPE(entry)
+#define __swp_offset(entry) SWP_OFFSET(entry)
+
+#endif /* PLATFORM */
+
+#define KILOBYTES(x)  ((x) * (1024))
+#define MEGABYTES(x)  ((x) * (1048576))
+#define GIGABYTES(x)  ((x) * (1073741824))
+
+#define MEGABYTE_MASK (MEGABYTES(1)-1)
+
+#define SIZEOF_64BIT  (8)
+#define SIZEOF_32BIT  (4)
+#define SIZEOF_16BIT  (2)
+#define SIZEOF_8BIT   (1)
+
+#ifdef ARM
+#define MAX_HEXADDR_STRLEN (8)
+#define UVADDR_PRLEN       (8)
+#endif
+#ifdef X86
+#define MAX_HEXADDR_STRLEN (8)             
+#define UVADDR_PRLEN       (8)
+#endif
+#ifdef ALPHA
+#define MAX_HEXADDR_STRLEN (16)