[Crash-utility] [PATCH v2 6/6] crash: add ARM crashdump support

Thursday, 26 August 2010

This patch adds minimal support for reading ARM crashdumps. Currently supported
dumpfiles are /dev/mem, diskdump and vmcore. Stack unwinding can be done using
framepointers or unwinding tables depending on kernel configuration.

Signed-off-by: Jan Karlsson <jan.karlsson(a)sonyericsson.com&gt;
Signed-off-by: Thomas Fänge <thomas.fange(a)sonyericsson.com&gt;
Signed-off-by: Mika Westerberg <ext-mika.1.westerberg(a)nokia.com&gt;
---
 Makefile     |   12 +-
 arm.c        | 1741 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 defs.h       |  137 +++++
 diskdump.c   |    8 +
 unwind_arm.c |  697 +++++++++++++++++++++++
 5 files changed, 2593 insertions(+), 2 deletions(-)
 create mode 100644 arm.c
 create mode 100644 unwind_arm.c

diff --git a/Makefile b/Makefile
index 038c887..f79f6a9 100644
--- a/Makefile
+++ b/Makefile
@@ -80,11 +80,12 @@ UNWIND_HFILES=unwind.h unwind_i.h rse.h unwind_x86.h unwind_x86_64.h
 CFILES=main.c tools.c global_data.c memory.c filesys.c help.c task.c \
 	kernel.c test.c gdb_interface.c configure.c net.c dev.c \
 	alpha.c x86.c ppc.c ia64.c s390.c s390x.c s390dbf.c ppc64.c x86_64.c \
+	arm.c \
 	extensions.c remote.c va_server.c va_server_v1.c symbols.c cmdline.c \
 	lkcd_common.c lkcd_v1.c lkcd_v2_v3.c lkcd_v5.c lkcd_v7.c lkcd_v8.c\
 	lkcd_fix_mem.c s390_dump.c lkcd_x86_trace.c \
 	netdump.c diskdump.c xendump.c unwind.c unwind_decoder.c \
-	unwind_x86_32_64.c \
+	unwind_x86_32_64.c unwind_arm.c \
  	xen_hyper.c xen_hyper_command.c xen_hyper_global_data.c \
 	xen_hyper_dump_tables.c kvmdump.c qemu.c qemu-load.c
 
@@ -96,11 +97,12 @@ SOURCE_FILES=${CFILES} ${GENERIC_HFILES} ${MCORE_HFILES} \
 OBJECT_FILES=main.o tools.o global_data.o memory.o filesys.o help.o task.o \
 	build_data.o kernel.o test.o gdb_interface.o net.o dev.o \
 	alpha.o x86.o ppc.o ia64.o s390.o s390x.o s390dbf.o ppc64.o x86_64.o \
+	arm.o \
 	extensions.o remote.o va_server.o va_server_v1.o symbols.o cmdline.o \
 	lkcd_common.o lkcd_v1.o lkcd_v2_v3.o lkcd_v5.o lkcd_v7.o lkcd_v8.o \
 	lkcd_fix_mem.o s390_dump.o netdump.o diskdump.o xendump.o \
 	lkcd_x86_trace.o unwind_v1.o unwind_v2.o unwind_v3.o \
-	unwind_x86_32_64.o \
+	unwind_x86_32_64.o unwind_arm.o \
  	xen_hyper.o xen_hyper_command.o xen_hyper_global_data.o \
 	xen_hyper_dump_tables.o kvmdump.o qemu.o qemu-load.o
 
@@ -419,6 +421,9 @@ ppc64.o: ${GENERIC_HFILES} ppc64.c
 x86_64.o: ${GENERIC_HFILES} ${REDHAT_HFILES} x86_64.c
 	cc -c ${CRASH_CFLAGS} x86_64.c ${WARNING_OPTIONS} ${WARNING_ERROR}
 
+arm.o: ${GENERIC_HFILES} ${REDHAT_HFILES} arm.c
+	cc -c ${CRASH_CFLAGS} arm.c ${WARNING_OPTIONS} ${WARNING_ERROR}
+
 s390.o: ${GENERIC_HFILES} ${IBM_HFILES} s390.c
 	cc -c ${CRASH_CFLAGS} s390.c ${WARNING_OPTIONS} ${WARNING_ERROR}
 
@@ -460,6 +465,9 @@ lkcd_x86_trace.o: ${GENERIC_HFILES} ${LKCD_TRACE_HFILES}
lkcd_x86_trace.c
 unwind_x86_32_64.o: ${GENERIC_HFILES} ${UNWIND_HFILES} unwind_x86_32_64.c
 	cc -c ${CRASH_CFLAGS} unwind_x86_32_64.c -o unwind_x86_32_64.o ${WARNING_OPTIONS}
${WARNING_ERROR}
 
+unwind_arm.o: ${GENERIC_HFILES} ${UNWIND_HFILES} unwind_arm.c
+	cc -c ${CRASH_CFLAGS} unwind_arm.c -o unwind_arm.o ${WARNING_OPTIONS} ${WARNING_ERROR}
+
 unwind_v1.o: ${GENERIC_HFILES} ${UNWIND_HFILES} unwind.c unwind_decoder.c
 	cc -c ${CRASH_CFLAGS} unwind.c -DREDHAT -DUNWIND_V1 -o unwind_v1.o ${WARNING_OPTIONS}
${WARNING_ERROR}
 
