9 files changed, 218 insertions, 9 deletions

diff --git a/arch/arm/kernel/Makefile b/arch/arm/kernel/Makefile
index eb9092ca8008..1d296fc8494e 100644
--- a/arch/arm/kernel/Makefile
+++ b/arch/arm/kernel/Makefile
@@ -28,6 +28,7 @@ obj-$(CONFIG_KPROBES)		+= kprobes.o kprobes-decode.o
 obj-$(CONFIG_ATAGS_PROC)        += atags.o
 obj-$(CONFIG_OABI_COMPAT)       += sys_oabi-compat.o
 obj-$(CONFIG_ARM_THUMBEE)       += thumbee.o
+obj-$(CONFIG_KGDB)              += kgdb.o
 
 obj-$(CONFIG_CRUNCH)            += crunch.o crunch-bits.o
 AFLAGS_crunch-bits.o            := -Wa,-mcpu=ep9312
diff --git a/arch/arm/kernel/ecard.c b/arch/arm/kernel/ecard.c
index 8bfd299bfe77..f5cfdabcb87d 100644
--- a/arch/arm/kernel/ecard.c
+++ b/arch/arm/kernel/ecard.c
@@ -783,7 +783,7 @@ static void ecard_proc_init(void)
 
 #define ec_set_resource(ec,nr,st,sz)                            \
         do {                                                    \
-                (ec)->resource[nr].name = ec->dev.bus_id;       \
+                (ec)->resource[nr].name = dev_name(&ec->dev);   \
                 (ec)->resource[nr].start = st;                  \
                 (ec)->resource[nr].end = (st) + (sz) - 1;       \
                 (ec)->resource[nr].flags = IORESOURCE_MEM;      \
@@ -853,8 +853,7 @@ static struct expansion_card *__init ecard_alloc_card(int type, int slot)
         for (i = 0; i < ECARD_NUM_RESOURCES; i++) {
                 if (ec->resource[i].flags &&
                     request_resource(&iomem_resource, &ec->resource[i])) {
-                        printk(KERN_ERR "%s: resource(s) not available\n",
-                                ec->dev.bus_id);
+                        dev_err(&ec->dev, "resource(s) not available\n");
                         ec->resource[i].end -= ec->resource[i].start;
                         ec->resource[i].start = 0;
                         ec->resource[i].flags = 0;
diff --git a/arch/arm/kernel/kgdb.c b/arch/arm/kernel/kgdb.c
new file mode 100644
index 000000000000..aaffaecffcd1
--- /dev/null
+++ b/arch/arm/kernel/kgdb.c
@@ -0,0 +1,201 @@
+/*
+ * arch/arm/kernel/kgdb.c
+ *
+ * ARM KGDB support
+ *
+ * Copyright (c) 2002-2004 MontaVista Software, Inc
+ * Copyright (c) 2008 Wind River Systems, Inc.
+ *
+ * Authors:  George Davis <davis_g@mvista.com>
+ *           Deepak Saxena <dsaxena@plexity.net>
+ */
+#include <linux/kgdb.h>
+#include <asm/traps.h>
+
+/* Make a local copy of the registers passed into the handler (bletch) */
+void pt_regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs *kernel_regs)
+{
+        int regno;
+
+        /* Initialize all to zero. */
+        for (regno = 0; regno < GDB_MAX_REGS; regno++)
+                gdb_regs[regno] = 0;
+
+        gdb_regs[_R0]           = kernel_regs->ARM_r0;
+        gdb_regs[_R1]           = kernel_regs->ARM_r1;
+        gdb_regs[_R2]           = kernel_regs->ARM_r2;
+        gdb_regs[_R3]           = kernel_regs->ARM_r3;
+        gdb_regs[_R4]           = kernel_regs->ARM_r4;
+        gdb_regs[_R5]           = kernel_regs->ARM_r5;
+        gdb_regs[_R6]           = kernel_regs->ARM_r6;
+        gdb_regs[_R7]           = kernel_regs->ARM_r7;
+        gdb_regs[_R8]           = kernel_regs->ARM_r8;
+        gdb_regs[_R9]           = kernel_regs->ARM_r9;
+        gdb_regs[_R10]          = kernel_regs->ARM_r10;
+        gdb_regs[_FP]           = kernel_regs->ARM_fp;
+        gdb_regs[_IP]           = kernel_regs->ARM_ip;
+        gdb_regs[_SPT]          = kernel_regs->ARM_sp;
+        gdb_regs[_LR]           = kernel_regs->ARM_lr;
+        gdb_regs[_PC]           = kernel_regs->ARM_pc;
+        gdb_regs[_CPSR]         = kernel_regs->ARM_cpsr;
+}
+
+/* Copy local gdb registers back to kgdb regs, for later copy to kernel */
+void gdb_regs_to_pt_regs(unsigned long *gdb_regs, struct pt_regs *kernel_regs)
+{
+        kernel_regs->ARM_r0     = gdb_regs[_R0];
+        kernel_regs->ARM_r1     = gdb_regs[_R1];
+        kernel_regs->ARM_r2     = gdb_regs[_R2];
+        kernel_regs->ARM_r3     = gdb_regs[_R3];
+        kernel_regs->ARM_r4     = gdb_regs[_R4];
+        kernel_regs->ARM_r5     = gdb_regs[_R5];
+        kernel_regs->ARM_r6     = gdb_regs[_R6];
+        kernel_regs->ARM_r7     = gdb_regs[_R7];
+        kernel_regs->ARM_r8     = gdb_regs[_R8];
+        kernel_regs->ARM_r9     = gdb_regs[_R9];
+        kernel_regs->ARM_r10    = gdb_regs[_R10];
+        kernel_regs->ARM_fp     = gdb_regs[_FP];
+        kernel_regs->ARM_ip     = gdb_regs[_IP];
+        kernel_regs->ARM_sp     = gdb_regs[_SPT];
+        kernel_regs->ARM_lr     = gdb_regs[_LR];
+        kernel_regs->ARM_pc     = gdb_regs[_PC];
+        kernel_regs->ARM_cpsr   = gdb_regs[_CPSR];
+}
+
+void
+sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *task)
+{
+        struct pt_regs *thread_regs;
+        int regno;
+
+        /* Just making sure... */
+        if (task == NULL)
+                return;
+
+        /* Initialize to zero */
+        for (regno = 0; regno < GDB_MAX_REGS; regno++)
+                gdb_regs[regno] = 0;
+
+        /* Otherwise, we have only some registers from switch_to() */
+        thread_regs             = task_pt_regs(task);
+        gdb_regs[_R0]           = thread_regs->ARM_r0;
+        gdb_regs[_R1]           = thread_regs->ARM_r1;
+        gdb_regs[_R2]           = thread_regs->ARM_r2;
+        gdb_regs[_R3]           = thread_regs->ARM_r3;
+        gdb_regs[_R4]           = thread_regs->ARM_r4;
+        gdb_regs[_R5]           = thread_regs->ARM_r5;
+        gdb_regs[_R6]           = thread_regs->ARM_r6;
+        gdb_regs[_R7]           = thread_regs->ARM_r7;
+        gdb_regs[_R8]           = thread_regs->ARM_r8;
+        gdb_regs[_R9]           = thread_regs->ARM_r9;
+        gdb_regs[_R10]          = thread_regs->ARM_r10;
+        gdb_regs[_FP]           = thread_regs->ARM_fp;
+        gdb_regs[_IP]           = thread_regs->ARM_ip;
+        gdb_regs[_SPT]          = thread_regs->ARM_sp;
+        gdb_regs[_LR]           = thread_regs->ARM_lr;
+        gdb_regs[_PC]           = thread_regs->ARM_pc;
+        gdb_regs[_CPSR]         = thread_regs->ARM_cpsr;
+}
+
+static int compiled_break;
+
+int kgdb_arch_handle_exception(int exception_vector, int signo,
+                               int err_code, char *remcom_in_buffer,
+                               char *remcom_out_buffer,
+                               struct pt_regs *linux_regs)
+{
+        unsigned long addr;
+        char *ptr;
+
+        switch (remcom_in_buffer[0]) {
+        case 'D':
+        case 'k':
+        case 'c':
+                kgdb_contthread = NULL;
+
+                /*
+                 * Try to read optional parameter, pc unchanged if no parm.
+                 * If this was a compiled breakpoint, we need to move
+                 * to the next instruction or we will just breakpoint
+                 * over and over again.
+                 */
+                ptr = &remcom_in_buffer[1];
+                if (kgdb_hex2long(&ptr, &addr))
+                        linux_regs->ARM_pc = addr;
+                else if (compiled_break == 1)
+                        linux_regs->ARM_pc += 4;
+
+                compiled_break = 0;
+
+                return 0;
+        }
+
+        return -1;
+}
+
+static int kgdb_brk_fn(struct pt_regs *regs, unsigned int instr)
+{
+        kgdb_handle_exception(1, SIGTRAP, 0, regs);
+
+        return 0;
+}
+
+static int kgdb_compiled_brk_fn(struct pt_regs *regs, unsigned int instr)
+{
+        compiled_break = 1;
+        kgdb_handle_exception(1, SIGTRAP, 0, regs);
+
+        return 0;
+}
+
+static struct undef_hook kgdb_brkpt_hook = {
+        .instr_mask             = 0xffffffff,
+        .instr_val              = KGDB_BREAKINST,
+        .fn                     = kgdb_brk_fn
+};
+
+static struct undef_hook kgdb_compiled_brkpt_hook = {
+        .instr_mask             = 0xffffffff,
+        .instr_val              = KGDB_COMPILED_BREAK,
+        .fn                     = kgdb_compiled_brk_fn
+};
+
+/**
+ *      kgdb_arch_init - Perform any architecture specific initalization.
+ *
+ *      This function will handle the initalization of any architecture
+ *      specific callbacks.
+ */
+int kgdb_arch_init(void)
+{
+        register_undef_hook(&kgdb_brkpt_hook);
+        register_undef_hook(&kgdb_compiled_brkpt_hook);
+
+        return 0;
+}
+
+/**
+ *      kgdb_arch_exit - Perform any architecture specific uninitalization.
+ *
+ *      This function will handle the uninitalization of any architecture
+ *      specific callbacks, for dynamic registration and unregistration.
+ */
+void kgdb_arch_exit(void)
+{
+        unregister_undef_hook(&kgdb_brkpt_hook);
+        unregister_undef_hook(&kgdb_compiled_brkpt_hook);
+}
+
+/*
+ * Register our undef instruction hooks with ARM undef core.
+ * We regsiter a hook specifically looking for the KGB break inst
+ * and we handle the normal undef case within the do_undefinstr
+ * handler.
+ */
+struct kgdb_arch arch_kgdb_ops = {
+#ifndef __ARMEB__
+        .gdb_bpt_instr          = {0xfe, 0xde, 0xff, 0xe7}
+#else /* ! __ARMEB__ */
+        .gdb_bpt_instr          = {0xe7, 0xff, 0xde, 0xfe}
+#endif
+};
diff --git a/arch/arm/kernel/kprobes.c b/arch/arm/kernel/kprobes.c
index 5ee39e10c8d1..d28513f14d05 100644
--- a/arch/arm/kernel/kprobes.c
+++ b/arch/arm/kernel/kprobes.c
@@ -296,8 +296,7 @@ static __used __kprobes void *trampoline_handler(struct pt_regs *regs)
         unsigned long trampoline_address = (unsigned long)&kretprobe_trampoline;
 
         INIT_HLIST_HEAD(&empty_rp);
-        spin_lock_irqsave(&kretprobe_lock, flags);
-        head = kretprobe_inst_table_head(current);
+        kretprobe_hash_lock(current, &head, &flags);
 
         /*
          * It is possible to have multiple instances associated with a given
@@ -337,7 +336,7 @@ static __used __kprobes void *trampoline_handler(struct pt_regs *regs)
         }
 
         kretprobe_assert(ri, orig_ret_address, trampoline_address);
-        spin_unlock_irqrestore(&kretprobe_lock, flags);
+        kretprobe_hash_unlock(current, &flags);
 
         hlist_for_each_entry_safe(ri, node, tmp, &empty_rp, hlist) {
                 hlist_del(&ri->hlist);
@@ -347,7 +346,6 @@ static __used __kprobes void *trampoline_handler(struct pt_regs *regs)
         return (void *)orig_ret_address;
 }
 
-/* Called with kretprobe_lock held. */
 void __kprobes arch_prepare_kretprobe(struct kretprobe_instance *ri,
                                       struct pt_regs *regs)
 {
diff --git a/arch/arm/kernel/module.c b/arch/arm/kernel/module.c
index 79b7e5cf5416..a68259a0cccd 100644
--- a/arch/arm/kernel/module.c
+++ b/arch/arm/kernel/module.c
@@ -13,6 +13,7 @@
 #include <linux/module.h>
 #include <linux/moduleloader.h>
 #include <linux/kernel.h>
+#include <linux/mm.h>
 #include <linux/elf.h>
 #include <linux/vmalloc.h>
 #include <linux/slab.h>
diff --git a/arch/arm/kernel/process.c b/arch/arm/kernel/process.c
index 199b3680118b..89bfded70a1f 100644
--- a/arch/arm/kernel/process.c
+++ b/arch/arm/kernel/process.c
@@ -162,7 +162,7 @@ void cpu_idle(void)
                 if (!idle)
                         idle = default_idle;
                 leds_event(led_idle_start);
-                tick_nohz_stop_sched_tick();
+                tick_nohz_stop_sched_tick(1);
                 while (!need_resched())
                         idle();
                 leds_event(led_idle_end);
diff --git a/arch/arm/kernel/setup.c b/arch/arm/kernel/setup.c
index b7b0720bc1bb..38f0e7940a13 100644
--- a/arch/arm/kernel/setup.c
+++ b/arch/arm/kernel/setup.c
@@ -36,6 +36,7 @@
 #include <asm/mach/arch.h>
 #include <asm/mach/irq.h>
 #include <asm/mach/time.h>
+#include <asm/traps.h>
 
 #include "compat.h"
 #include "atags.h"
@@ -853,6 +854,7 @@ void __init setup_arch(char **cmdline_p)
         conswitchp = &dummy_con;
 #endif
 #endif
+        early_trap_init();
 }
 
 
diff --git a/arch/arm/kernel/time.c b/arch/arm/kernel/time.c
index cc5145b28e7f..368d171754cf 100644
--- a/arch/arm/kernel/time.c
+++ b/arch/arm/kernel/time.c
@@ -130,7 +130,9 @@ static const struct leds_evt_name evt_names[] = {
         { "red",   led_red_on,   led_red_off   },
 };
 
-static ssize_t leds_store(struct sys_device *dev, const char *buf, size_t size)
+static ssize_t leds_store(struct sys_device *dev,
+                        struct sysdev_attribute *attr,
+                        const char *buf, size_t size)
 {
         int ret = -EINVAL, len = strcspn(buf, " ");
 
diff --git a/arch/arm/kernel/traps.c b/arch/arm/kernel/traps.c
index 5595fdd75e82..7277aef83098 100644
--- a/arch/arm/kernel/traps.c
+++ b/arch/arm/kernel/traps.c
@@ -708,6 +708,11 @@ EXPORT_SYMBOL(abort);
 
 void __init trap_init(void)
 {
+        return;
+}
+
+void __init early_trap_init(void)
+{
         unsigned long vectors = CONFIG_VECTORS_BASE;
         extern char __stubs_start[], __stubs_end[];
         extern char __vectors_start[], __vectors_end[];