diff --git a/arm.c b/arm.c
new file mode 100644
index 0000000..f6d1b27
--- /dev/null
+++ b/arm.c
@@ -0,0 +1,1741 @@
+/*
+ * arm.c - core analysis suite
+ *
+ * Authors:
+ *   Thomas Fänge <thomas.fange(a)sonyericsson.com&gt;
+ *   Jan Karlsson <jan.karlsson(a)sonyericsson.com&gt;
+ *   Mika Westerberg <ext-mika.1.westerberg(a)nokia.com&gt;
+ *
+ * Copyright (C) 2010 Nokia Corporation
+ * Copyright (C) 2010 Sony Ericsson. 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 ARM
+#include <elf.h>
+
+#include "defs.h"
+
+static void arm_parse_cmdline_args(void);
+static int arm_get_crash_notes(void);
+static int arm_verify_symbol(const char *, ulong, char);
+static int arm_is_module_addr(ulong);
+static int arm_is_kvaddr(ulong);
+static int arm_in_exception_text(ulong);
+static void arm_back_trace(struct bt_info *);
+static void arm_back_trace_cmd(struct bt_info *);
+static ulong arm_processor_speed(void);
+static int arm_translate_pte(ulong, void *, ulonglong);
+static int arm_vtop(ulong, ulong *, physaddr_t *, int);
+static int arm_kvtop(struct task_context *, ulong, physaddr_t *, int);
+static int arm_uvtop(struct task_context *, ulong, physaddr_t *, int);
+static int arm_get_frame(struct bt_info *, ulong *, ulong *);
+static int arm_get_dumpfile_stack_frame(struct bt_info *, ulong *, ulong *);
+static void arm_get_stack_frame(struct bt_info *, ulong *, ulong *);
+static void arm_dump_exception_stack(ulong, ulong);
+static void arm_display_full_frame(struct bt_info *, ulong);
+static ulong arm_vmalloc_start(void);
+static int arm_is_task_addr(ulong);
+static int arm_dis_filter(ulong, char *);
+static int arm_eframe_search(struct bt_info *);
+static ulong arm_get_task_pgd(ulong);
+static void arm_cmd_mach(void);
+static void arm_display_machine_stats(void);
+static int arm_get_smp_cpus(void);
+static void print_irq_member(char *, ulong, char *);
+static void arm_dump_irq(int);
+static void arm_init_machspec(void);
+
+static struct line_number_hook arm_line_number_hooks[];
+static struct machine_specific arm_machine_specific;
+
+/**
+ * struct arm_cpu_context_save - idle task registers
+ *
+ * This structure holds idle task registers. Only FP, SP, and PC are needed for
+ * unwinding the stack.
+ */
+struct arm_cpu_context_save {
+	ulong	fp;
+	ulong	sp;
+	ulong	pc;
+};
+
+/*
+ * Holds registers during the crash.
+ */
+static struct arm_pt_regs panic_task_regs;
+
+#define PGDIR_SIZE() (4 * PAGESIZE())
+#define PGDIR_OFFSET(X) (((ulong)(X)) & (PGDIR_SIZE() - 1))
+
+#define _SECTION_PAGE_MASK	(~((MEGABYTES(1))-1))
+
+#define PMD_TYPE_MASK   3
+#define PMD_TYPE_SECT   2
+#define PMD_TYPE_TABLE  1
+
+static inline ulong *
+pmd_page_addr(ulong pmd)
+{
+	ulong ptr;
+
+	ptr = pmd & ~(PTRS_PER_PTE * sizeof(void *) - 1);
+	ptr += PTRS_PER_PTE * sizeof(void *);
+
+	return (ulong *)ptr;
+}
+
+/*
+ * "Linux" PTE definitions.
+ */
+#define L_PTE_PRESENT		(1 << 0)
+#define L_PTE_YOUNG		(1 << 1)
+#define L_PTE_FILE		(1 << 2)
+#define L_PTE_DIRTY		(1 << 6)
+#define L_PTE_WRITE		(1 << 7)
+#define L_PTE_USER		(1 << 8)
+#define L_PTE_EXEC		(1 << 9)
+#define L_PTE_SHARED		(1 << 10)
+
+#define pte_val(pte)		(pte)
+
+#define pte_present(pte)	(pte_val(pte) & L_PTE_PRESENT)
+#define pte_write(pte)		(pte_val(pte) & L_PTE_WRITE)
+#define pte_dirty(pte)		(pte_val(pte) & L_PTE_DIRTY)
+#define pte_young(pte)		(pte_val(pte) & L_PTE_YOUNG)
+
+/*
+ * Following stuff is taken directly from the kernel sources. These are used in
+ * dump_exception_stack() to format an exception stack entry.
+ */
+#define USR26_MODE	0x00000000
+#define FIQ26_MODE	0x00000001
+#define IRQ26_MODE	0x00000002
+#define SVC26_MODE	0x00000003
+#define USR_MODE	0x00000010
+#define FIQ_MODE	0x00000011
+#define IRQ_MODE	0x00000012
+#define SVC_MODE	0x00000013
+#define ABT_MODE	0x00000017
+#define UND_MODE	0x0000001b
+#define SYSTEM_MODE	0x0000001f
+#define MODE32_BIT	0x00000010
+#define MODE_MASK	0x0000001f
+#define PSR_T_BIT	0x00000020
+#define PSR_F_BIT	0x00000040
+#define PSR_I_BIT	0x00000080
+#define PSR_A_BIT	0x00000100
+#define PSR_E_BIT	0x00000200
+#define PSR_J_BIT	0x01000000
+#define PSR_Q_BIT	0x08000000
+#define PSR_V_BIT	0x10000000
+#define PSR_C_BIT	0x20000000
+#define PSR_Z_BIT	0x40000000
+#define PSR_N_BIT	0x80000000
+
+#define isa_mode(regs) \
+	((((regs)->ARM_cpsr & PSR_J_BIT) >> 23) | \
+	 (((regs)->ARM_cpsr & PSR_T_BIT) >> 5))
+
+#define processor_mode(regs) \
+	((regs)->ARM_cpsr & MODE_MASK)
+
+#define interrupts_enabled(regs) \
+	(!((regs)->ARM_cpsr & PSR_I_BIT))
+
+#define fast_interrupts_enabled(regs) \
+	(!((regs)->ARM_cpsr & PSR_F_BIT))
+
+static const char *processor_modes[] = {
+	"USER_26", "FIQ_26", "IRQ_26", "SVC_26",
"UK4_26", "UK5_26",
+	"UK6_26", "UK7_26" , "UK8_26", "UK9_26",
"UK10_26", "UK11_26",
+	"UK12_26", "UK13_26", "UK14_26", "UK15_26",
"USER_32", "FIQ_32",
+	"IRQ_32", "SVC_32", "UK4_32", "UK5_32",
"UK6_32", "ABT_32",
+	"UK8_32", "UK9_32", "UK10_32", "UND_32",
"UK12_32", "UK13_32",
+	"UK14_32", "SYS_32",
+};
+
+static const char *isa_modes[] = {
+	"ARM" , "Thumb" , "Jazelle", "ThumbEE",
+};
+
+#define NOT_IMPLEMENTED() \
+	error(FATAL, "%s: N/A\n", __func__)
+
+/*
+ * Do all necessary machine-specific setup here. This is called several times
+ * during initialization.
+ */
+void
+arm_init(int when)
+{
+	switch (when) {
+	case PRE_SYMTAB:
+		machdep->verify_symbol = arm_verify_symbol;
+		machdep->machspec = &arm_machine_specific;
+		if (pc->flags & KERNEL_DEBUG_QUERY)
+			return;
+		machdep->pagesize = memory_page_size();
+		machdep->pageshift = ffs(machdep->pagesize) - 1;
+		machdep->pageoffset = machdep->pagesize - 1;
+		machdep->pagemask = ~((ulonglong)machdep->pageoffset);
+		machdep->stacksize = machdep->pagesize * 2;
+		machdep->last_pgd_read = 0;
+		machdep->last_pmd_read = 0;
+		machdep->last_ptbl_read = 0;
+		machdep->verify_paddr = generic_verify_paddr;
+		machdep->ptrs_per_pgd = PTRS_PER_PGD;
+
+		if (machdep->cmdline_args[0])
+			arm_parse_cmdline_args();
+		break;
+
+	case PRE_GDB:
+		if ((machdep->pgd = (char *)malloc(PGDIR_SIZE())) == NULL)
+			error(FATAL, "cannot malloc pgd space.");
+		if ((machdep->ptbl = (char *)malloc(PAGESIZE())) == NULL)
+			error(FATAL, "cannot malloc ptbl space.");
+
+		/*
+		 * Kernel text starts 16k after PAGE_OFFSET.
+		 */
+	        machdep->kvbase = symbol_value("_stext") & 0xffff0000UL;
+		machdep->identity_map_base = machdep->kvbase;
+		machdep->is_kvaddr = arm_is_kvaddr;
+		machdep->is_uvaddr = generic_is_uvaddr;
+		machdep->eframe_search = arm_eframe_search;
+		machdep->back_trace = arm_back_trace_cmd;
+		machdep->processor_speed = arm_processor_speed;
+		machdep->uvtop = arm_uvtop;
+		machdep->kvtop = arm_kvtop;
+		machdep->get_task_pgd = arm_get_task_pgd;
+		machdep->get_stack_frame = arm_get_stack_frame;
+		machdep->get_stackbase = generic_get_stackbase;
+		machdep->get_stacktop = generic_get_stacktop;
+		machdep->translate_pte = arm_translate_pte;
+		machdep->memory_size = generic_memory_size;
+		machdep->vmalloc_start = arm_vmalloc_start;
+		machdep->is_task_addr = arm_is_task_addr;
+		machdep->dis_filter = arm_dis_filter;
+		machdep->cmd_mach = arm_cmd_mach;
+		machdep->get_smp_cpus = arm_get_smp_cpus;
+		machdep->line_number_hooks = arm_line_number_hooks;
+		machdep->value_to_symbol = generic_machdep_value_to_symbol;
+		machdep->init_kernel_pgd = NULL;
+
+		if (symbol_exists("irq_desc"))
+			machdep->dump_irq = arm_dump_irq;
+
+		arm_init_machspec();
+		break;
+
+	case POST_GDB:
+		if (symbol_exists("irq_desc")) {
+			ARRAY_LENGTH_INIT(machdep->nr_irqs, irq_desc,
+					  "irq_desc", NULL, 0);
+			if (MEMBER_EXISTS("irq_desc", "name"))
+				MEMBER_OFFSET_INIT(irq_desc_t_name, "irq_desc",
+						   "name");
+		}
+
+		/*
+		 * Registers for idle threads are saved in
+		 * thread_info.cpu_context.
+		 */
+		STRUCT_SIZE_INIT(cpu_context_save, "cpu_context_save");
+		MEMBER_OFFSET_INIT(cpu_context_save_fp,
+			"cpu_context_save", "fp");
+		MEMBER_OFFSET_INIT(cpu_context_save_sp,
+			"cpu_context_save", "sp");
+		MEMBER_OFFSET_INIT(cpu_context_save_pc,
+			"cpu_context_save", "pc");
+		MEMBER_OFFSET_INIT(thread_info_cpu_context,
+			"thread_info", "cpu_context");
+
+		/*
+		 * We need to have information about note_buf_t which is used to
+		 * hold ELF note containing registers and status of the thread
+		 * that panic'd.
+		 */
+		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");
+
+		/*
+		 * 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() && !arm_get_crash_notes())
+			error(WARNING, "Couldn't retrieve crash_notes\n");
+		break;
+
+	case POST_VM:
+		machdep->machspec->vmalloc_start_addr = vt->high_memory;
+		/*
+		 * Modules are placed in first vmalloc'd area. This is 16MB
+		 * below PAGE_OFFSET.
+		 */
+		machdep->machspec->modules_vaddr = first_vmalloc_address();
+		machdep->machspec->modules_end = machdep->kvbase - 1;
+
+		if (init_unwind_tables()) {
+			if (CRASHDEBUG(1))
+				fprintf(fp, "using unwind tables\n");
+		} else {
+			if (CRASHDEBUG(1))
+				fprintf(fp, "using framepointers\n");
+		}
+		break;
+	}
+}
+
+void
+arm_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_BASE)
+		fprintf(fp, "%sPHYS_BASE", 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",
+		machdep->memsize, machdep->memsize);
+	fprintf(fp, "               bits: %d\n", machdep->bits);
+	fprintf(fp, "            nr_irqs: %d\n", machdep->nr_irqs);
+	fprintf(fp, "      eframe_search: arm_eframe_search()\n");
+	fprintf(fp, "         back_trace: arm_back_trace_cmd()\n");
+	fprintf(fp, "    processor_speed: arm_processor_speed()\n");
+	fprintf(fp, "              uvtop: arm_uvtop()\n");
+	fprintf(fp, "              kvtop: arm_kvtop()\n");
+	fprintf(fp, "       get_task_pgd: arm_get_task_pgd()\n");
+	if (symbol_exists("irq_desc"))
+		fprintf(fp, "           dump_irq: arm_dump_irq()\n");
+	else
+		fprintf(fp, "           dump_irq: NULL\n");
+	fprintf(fp, "    get_stack_frame: arm_get_stack_frame()\n");
+	fprintf(fp, "      get_stackbase: generic_get_stackbase()\n");
+	fprintf(fp, "       get_stacktop: generic_get_stacktop()\n");
+	fprintf(fp, "      translate_pte: arm_translate_pte()\n");
+	fprintf(fp, "        memory_size: generic_memory_size()\n");
+	fprintf(fp, "      vmalloc_start: arm_vmalloc_start()\n");
+	fprintf(fp, "       is_task_addr: arm_is_task_addr()\n");
+	fprintf(fp, "      verify_symbol: arm_verify_symbol()\n");
+	fprintf(fp, "         dis_filter: arm_dis_filter()\n");
+	fprintf(fp, "           cmd_mach: arm_cmd_mach()\n");
+	fprintf(fp, "       get_smp_cpus: arm_get_smp_cpus()\n");
+	fprintf(fp, "          is_kvaddr: generic_is_kvaddr()\n");
+	fprintf(fp, "          is_uvaddr: generic_is_uvaddr()\n");
+	fprintf(fp, "       verify_paddr: generic_verify_paddr()\n");
+	fprintf(fp, " xendump_p2m_create: NULL\n");
+	fprintf(fp, "xen_kdump_p2m_create: NULL\n");
+	fprintf(fp, "  line_number_hooks: arm_line_number_hooks\n");
+	fprintf(fp, "      last_pgd_read: %lx\n", machdep->last_pgd_read);
+	fprintf(fp, "      last_pmd_read: %lx\n", machdep->last_pmd_read);
+	fprintf(fp, "     last_ptbl_read: %lx\n", machdep->last_ptbl_read);
+	fprintf(fp, "clear_machdep_cache: NULL\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, "          phys_base: %lx\n", ms->phys_base);
+	fprintf(fp, " vmalloc_start_addr: %lx\n", ms->vmalloc_start_addr);
+	fprintf(fp, "      modules_vaddr: %lx\n", ms->modules_vaddr);
+	fprintf(fp, "        modules_end: %lx\n", ms->modules_end);
+	fprintf(fp, "  kernel_text_start: %lx\n", ms->kernel_text_start);
+	fprintf(fp, "    kernel_text_end: %lx\n", ms->kernel_text_end);
+	fprintf(fp, "exception_text_start: %lx\n", ms->exception_text_start);
+	fprintf(fp, " exception_text_end: %lx\n", ms->exception_text_end);
+	fprintf(fp, "     crash_task_pid: %ld\n", ms->crash_task_pid);
+	fprintf(fp, "    crash_task_regs: %lx\n", (ulong)ms->crash_task_regs);
+}
+
+/*
+ * Parse machine dependent command line arguments.
+ *
+ * Force the phys_base address via:
+ *
+ *  --machdep phys_base=<address>
+ */
+static void
+arm_parse_cmdline_args(void)
+{
+	int index, i, c, err;
+	char *arglist[MAXARGS];
+	char buf[BUFSIZE];
+	char *p;
+	ulong value;
+
+	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_base=")) {
+				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_base=");
+				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_base = value;
+
+					error(NOTE,
+						"setting phys_base to: 0x%lx\n",
+						machdep->machspec->phys_base);
+
+					machdep->flags |= PHYS_BASE;
+					continue;
+				}
+			}
+
+			error(WARNING, "ignoring --machdep option: %s\n",
+				arglist[i]);
+		}
+	}
+}
+
+/*
+ * Retrieve task registers for the time of the crash.
+ */
+static int
+arm_get_crash_notes(void)
+{
+	struct machine_specific *ms = machdep->machspec;
+	ulong crash_notes;
+	Elf32_Nhdr *note;
+	ulong ptr, offset;
+	char *buf, *p;
+
+	if (!symbol_exists("crash_notes"))
+		return FALSE;
+
+	crash_notes = symbol_value("crash_notes");
+
+	if (kt->cpus > 1)
+		error(WARNING, "only one CPU is currently supported\n");
+
+	/*
+	 * Read crash_notes for the first CPU. crash_notes are in standard ELF
+	 * note format.
+	 */
+	if (!readmem(crash_notes, KVADDR, &ptr, sizeof(ptr), "crash_notes",
+		     RETURN_ON_ERROR)) {
+		error(WARNING, "cannot read crash_notes\n");
+		return FALSE;
+	}
+
+	buf = GETBUF(SIZE(note_buf));
+
+	if (!readmem(ptr, 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 = (Elf32_Nhdr *)buf;
+	p = buf + sizeof(Elf32_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(Elf32_Nhdr);
+	offset = roundup(offset + note->n_namesz, 4);
+	p = buf + offset; /* start of elf_prstatus */
+
+	BCOPY(p + OFFSET(elf_prstatus_pr_reg), &panic_task_regs,
+	      sizeof(panic_task_regs));
+
+	/*
+	 * And finally we have pid and registers for the crashed task. This is
+	 * used later on when dumping backtrace.
+	 */
+	ms->crash_task_pid = *(ulong *)(p + OFFSET(elf_prstatus_pr_pid));
+	ms->crash_task_regs = &panic_task_regs;
+
+	FREEBUF(buf);
+	return TRUE;
+
+fail:
+	FREEBUF(buf);
+	return FALSE;
+}
+
+/*
+ * Accept or reject a symbol from the kernel namelist.
+ */
+static int
+arm_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 (CRASHDEBUG(8) && name && strlen(name))
+		fprintf(fp, "%08lx %s\n", value, name);
+
+	return TRUE;
+}
+
+static int
+arm_is_module_addr(ulong vaddr)
+{
+	ulong modules_start;
+	ulong modules_end = machdep->kvbase - 1;
+
+	if (!MODULES_VADDR) {
+		/*
+		 * In case we are still initializing, and vm_init() has not been
+		 * called, we use defaults here which is 16MB below kernel start
+		 * address.
+		 */
+		modules_start = machdep->kvbase - 16 * 1024 * 1024;
+	} else {
+		modules_start = MODULES_VADDR;
+	}
+
+	return (vaddr >= modules_start && vaddr <= modules_end);
+}
+
+int
+arm_is_vmalloc_addr(ulong vaddr)
+{
+	if (arm_is_module_addr(vaddr))
+		return TRUE;
+
+	if (!VMALLOC_START)
+		return FALSE;
+
+	return (vaddr >= VMALLOC_START);
+}
+
+/*
+ * Check whether given address falls inside kernel address space (including
+ * modules).
+ */
+static int
+arm_is_kvaddr(ulong vaddr)
+{
+	if (arm_is_module_addr(vaddr))
+		return TRUE;
+
+	return (vaddr >= machdep->kvbase);
+}
+
+/*
+ * Returns TRUE if given pc is in exception area.
+ */
+static int
+arm_in_exception_text(ulong pc)
+{
+	ulong exception_start = machdep->machspec->exception_text_start;
+	ulong exception_end = machdep->machspec->exception_text_end;
+
+	if (exception_start && exception_end)
+		return (pc >= exception_start && pc < exception_end);
+
+	return FALSE;
+}
+
+/*
+ *  Unroll the kernel stack using a minimal amount of gdb services.
+ */
+static void
+arm_back_trace(struct bt_info *bt)
+{
+	int n = 0;
+
+	/*
+	 * In case bt->machdep contains pointer to a full register set, we take
+	 * FP from there.
+	 */
+	if (bt->machdep) {
+		const struct arm_pt_regs *regs = bt->machdep;
+		bt->frameptr = regs->ARM_fp;
+	}
+
+	/*
+	 * Stack frame layout:
+	 *             optionally saved caller registers (r4 - r10)
+	 *             saved fp
+	 *             saved sp
+	 *             saved lr
+	 *    frame => saved pc
+	 *             optionally saved arguments (r0 - r3)
+	 * saved sp => <next word>
+	 *
+	 * Functions start with the following code sequence:
+	 *                  mov   ip, sp
+	 *                  stmfd sp!, {r0 - r3} (optional)
+	 * corrected pc =>  stmfd sp!, {..., fp, ip, lr, pc}
+	 */
+	while (bt->frameptr && INSTACK(bt->frameptr, bt)) {
+		ulong from;
+		ulong sp;
+
+		/*
+		 * We correct the PC to point to the actual instruction (current
+		 * value is PC + 8).
+		 */
+		bt->instptr = GET_STACK_ULONG(bt->frameptr - 0);
+		bt->instptr -= 8;
+
+		/*
+		 * Now get LR, saved SP and FP from the frame as well.
+		 */
+		from = GET_STACK_ULONG(bt->frameptr - 4);
+		sp = GET_STACK_ULONG(bt->frameptr - 8);
+		bt->frameptr = GET_STACK_ULONG(bt->frameptr - 12);
+
+		arm_dump_backtrace_entry(bt, n++, from, sp);
+
+		bt->stkptr = sp;
+	}
+}
+
+/*
+ * Unroll a kernel stack.
+ */
+static void
+arm_back_trace_cmd(struct bt_info *bt)
+{
+	if (kt->flags & DWARF_UNWIND)
+		unwind_backtrace(bt);
+	else
+		arm_back_trace(bt);
+}
+
+/*
+ * Calculate and return the speed of the processor.
+ */
+static ulong
+arm_processor_speed(void)
+{
+	/*
+	 * For now, we don't support reading CPU speed.
+	 */
+	return 0;
+}
+
+/*
+ * Translate a PTE, returning TRUE if the page is present. If a physaddr pointer
+ * is passed in, don't print anything.
+ */
+static int
+arm_translate_pte(ulong pte, void *physaddr, ulonglong pae_pte)
+{
+	char ptebuf[BUFSIZE];
+	char physbuf[BUFSIZE];
+	char buf[BUFSIZE];
+	int page_present;
+	ulong paddr;
+	int len1, len2, others;
+
+	page_present = pte_present(pte);
+	paddr = PAGEBASE(pte);
+
+	if (physaddr) {
+		*((ulong *)physaddr) = paddr;
+		return page_present;
+	}
+
+	sprintf(ptebuf, "%lx", pte);
+	len1 = MAX(strlen(ptebuf), strlen("PTE"));
+	fprintf(fp, "%s  ", mkstring(buf, len1, CENTER | LJUST, "PTE"));
+
+	if (!page_present && pte) {
+		/* swap page, not handled yet */
+		return page_present;
+	}
+
+	sprintf(physbuf, "%lx", paddr);
+	len2 = MAX(strlen(physbuf), strlen("PHYSICAL"));
+	fprintf(fp, "%s  ", mkstring(buf, 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_present(pte))
+			fprintf(fp, "%sPRESENT", others++ ? "|" : "");
+		if (pte_write(pte))
+			fprintf(fp, "%sWRITE", others++ ? "|" : "");
+		if (pte_dirty(pte))
+			fprintf(fp, "%sDIRTY", others++ ? "|" : "");
+		if (pte_young(pte))
+			fprintf(fp, "%sYOUNG", others++ ? "|" : "");
+	} else {
+		fprintf(fp, "no mapping");
+	}
+
+	fprintf(fp, ")\n");
+
+	return 0;
+}
+
+/*
+ * Virtual to physical memory translation. This function will be called by both
+ * arm_kvtop() and arm_uvtop().
+ */
+static int
+arm_vtop(ulong vaddr, ulong *pgd, physaddr_t *paddr, int verbose)
+{
+	char buf[BUFSIZE];
+	ulong *page_dir;
+	ulong *page_middle;
+	ulong *page_table;
+	ulong pgd_pte;
+	ulong pmd_pte;
+	ulong pte;
+
+	/*
+	 * Page tables in ARM Linux
+	 *
+	 * In hardware PGD is 16k (having 4096 pointers to PTE) and PTE is 1k
+	 * (containing 256 translations).
+	 *
+	 * Linux, however, wants to have PTEs as page sized entities. This means
+	 * that in ARM Linux we have following setup (see also
+	 * arch/arm/include/asm/pgtable.h)
+	 *
+	 *     PGD                   PTE
+	 * +---------+
+	 * |         | 0  ---->  +------------+
+	 * +- - - - -+           | h/w pt 0   |
+	 * |         | 4  ---->  +------------+ +1024
+	 * +- - - - -+           | h/w pt 1   |
+	 * .         .           +------------+ +2048
+	 * .         .           | Linux pt 0 |
+	 * .         .           +------------+ +3072
+	 * |         | 4095      | Linux pt 1 |
+	 * +---------+           +------------+ +4096
+	 *
+	 * So in Linux implementation we have two hardware pointers to second
+	 * level page tables. After these come "Linux" versions of the page
+	 * tables.
+	 *
+	 * Linux PT entries contain bits that are not supported on hardware, for
+	 * example "young" and "dirty" flags.
+	 *
+	 * Our translation scheme only uses Linux PTEs here. Hardware entries
+	 * are 1024 bytes below Linux versions.
+	 */
+
+	if (verbose)
+		fprintf(fp, "PAGE DIRECTORY: %lx\n", (ulong)pgd);
+
+	/*
+	 * pgd_offset(pgd, vaddr)
+	 */
+	page_dir = pgd + PGD_OFFSET(vaddr) * 2;
+
+	FILL_PGD(PAGEBASE(pgd), KVADDR, PGDIR_SIZE());
+	pgd_pte = ULONG(machdep->pgd + PGDIR_OFFSET(page_dir));
+
+	if (verbose)
+		fprintf(fp, "  PGD: %s => %lx\n",
+			mkstring(buf, VADDR_PRLEN, RJUST | LONG_HEX,
+			MKSTR((ulong)page_dir)), pgd_pte);
+
+	if (!pgd_pte)
+		return FALSE;
+
+	/*
+	 * pmd_offset(pgd, vaddr)
+	 *
+	 * Here PMD is folded into a PGD.
+	 */
+	pmd_pte = pgd_pte;
+	page_middle = page_dir;
+
+	if (verbose)
+		fprintf(fp, "  PMD: %s => %lx\n",
+			mkstring(buf, VADDR_PRLEN, RJUST | LONG_HEX,
+			MKSTR((ulong)page_middle)), pmd_pte);
+
+	if ((pmd_pte & PMD_TYPE_MASK) == PMD_TYPE_SECT) {
+		if (verbose) {
+			fprintf(fp, " PAGE: %s  (1MB)\n\n",
+				mkstring(buf, VADDR_PRLEN, RJUST | LONG_HEX,
+				MKSTR(PAGEBASE(pmd_pte))));
+		}
+		*paddr = PAGEBASE(pmd_pte) + (vaddr & ~_SECTION_PAGE_MASK);
+		return TRUE;
+	}
+
+	/*
+	 * pte_offset_map(pmd, vaddr)
+	 */
+	page_table = (ulong *)PTOV(pmd_page_addr(pmd_pte)) + PTE_OFFSET(vaddr);
+
+	FILL_PTBL(PAGEBASE(page_table), KVADDR, PAGESIZE());
+	pte = ULONG(machdep->ptbl + PAGEOFFSET(page_table));
+
+	if (verbose) {
+		fprintf(fp, "  PTE: %s => %lx\n\n",
+			mkstring(buf, VADDR_PRLEN, RJUST | LONG_HEX,
+			MKSTR((ulong)page_table)), pte);
+	}
+
+	if (!pte_present(pte)) {
+		if (pte && verbose) {
+			fprintf(fp, "\n");
+			arm_translate_pte(pte, 0, 0);
+		}
+		return FALSE;
+	}
+
+	*paddr = PAGEBASE(pte) + PAGEOFFSET(vaddr);
+
+	if (verbose) {
+		fprintf(fp, " PAGE: %s\n\n",
+			mkstring(buf, VADDR_PRLEN, RJUST | LONG_HEX,
+			MKSTR(PAGEBASE(pte))));
+		arm_translate_pte(pte, 0, 0);
+	}
+
+	return TRUE;
+}
+
+/*
+ * Translates a user virtual address to its physical address. cmd_vtop() sets
+ * the verbose flag so that the pte translation gets displayed; all other
+ * callers quietly accept the translation.
+ */
+static int
+arm_uvtop(struct task_context *tc, ulong uvaddr, physaddr_t *paddr, int verbose)
+{
+	ulong *pgd;
+	ulong mm;
+
+	if (!tc)
+		error(FATAL, "current context invalid\n");
+
+	*paddr = 0;
+
+	if (IS_KVADDR(uvaddr))
+		return arm_kvtop(tc, uvaddr, paddr, verbose);
+
+	mm = task_mm(tc->task, TRUE);
+	if (mm)
+		pgd = ULONG_PTR(tt->mm_struct + OFFSET(mm_struct_pgd));
+	else
+		readmem(tc->mm_struct + OFFSET(mm_struct_pgd), KVADDR, &pgd,
+			sizeof(long), "mm_struct pgd", FAULT_ON_ERROR);
+
+	return arm_vtop(uvaddr, pgd, paddr, verbose);
+}
+
+/*
+ * Translates a kernel virtual address to its physical address. cmd_vtop() sets
+ * the verbose flag so that the pte translation gets displayed; all other
+ * callers quietly accept the translation.
+ */
+static int
+arm_kvtop(struct task_context *tc, ulong kvaddr, physaddr_t *paddr, int verbose)
+{
+	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;
+	}
+
+	return arm_vtop(kvaddr, (ulong *)vt->kernel_pgd[0], paddr, verbose);
+}
+
+/*
+ * Get SP and PC values for idle tasks.
+ */
+static int
+arm_get_frame(struct bt_info *bt, ulong *pcp, ulong *spp)
+{
+	const char *cpu_context;
+
+	if (!bt->tc || !(tt->flags & THREAD_INFO))
+		return FALSE;
+
+	/*
+	 * Update thread_info in tt.
+	 */
+	if (!fill_thread_info(bt->tc->thread_info))
+		return FALSE;
+
+	cpu_context = tt->thread_info + OFFSET(thread_info_cpu_context);
+
+#define GET_REG(ptr, cp, off) ((*ptr) = (*((ulong *)((cp) + OFFSET(off)))))
+	/*
+	 * Unwinding code needs FP value also so we pass it with bt.
+	 */
+	GET_REG(&bt->frameptr, cpu_context, cpu_context_save_fp);
+	GET_REG(spp, cpu_context, cpu_context_save_sp);
+	GET_REG(pcp, cpu_context, cpu_context_save_pc);
+
+	return TRUE;
+}
+
+/*
+ * Get the starting point for the active cpu in a diskdump.
+ *
+ * Note that we currently support only UP machines. In future we might want to
+ * support SMP machines as well.
+ */
+static int
+arm_get_dumpfile_stack_frame(struct bt_info *bt, ulong *nip, ulong *ksp)
+{
+	const struct machine_specific *ms = machdep->machspec;
+
+	if (!ms->crash_task_regs)
+		return FALSE;
+
+	if (tt->panic_task != bt->task || bt->tc->pid != ms->crash_task_pid)
+		return FALSE;
+
+	/*
+	 * We got registers for panic task from crash_notes. Just return them.
+	 */
+	*nip = ms->crash_task_regs->ARM_pc;
+	*ksp = ms->crash_task_regs->ARM_sp;
+
+	/*
+	 * Also store pointer to all registers in case unwinding code needs
+	 * to access LR.
+	 */
+	bt->machdep = ms->crash_task_regs;
+
+	return TRUE;
+}
+
+/*
+ * Get a stack frame combination of PC and SP from the most relevant spot.
+ */
+static void
+arm_get_stack_frame(struct bt_info *bt, ulong *pcp, ulong *spp)
+{
+	ulong ip, sp;
+	int ret;
+
+	ip = sp = 0;
+	bt->machdep = NULL;
+
+	if (DUMPFILE() && is_task_active(bt->task))
+		ret = arm_get_dumpfile_stack_frame(bt, &ip, &sp);
+	else
+		ret = arm_get_frame(bt, &ip, &sp);
+
+	if (!ret) {
+		error(WARNING, "cannot get stackframe for task\n");
+		return;
+	}
+
+	if (pcp)
+		*pcp = ip;
+	if (spp)
+		*spp = sp;
+}
+
+/*
+ * Prints out exception stack starting from start.
+ */
+void
+arm_dump_exception_stack(ulong start, ulong end)
+{
+	struct arm_pt_regs regs;
+	ulong flags;
+	char buf[64];
+
+	if (!readmem(start, KVADDR, &regs, sizeof(regs),
+		     "exception regs", RETURN_ON_ERROR)) {
+		error(WARNING, "failed to read exception registers\n");
+		return;
+	}
+
+	fprintf(fp, "    pc : [<%08lx>]    lr : [<%08lx>]    psr:
%08lx\n"
+		"    sp : %08lx  ip : %08lx  fp : %08lx\n",
+		regs.ARM_pc, regs.ARM_lr, regs.ARM_cpsr,
+		regs.ARM_sp, regs.ARM_ip, regs.ARM_fp);
+	fprintf(fp, "    r10: %08lx  r9 : %08lx  r8 : %08lx\n",
+		regs.ARM_r10, regs.ARM_r9, regs.ARM_r8);
+	fprintf(fp, "    r7 : %08lx  r6 : %08lx  r5 : %08lx  r4 : %08lx\n",
+		regs.ARM_r7, regs.ARM_r6,
+		regs.ARM_r5, regs.ARM_r4);
+	fprintf(fp, "    r3 : %08lx  r2 : %08lx  r1 : %08lx  r0 : %08lx\n",
+		regs.ARM_r3, regs.ARM_r2,
+		regs.ARM_r1, regs.ARM_r0);
+
+	flags = regs.ARM_cpsr;
+	buf[0] = flags & PSR_N_BIT ? 'N' : 'n';
+	buf[1] = flags & PSR_Z_BIT ? 'Z' : 'z';
+	buf[2] = flags & PSR_C_BIT ? 'C' : 'c';
+	buf[3] = flags & PSR_V_BIT ? 'V' : 'v';
+	buf[4] = '\0';
+
+	fprintf(fp, "    Flags: %s  IRQs o%s  FIQs o%s  Mode %s  ISA %s\n",
+		buf, interrupts_enabled(&regs) ? "n" : "ff",
+		fast_interrupts_enabled(&regs) ? "n" : "ff",
+		processor_modes[processor_mode(&regs)],
+		isa_modes[isa_mode(&regs)]);
+}
+
+static void
+arm_display_full_frame(struct bt_info *bt, ulong sp)
+{
+	ulong words, addr;
+	ulong *up;
+	char buf[BUFSIZE];
+	int i, u_idx;
+
+	if (!INSTACK(sp, bt) || !INSTACK(bt->stkptr, bt))
+		return;
+
+	words = (sp - bt->stkptr) / sizeof(ulong);
+
+	if (words == 0) {
+		fprintf(fp, "    (no frame)\n");
+		return;
+	}
+
+	addr = bt->stkptr;
+	u_idx = (bt->stkptr - bt->stackbase) / sizeof(ulong);
+	for (i = 0; i < words; i++, u_idx++) {
+		if ((i % 4) == 0)
+			fprintf(fp, "%s    %lx: ", i ? "\n" : "", addr);
+
+		up = (ulong *)(&bt->stackbuf[u_idx * sizeof(ulong)]);
+		fprintf(fp, "%s ", format_stack_entry(bt, buf, *up, 0));
+		addr += sizeof(ulong);
+	}
+	fprintf(fp, "\n");
+}
+
+/*
+ * Prints out a single stack frame. What is printed depends on flags passed in
+ * with bt.
+ *
+ * What is expected when calling this function:
+ *	bt->frameptr = current FP (or 0 if there is no such)
+ *	bt->stkptr = current SP
+ *	bt->instptr = current PC
+ *
+ *	from = LR
+ *	sp = previous/saved SP
+ */
+void
+arm_dump_backtrace_entry(struct bt_info *bt, int level, ulong from, ulong sp)
+{
+	struct load_module *lm;
+	const char *name;
+
+	name = closest_symbol(bt->instptr);
+
+	if (module_symbol(bt->instptr, NULL, &lm, NULL, 0)) {
+		fprintf(fp, "%s#%d [<%08lx>] (%s [%s]) from [<%08lx>]\n",
+			level < 10 ? " " : "",
+			level, bt->instptr, name, lm->mod_name, from);
+	} else {
+		fprintf(fp, "%s#%d [<%08lx>] (%s) from [<%08lx>]\n",
+			level < 10 ? " " : "",
+			level, bt->instptr, name, from);
+	}
+
+	if (bt->flags & BT_LINE_NUMBERS) {
+		char buf[BUFSIZE];
+
+		get_line_number(bt->instptr, buf, FALSE);
+		if (strlen(buf))
+			fprintf(fp, "    %s\n", buf);
+	}
+
+	if (arm_in_exception_text(bt->instptr))
+		arm_dump_exception_stack(sp, sp + sizeof(struct arm_pt_regs));
+
+	if (bt->flags & BT_FULL) {
+		if (kt->flags & DWARF_UNWIND) {
+			fprintf(fp, "    "
+				"[PC: %08lx  LR: %08lx  SP: %08lx  SIZE: %d]\n",
+				bt->instptr, from, bt->stkptr, sp - bt->stkptr);
+		} else {
+			fprintf(fp, "    "
+				"[PC: %08lx  LR: %08lx  SP: %08lx  FP: %08lx  "
+				"SIZE: %d]\n",
+				bt->instptr, from, bt->stkptr, bt->frameptr,
+				sp - bt->stkptr);
+		}
+		arm_display_full_frame(bt, sp);
+	}
+}
+
+/*
+ * Determine where vmalloc'd memory starts.
+ */
+static ulong
+arm_vmalloc_start(void)
+{
+	return vt->high_memory;
+}
+
+/*
+ * Checks whether given task is valid task address.
+ */
+static int
+arm_is_task_addr(ulong task)
+{
+	if (tt->flags & THREAD_INFO)
+		return IS_KVADDR(task);
+
+	return (IS_KVADDR(task) && ALIGNED_STACK_OFFSET(task) == 0);
+}
+
+/*
+ * Filter dissassembly output if the output radix is not gdb's default 10
+ */
+static int
+arm_dis_filter(ulong vaddr, char *inbuf)
+{
+	char buf1[BUFSIZE];
+	char buf2[BUFSIZE];
+	char *colon, *p1;
+	int argc;
+	char *argv[MAXARGS];
+	ulong value;
+
+	if (!inbuf)
+		return TRUE;
+/*
+ *  For some reason gdb can go off into the weeds translating text addresses,
+ *  (on alpha -- not necessarily seen on arm) so this routine both fixes the
+ *  references as well as imposing the current output radix on the translations.
+ */
+	console("IN: %s", inbuf);
+
+	colon = strstr(inbuf, ":");
+
+	if (colon) {
+		sprintf(buf1, "0x%lx <%s>", vaddr,
+			value_to_symstr(vaddr, buf2, pc->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, pc->output_radix));
+
+		sprintf(p1, buf1);
+	}
+
+	console("    %s", inbuf);
+
+	return TRUE;
+}
+
+/*
+ * Look for likely exception frames in a stack.
+ */
+static int
+arm_eframe_search(struct bt_info *bt)
+{
+	return (NOT_IMPLEMENTED());
+}
+
+/*
+ * Get the relevant page directory pointer from a task structure.
+ */
+static ulong
+arm_get_task_pgd(ulong task)
+{
+	return (NOT_IMPLEMENTED());
+}
+
+/*
+ * Machine dependent command.
+ */
+static void
+arm_cmd_mach(void)
+{
+	int c;
+
+	while ((c = getopt(argcnt, args, "cm")) != -1) {
+		switch (c) {
+		case 'c':
+		case 'm':
+			fprintf(fp, "ARM: '-%c' option is not supported\n", c);
+			break;
+
+		default:
+			argerrs++;
+			break;
+		}
+	}
+
+	if (argerrs)
+		cmd_usage(pc->curcmd, SYNOPSIS);
+
+	arm_display_machine_stats();
+}
+
+static void
+arm_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());
+	fprintf(fp, "    PROCESSOR SPEED: ");
+	if ((mhz = machdep->processor_speed()))
+		fprintf(fp, "%ld Mhz\n", mhz);
+	else
+		fprintf(fp, "(unknown)\n");
+	fprintf(fp, "                 HZ: %d\n", machdep->hz);
+	fprintf(fp, "          PAGE SIZE: %d\n", PAGESIZE());
+	fprintf(fp, "KERNEL VIRTUAL BASE: %lx\n", machdep->kvbase);
+	fprintf(fp, "KERNEL VMALLOC BASE: %lx\n", vt->vmalloc_start);
+	fprintf(fp, "  KERNEL STACK SIZE: %ld\n", STACKSIZE());
+}
+
+static int
+arm_get_smp_cpus(void)
+{
+	return get_cpus_online();
+}
+
+static void
+print_irq_member(char *irq, ulong val, char *ind)
+{
+	char buf[BUFSIZE];
+	ulong val2;
+
+	fprintf(fp, "%17s: %8lx  ", irq, val);
+	if (val) {
+		if (is_kernel_text(val))
+			fprintf(fp, "<%s>", value_to_symstr(val, buf, 0));
+		else if (readmem(val, KVADDR, &val2,
+			sizeof(ulong), ind, RETURN_ON_ERROR|QUIET) &&
+			is_kernel_text(val2))
+			fprintf(fp, "<%s>", value_to_symstr(val2, buf, 0));
+	}
+	fprintf(fp, "\n");
+}
+
+/*
+ *  Do the work for cmd_irq().
+ */
+static void
+arm_dump_irq(int irq)
+{
+	struct datatype_member datatype_member, *dm;
+	ulong irq_desc_addr;
+	ulong irq_desc_ptr;
+	long len;
+	char buf[BUFSIZE];
+	int type, status, depth, others;
+	ulong handler, action, value;
+	ulong tmp1, tmp2;
+
+	dm = &datatype_member;
+
+	if (!VALID_STRUCT(irq_desc_t))
+		error(FATAL, "cannot determine size of irq_desc\n");
+	len = SIZE(irq_desc_t);
+
+        if (symbol_exists("irq_desc"))
+		irq_desc_addr = symbol_value("irq_desc") + (len * irq);
+        else if (symbol_exists("_irq_desc"))
+		irq_desc_addr = symbol_value("_irq_desc") + (len * irq);
+	else if (symbol_exists("irq_desc_ptrs")) {
+		get_symbol_data("irq_desc_ptrs", sizeof(void *), &irq_desc_ptr);
+		irq_desc_ptr += (irq * sizeof(void *));
+		readmem(irq_desc_ptr, KVADDR, &irq_desc_addr,
+                        sizeof(void *), "irq_desc_ptrs entry",
+                        FAULT_ON_ERROR);
+		if (!irq_desc_addr) {
+			fprintf(fp, "    IRQ: %d (unused)\n\n", irq);
+			return;
+		}
+	} else {
+		irq_desc_addr = 0;
+		error(FATAL,
+		    "neither irq_desc, _irq_desc, nor irq_desc_ptrs "
+		    "symbols exist\n");
+	}
+
+        readmem(irq_desc_addr + OFFSET(irq_desc_t_status), KVADDR, &status,
+                sizeof(int), "irq_desc entry", FAULT_ON_ERROR);
+	if (VALID_MEMBER(irq_desc_t_handler))
+	        readmem(irq_desc_addr + OFFSET(irq_desc_t_handler), KVADDR,
+			&handler, sizeof(long), "irq_desc entry",
+			FAULT_ON_ERROR);
+	else if (VALID_MEMBER(irq_desc_t_chip))
+	        readmem(irq_desc_addr + OFFSET(irq_desc_t_chip), KVADDR,
+			&handler, sizeof(long), "irq_desc entry",
+			FAULT_ON_ERROR);
+        readmem(irq_desc_addr + OFFSET(irq_desc_t_action), KVADDR, &action,
+                sizeof(long), "irq_desc entry", FAULT_ON_ERROR);
+        readmem(irq_desc_addr + OFFSET(irq_desc_t_depth), KVADDR, &depth,
+                sizeof(int), "irq_desc entry", FAULT_ON_ERROR);
+
+	if (!action && (handler == (ulong)pc->curcmd_private))
+		return;
+
+	fprintf(fp, "    IRQ: %d\n", irq);
+	fprintf(fp, "ADDRESS: %08lx\n", irq_desc_addr);
+
+	if (VALID_MEMBER(irq_desc_t_name)) {
+		readmem(irq_desc_addr+OFFSET(irq_desc_t_name),
+			KVADDR,	&tmp1, sizeof(void *),
+			"irq_desc name", FAULT_ON_ERROR);
+		if (tmp1) {
+			fprintf(fp, "   NAME: %lx", tmp1);
+			BZERO(buf, BUFSIZE);
+			if (read_string(tmp1, buf, BUFSIZE-1))
+				fprintf(fp, " \"%s\"", buf);
+			fprintf(fp, "\n");
+		}
+	}
+
+	type = status & IRQ_TYPE_SENSE_MASK;
+	fprintf(fp, "   TYPE: %x %s", type, type ? "(" : "");
+	others = 0;
+
+	if (type & IRQ_TYPE_EDGE_BOTH == IRQ_TYPE_EDGE_BOTH)
+		fprintf(fp, "%sEDGE_BOTH", others++ ? "|" : "");
+	else {
+		if (type & IRQ_TYPE_EDGE_RISING)
+			fprintf(fp, "%sEDGE_RISING", others++ ? "|" : "");
+		if (type & IRQ_TYPE_EDGE_FALLING)
+			fprintf(fp, "%sEDGE_FALLING", others++ ? "|" : "");
+	}
+	if (type & IRQ_TYPE_LEVEL_HIGH)
+		fprintf(fp, "%sLEVEL_HIGH", others++ ? "|" : "");
+	if (type & IRQ_TYPE_LEVEL_LOW)
+		fprintf(fp, "%sLEVEL_LOW", others++ ? "|" : "");
+	fprintf(fp, "%s\n", type ? ")" : "");
+
+	fprintf(fp, "  PROBE: %s\n", status & IRQ_TYPE_PROBE ? "true" :
"false");
+
+	fprintf(fp, " STATUS: %x %s", status, status ? "(" : "");
+	others = 0;
+	if (status & IRQ_INPROGRESS) {
+		fprintf(fp, "IRQ_INPROGRESS");
+		others++;
+	}
+	if (status & IRQ_DISABLED)
+		fprintf(fp, "%sIRQ_DISABLED", others++ ? "|" : "");
+        if (status & IRQ_PENDING)
+                fprintf(fp, "%sIRQ_PENDING", others++ ? "|" :
"");
+        if (status & IRQ_REPLAY)
+                fprintf(fp, "%sIRQ_REPLAY", others++ ? "|" :
"");
+        if (status & IRQ_AUTODETECT)
+                fprintf(fp, "%sIRQ_AUTODETECT", others++ ? "|" :
"");
+        if (status & IRQ_WAITING)
+                fprintf(fp, "%sIRQ_WAITING", others++ ? "|" :
"");
+        if (status & IRQ_LEVEL)
+                fprintf(fp, "%sIRQ_LEVEL", others++ ? "|" :
"");
+        if (status & IRQ_MASKED)
+                fprintf(fp, "%sIRQ_MASKED", others++ ? "|" :
"");
+
+        if (status & IRQ_PER_CPU)
+                fprintf(fp, "%sIRQ_PER_CPU", others++ ? "|" :
"");
+        if (status & IRQ_NOPROBE)
+                fprintf(fp, "%sIRQ_NOPROBE", others++ ? "|" :
"");
+        if (status & IRQ_NOREQUEST)
+                fprintf(fp, "%sIRQ_NOREQUEST", others++ ? "|" :
"");
+        if (status & IRQ_NOAUTOEN)
+                fprintf(fp, "%sIRQ_NOAUTOEN", others++ ? "|" :
"");
+        if (status & IRQ_WAKEUP)
+                fprintf(fp, "%sIRQ_WAKEUP", others++ ? "|" :
"");
+        if (status & IRQ_MOVE_PENDING)
+                fprintf(fp, "%sIRQ_MOVE_PENDING", others++ ? "|" :
"");
+        if (status & IRQ_NO_BALANCING)
+                fprintf(fp, "%sIRQ_NO_BALANCING", others++ ? "|" :
"");
+        if (status & IRQ_SPURIOUS_DISABLED)
+                fprintf(fp, "%sIRQ_SPURIOUS_DISABLED", others++ ? "|"
: "");
+        if (status & IRQ_MOVE_PCNTXT)
+                fprintf(fp, "%sIRQ_MOVE_PCNTXT", others++ ? "|" :
"");
+        if (status & IRQ_AFFINITY_SET)
+                fprintf(fp, "%sIRQ_AFFINITY_SET", others++ ? "|" :
"");
+
+
+	fprintf(fp, "%s\n", status ? ")" : "");
+
+	fprintf(fp, "HANDLER: %8lx  ", handler);
+	if (value_symbol(handler)) {
+		pad_line(fp, VADDR_PRLEN == 8 ? VADDR_PRLEN+2 : VADDR_PRLEN-6, ' ');
+		fprintf(fp, "<%s>", value_symbol(handler));
+	}
+	fprintf(fp, "\n", handler);
+
+#define CHECK_HANDLER_OPT_MEMBER_PRT(x)					 \
+	if (VALID_MEMBER(hw_interrupt_type_ ## x)) {			 \
+		readmem(handler+OFFSET(hw_interrupt_type_ ## x), KVADDR, \
+			&tmp1, sizeof(void *),	"hw_interrupt_type " #x, \
+			FAULT_ON_ERROR);				 \
+		print_irq_member(#x, tmp1, #x " indirection");		 \
+	} else if (VALID_MEMBER(irq_chip_ ## x)) {			 \
+		readmem(handler+OFFSET(irq_chip_ ## x),KVADDR, &tmp1,	 \
+			sizeof(void *), "irq_chip " #x, FAULT_ON_ERROR); \
+		print_irq_member(#x, tmp1, #x " indirection");		 \
+	}
+
+#define CHECK_HANDLER_OPT_MEMBER(x)					 \
+	if (VALID_MEMBER(hw_interrupt_type_ ## x))			 \
+		readmem(handler+OFFSET(hw_interrupt_type_ ## x), KVADDR, \
+			&tmp1, sizeof(void *), "hw_interrupt_type " #x,	 \
+			FAULT_ON_ERROR);				 \
+	else if (VALID_MEMBER(irq_chip_ ## x))				 \
+		readmem(handler+OFFSET(irq_chip_ ## x),KVADDR, &tmp1,	 \
+			sizeof(void *), "irq_chip " #x, FAULT_ON_ERROR); \
+
+#define CHECK_HANDLER_MEMBER_PRT(x,s1,s2)				 \
+	if (VALID_MEMBER(x)) {						 \
+		readmem(handler+OFFSET(x), KVADDR, &tmp1, sizeof(void *),\
+			s1, FAULT_ON_ERROR);				 \
+			print_irq_member(s2, tmp1, s2 " indirection");	 \
+	}
+
+	if (handler) {
+		CHECK_HANDLER_OPT_MEMBER(typename);
+
+		fprintf(fp, "         typename: %lx  ", tmp1);
+		BZERO(buf, BUFSIZE);
+		if (read_string(tmp1, buf, BUFSIZE-1))
+			fprintf(fp, "\"%s\"", buf);
+		fprintf(fp, "\n");
+
+		CHECK_HANDLER_OPT_MEMBER(startup);
+
+		print_irq_member("startup", tmp1, "startup indirection");
+
+		CHECK_HANDLER_OPT_MEMBER(shutdown);
+
+		print_irq_member("shutdown", tmp1, "shutdown indirection");
+
+		CHECK_HANDLER_MEMBER_PRT(hw_interrupt_type_handle,
+					 "hw_interrupt_type handle",
+					 "handle");
+
+		CHECK_HANDLER_OPT_MEMBER(enable);
+
+		print_irq_member("enable", tmp1, "enable indirection");
+
+		CHECK_HANDLER_OPT_MEMBER(disable);
+
+		print_irq_member("disable", tmp1, "disable indirection");
+
+		CHECK_HANDLER_OPT_MEMBER(ack);
+
+		print_irq_member("ack", tmp1, "ack indirection");
+
+		CHECK_HANDLER_MEMBER_PRT(irq_chip_mask, "irq_chip mask","mask");
+
+		CHECK_HANDLER_MEMBER_PRT(irq_chip_mask_ack, "irq_chip mask_ack",
+					 "mask_ack");
+
+		CHECK_HANDLER_MEMBER_PRT(irq_chip_unmask, "irq_chip unmask",
+					 "unmask");
+
+		CHECK_HANDLER_MEMBER_PRT(irq_chip_eoi,"irq_chip eoi","eoi");
+
+		CHECK_HANDLER_OPT_MEMBER_PRT(startup);
+
+		CHECK_HANDLER_OPT_MEMBER_PRT(set_affinity);
+
+		CHECK_HANDLER_MEMBER_PRT(irq_chip_retrigger,
+					 "irq_chip retrigger", "retrigger");
+		CHECK_HANDLER_MEMBER_PRT(irq_chip_set_type,
+					 "irq_chip set_type", "set_type");
+		CHECK_HANDLER_MEMBER_PRT(irq_chip_set_wake,
+					 "irq_chip set_wake", "set_wake");
+	}
+
+do_linked_action:
+
+	fprintf(fp, " ACTION: ");
+        if (value_symbol(action)) {
+                fprintf(fp, "%lx  ", action);
+                pad_line(fp, VADDR_PRLEN == 8 ?
+			VADDR_PRLEN+2 : VADDR_PRLEN - 6, ' ');
+                fprintf(fp, "<%s>\n", value_symbol(action));
+        } else if (action) {
+                fprintf(fp, "%8lx\n", action);
+	} else {
+		fprintf(fp, "(none)\n");
+	}
+
+	if (action) {
+                readmem(action+OFFSET(irqaction_handler), KVADDR,
+                        &tmp1, sizeof(void *),
+                        "irqaction handler", FAULT_ON_ERROR);
+
+		print_irq_member("handler", tmp1, "handler indirection");
+
+                readmem(action+OFFSET(irqaction_flags), KVADDR,
+                        &value, sizeof(void *),
+                        "irqaction flags", FAULT_ON_ERROR);
+                fprintf(fp, "            flags: %8lx\n", value);
+
+		if (VALID_MEMBER(irqaction_mask)) {
+			readmem(action+OFFSET(irqaction_mask), KVADDR,
+				&tmp1, sizeof(void *),
+				"irqaction mask", FAULT_ON_ERROR);
+			fprintf(fp, "             mask: %8lx\n", tmp1);
+		}
+
+                readmem(action+OFFSET(irqaction_name), KVADDR,
+                        &tmp1, sizeof(void *),
+                        "irqaction name", FAULT_ON_ERROR);
+                fprintf(fp, "             name: %8lx  ", tmp1);
+                BZERO(buf, BUFSIZE);
+                if (read_string(tmp1, buf, BUFSIZE-1))
+                        fprintf(fp, "\"%s\"", buf);
+                fprintf(fp, "\n");
+
+                readmem(action+OFFSET(irqaction_dev_id), KVADDR,
+                        &tmp1, sizeof(void *),
+                        "irqaction dev_id", FAULT_ON_ERROR);
+                fprintf(fp, "           dev_id: %8lx\n", tmp1);
+
+                readmem(action+OFFSET(irqaction_next), KVADDR,
+                        &action, sizeof(void *),
+                        "irqaction dev_id", FAULT_ON_ERROR);
+                fprintf(fp, "             next: %8lx\n", action);
+	}
+
+	if (action)
+		goto do_linked_action;
+
+	fprintf(fp, "  DEPTH: %d\n\n", depth);
+}
+
+/*
+ * Initialize ARM specific stuff.
+ */
+static void
+arm_init_machspec(void)
+{
+	struct machine_specific *ms = machdep->machspec;
+	ulong phys_base;
+
+	if (symbol_exists("__exception_text_start") &&
+	    symbol_exists("__exception_text_end")) {
+		ms->exception_text_start = symbol_value("__exception_text_start");
+		ms->exception_text_end = symbol_value("__exception_text_end");
+	}
+
+	if (symbol_exists("_stext") && symbol_exists("_etext")) {
+		ms->kernel_text_start = symbol_value("_stext");
+		ms->kernel_text_end = symbol_value("_etext");
+	}
+
+	if (CRASHDEBUG(1)) {
+		fprintf(fp, "kernel text:    [%lx - %lx]\n",
+			ms->kernel_text_start, ms->kernel_text_end);
+		fprintf(fp, "exception text: [%lx - %lx]\n",
+			ms->exception_text_start, ms->exception_text_end);
+	}
+
+	if (machdep->flags & PHYS_BASE) /* --machdep override */
+		return;
+
+	/*
+	 * Next determine suitable value for phys_base. User can override this
+	 * by passing valid '--machdep phys_base=<addr>' option.
+	 */
+	ms->phys_base = 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_base = htol(buf, RETURN_ON_ERROR | QUIET, &errflag);
+		if (errflag)
+			return;
+
+		ms->phys_base = phys_base;
+	} else if (DISKDUMP_DUMPFILE() && diskdump_phys_base(&phys_base)) {
+		ms->phys_base = phys_base;
+	} else if (KDUMP_DUMPFILE() && kdump_phys_base(&phys_base)) {
+		ms->phys_base = phys_base;
+	} else {
+		error(WARNING,
+			"phys_base cannot be determined from the dumpfile.\n"
+			"Using default value of 0. If this is not correct,\n"
+			"consider using '--machdep phys_base=<addr>'\n");
+	}
+
+	if (CRASHDEBUG(1))
+		fprintf(fp, "using %lx as phys_base\n", ms->phys_base);
+}
+
+static const char *hook_files[] = {
+	"arch/arm/kernel/entry-armv.S",
+	"arch/arm/kernel/entry-common.S",
+};
+
+#define ENTRY_ARMV_S	((char **)&hook_files[0])
+#define ENTRY_COMMON_S	((char **)&hook_files[1])
+
+static struct line_number_hook arm_line_number_hooks[] = {
+	{ "__dabt_svc", ENTRY_ARMV_S },
+	{ "__irq_svc", ENTRY_ARMV_S },
+	{ "__und_svc", ENTRY_ARMV_S },
+	{ "__pabt_svc", ENTRY_ARMV_S },
+	{ "__switch_to", ENTRY_ARMV_S },
+
+	{ "ret_fast_syscall", ENTRY_COMMON_S },
+	{ "ret_slow_syscall", ENTRY_COMMON_S },
+	{ "ret_from_fork", ENTRY_COMMON_S },
+	{ NULL, NULL },
+};
+#endif /* ARM */
diff --git a/defs.h b/defs.h
index c8bae00..f9118f0 100755
--- a/defs.h
+++ b/defs.h
@@ -84,6 +84,9 @@
 #ifdef S390X
 #define NR_CPUS  (64)
 #endif
+#ifdef ARM
+#define NR_CPUS  (1)
+#endif
 
 #define BUFSIZE  (1500)
 #define NULLCHAR ('\0')
@@ -1513,6 +1516,22 @@ struct offset_table {                    /* stash of commonly-used
offsets */
 	long mm_rss_stat_count;
 	long module_module_init;
 	long module_init_text_size;
+#ifdef ARM
+	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;
+#endif /* ARM */
 };
 
 struct size_table {         /* stash of commonly-used sizes */
@@ -1625,6 +1644,12 @@ struct size_table {         /* stash of commonly-used sizes */
 	long module_sect_attr;
 	long task_struct_utime;
 	long task_struct_stime;
+#ifdef ARM
+	long cpu_context_save;
+	long elf_prstatus;
+	long note_buf;
+	long unwind_idx;
+#endif /* ARM */
 };
 
 struct array_table {
@@ -2099,6 +2124,49 @@ struct load_module {
  *  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 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 */
+
 #ifdef X86
 #define _32BIT_
 #define MACHINE_TYPE       "X86"
@@ -2795,6 +2863,10 @@ struct efi_memory_desc_t {
 #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)
@@ -2971,6 +3043,13 @@ struct efi_memory_desc_t {
 #define IRQ_AFFINITY_SET	\
 	(THIS_KERNEL_VERSION >= LINUX(2,6,21) ? IRQ_AFFINITY_SET_2_6_21 : 0)
 
+#ifdef ARM
+#define SA_PROBE                SA_ONESHOT
+#define SA_SAMPLE_RANDOM        SA_RESTART
+#define SA_SHIRQ                0x04000000
+#define SA_RESTORER             0x04000000
+#endif
+
 #ifdef X86
 #define SA_PROBE                SA_ONESHOT
 #define SA_SAMPLE_RANDOM        SA_RESTART
@@ -3301,6 +3380,9 @@ void program_usage(int);
 #define SHORT_FORM (0)
 void dump_program_context(void);
 void dump_build_data(void);
+#ifdef ARM
+#define machdep_init(X) arm_init(X)
+#endif
 #ifdef X86
 #define machdep_init(X) x86_init(X)
 #endif
@@ -3659,6 +3741,9 @@ void help_init(void);
 void cmd_usage(char *, int);
 void display_version(void);
 void display_help_screen(char *);
+#ifdef ARM
+#define dump_machdep_table(X) arm_dump_machdep_table(X)
+#endif
 #ifdef X86
 #define dump_machdep_table(X) x86_dump_machdep_table(X)
 #endif
@@ -3937,6 +4022,58 @@ void read_in_kernel_config(int);
 void dev_init(void);
 void dump_dev_table(void);
 
+#ifdef ARM
+void arm_init(int);
+void arm_dump_machdep_table(ulong);
+int arm_is_vmalloc_addr(ulong);
+void arm_dump_backtrace_entry(struct bt_info *, int, ulong, ulong);
+
+#define display_idt_table() \
+        error(FATAL, "-d option is not applicable to ARM architecture\n")
+
+struct arm_pt_regs {
+	ulong uregs[18];
+};
+
+#define ARM_cpsr	uregs[16]
+#define ARM_pc		uregs[15]
+#define ARM_lr		uregs[14]
+#define ARM_sp		uregs[13]
+#define ARM_ip		uregs[12]
+#define ARM_fp		uregs[11]
+#define ARM_r10		uregs[10]
+#define ARM_r9		uregs[9]
+#define ARM_r8		uregs[8]
+#define ARM_r7		uregs[7]
+#define ARM_r6		uregs[6]
+#define ARM_r5		uregs[5]
+#define ARM_r4		uregs[4]
+#define ARM_r3		uregs[3]
+#define ARM_r2		uregs[2]
+#define ARM_r1		uregs[1]
+#define ARM_r0		uregs[0]
+#define ARM_ORIG_r0	uregs[17]
+
+#define KSYMS_START	(0x1)
+#define PHYS_BASE	(0x2)
+
+struct machine_specific {
+	ulong phys_base;
+	ulong vmalloc_start_addr;
+	ulong modules_vaddr;
+	ulong modules_end;
+	ulong kernel_text_start;
+	ulong kernel_text_end;
+	ulong exception_text_start;
+	ulong exception_text_end;
+	ulong crash_task_pid;
+	struct arm_pt_regs *crash_task_regs;
+};
+
+int init_unwind_tables(void);
+void unwind_backtrace(struct bt_info *);
+#endif /* ARM */
+
 /*
  *  alpha.c
  */
diff --git a/diskdump.c b/diskdump.c
index 3aab338..e52e603 100644
--- a/diskdump.c
+++ b/diskdump.c
@@ -528,7 +528,15 @@ page_is_cached(physaddr_t paddr)
 static ulong
 paddr_to_pfn(physaddr_t paddr)
 {
+#ifdef ARM
+	/*
+	 * In ARM, PFN 0 means first page in kernel direct-mapped view.
+	 * This is also first page in mem_map as well.
+	 */
+	return (paddr - machdep->machspec->phys_base) >> dd->block_shift;
+#else
 	return paddr >> dd->block_shift;
+#endif
 }
 
 /*
diff --git a/unwind_arm.c b/unwind_arm.c
new file mode 100644
index 0000000..8352e2d
--- /dev/null
+++ b/unwind_arm.c
@@ -0,0 +1,697 @@
+/*
+ * Stack unwinding support for ARM
+ *
+ * This code is derived from the kernel source:
+ * arch/arm/kernel/unwind.c
+ * Copyright (C) 2008 ARM Limited
+ *
+ * Created by: Mika Westerberg <ext-mika.1.westerberg(a)nokia.com&gt;
+ * Copyright (C) 2010 Nokia Corporation
+ *
+ * For more information about ARM unwind tables see "Exception handling ABI for
+ * the ARM architecture" document at:
+ *
+ * http://infocenter.arm.com/help/topic/com.arm.doc.subset.swdev.abi/index.html
+ *
+ * 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 ARM
+
+#include "defs.h"
+
+/**
+ * struct unwind_idx - index table entry
+ * @addr: prel31 offset to the start of the function
+ * @insn: index table entry.
+ *
+ * @insn can be encoded as follows:
+ *     1. if bit31 is clear this points to the start of the EHT entry
+ *        (prel31 offset)
+ *     2. if bit31 is set, this contains the EHT entry itself
+ *     3. if 0x1, cannot unwind.
+ *
+ * In case 1. @insn points to the EH table that comes directly after index
+ * table. This offset is relative to address of @insn which implies that we must
+ * allocate both index table and EH table in single chunk.
+ */
+struct unwind_idx {
+	ulong	addr;
+	ulong	insn;
+};
+
+/**
+ * struct unwind_table - per-module unwind table
+ * @idx: pointer to the star of the unwind table
+ * @start: pointer to the start of the index table
+ * @end: pointer to the last element +1 of the index table
+ * @begin_addr: start address which this table covers
+ * @end_addr: end address which this table covers
+ *
+ * Kernel stores per-module unwind tables in this format. There can be more than
+ * one table per module as we have different ELF sections in the module.
+ */
+struct unwind_table {
+	struct unwind_idx	*idx;
+	struct unwind_idx	*start;
+	struct unwind_idx	*end;
+	ulong			begin_addr;
+	ulong			end_addr;
+};
+
+/*
+ * Unwind table pointers to master kernel table and for modules.
+ */
+static struct unwind_table	*kernel_unwind_table;
+static struct unwind_table	*module_unwind_tables;
+
+struct unwind_ctrl_block {
+	ulong	vrs[16];
+	ulong	*insn;
+	int	entries;
+	int	byte;
+};
+
+struct stackframe {
+	ulong	fp;
+	ulong	sp;
+	ulong	lr;
+	ulong	pc;
+};
+
+enum regs {
+	FP = 11,
+	SP = 13,
+	LR = 14,
+	PC = 15,
+};
+
+static int init_kernel_unwind_table(void);
+static void free_kernel_unwind_table(void);
+static int read_module_unwind_table(struct unwind_table *, ulong);
+static int init_module_unwind_tables(void);
+static ulong unwind_get_byte(struct unwind_ctrl_block *);
+static ulong get_value_from_stack(ulong *);
+static int unwind_exec_insn(struct unwind_ctrl_block *);
+static int is_core_kernel_text(ulong);
+static struct unwind_idx *search_index(ulong);
+static ulong *prel31_to_addr(ulong *);
+static int unwind_frame(struct stackframe *, ulong);
+
+/*
+ * Function reads in-memory kernel and module unwind tables and makes
+ * local copy of them for unwinding. If unwinding tables cannot be found, this
+ * function returns FALSE, otherwise TRUE.
+ */
+int
+init_unwind_tables(void)
+{
+	if (!symbol_exists("__start_unwind_idx") ||
+	    !symbol_exists("__stop_unwind_idx") ||
+	    !symbol_exists("__start_unwind_tab") ||
+	    !symbol_exists("__stop_unwind_tab") ||
+	    !symbol_exists("unwind_tables")) {
+		return FALSE;
+	}
+
+	if (!init_kernel_unwind_table()) {
+		error(WARNING,
+		      "UNWIND: failed to initialize kernel unwind table\n");
+		return FALSE;
+	}
+
+	/*
+	 * Initialize symbols for per-module unwind tables. Actually there are
+	 * several tables per module (one per code section).
+	 */
+	STRUCT_SIZE_INIT(unwind_table, "unwind_table");
+	MEMBER_OFFSET_INIT(unwind_table_list, "unwind_table", "list");
+	MEMBER_OFFSET_INIT(unwind_table_start, "unwind_table", "start");
+	MEMBER_OFFSET_INIT(unwind_table_stop, "unwind_table", "stop");
+	MEMBER_OFFSET_INIT(unwind_table_begin_addr, "unwind_table",
+			   "begin_addr");
+	MEMBER_OFFSET_INIT(unwind_table_end_addr, "unwind_table",
"end_addr");
+
+	STRUCT_SIZE_INIT(unwind_idx, "unwind_idx");
+	MEMBER_OFFSET_INIT(unwind_idx_addr, "unwind_idx", "addr");
+	MEMBER_OFFSET_INIT(unwind_idx_insn, "unwind_idx", "insn");
+
+	if (!init_module_unwind_tables()) {
+		error(WARNING,
+		      "UNWIND: failed to initialize module unwind tables\n");
+		free_kernel_unwind_table();
+		return FALSE;
+	}
+
+	/*
+	 * We abuse DWARF_UNWIND flag a little here as ARM unwinding tables are
+	 * not in DWARF format but we can use the flags to indicate that we have
+	 * unwind tables support ready.
+	 */
+	kt->flags |= DWARF_UNWIND_CAPABLE;
+	kt->flags |= DWARF_UNWIND;
+
+	return TRUE;
+}
+
+/*
+ * Allocate and fill master kernel unwind table.
+ */
+static int
+init_kernel_unwind_table(void)
+{
+	ulong idx_start, idx_end, idx_size;
+	ulong tab_end, tab_size;
+
+	kernel_unwind_table = calloc(sizeof(*kernel_unwind_table), 1);
+	if (!kernel_unwind_table)
+		return FALSE;
+
+	idx_start = symbol_value("__start_unwind_idx");
+	idx_end = symbol_value("__stop_unwind_idx");
+	tab_end = symbol_value("__stop_unwind_tab");
+
+	/*
+	 * Calculate sizes of the idx table and the EH table.
+	 */
+	idx_size = idx_end - idx_start;
+	tab_size = tab_end - idx_start;
+
+	kernel_unwind_table->idx = calloc(tab_size, 1);
+	if (!kernel_unwind_table->idx)
+		goto fail;
+
+	/*
+	 * Now read in both the index table and the EH table. We need to read in
+	 * both because prel31 offsets in the index table are relative to the
+	 * index address.
+	 */
+	if (!readmem(idx_start, KVADDR, kernel_unwind_table->idx, tab_size,
+		     "master kernel unwind table", RETURN_ON_ERROR))
+		goto fail;
+
+	kernel_unwind_table->start = kernel_unwind_table->idx;
+	kernel_unwind_table->end = (struct unwind_idx *)
+		((char *)kernel_unwind_table->idx + idx_size);
+	kernel_unwind_table->begin_addr = kernel_unwind_table->start->addr;
+	kernel_unwind_table->end_addr = (kernel_unwind_table->end - 1)->addr;
+
+	if (CRASHDEBUG(1)) {
+		fprintf(fp, "UNWIND: master kernel table start\n");
+		fprintf(fp, "UNWIND: size      : %ld\n", tab_size);
+		fprintf(fp, "UNWIND: start     : %p\n", kernel_unwind_table->start);
+		fprintf(fp, "UNWIND: end       : %p\n", kernel_unwind_table->end);
+		fprintf(fp, "UNWIND: begin_addr: 0x%lx\n",
+			kernel_unwind_table->begin_addr);
+		fprintf(fp, "UNWIND: begin_addr: 0x%lx\n",
+			kernel_unwind_table->end_addr);
+		fprintf(fp, "UNWIND: master kernel table end\n");
+	}
+
+	return TRUE;
+
+fail:
+	free(kernel_unwind_table->idx);
+	free(kernel_unwind_table);
+	return FALSE;
+}
+
+static void
+free_kernel_unwind_table(void)
+{
+	free(kernel_unwind_table->idx);
+	free(kernel_unwind_table);
+}
+
+/*
+ * Read single module unwind table from addr.
+ */
+static int
+read_module_unwind_table(struct unwind_table *tbl, ulong addr)
+{
+	ulong idx_start, idx_stop, idx_size;
+	char *buf;
+
+	buf = GETBUF(SIZE(unwind_table));
+
+	/*
+	 * First read in the unwind table for this module. It then contains
+	 * pointers to the index table which we will read later.
+	 */
+	if (!readmem(addr, KVADDR, buf, SIZE(unwind_table),
+		     "module unwind table", RETURN_ON_ERROR)) {
+		error(WARNING, "UNWIND: cannot read unwind table\n");
+		goto fail;
+	}
+
+#define TABLE_VALUE(b, offs) (*((ulong *)((b) + OFFSET(offs))))
+
+	idx_start = TABLE_VALUE(buf, unwind_table_start);
+	idx_stop = TABLE_VALUE(buf, unwind_table_stop);
+	idx_size = idx_stop - idx_start;
+
+	/*
+	 * We know the size of the index table. Allocate memory for the table
+	 * (including the EH table) and read the contents from the kernel
+	 * memory.
+	 */
+	tbl->idx = calloc(idx_size, 1);
+	if (!tbl->idx)
+		goto fail;
+
+	if (!readmem(idx_start, KVADDR, tbl->idx, idx_size,
+		     "module unwind index table", RETURN_ON_ERROR)) {
+		free(tbl->idx);
+		goto fail;
+	}
+
+	tbl->start = &tbl->idx[0];
+	tbl->end = (struct unwind_idx *)((char *)tbl->start + idx_size);
+	tbl->begin_addr = TABLE_VALUE(buf, unwind_table_begin_addr);
+	tbl->end_addr = TABLE_VALUE(buf, unwind_table_end_addr);
+
+	if (CRASHDEBUG(1)) {
+		fprintf(fp, "UNWIND: module table start\n");
+		fprintf(fp, "UNWIND: start     : %p\n", tbl->start);
+		fprintf(fp, "UNWIND: end       : %p\n", tbl->end);
+		fprintf(fp, "UNWIND: begin_addr: 0x%lx\n", tbl->begin_addr);
+		fprintf(fp, "UNWIND: begin_addr: 0x%lx\n", tbl->end_addr);
+		fprintf(fp, "UNWIND: module table end\n");
+	}
+
+	FREEBUF(buf);
+	return TRUE;
+
+fail:
+	FREEBUF(buf);
+	free(tbl->idx);
+	return FALSE;
+}
+
+/*
+ * Allocate and fill per-module unwind tables.
+ */
+static int
+init_module_unwind_tables(void)
+{
+	ulong head = symbol_value("unwind_tables");
+	struct unwind_table *tbl;
+	struct list_data ld;
+	ulong *table_list;
+	int cnt, i, n;
+
+	BZERO(&ld, sizeof(ld));
+	ld.start = head;
+	ld.member_offset = OFFSET(unwind_table_list);
+
+	if (CRASHDEBUG(1))
+		ld.flags |= VERBOSE;
+
+	/*
+	 * Iterate through unwind table list and store start address of each
+	 * table in table_list.
+	 */
+	hq_open();
+	cnt = do_list(&ld);
+	table_list = (ulong *)GETBUF(cnt * sizeof(ulong));
+	cnt = retrieve_list(table_list, cnt);
+	hq_close();
+
+	module_unwind_tables = calloc(sizeof(struct unwind_table), cnt);
+	if (!module_unwind_tables) {
+		error(WARNING,
+		      "UNWIND: failed to allocate memory for (%d tables)\n",
+		      cnt);
+		FREEBUF(table_list);
+		return FALSE;
+	}
+
+	/* we skip the first address as it is just head pointer */
+	for (i = 1, n = 0; i < cnt; i++, n++) {
+		tbl = &module_unwind_tables[n];
+		if (!read_module_unwind_table(tbl, table_list[i]))
+			goto fail;
+	}
+
+	/* just in case, zero the last entry (again) */
+	BZERO(&module_unwind_tables[n], sizeof(module_unwind_tables[n]));
+
+	FREEBUF(table_list);
+	return TRUE;
+
+fail:
+	FREEBUF(table_list);
+
+	while (--n >= 0) {
+		tbl = &module_unwind_tables[n];
+		free(tbl->idx);
+	}
+
+	free(module_unwind_tables);
+	return FALSE;
+}
+
+/*
+ * Return next insn byte from ctl or 0 in case of failure. As a side-effect,
+ * changes ctrl according the next byte.
+ */
+static ulong
+unwind_get_byte(struct unwind_ctrl_block *ctrl)
+{
+	ulong ret;
+
+	if (ctrl->entries <= 0) {
+		error(WARNING, "UNWIND: corrupt unwind entry\n");
+		return 0;
+	}
+
+	ret = (*ctrl->insn >> (ctrl->byte * 8)) & 0xff;
+
+	if (!ctrl->byte) {
+		ctrl->insn++;
+		ctrl->entries--;
+		ctrl->byte = 3;
+	} else {
+		ctrl->byte--;
+	}
+
+	return ret;
+}
+
+/*
+ * Gets one value from stack pointed by vsp.
+ */
+static ulong
+get_value_from_stack(ulong *vsp)
+{
+	ulong val;
+
+	/*
+	 * We just read the value from kernel memory instead of peeking it from
+	 * the bt->stack.
+	 */
+	if (!readmem((ulong)vsp, KVADDR, &val, sizeof(val),
+		"unwind stack value", RETURN_ON_ERROR)) {
+		error(FATAL, "unwind: failed to read value from stack\n");
+	}
+
+	return val;
+}
+
+/*
+ * Execute the next unwind instruction.
+ */
+static int
+unwind_exec_insn(struct unwind_ctrl_block *ctrl)
+{
+	ulong insn = unwind_get_byte(ctrl);
+
+	if ((insn & 0xc0) == 0) {
+		/*
+		 * 00xx xxxx: vsp = vsp + (xx xxx << 2) + 4
+		 *
+		 * Note that it seems that there is a typo in the spec and this
+		 * is corrected in kernel.
+		 */
+		ctrl->vrs[SP] += ((insn & 0x3f) << 2) + 4;
+	} else if ((insn & 0xc0) == 0x40) {
+		/* 00xx xxxx: vsp = vsp + (xx xxx << 2) + 4 */
+		ctrl->vrs[SP] -= ((insn & 0x3f) << 2) + 4;
+	} else if ((insn & 0xf0) == 0x80) {
+		/*
+		 * Pop up to 12 integer registers under masks
+		 * {r15-r12}, {r11-r4}.
+		 */
+		ulong mask;
+		ulong *vsp = (ulong *)ctrl->vrs[SP];
+		int load_sp, reg = 4;
+
+		insn = (insn << 8) | unwind_get_byte(ctrl);
+		mask = insn & 0x0fff;
+		if (mask == 0) {
+			error(WARNING, "UNWIND: refuse to unwind\n");
+			return FALSE;
+		}
+
+		/* pop {r4-r15} according to mask */
+		load_sp = mask & (1 << (13 - 4));
+		while (mask) {
+			if (mask & 1)
+				ctrl->vrs[reg] = get_value_from_stack(vsp++);
+			mask >>= 1;
+			reg++;
+		}
+		if (!load_sp)
+			ctrl->vrs[SP] = (ulong)vsp;
+	} else if ((insn & 0xf0) == 0x90 &&
+		   (insn & 0x0d) != 0x0d) {
+		/* 1001 nnnn: set vsp = r[nnnn] */
+		ctrl->vrs[SP] = ctrl->vrs[insn & 0x0f];
+	} else if ((insn & 0xf0) == 0xa0) {
+		/*
+		 * 1010 0nnn: pop r4-r[4+nnn]
+		 * 1010 1nnn: pop r4-r[4+nnn], r14
+		 */
+		ulong *vsp = (ulong *)ctrl->vrs[SP];
+		int reg;
+
+		for (reg = 4; reg <= 4 + (insn & 7); reg++)
+			ctrl->vrs[reg] = get_value_from_stack(vsp++);
+
+		if (insn & 0x80)
+			ctrl->vrs[14] = get_value_from_stack(vsp++);
+
+		ctrl->vrs[SP] = (ulong)vsp;
+	} else if (insn == 0xb0) {
+		/* 1011 0000: finish */
+		if (ctrl->vrs[PC] == 0)
+			ctrl->vrs[PC] = ctrl->vrs[LR];
+		/* no further processing */
+		ctrl->entries = 0;
+	} else if (insn == 0xb1) {
+		/* 1011 0001 xxxx yyyy: spare */
+		ulong mask = unwind_get_byte(ctrl);
+		ulong *vsp = (ulong *)ctrl->vrs[SP];
+		int reg = 0;
+
+		if (mask == 0 || mask & 0xf0) {
+			error(WARNING, "UNWIND: spare error\n");
+			return FALSE;
+		}
+
+		/* pop r0-r3 according to mask */
+		while (mask) {
+			if (mask & 1)
+				ctrl->vrs[reg] = get_value_from_stack(vsp++);
+			mask >>= 1;
+			reg++;
+		}
+		ctrl->vrs[SP] = (ulong)vsp;
+	} else if (insn == 0xb2) {
+		/* 1011 0010 uleb128: vsp = vsp + 0x204 (uleb128 << 2) */
+		ulong uleb128 = unwind_get_byte(ctrl);
+
+		ctrl->vrs[SP] += 0x204 + (uleb128 << 2);
+	} else {
+		error(WARNING, "UNWIND: unhandled instruction: %02lx\n", insn);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static int
+is_core_kernel_text(ulong pc)
+{
+	ulong text_start = machdep->machspec->kernel_text_start;
+	ulong text_end = machdep->machspec->kernel_text_end;
+
+	if (text_start && text_end)
+		return (pc >= text_start && pc <= text_end);
+
+	return FALSE;
+}
+
+static struct unwind_idx *
+search_index(ulong ip)
+{
+	struct unwind_idx *start = NULL;
+	struct unwind_idx *end = NULL;
+
+	/*
+	 * First check if this address is in the master kernel unwind table or
+	 * some of the module unwind tables.
+	 */
+	if (is_core_kernel_text(ip)) {
+		start = kernel_unwind_table->start;
+		end = kernel_unwind_table->end;
+	} else {
+		struct unwind_table *tbl;
+
+		for (tbl = &module_unwind_tables[0]; tbl->idx; tbl++) {
+			if (ip >= tbl->begin_addr && ip < tbl->end_addr) {
+				start = tbl->start;
+				end = tbl->end;
+				break;
+			}
+		}
+	}
+
+	if (start && end) {
+		/*
+		 * Do a binary search for the addresses in the index table.
+		 * Addresses are guaranteed to be sorted in ascending order.
+		 */
+		while (start < end - 1) {
+			struct unwind_idx *mid = start + ((end - start + 1) >> 1);
+
+			if (ip < mid->addr)
+				end = mid;
+			else
+				start = mid;
+		}
+
+		return start;
+	}
+
+	return NULL;
+}
+
+/*
+ * Convert a prel31 symbol to an absolute address.
+ */
+static ulong *
+prel31_to_addr(ulong *ptr)
+{
+	/* sign extend to 32 bits */
+	long offset = (((long)*ptr) << 1) >> 1;
+	return (ulong *)((ulong)ptr + offset);
+}
+
+static int
+unwind_frame(struct stackframe *frame, ulong stacktop)
+{
+	struct unwind_ctrl_block ctrl;
+	struct unwind_idx *idx;
+	ulong low, high;
+
+	low = frame->sp;
+	high = stacktop;
+
+	idx = search_index(frame->pc);
+	if (!idx) {
+		error(WARNING, "UNWIND: cannot find index for %lx\n",
+		      frame->pc);
+		return FALSE;
+	}
+
+	ctrl.vrs[FP] = frame->fp;
+	ctrl.vrs[SP] = frame->sp;
+	ctrl.vrs[LR] = frame->lr;
+	ctrl.vrs[PC] = 0;
+
+	if (CRASHDEBUG(5)) {
+		fprintf(fp, "UNWIND: >frame: FP=%lx\n", ctrl.vrs[FP]);
+		fprintf(fp, "UNWIND: >frame: SP=%lx\n", ctrl.vrs[SP]);
+		fprintf(fp, "UNWIND: >frame: LR=%lx\n", ctrl.vrs[LR]);
+		fprintf(fp, "UNWIND: >frame: PC=%lx\n", ctrl.vrs[PC]);
+	}
+
+	if (idx->insn == 1) {
+		/* can't unwind */
+		return FALSE;
+	} else if ((idx->insn & 0x80000000) == 0) {
+		/* insn contains offset to eht entry */
+		ctrl.insn = prel31_to_addr(&idx->insn);
+	} else if ((idx->insn & 0xff000000) == 0x80000000) {
+		/* eht entry is in insn itself */
+		ctrl.insn = &idx->insn;
+	} else {
+		error(WARNING, "UNWIND: unsupported instruction %lx\n",
+		      idx->insn);
+		return FALSE;
+	}
+
+	/* check the personality routine */
+	if ((*ctrl.insn & 0xff000000) == 0x80000000) {
+		ctrl.byte = 2;
+		ctrl.entries = 1;
+	} else if ((*ctrl.insn & 0xff000000) == 0x81000000) {
+		ctrl.byte = 1;
+		ctrl.entries = 1 + ((*ctrl.insn & 0x00ff0000) >> 16);
+	} else {
+		error(WARNING, "UNWIND: unsupported personality routine\n");
+		return FALSE;
+	}
+
+	/* now, execute the instructions */
+	while (ctrl.entries > 0) {
+		if (!unwind_exec_insn(&ctrl)) {
+			error(WARNING, "UNWIND: failed to exec instruction\n");
+			return FALSE;
+		}
+
+		if (ctrl.vrs[SP] < low || ctrl.vrs[SP] >= high)
+			return FALSE;
+	}
+
+	if (ctrl.vrs[PC] == 0)
+		ctrl.vrs[PC] = ctrl.vrs[LR];
+
+	if (frame->pc == ctrl.vrs[PC])
+		return FALSE;
+
+	frame->fp = ctrl.vrs[FP];
+	frame->sp = ctrl.vrs[SP];
+	frame->lr = ctrl.vrs[LR];
+	frame->pc = ctrl.vrs[PC];
+
+	if (CRASHDEBUG(5)) {
+		fprintf(fp, "UNWIND: <frame: FP=%lx\n", ctrl.vrs[FP]);
+		fprintf(fp, "UNWIND: <frame: SP=%lx\n", ctrl.vrs[SP]);
+		fprintf(fp, "UNWIND: <frame: LR=%lx\n", ctrl.vrs[LR]);
+		fprintf(fp, "UNWIND: <frame: PC=%lx\n", ctrl.vrs[PC]);
+	}
+
+	return TRUE;
+}
+
+void
+unwind_backtrace(struct bt_info *bt)
+{
+	struct stackframe frame;
+	int n = 0;
+
+	BZERO(&frame, sizeof(frame));
+	frame.fp = bt->frameptr;
+	frame.sp = bt->stkptr;
+	frame.pc = bt->instptr;
+
+	/*
+	 * In case bt->machdep contains pointer to a full register set, we take
+	 * LR from there.
+	 */
+	if (bt->machdep) {
+		const struct arm_pt_regs *regs = bt->machdep;
+		frame.lr = regs->ARM_lr;
+	}
+
+	while (IS_KVADDR(bt->instptr)) {
+		if (!unwind_frame(&frame, bt->stacktop))
+			break;
+
+		arm_dump_backtrace_entry(bt, n++, frame.lr, frame.sp);
+
+		bt->instptr = frame.pc;
+		bt->stkptr = frame.sp;
+	}
+}
+#endif /* ARM */
-- 
1.5.6.5


    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

[Crash-utility] [PATCH v2 6/6] crash: add ARM crashdump support