Merge branch 'master' of /home/davem/src/GIT/linux-2.6/

74 files changed, 9944 insertions, 2920 deletions

diff --git a/kernel/Makefile b/kernel/Makefile
index 149e18ef1ab1..057472fbc272 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -75,7 +75,7 @@ obj-$(CONFIG_AUDITSYSCALL) += auditsc.o
 obj-$(CONFIG_GCOV_KERNEL) += gcov/
 obj-$(CONFIG_AUDIT_TREE) += audit_tree.o
 obj-$(CONFIG_KPROBES) += kprobes.o
-obj-$(CONFIG_KGDB) += kgdb.o
+obj-$(CONFIG_KGDB) += debug/
 obj-$(CONFIG_DETECT_SOFTLOCKUP) += softlockup.o
 obj-$(CONFIG_DETECT_HUNG_TASK) += hung_task.o
 obj-$(CONFIG_GENERIC_HARDIRQS) += irq/
diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index 291775021b2e..422cb19f156e 100644
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -2994,7 +2994,6 @@ static void cgroup_event_remove(struct work_struct *work)
                         remove);
         struct cgroup *cgrp = event->cgrp;
 
-        /* TODO: check return code */
         event->cft->unregister_event(cgrp, event->cft, event->eventfd);
 
         eventfd_ctx_put(event->eventfd);
diff --git a/kernel/cpu.c b/kernel/cpu.c
index 545777574779..8b92539b4754 100644
--- a/kernel/cpu.c
+++ b/kernel/cpu.c
@@ -20,6 +20,20 @@
 /* Serializes the updates to cpu_online_mask, cpu_present_mask */
 static DEFINE_MUTEX(cpu_add_remove_lock);
 
+/*
+ * The following two API's must be used when attempting
+ * to serialize the updates to cpu_online_mask, cpu_present_mask.
+ */
+void cpu_maps_update_begin(void)
+{
+        mutex_lock(&cpu_add_remove_lock);
+}
+
+void cpu_maps_update_done(void)
+{
+        mutex_unlock(&cpu_add_remove_lock);
+}
+
 static __cpuinitdata RAW_NOTIFIER_HEAD(cpu_chain);
 
 /* If set, cpu_up and cpu_down will return -EBUSY and do nothing.
@@ -27,6 +41,8 @@ static __cpuinitdata RAW_NOTIFIER_HEAD(cpu_chain);
  */
 static int cpu_hotplug_disabled;
 
+#ifdef CONFIG_HOTPLUG_CPU
+
 static struct {
         struct task_struct *active_writer;
         struct mutex lock; /* Synchronizes accesses to refcount, */
@@ -41,8 +57,6 @@ static struct {
         .refcount = 0,
 };
 
-#ifdef CONFIG_HOTPLUG_CPU
-
 void get_online_cpus(void)
 {
         might_sleep();
@@ -67,22 +81,6 @@ void put_online_cpus(void)
 }
 EXPORT_SYMBOL_GPL(put_online_cpus);
 
-#endif  /* CONFIG_HOTPLUG_CPU */
-
-/*
- * The following two API's must be used when attempting
- * to serialize the updates to cpu_online_mask, cpu_present_mask.
- */
-void cpu_maps_update_begin(void)
-{
-        mutex_lock(&cpu_add_remove_lock);
-}
-
-void cpu_maps_update_done(void)
-{
-        mutex_unlock(&cpu_add_remove_lock);
-}
-
 /*
  * This ensures that the hotplug operation can begin only when the
  * refcount goes to zero.
@@ -124,6 +122,12 @@ static void cpu_hotplug_done(void)
         cpu_hotplug.active_writer = NULL;
         mutex_unlock(&cpu_hotplug.lock);
 }
+
+#else /* #if CONFIG_HOTPLUG_CPU */
+static void cpu_hotplug_begin(void) {}
+static void cpu_hotplug_done(void) {}
+#endif  /* #esle #if CONFIG_HOTPLUG_CPU */
+
 /* Need to know about CPUs going up/down? */
 int __ref register_cpu_notifier(struct notifier_block *nb)
 {
@@ -134,8 +138,29 @@ int __ref register_cpu_notifier(struct notifier_block *nb)
         return ret;
 }
 
+static int __cpu_notify(unsigned long val, void *v, int nr_to_call,
+                        int *nr_calls)
+{
+        int ret;
+
+        ret = __raw_notifier_call_chain(&cpu_chain, val, v, nr_to_call,
+                                        nr_calls);
+
+        return notifier_to_errno(ret);
+}
+
+static int cpu_notify(unsigned long val, void *v)
+{
+        return __cpu_notify(val, v, -1, NULL);
+}
+
 #ifdef CONFIG_HOTPLUG_CPU
 
+static void cpu_notify_nofail(unsigned long val, void *v)
+{
+        BUG_ON(cpu_notify(val, v));
+}
+
 EXPORT_SYMBOL(register_cpu_notifier);
 
 void __ref unregister_cpu_notifier(struct notifier_block *nb)
@@ -181,8 +206,7 @@ static int __ref take_cpu_down(void *_param)
         if (err < 0)
                 return err;
 
-        raw_notifier_call_chain(&cpu_chain, CPU_DYING | param->mod,
-                                param->hcpu);
+        cpu_notify(CPU_DYING | param->mod, param->hcpu);
 
         if (task_cpu(param->caller) == cpu)
                 move_task_off_dead_cpu(cpu, param->caller);
@@ -212,17 +236,14 @@ static int __ref _cpu_down(unsigned int cpu, int tasks_frozen)
 
         cpu_hotplug_begin();
         set_cpu_active(cpu, false);
-        err = __raw_notifier_call_chain(&cpu_chain, CPU_DOWN_PREPARE | mod,
-                                        hcpu, -1, &nr_calls);
-        if (err == NOTIFY_BAD) {
+        err = __cpu_notify(CPU_DOWN_PREPARE | mod, hcpu, -1, &nr_calls);
+        if (err) {
                 set_cpu_active(cpu, true);
 
                 nr_calls--;
-                __raw_notifier_call_chain(&cpu_chain, CPU_DOWN_FAILED | mod,
-                                          hcpu, nr_calls, NULL);
+                __cpu_notify(CPU_DOWN_FAILED | mod, hcpu, nr_calls, NULL);
                 printk("%s: attempt to take down CPU %u failed\n",
                                 __func__, cpu);
-                err = -EINVAL;
                 goto out_release;
         }
 
@@ -230,9 +251,7 @@ static int __ref _cpu_down(unsigned int cpu, int tasks_frozen)
         if (err) {
                 set_cpu_active(cpu, true);
                 /* CPU didn't die: tell everyone.  Can't complain. */
-                if (raw_notifier_call_chain(&cpu_chain, CPU_DOWN_FAILED | mod,
-                                            hcpu) == NOTIFY_BAD)
-                        BUG();
+                cpu_notify_nofail(CPU_DOWN_FAILED | mod, hcpu);
 
                 goto out_release;
         }
@@ -246,19 +265,14 @@ static int __ref _cpu_down(unsigned int cpu, int tasks_frozen)
         __cpu_die(cpu);
 
         /* CPU is completely dead: tell everyone.  Too late to complain. */
-        if (raw_notifier_call_chain(&cpu_chain, CPU_DEAD | mod,
-                                    hcpu) == NOTIFY_BAD)
-                BUG();
+        cpu_notify_nofail(CPU_DEAD | mod, hcpu);
 
         check_for_tasks(cpu);
 
 out_release:
         cpu_hotplug_done();
-        if (!err) {
-                if (raw_notifier_call_chain(&cpu_chain, CPU_POST_DEAD | mod,
-                                            hcpu) == NOTIFY_BAD)
-                        BUG();
-        }
+        if (!err)
+                cpu_notify_nofail(CPU_POST_DEAD | mod, hcpu);
         return err;
 }
 
@@ -293,13 +307,11 @@ static int __cpuinit _cpu_up(unsigned int cpu, int tasks_frozen)
                 return -EINVAL;
 
         cpu_hotplug_begin();
-        ret = __raw_notifier_call_chain(&cpu_chain, CPU_UP_PREPARE | mod, hcpu,
-                                                        -1, &nr_calls);
-        if (ret == NOTIFY_BAD) {
+        ret = __cpu_notify(CPU_UP_PREPARE | mod, hcpu, -1, &nr_calls);
+        if (ret) {
                 nr_calls--;
                 printk("%s: attempt to bring up CPU %u failed\n",
                                 __func__, cpu);
-                ret = -EINVAL;
                 goto out_notify;
         }
 
@@ -312,12 +324,11 @@ static int __cpuinit _cpu_up(unsigned int cpu, int tasks_frozen)
         set_cpu_active(cpu, true);
 
         /* Now call notifier in preparation. */
-        raw_notifier_call_chain(&cpu_chain, CPU_ONLINE | mod, hcpu);
+        cpu_notify(CPU_ONLINE | mod, hcpu);
 
 out_notify:
         if (ret != 0)
-                __raw_notifier_call_chain(&cpu_chain,
-                                CPU_UP_CANCELED | mod, hcpu, nr_calls, NULL);
+                __cpu_notify(CPU_UP_CANCELED | mod, hcpu, nr_calls, NULL);
         cpu_hotplug_done();
 
         return ret;
@@ -326,6 +337,12 @@ out_notify:
 int __cpuinit cpu_up(unsigned int cpu)
 {
         int err = 0;
+
+#ifdef  CONFIG_MEMORY_HOTPLUG
+        int nid;
+        pg_data_t       *pgdat;
+#endif
+
         if (!cpu_possible(cpu)) {
                 printk(KERN_ERR "can't online cpu %d because it is not "
                         "configured as may-hotadd at boot time\n", cpu);
@@ -336,6 +353,28 @@ int __cpuinit cpu_up(unsigned int cpu)
                 return -EINVAL;
         }
 
+#ifdef  CONFIG_MEMORY_HOTPLUG
+        nid = cpu_to_node(cpu);
+        if (!node_online(nid)) {
+                err = mem_online_node(nid);
+                if (err)
+                        return err;
+        }
+
+        pgdat = NODE_DATA(nid);
+        if (!pgdat) {
+                printk(KERN_ERR
+                        "Can't online cpu %d due to NULL pgdat\n", cpu);
+                return -ENOMEM;
+        }
+
+        if (pgdat->node_zonelists->_zonerefs->zone == NULL) {
+                mutex_lock(&zonelists_mutex);
+                build_all_zonelists(NULL);
+                mutex_unlock(&zonelists_mutex);
+        }
+#endif
+
         cpu_maps_update_begin();
 
         if (cpu_hotplug_disabled) {
@@ -355,7 +394,7 @@ static cpumask_var_t frozen_cpus;
 
 int disable_nonboot_cpus(void)
 {
-        int cpu, first_cpu, error;
+        int cpu, first_cpu, error = 0;
 
         cpu_maps_update_begin();
         first_cpu = cpumask_first(cpu_online_mask);
@@ -453,7 +492,7 @@ void __cpuinit notify_cpu_starting(unsigned int cpu)
         if (frozen_cpus != NULL && cpumask_test_cpu(cpu, frozen_cpus))
                 val = CPU_STARTING_FROZEN;
 #endif /* CONFIG_PM_SLEEP_SMP */
-        raw_notifier_call_chain(&cpu_chain, val, (void *)(long)cpu);
+        cpu_notify(val, (void *)(long)cpu);
 }
 
 #endif /* CONFIG_SMP */
diff --git a/kernel/cpuset.c b/kernel/cpuset.c
index 9a50c5f6e727..02b9611eadde 100644
--- a/kernel/cpuset.c
+++ b/kernel/cpuset.c
@@ -946,16 +946,62 @@ static void cpuset_migrate_mm(struct mm_struct *mm, const nodemask_t *from,
  * In order to avoid seeing no nodes if the old and new nodes are disjoint,
  * we structure updates as setting all new allowed nodes, then clearing newly
  * disallowed ones.
- *
- * Called with task's alloc_lock held
  */
 static void cpuset_change_task_nodemask(struct task_struct *tsk,
                                         nodemask_t *newmems)
 {
+repeat:
+        /*
+         * Allow tasks that have access to memory reserves because they have
+         * been OOM killed to get memory anywhere.
+         */
+        if (unlikely(test_thread_flag(TIF_MEMDIE)))
+                return;
+        if (current->flags & PF_EXITING) /* Let dying task have memory */
+                return;
+
+        task_lock(tsk);
         nodes_or(tsk->mems_allowed, tsk->mems_allowed, *newmems);
-        mpol_rebind_task(tsk, &tsk->mems_allowed);
-        mpol_rebind_task(tsk, newmems);
+        mpol_rebind_task(tsk, newmems, MPOL_REBIND_STEP1);
+
+
+        /*
+         * ensure checking ->mems_allowed_change_disable after setting all new
+         * allowed nodes.
+         *
+         * the read-side task can see an nodemask with new allowed nodes and
+         * old allowed nodes. and if it allocates page when cpuset clears newly
+         * disallowed ones continuous, it can see the new allowed bits.
+         *
+         * And if setting all new allowed nodes is after the checking, setting
+         * all new allowed nodes and clearing newly disallowed ones will be done
+         * continuous, and the read-side task may find no node to alloc page.
+         */
+        smp_mb();
+
+        /*
+         * Allocation of memory is very fast, we needn't sleep when waiting
+         * for the read-side.
+         */
+        while (ACCESS_ONCE(tsk->mems_allowed_change_disable)) {
+                task_unlock(tsk);
+                if (!task_curr(tsk))
+                        yield();
+                goto repeat;
+        }
+
+        /*
+         * ensure checking ->mems_allowed_change_disable before clearing all new
+         * disallowed nodes.
+         *
+         * if clearing newly disallowed bits before the checking, the read-side
+         * task may find no node to alloc page.
+         */
+        smp_mb();
+
+        mpol_rebind_task(tsk, newmems, MPOL_REBIND_STEP2);
         tsk->mems_allowed = *newmems;
+        task_unlock(tsk);
 }
 
 /*
@@ -978,9 +1024,7 @@ static void cpuset_change_nodemask(struct task_struct *p,
         cs = cgroup_cs(scan->cg);
         guarantee_online_mems(cs, newmems);
 
-        task_lock(p);
         cpuset_change_task_nodemask(p, newmems);
-        task_unlock(p);
 
         NODEMASK_FREE(newmems);
 
@@ -1383,9 +1427,7 @@ static void cpuset_attach_task(struct task_struct *tsk, nodemask_t *to,
         err = set_cpus_allowed_ptr(tsk, cpus_attach);
         WARN_ON_ONCE(err);
 
-        task_lock(tsk);
         cpuset_change_task_nodemask(tsk, to);
-        task_unlock(tsk);
         cpuset_update_task_spread_flag(cs, tsk);
 
 }
@@ -2427,7 +2469,8 @@ void cpuset_unlock(void)
 }
 
 /**
- * cpuset_mem_spread_node() - On which node to begin search for a page
+ * cpuset_mem_spread_node() - On which node to begin search for a file page
+ * cpuset_slab_spread_node() - On which node to begin search for a slab page
  *
  * If a task is marked PF_SPREAD_PAGE or PF_SPREAD_SLAB (as for
  * tasks in a cpuset with is_spread_page or is_spread_slab set),
@@ -2452,16 +2495,27 @@ void cpuset_unlock(void)
  * See kmem_cache_alloc_node().
  */
 
-int cpuset_mem_spread_node(void)
+static int cpuset_spread_node(int *rotor)
 {
         int node;
 
-        node = next_node(current->cpuset_mem_spread_rotor, current->mems_allowed);
+        node = next_node(*rotor, current->mems_allowed);
         if (node == MAX_NUMNODES)
                 node = first_node(current->mems_allowed);
-        current->cpuset_mem_spread_rotor = node;
+        *rotor = node;
         return node;
 }
+
+int cpuset_mem_spread_node(void)
+{
+        return cpuset_spread_node(&current->cpuset_mem_spread_rotor);
+}
+
+int cpuset_slab_spread_node(void)
+{
+        return cpuset_spread_node(&current->cpuset_slab_spread_rotor);
+}
+
 EXPORT_SYMBOL_GPL(cpuset_mem_spread_node);
 
 /**
diff --git a/kernel/cred.c b/kernel/cred.c
index 2c24870c55d1..a2d5504fbcc2 100644
--- a/kernel/cred.c
+++ b/kernel/cred.c
@@ -347,66 +347,6 @@ struct cred *prepare_exec_creds(void)
 }
 
 /*
- * prepare new credentials for the usermode helper dispatcher
- */
-struct cred *prepare_usermodehelper_creds(void)
-{
-#ifdef CONFIG_KEYS
-        struct thread_group_cred *tgcred = NULL;
-#endif
-        struct cred *new;
-
-#ifdef CONFIG_KEYS
-        tgcred = kzalloc(sizeof(*new->tgcred), GFP_ATOMIC);
-        if (!tgcred)
-                return NULL;
-#endif
-
-        new = kmem_cache_alloc(cred_jar, GFP_ATOMIC);
-        if (!new)
-                goto free_tgcred;
-
-        kdebug("prepare_usermodehelper_creds() alloc %p", new);
-
-        memcpy(new, &init_cred, sizeof(struct cred));
-
-        atomic_set(&new->usage, 1);
-        set_cred_subscribers(new, 0);
-        get_group_info(new->group_info);
-        get_uid(new->user);
-
-#ifdef CONFIG_KEYS
-        new->thread_keyring = NULL;
-        new->request_key_auth = NULL;
-        new->jit_keyring = KEY_REQKEY_DEFL_DEFAULT;
-
-        atomic_set(&tgcred->usage, 1);
-        spin_lock_init(&tgcred->lock);
-        new->tgcred = tgcred;
-#endif
-
-#ifdef CONFIG_SECURITY
-        new->security = NULL;
-#endif
-        if (security_prepare_creds(new, &init_cred, GFP_ATOMIC) < 0)
-                goto error;
-        validate_creds(new);
-
-        BUG_ON(atomic_read(&new->usage) != 1);
-        return new;
-
-error:
-        put_cred(new);
-        return NULL;
-
-free_tgcred:
-#ifdef CONFIG_KEYS
-        kfree(tgcred);
-#endif
-        return NULL;
-}
-
-/*
  * Copy credentials for the new process created by fork()
  *
  * We share if we can, but under some circumstances we have to generate a new
diff --git a/kernel/debug/Makefile b/kernel/debug/Makefile
new file mode 100644
index 000000000000..a85edc339985
--- /dev/null
+++ b/kernel/debug/Makefile
@@ -0,0 +1,6 @@
+#
+# Makefile for the linux kernel debugger
+#
+
+obj-$(CONFIG_KGDB) += debug_core.o gdbstub.o
+obj-$(CONFIG_KGDB_KDB) += kdb/
diff --git a/kernel/debug/debug_core.c b/kernel/debug/debug_core.c
new file mode 100644
index 000000000000..5cb7cd1de10c
--- /dev/null
+++ b/kernel/debug/debug_core.c
@@ -0,0 +1,983 @@
+/*
+ * Kernel Debug Core
+ *
+ * Maintainer: Jason Wessel <jason.wessel@windriver.com>
+ *
+ * Copyright (C) 2000-2001 VERITAS Software Corporation.
+ * Copyright (C) 2002-2004 Timesys Corporation
+ * Copyright (C) 2003-2004 Amit S. Kale <amitkale@linsyssoft.com>
+ * Copyright (C) 2004 Pavel Machek <pavel@suse.cz>
+ * Copyright (C) 2004-2006 Tom Rini <trini@kernel.crashing.org>
+ * Copyright (C) 2004-2006 LinSysSoft Technologies Pvt. Ltd.
+ * Copyright (C) 2005-2009 Wind River Systems, Inc.
+ * Copyright (C) 2007 MontaVista Software, Inc.
+ * Copyright (C) 2008 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
+ *
+ * Contributors at various stages not listed above:
+ *  Jason Wessel ( jason.wessel@windriver.com )
+ *  George Anzinger <george@mvista.com>
+ *  Anurekh Saxena (anurekh.saxena@timesys.com)
+ *  Lake Stevens Instrument Division (Glenn Engel)
+ *  Jim Kingdon, Cygnus Support.
+ *
+ * Original KGDB stub: David Grothe <dave@gcom.com>,
+ * Tigran Aivazian <tigran@sco.com>
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2. This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ */
+#include <linux/pid_namespace.h>
+#include <linux/clocksource.h>
+#include <linux/interrupt.h>
+#include <linux/spinlock.h>
+#include <linux/console.h>
+#include <linux/threads.h>
+#include <linux/uaccess.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/ptrace.h>
+#include <linux/string.h>
+#include <linux/delay.h>
+#include <linux/sched.h>
+#include <linux/sysrq.h>
+#include <linux/init.h>
+#include <linux/kgdb.h>
+#include <linux/kdb.h>
+#include <linux/pid.h>
+#include <linux/smp.h>
+#include <linux/mm.h>
+
+#include <asm/cacheflush.h>
+#include <asm/byteorder.h>
+#include <asm/atomic.h>
+#include <asm/system.h>
+
+#include "debug_core.h"
+
+static int kgdb_break_asap;
+
+struct debuggerinfo_struct kgdb_info[NR_CPUS];
+
+/**
+ * kgdb_connected - Is a host GDB connected to us?
+ */
+int                             kgdb_connected;
+EXPORT_SYMBOL_GPL(kgdb_connected);
+
+/* All the KGDB handlers are installed */
+int                     kgdb_io_module_registered;
+
+/* Guard for recursive entry */
+static int                      exception_level;
+
+struct kgdb_io          *dbg_io_ops;
+static DEFINE_SPINLOCK(kgdb_registration_lock);
+
+/* kgdb console driver is loaded */
+static int kgdb_con_registered;
+/* determine if kgdb console output should be used */
+static int kgdb_use_con;
+/* Flag for alternate operations for early debugging */
+bool dbg_is_early = true;
+/* Next cpu to become the master debug core */
+int dbg_switch_cpu;
+
+/* Use kdb or gdbserver mode */
+int dbg_kdb_mode = 1;
+
+static int __init opt_kgdb_con(char *str)
+{
+        kgdb_use_con = 1;
+        return 0;
+}
+
+early_param("kgdbcon", opt_kgdb_con);
+
+module_param(kgdb_use_con, int, 0644);
+
+/*
+ * Holds information about breakpoints in a kernel. These breakpoints are
+ * added and removed by gdb.
+ */
+static struct kgdb_bkpt         kgdb_break[KGDB_MAX_BREAKPOINTS] = {
+        [0 ... KGDB_MAX_BREAKPOINTS-1] = { .state = BP_UNDEFINED }
+};
+
+/*
+ * The CPU# of the active CPU, or -1 if none:
+ */
+atomic_t                        kgdb_active = ATOMIC_INIT(-1);
+EXPORT_SYMBOL_GPL(kgdb_active);
+
+/*
+ * We use NR_CPUs not PERCPU, in case kgdb is used to debug early
+ * bootup code (which might not have percpu set up yet):
+ */
+static atomic_t                 passive_cpu_wait[NR_CPUS];
+static atomic_t                 cpu_in_kgdb[NR_CPUS];
+static atomic_t                 kgdb_break_tasklet_var;
+atomic_t                        kgdb_setting_breakpoint;
+
+struct task_struct              *kgdb_usethread;
+struct task_struct              *kgdb_contthread;
+
+int                             kgdb_single_step;
+static pid_t                    kgdb_sstep_pid;
+
+/* to keep track of the CPU which is doing the single stepping*/
+atomic_t                        kgdb_cpu_doing_single_step = ATOMIC_INIT(-1);
+
+/*
+ * If you are debugging a problem where roundup (the collection of
+ * all other CPUs) is a problem [this should be extremely rare],
+ * then use the nokgdbroundup option to avoid roundup. In that case
+ * the other CPUs might interfere with your debugging context, so
+ * use this with care:
+ */
+static int kgdb_do_roundup = 1;
+
+static int __init opt_nokgdbroundup(char *str)
+{
+        kgdb_do_roundup = 0;
+
+        return 0;
+}
+
+early_param("nokgdbroundup", opt_nokgdbroundup);
+
+/*
+ * Finally, some KGDB code :-)
+ */
+
+/*
+ * Weak aliases for breakpoint management,
+ * can be overriden by architectures when needed:
+ */
+int __weak kgdb_arch_set_breakpoint(unsigned long addr, char *saved_instr)
+{
+        int err;
+
+        err = probe_kernel_read(saved_instr, (char *)addr, BREAK_INSTR_SIZE);
+        if (err)
+                return err;
+
+        return probe_kernel_write((char *)addr, arch_kgdb_ops.gdb_bpt_instr,
+                                  BREAK_INSTR_SIZE);
+}
+
+int __weak kgdb_arch_remove_breakpoint(unsigned long addr, char *bundle)
+{
+        return probe_kernel_write((char *)addr,
+                                  (char *)bundle, BREAK_INSTR_SIZE);
+}
+
+int __weak kgdb_validate_break_address(unsigned long addr)
+{
+        char tmp_variable[BREAK_INSTR_SIZE];
+        int err;
+        /* Validate setting the breakpoint and then removing it.  In the
+         * remove fails, the kernel needs to emit a bad message because we
+         * are deep trouble not being able to put things back the way we
+         * found them.
+         */
+        err = kgdb_arch_set_breakpoint(addr, tmp_variable);
+        if (err)
+                return err;
+        err = kgdb_arch_remove_breakpoint(addr, tmp_variable);
+        if (err)
+                printk(KERN_ERR "KGDB: Critical breakpoint error, kernel "
+                   "memory destroyed at: %lx", addr);
+        return err;
+}
+
+unsigned long __weak kgdb_arch_pc(int exception, struct pt_regs *regs)
+{
+        return instruction_pointer(regs);
+}
+
+int __weak kgdb_arch_init(void)
+{
+        return 0;
+}
+
+int __weak kgdb_skipexception(int exception, struct pt_regs *regs)
+{
+        return 0;
+}
+
+/**
+ *      kgdb_disable_hw_debug - Disable hardware debugging while we in kgdb.
+ *      @regs: Current &struct pt_regs.
+ *
+ *      This function will be called if the particular architecture must
+ *      disable hardware debugging while it is processing gdb packets or
+ *      handling exception.
+ */
+void __weak kgdb_disable_hw_debug(struct pt_regs *regs)
+{
+}
+
+/*
+ * Some architectures need cache flushes when we set/clear a
+ * breakpoint:
+ */
+static void kgdb_flush_swbreak_addr(unsigned long addr)
+{
+        if (!CACHE_FLUSH_IS_SAFE)
+                return;
+
+        if (current->mm && current->mm->mmap_cache) {
+                flush_cache_range(current->mm->mmap_cache,
+                                  addr, addr + BREAK_INSTR_SIZE);
+        }
+        /* Force flush instruction cache if it was outside the mm */
+        flush_icache_range(addr, addr + BREAK_INSTR_SIZE);
+}
+
+/*
+ * SW breakpoint management:
+ */
+int dbg_activate_sw_breakpoints(void)
+{
+        unsigned long addr;
+        int error;
+        int ret = 0;
+        int i;
+
+        for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
+                if (kgdb_break[i].state != BP_SET)
+                        continue;
+
+                addr = kgdb_break[i].bpt_addr;
+                error = kgdb_arch_set_breakpoint(addr,
+                                kgdb_break[i].saved_instr);
+                if (error) {
+                        ret = error;
+                        printk(KERN_INFO "KGDB: BP install failed: %lx", addr);
+                        continue;
+                }
+
+                kgdb_flush_swbreak_addr(addr);
+                kgdb_break[i].state = BP_ACTIVE;
+        }
+        return ret;
+}
+
+int dbg_set_sw_break(unsigned long addr)
+{
+        int err = kgdb_validate_break_address(addr);
+        int breakno = -1;
+        int i;
+
+        if (err)
+                return err;
+
+        for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
+                if ((kgdb_break[i].state == BP_SET) &&
+                                        (kgdb_break[i].bpt_addr == addr))
+                        return -EEXIST;
+        }
+        for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
+                if (kgdb_break[i].state == BP_REMOVED &&
+                                        kgdb_break[i].bpt_addr == addr) {
+                        breakno = i;
+                        break;
+                }
+        }
+
+        if (breakno == -1) {
+                for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
+                        if (kgdb_break[i].state == BP_UNDEFINED) {
+                                breakno = i;
+                                break;
+                        }
+                }
+        }
+
+        if (breakno == -1)
+                return -E2BIG;
+
+        kgdb_break[breakno].state = BP_SET;
+        kgdb_break[breakno].type = BP_BREAKPOINT;
+        kgdb_break[breakno].bpt_addr = addr;
+
+        return 0;
+}
+
+int dbg_deactivate_sw_breakpoints(void)
+{
+        unsigned long addr;
+        int error;
+        int ret = 0;
+        int i;
+
+        for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
+                if (kgdb_break[i].state != BP_ACTIVE)
+                        continue;
+                addr = kgdb_break[i].bpt_addr;
+                error = kgdb_arch_remove_breakpoint(addr,
+                                        kgdb_break[i].saved_instr);
+                if (error) {
+                        printk(KERN_INFO "KGDB: BP remove failed: %lx\n", addr);
+                        ret = error;
+                }
+
+                kgdb_flush_swbreak_addr(addr);
+                kgdb_break[i].state = BP_SET;
+        }
+        return ret;
+}
+
+int dbg_remove_sw_break(unsigned long addr)
+{
+        int i;
+
+        for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
+                if ((kgdb_break[i].state == BP_SET) &&
+                                (kgdb_break[i].bpt_addr == addr)) {
+                        kgdb_break[i].state = BP_REMOVED;
+                        return 0;
+                }
+        }
+        return -ENOENT;
+}
+
+int kgdb_isremovedbreak(unsigned long addr)
+{
+        int i;
+
+        for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
+                if ((kgdb_break[i].state == BP_REMOVED) &&
+                                        (kgdb_break[i].bpt_addr == addr))
+                        return 1;
+        }
+        return 0;
+}
+
+int dbg_remove_all_break(void)
+{
+        unsigned long addr;
+        int error;
+        int i;
+
+        /* Clear memory breakpoints. */
+        for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
+                if (kgdb_break[i].state != BP_ACTIVE)
+                        goto setundefined;
+                addr = kgdb_break[i].bpt_addr;
+                error = kgdb_arch_remove_breakpoint(addr,
+                                kgdb_break[i].saved_instr);
+                if (error)
+                        printk(KERN_ERR "KGDB: breakpoint remove failed: %lx\n",
+                           addr);
+setundefined:
+                kgdb_break[i].state = BP_UNDEFINED;
+        }
+
+        /* Clear hardware breakpoints. */
+        if (arch_kgdb_ops.remove_all_hw_break)
+                arch_kgdb_ops.remove_all_hw_break();
+
+        return 0;
+}
+
+/*
+ * Return true if there is a valid kgdb I/O module.  Also if no
+ * debugger is attached a message can be printed to the console about
+ * waiting for the debugger to attach.
+ *
+ * The print_wait argument is only to be true when called from inside
+ * the core kgdb_handle_exception, because it will wait for the
+ * debugger to attach.
+ */
+static int kgdb_io_ready(int print_wait)
+{
+        if (!dbg_io_ops)
+                return 0;
+        if (kgdb_connected)
+                return 1;
+        if (atomic_read(&kgdb_setting_breakpoint))
+                return 1;
+        if (print_wait) {
+#ifdef CONFIG_KGDB_KDB
+                if (!dbg_kdb_mode)
+                        printk(KERN_CRIT "KGDB: waiting... or $3#33 for KDB\n");
+#else
+                printk(KERN_CRIT "KGDB: Waiting for remote debugger\n");
+#endif
+        }
+        return 1;
+}
+
+static int kgdb_reenter_check(struct kgdb_state *ks)
+{
+        unsigned long addr;
+
+        if (atomic_read(&kgdb_active) != raw_smp_processor_id())
+                return 0;
+
+        /* Panic on recursive debugger calls: */
+        exception_level++;
+        addr = kgdb_arch_pc(ks->ex_vector, ks->linux_regs);
+        dbg_deactivate_sw_breakpoints();
+
+        /*
+         * If the break point removed ok at the place exception
+         * occurred, try to recover and print a warning to the end
+         * user because the user planted a breakpoint in a place that
+         * KGDB needs in order to function.
+         */
+        if (dbg_remove_sw_break(addr) == 0) {
+                exception_level = 0;
+                kgdb_skipexception(ks->ex_vector, ks->linux_regs);
+                dbg_activate_sw_breakpoints();
+                printk(KERN_CRIT "KGDB: re-enter error: breakpoint removed %lx\n",
+                        addr);
+                WARN_ON_ONCE(1);
+
+                return 1;
+        }
+        dbg_remove_all_break();
+        kgdb_skipexception(ks->ex_vector, ks->linux_regs);
+
+        if (exception_level > 1) {
+                dump_stack();
+                panic("Recursive entry to debugger");
+        }
+
+        printk(KERN_CRIT "KGDB: re-enter exception: ALL breakpoints killed\n");
+#ifdef CONFIG_KGDB_KDB
+        /* Allow kdb to debug itself one level */
+        return 0;
+#endif
+        dump_stack();
+        panic("Recursive entry to debugger");
+
+        return 1;
+}
+
+static void dbg_cpu_switch(int cpu, int next_cpu)
+{
+        /* Mark the cpu we are switching away from as a slave when it
+         * holds the kgdb_active token.  This must be done so that the
+         * that all the cpus wait in for the debug core will not enter
+         * again as the master. */
+        if (cpu == atomic_read(&kgdb_active)) {
+                kgdb_info[cpu].exception_state |= DCPU_IS_SLAVE;
+                kgdb_info[cpu].exception_state &= ~DCPU_WANT_MASTER;
+        }
+        kgdb_info[next_cpu].exception_state |= DCPU_NEXT_MASTER;
+}
+
+static int kgdb_cpu_enter(struct kgdb_state *ks, struct pt_regs *regs)
+{
+        unsigned long flags;
+        int sstep_tries = 100;
+        int error;
+        int i, cpu;
+        int trace_on = 0;
+acquirelock:
+        /*
+         * Interrupts will be restored by the 'trap return' code, except when
+         * single stepping.
+         */
+        local_irq_save(flags);
+
+        cpu = ks->cpu;
+        kgdb_info[cpu].debuggerinfo = regs;
+        kgdb_info[cpu].task = current;
+        kgdb_info[cpu].ret_state = 0;
+        kgdb_info[cpu].irq_depth = hardirq_count() >> HARDIRQ_SHIFT;
+        /*
+         * Make sure the above info reaches the primary CPU before
+         * our cpu_in_kgdb[] flag setting does:
+         */
+        atomic_inc(&cpu_in_kgdb[cpu]);
+
+        if (exception_level == 1)
+                goto cpu_master_loop;
+
+        /*
+         * CPU will loop if it is a slave or request to become a kgdb
+         * master cpu and acquire the kgdb_active lock:
+         */
+        while (1) {
+cpu_loop:
+                if (kgdb_info[cpu].exception_state & DCPU_NEXT_MASTER) {
+                        kgdb_info[cpu].exception_state &= ~DCPU_NEXT_MASTER;
+                        goto cpu_master_loop;
+                } else if (kgdb_info[cpu].exception_state & DCPU_WANT_MASTER) {
+                        if (atomic_cmpxchg(&kgdb_active, -1, cpu) == cpu)
+                                break;
+                } else if (kgdb_info[cpu].exception_state & DCPU_IS_SLAVE) {
+                        if (!atomic_read(&passive_cpu_wait[cpu]))
+                                goto return_normal;
+                } else {
+return_normal:
+                        /* Return to normal operation by executing any
+                         * hw breakpoint fixup.
+                         */
+                        if (arch_kgdb_ops.correct_hw_break)
+                                arch_kgdb_ops.correct_hw_break();
+                        if (trace_on)
+                                tracing_on();
+                        atomic_dec(&cpu_in_kgdb[cpu]);
+                        touch_softlockup_watchdog_sync();
+                        clocksource_touch_watchdog();
+                        local_irq_restore(flags);
+                        return 0;
+                }
+                cpu_relax();
+        }
+
+        /*
+         * For single stepping, try to only enter on the processor
+         * that was single stepping.  To gaurd against a deadlock, the
+         * kernel will only try for the value of sstep_tries before
+         * giving up and continuing on.
+         */
+        if (atomic_read(&kgdb_cpu_doing_single_step) != -1 &&
+            (kgdb_info[cpu].task &&
+             kgdb_info[cpu].task->pid != kgdb_sstep_pid) && --sstep_tries) {
+                atomic_set(&kgdb_active, -1);
+                touch_softlockup_watchdog_sync();
+                clocksource_touch_watchdog();
+                local_irq_restore(flags);
+
+                goto acquirelock;
+        }
+
+        if (!kgdb_io_ready(1)) {
+                kgdb_info[cpu].ret_state = 1;
+                goto kgdb_restore; /* No I/O connection, resume the system */
+        }
+
+        /*
+         * Don't enter if we have hit a removed breakpoint.
+         */
+        if (kgdb_skipexception(ks->ex_vector, ks->linux_regs))
+                goto kgdb_restore;
+
+        /* Call the I/O driver's pre_exception routine */
+        if (dbg_io_ops->pre_exception)
+                dbg_io_ops->pre_exception();
+
+        kgdb_disable_hw_debug(ks->linux_regs);
+
+        /*
+         * Get the passive CPU lock which will hold all the non-primary
+         * CPU in a spin state while the debugger is active
+         */
+        if (!kgdb_single_step) {
+                for (i = 0; i < NR_CPUS; i++)
+                        atomic_inc(&passive_cpu_wait[i]);
+        }
+
+#ifdef CONFIG_SMP
+        /* Signal the other CPUs to enter kgdb_wait() */
+        if ((!kgdb_single_step) && kgdb_do_roundup)
+                kgdb_roundup_cpus(flags);
+#endif
+
+        /*
+         * Wait for the other CPUs to be notified and be waiting for us:
+         */
+        for_each_online_cpu(i) {
+                while (kgdb_do_roundup && !atomic_read(&cpu_in_kgdb[i]))
+                        cpu_relax();
+        }
+
+        /*
+         * At this point the primary processor is completely
+         * in the debugger and all secondary CPUs are quiescent
+         */
+        dbg_deactivate_sw_breakpoints();
+        kgdb_single_step = 0;
+        kgdb_contthread = current;
+        exception_level = 0;
+        trace_on = tracing_is_on();
+        if (trace_on)
+                tracing_off();
+
+        while (1) {
+cpu_master_loop:
+                if (dbg_kdb_mode) {
+                        kgdb_connected = 1;
+                        error = kdb_stub(ks);
+                } else {
+                        error = gdb_serial_stub(ks);
+                }
+
+                if (error == DBG_PASS_EVENT) {
+                        dbg_kdb_mode = !dbg_kdb_mode;
+                        kgdb_connected = 0;
+                } else if (error == DBG_SWITCH_CPU_EVENT) {
+                        dbg_cpu_switch(cpu, dbg_switch_cpu);
+                        goto cpu_loop;
+                } else {
+                        kgdb_info[cpu].ret_state = error;
+                        break;
+                }
+        }
+
+        /* Call the I/O driver's post_exception routine */
+        if (dbg_io_ops->post_exception)
+                dbg_io_ops->post_exception();
+
+        atomic_dec(&cpu_in_kgdb[ks->cpu]);
+
+        if (!kgdb_single_step) {
+                for (i = NR_CPUS-1; i >= 0; i--)
+                        atomic_dec(&passive_cpu_wait[i]);
+                /*
+                 * Wait till all the CPUs have quit from the debugger,
+                 * but allow a CPU that hit an exception and is
+                 * waiting to become the master to remain in the debug
+                 * core.
+                 */
+                for_each_online_cpu(i) {
+                        while (kgdb_do_roundup &&
+                               atomic_read(&cpu_in_kgdb[i]) &&
+                               !(kgdb_info[i].exception_state &
+                                 DCPU_WANT_MASTER))
+                                cpu_relax();
+                }
+        }
+
+kgdb_restore:
+        if (atomic_read(&kgdb_cpu_doing_single_step) != -1) {
+                int sstep_cpu = atomic_read(&kgdb_cpu_doing_single_step);
+                if (kgdb_info[sstep_cpu].task)
+                        kgdb_sstep_pid = kgdb_info[sstep_cpu].task->pid;
+                else
+                        kgdb_sstep_pid = 0;
+        }
+        if (trace_on)
+                tracing_on();
+        /* Free kgdb_active */
+        atomic_set(&kgdb_active, -1);
+        touch_softlockup_watchdog_sync();
+        clocksource_touch_watchdog();
+        local_irq_restore(flags);
+
+        return kgdb_info[cpu].ret_state;
+}
+
+/*
+ * kgdb_handle_exception() - main entry point from a kernel exception
+ *
+ * Locking hierarchy:
+ *      interface locks, if any (begin_session)
+ *      kgdb lock (kgdb_active)
+ */
+int
+kgdb_handle_exception(int evector, int signo, int ecode, struct pt_regs *regs)
+{
+        struct kgdb_state kgdb_var;
+        struct kgdb_state *ks = &kgdb_var;
+        int ret;
+
+        ks->cpu                 = raw_smp_processor_id();
+        ks->ex_vector           = evector;
+        ks->signo               = signo;
+        ks->err_code            = ecode;
+        ks->kgdb_usethreadid    = 0;
+        ks->linux_regs          = regs;
+
+        if (kgdb_reenter_check(ks))
+                return 0; /* Ouch, double exception ! */
+        kgdb_info[ks->cpu].exception_state |= DCPU_WANT_MASTER;
+        ret = kgdb_cpu_enter(ks, regs);
+        kgdb_info[ks->cpu].exception_state &= ~(DCPU_WANT_MASTER |
+                                                DCPU_IS_SLAVE);
+        return ret;
+}
+
+int kgdb_nmicallback(int cpu, void *regs)
+{
+#ifdef CONFIG_SMP
+        struct kgdb_state kgdb_var;
+        struct kgdb_state *ks = &kgdb_var;
+
+        memset(ks, 0, sizeof(struct kgdb_state));
+        ks->cpu                 = cpu;
+        ks->linux_regs          = regs;
+
+        if (!atomic_read(&cpu_in_kgdb[cpu]) &&
+            atomic_read(&kgdb_active) != -1 &&
+            atomic_read(&kgdb_active) != cpu) {
+                kgdb_info[cpu].exception_state |= DCPU_IS_SLAVE;
+                kgdb_cpu_enter(ks, regs);
+                kgdb_info[cpu].exception_state &= ~DCPU_IS_SLAVE;
+                return 0;
+        }
+#endif
+        return 1;
+}
+
+static void kgdb_console_write(struct console *co, const char *s,
+   unsigned count)
+{
+        unsigned long flags;
+
+        /* If we're debugging, or KGDB has not connected, don't try
+         * and print. */
+        if (!kgdb_connected || atomic_read(&kgdb_active) != -1 || dbg_kdb_mode)
+                return;
+
+        local_irq_save(flags);
+        gdbstub_msg_write(s, count);
+        local_irq_restore(flags);
+}
+
+static struct console kgdbcons = {
+        .name           = "kgdb",
+        .write          = kgdb_console_write,
+        .flags          = CON_PRINTBUFFER | CON_ENABLED,
+        .index          = -1,
+};
+
+#ifdef CONFIG_MAGIC_SYSRQ
+static void sysrq_handle_dbg(int key, struct tty_struct *tty)
+{
+        if (!dbg_io_ops) {
+                printk(KERN_CRIT "ERROR: No KGDB I/O module available\n");
+                return;
+        }
+        if (!kgdb_connected) {
+#ifdef CONFIG_KGDB_KDB
+                if (!dbg_kdb_mode)
+                        printk(KERN_CRIT "KGDB or $3#33 for KDB\n");
+#else
+                printk(KERN_CRIT "Entering KGDB\n");
+#endif
+        }
+
+        kgdb_breakpoint();
+}
+
+static struct sysrq_key_op sysrq_dbg_op = {
+        .handler        = sysrq_handle_dbg,
+        .help_msg       = "debug(G)",
+        .action_msg     = "DEBUG",
+};
+#endif
+
+static int kgdb_panic_event(struct notifier_block *self,
+                            unsigned long val,
+                            void *data)
+{
+        if (dbg_kdb_mode)
+                kdb_printf("PANIC: %s\n", (char *)data);
+        kgdb_breakpoint();
+        return NOTIFY_DONE;
+}
+
+static struct notifier_block kgdb_panic_event_nb = {
+       .notifier_call   = kgdb_panic_event,
+       .priority        = INT_MAX,
+};
+
+void __weak kgdb_arch_late(void)
+{
+}
+
+void __init dbg_late_init(void)
+{
+        dbg_is_early = false;
+        if (kgdb_io_module_registered)
+                kgdb_arch_late();
+        kdb_init(KDB_INIT_FULL);
+}
+
+static void kgdb_register_callbacks(void)
+{
+        if (!kgdb_io_module_registered) {
+                kgdb_io_module_registered = 1;
+                kgdb_arch_init();
+                if (!dbg_is_early)
+                        kgdb_arch_late();
+                atomic_notifier_chain_register(&panic_notifier_list,
+                                               &kgdb_panic_event_nb);
+#ifdef CONFIG_MAGIC_SYSRQ
+                register_sysrq_key('g', &sysrq_dbg_op);
+#endif
+                if (kgdb_use_con && !kgdb_con_registered) {
+                        register_console(&kgdbcons);
+                        kgdb_con_registered = 1;
+                }
+        }
+}
+
+static void kgdb_unregister_callbacks(void)
+{
+        /*
+         * When this routine is called KGDB should unregister from the
+         * panic handler and clean up, making sure it is not handling any
+         * break exceptions at the time.
+         */
+        if (kgdb_io_module_registered) {
+                kgdb_io_module_registered = 0;
+                atomic_notifier_chain_unregister(&panic_notifier_list,
+                                               &kgdb_panic_event_nb);
+                kgdb_arch_exit();
+#ifdef CONFIG_MAGIC_SYSRQ
+                unregister_sysrq_key('g', &sysrq_dbg_op);
+#endif
+                if (kgdb_con_registered) {
+                        unregister_console(&kgdbcons);
+                        kgdb_con_registered = 0;
+                }
+        }
+}
+
+/*
+ * There are times a tasklet needs to be used vs a compiled in
+ * break point so as to cause an exception outside a kgdb I/O module,
+ * such as is the case with kgdboe, where calling a breakpoint in the
+ * I/O driver itself would be fatal.
+ */
+static void kgdb_tasklet_bpt(unsigned long ing)
+{
+        kgdb_breakpoint();
+        atomic_set(&kgdb_break_tasklet_var, 0);
+}
+
+static DECLARE_TASKLET(kgdb_tasklet_breakpoint, kgdb_tasklet_bpt, 0);
+
+void kgdb_schedule_breakpoint(void)
+{
+        if (atomic_read(&kgdb_break_tasklet_var) ||
+                atomic_read(&kgdb_active) != -1 ||
+                atomic_read(&kgdb_setting_breakpoint))
+                return;
+        atomic_inc(&kgdb_break_tasklet_var);
+        tasklet_schedule(&kgdb_tasklet_breakpoint);
+}
+EXPORT_SYMBOL_GPL(kgdb_schedule_breakpoint);
+
+static void kgdb_initial_breakpoint(void)
+{
+        kgdb_break_asap = 0;
+
+        printk(KERN_CRIT "kgdb: Waiting for connection from remote gdb...\n");
+        kgdb_breakpoint();
+}
+
+/**
+ *      kgdb_register_io_module - register KGDB IO module
+ *      @new_dbg_io_ops: the io ops vector
+ *
+ *      Register it with the KGDB core.
+ */
+int kgdb_register_io_module(struct kgdb_io *new_dbg_io_ops)
+{
+        int err;
+
+        spin_lock(&kgdb_registration_lock);
+
+        if (dbg_io_ops) {
+                spin_unlock(&kgdb_registration_lock);
+
+                printk(KERN_ERR "kgdb: Another I/O driver is already "
+                                "registered with KGDB.\n");
+                return -EBUSY;
+        }
+
+        if (new_dbg_io_ops->init) {
+                err = new_dbg_io_ops->init();
+                if (err) {
+                        spin_unlock(&kgdb_registration_lock);
+                        return err;
+                }
+        }
+
+        dbg_io_ops = new_dbg_io_ops;
+
+        spin_unlock(&kgdb_registration_lock);
+
+        printk(KERN_INFO "kgdb: Registered I/O driver %s.\n",
+               new_dbg_io_ops->name);
+
+        /* Arm KGDB now. */
+        kgdb_register_callbacks();
+
+        if (kgdb_break_asap)
+                kgdb_initial_breakpoint();
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(kgdb_register_io_module);
+
+/**
+ *      kkgdb_unregister_io_module - unregister KGDB IO module
+ *      @old_dbg_io_ops: the io ops vector
+ *
+ *      Unregister it with the KGDB core.
+ */
+void kgdb_unregister_io_module(struct kgdb_io *old_dbg_io_ops)
+{
+        BUG_ON(kgdb_connected);
+
+        /*
+         * KGDB is no longer able to communicate out, so
+         * unregister our callbacks and reset state.
+         */
+        kgdb_unregister_callbacks();
+
+        spin_lock(&kgdb_registration_lock);
+
+        WARN_ON_ONCE(dbg_io_ops != old_dbg_io_ops);
+        dbg_io_ops = NULL;
+
+        spin_unlock(&kgdb_registration_lock);
+
+        printk(KERN_INFO
+                "kgdb: Unregistered I/O driver %s, debugger disabled.\n",
+                old_dbg_io_ops->name);
+}
+EXPORT_SYMBOL_GPL(kgdb_unregister_io_module);
+
+int dbg_io_get_char(void)
+{
+        int ret = dbg_io_ops->read_char();
+        if (ret == NO_POLL_CHAR)
+                return -1;
+        if (!dbg_kdb_mode)
+                return ret;
+        if (ret == 127)
+                return 8;
+        return ret;
+}
+
+/**
+ * kgdb_breakpoint - generate breakpoint exception
+ *
+ * This function will generate a breakpoint exception.  It is used at the
+ * beginning of a program to sync up with a debugger and can be used
+ * otherwise as a quick means to stop program execution and "break" into
+ * the debugger.
+ */
+void kgdb_breakpoint(void)
+{
+        atomic_inc(&kgdb_setting_breakpoint);
+        wmb(); /* Sync point before breakpoint */
+        arch_kgdb_breakpoint();
+        wmb(); /* Sync point after breakpoint */
+        atomic_dec(&kgdb_setting_breakpoint);
+}
+EXPORT_SYMBOL_GPL(kgdb_breakpoint);
+
+static int __init opt_kgdb_wait(char *str)
+{
+        kgdb_break_asap = 1;
+
+        kdb_init(KDB_INIT_EARLY);
+        if (kgdb_io_module_registered)
+                kgdb_initial_breakpoint();
+
+        return 0;
+}
+
+early_param("kgdbwait", opt_kgdb_wait);
diff --git a/kernel/debug/debug_core.h b/kernel/debug/debug_core.h
new file mode 100644
index 000000000000..c5d753d80f67
--- /dev/null
+++ b/kernel/debug/debug_core.h
@@ -0,0 +1,81 @@
+/*
+ * Created by: Jason Wessel <jason.wessel@windriver.com>
+ *
+ * Copyright (c) 2009 Wind River Systems, Inc.  All Rights Reserved.
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#ifndef _DEBUG_CORE_H_
+#define _DEBUG_CORE_H_
+/*
+ * These are the private implementation headers between the kernel
+ * debugger core and the debugger front end code.
+ */
+
+/* kernel debug core data structures */
+struct kgdb_state {
+        int                     ex_vector;
+        int                     signo;
+        int                     err_code;
+        int                     cpu;
+        int                     pass_exception;
+        unsigned long           thr_query;
+        unsigned long           threadid;
+        long                    kgdb_usethreadid;
+        struct pt_regs          *linux_regs;
+};
+
+/* Exception state values */
+#define DCPU_WANT_MASTER 0x1 /* Waiting to become a master kgdb cpu */
+#define DCPU_NEXT_MASTER 0x2 /* Transition from one master cpu to another */
+#define DCPU_IS_SLAVE    0x4 /* Slave cpu enter exception */
+#define DCPU_SSTEP       0x8 /* CPU is single stepping */
+
+struct debuggerinfo_struct {
+        void                    *debuggerinfo;
+        struct task_struct      *task;
+        int                     exception_state;
+        int                     ret_state;
+        int                     irq_depth;
+};
+
+extern struct debuggerinfo_struct kgdb_info[];
+
+/* kernel debug core break point routines */
+extern int dbg_remove_all_break(void);
+extern int dbg_set_sw_break(unsigned long addr);
+extern int dbg_remove_sw_break(unsigned long addr);
+extern int dbg_activate_sw_breakpoints(void);
+extern int dbg_deactivate_sw_breakpoints(void);
+
+/* polled character access to i/o module */
+extern int dbg_io_get_char(void);
+
+/* stub return value for switching between the gdbstub and kdb */
+#define DBG_PASS_EVENT -12345
+/* Switch from one cpu to another */
+#define DBG_SWITCH_CPU_EVENT -123456
+extern int dbg_switch_cpu;
+
+/* gdbstub interface functions */
+extern int gdb_serial_stub(struct kgdb_state *ks);
+extern void gdbstub_msg_write(const char *s, int len);
+
+/* gdbstub functions used for kdb <-> gdbstub transition */
+extern int gdbstub_state(struct kgdb_state *ks, char *cmd);
+extern int dbg_kdb_mode;
+
+#ifdef CONFIG_KGDB_KDB
+extern int kdb_stub(struct kgdb_state *ks);
+extern int kdb_parse(const char *cmdstr);
+#else /* ! CONFIG_KGDB_KDB */
+static inline int kdb_stub(struct kgdb_state *ks)
+{
+        return DBG_PASS_EVENT;
+}
+#endif /* CONFIG_KGDB_KDB */
+
+#endif /* _DEBUG_CORE_H_ */
diff --git a/kernel/debug/gdbstub.c b/kernel/debug/gdbstub.c
new file mode 100644
index 000000000000..4b17b3269525
--- /dev/null
+++ b/kernel/debug/gdbstub.c
@@ -0,0 +1,1017 @@
+/*
+ * Kernel Debug Core
+ *
+ * Maintainer: Jason Wessel <jason.wessel@windriver.com>
+ *
+ * Copyright (C) 2000-2001 VERITAS Software Corporation.
+ * Copyright (C) 2002-2004 Timesys Corporation
+ * Copyright (C) 2003-2004 Amit S. Kale <amitkale@linsyssoft.com>
+ * Copyright (C) 2004 Pavel Machek <pavel@suse.cz>
+ * Copyright (C) 2004-2006 Tom Rini <trini@kernel.crashing.org>
+ * Copyright (C) 2004-2006 LinSysSoft Technologies Pvt. Ltd.
+ * Copyright (C) 2005-2009 Wind River Systems, Inc.
+ * Copyright (C) 2007 MontaVista Software, Inc.
+ * Copyright (C) 2008 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
+ *
+ * Contributors at various stages not listed above:
+ *  Jason Wessel ( jason.wessel@windriver.com )
+ *  George Anzinger <george@mvista.com>
+ *  Anurekh Saxena (anurekh.saxena@timesys.com)
+ *  Lake Stevens Instrument Division (Glenn Engel)
+ *  Jim Kingdon, Cygnus Support.
+ *
+ * Original KGDB stub: David Grothe <dave@gcom.com>,
+ * Tigran Aivazian <tigran@sco.com>
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2. This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ */
+
+#include <linux/kernel.h>
+#include <linux/kgdb.h>
+#include <linux/kdb.h>
+#include <linux/reboot.h>
+#include <linux/uaccess.h>
+#include <asm/cacheflush.h>
+#include <asm/unaligned.h>
+#include "debug_core.h"
+
+#define KGDB_MAX_THREAD_QUERY 17
+
+/* Our I/O buffers. */
+static char                     remcom_in_buffer[BUFMAX];
+static char                     remcom_out_buffer[BUFMAX];
+
+/* Storage for the registers, in GDB format. */
+static unsigned long            gdb_regs[(NUMREGBYTES +
+                                        sizeof(unsigned long) - 1) /
+                                        sizeof(unsigned long)];
+
+/*
+ * GDB remote protocol parser:
+ */
+
+static int hex(char ch)
+{
+        if ((ch >= 'a') && (ch <= 'f'))
+                return ch - 'a' + 10;
+        if ((ch >= '0') && (ch <= '9'))
+                return ch - '0';
+        if ((ch >= 'A') && (ch <= 'F'))
+                return ch - 'A' + 10;
+        return -1;
+}
+
+#ifdef CONFIG_KGDB_KDB
+static int gdbstub_read_wait(void)
+{
+        int ret = -1;
+        int i;
+
+        /* poll any additional I/O interfaces that are defined */
+        while (ret < 0)
+                for (i = 0; kdb_poll_funcs[i] != NULL; i++) {
+                        ret = kdb_poll_funcs[i]();
+                        if (ret > 0)
+                                break;
+                }
+        return ret;
+}
+#else
+static int gdbstub_read_wait(void)
+{
+        int ret = dbg_io_ops->read_char();
+        while (ret == NO_POLL_CHAR)
+                ret = dbg_io_ops->read_char();
+        return ret;
+}
+#endif
+/* scan for the sequence $<data>#<checksum> */
+static void get_packet(char *buffer)
+{
+        unsigned char checksum;
+        unsigned char xmitcsum;
+        int count;
+        char ch;
+
+        do {
+                /*
+                 * Spin and wait around for the start character, ignore all
+                 * other characters:
+                 */
+                while ((ch = (gdbstub_read_wait())) != '$')
+                        /* nothing */;
+
+                kgdb_connected = 1;
+                checksum = 0;
+                xmitcsum = -1;
+
+                count = 0;
+
+                /*
+                 * now, read until a # or end of buffer is found:
+                 */
+                while (count < (BUFMAX - 1)) {
+                        ch = gdbstub_read_wait();
+                        if (ch == '#')
+                                break;
+                        checksum = checksum + ch;
+                        buffer[count] = ch;
+                        count = count + 1;
+                }
+                buffer[count] = 0;
+
+                if (ch == '#') {
+                        xmitcsum = hex(gdbstub_read_wait()) << 4;
+                        xmitcsum += hex(gdbstub_read_wait());
+
+                        if (checksum != xmitcsum)
+                                /* failed checksum */
+                                dbg_io_ops->write_char('-');
+                        else
+                                /* successful transfer */
+                                dbg_io_ops->write_char('+');
+                        if (dbg_io_ops->flush)
+                                dbg_io_ops->flush();
+                }
+        } while (checksum != xmitcsum);
+}
+
+/*
+ * Send the packet in buffer.
+ * Check for gdb connection if asked for.
+ */
+static void put_packet(char *buffer)
+{
+        unsigned char checksum;
+        int count;
+        char ch;
+
+        /*
+         * $<packet info>#<checksum>.
+         */
+        while (1) {
+                dbg_io_ops->write_char('$');
+                checksum = 0;
+                count = 0;
+
+                while ((ch = buffer[count])) {
+                        dbg_io_ops->write_char(ch);
+                        checksum += ch;
+                        count++;
+                }
+
+                dbg_io_ops->write_char('#');
+                dbg_io_ops->write_char(hex_asc_hi(checksum));
+                dbg_io_ops->write_char(hex_asc_lo(checksum));
+                if (dbg_io_ops->flush)
+                        dbg_io_ops->flush();
+
+                /* Now see what we get in reply. */
+                ch = gdbstub_read_wait();
+
+                if (ch == 3)
+                        ch = gdbstub_read_wait();
+
+                /* If we get an ACK, we are done. */
+                if (ch == '+')
+                        return;
+
+                /*
+                 * If we get the start of another packet, this means
+                 * that GDB is attempting to reconnect.  We will NAK
+                 * the packet being sent, and stop trying to send this
+                 * packet.
+                 */
+                if (ch == '$') {
+                        dbg_io_ops->write_char('-');
+                        if (dbg_io_ops->flush)
+                                dbg_io_ops->flush();
+                        return;
+                }
+        }
+}
+
+static char gdbmsgbuf[BUFMAX + 1];
+
+void gdbstub_msg_write(const char *s, int len)
+{
+        char *bufptr;
+        int wcount;
+        int i;
+
+        if (len == 0)
+                len = strlen(s);
+
+        /* 'O'utput */
+        gdbmsgbuf[0] = 'O';
+
+        /* Fill and send buffers... */
+        while (len > 0) {
+                bufptr = gdbmsgbuf + 1;
+
+                /* Calculate how many this time */
+                if ((len << 1) > (BUFMAX - 2))
+                        wcount = (BUFMAX - 2) >> 1;
+                else
+                        wcount = len;
+
+                /* Pack in hex chars */
+                for (i = 0; i < wcount; i++)
+                        bufptr = pack_hex_byte(bufptr, s[i]);
+                *bufptr = '\0';
+
+                /* Move up */
+                s += wcount;
+                len -= wcount;
+
+                /* Write packet */
+                put_packet(gdbmsgbuf);
+        }
+}
+
+/*
+ * Convert the memory pointed to by mem into hex, placing result in
+ * buf.  Return a pointer to the last char put in buf (null). May
+ * return an error.
+ */
+int kgdb_mem2hex(char *mem, char *buf, int count)
+{
+        char *tmp;
+        int err;
+
+        /*
+         * We use the upper half of buf as an intermediate buffer for the
+         * raw memory copy.  Hex conversion will work against this one.
+         */
+        tmp = buf + count;
+
+        err = probe_kernel_read(tmp, mem, count);
+        if (!err) {
+                while (count > 0) {
+                        buf = pack_hex_byte(buf, *tmp);
+                        tmp++;
+                        count--;
+                }
+
+                *buf = 0;
+        }
+
+        return err;
+}
+
+/*
+ * Convert the hex array pointed to by buf into binary to be placed in
+ * mem.  Return a pointer to the character AFTER the last byte
+ * written.  May return an error.
+ */
+int kgdb_hex2mem(char *buf, char *mem, int count)
+{
+        char *tmp_raw;
+        char *tmp_hex;
+
+        /*
+         * We use the upper half of buf as an intermediate buffer for the
+         * raw memory that is converted from hex.
+         */
+        tmp_raw = buf + count * 2;
+
+        tmp_hex = tmp_raw - 1;
+        while (tmp_hex >= buf) {
+                tmp_raw--;
+                *tmp_raw = hex(*tmp_hex--);
+                *tmp_raw |= hex(*tmp_hex--) << 4;
+        }
+
+        return probe_kernel_write(mem, tmp_raw, count);
+}
+
+/*
+ * While we find nice hex chars, build a long_val.
+ * Return number of chars processed.
+ */
+int kgdb_hex2long(char **ptr, unsigned long *long_val)
+{
+        int hex_val;
+        int num = 0;
+        int negate = 0;
+
+        *long_val = 0;
+
+        if (**ptr == '-') {
+                negate = 1;
+                (*ptr)++;
+        }
+        while (**ptr) {
+                hex_val = hex(**ptr);
+                if (hex_val < 0)
+                        break;
+
+                *long_val = (*long_val << 4) | hex_val;
+                num++;
+                (*ptr)++;
+        }
+
+        if (negate)
+                *long_val = -*long_val;
+
+        return num;
+}
+
+/*
+ * Copy the binary array pointed to by buf into mem.  Fix $, #, and
+ * 0x7d escaped with 0x7d. Return -EFAULT on failure or 0 on success.
+ * The input buf is overwitten with the result to write to mem.
+ */
+static int kgdb_ebin2mem(char *buf, char *mem, int count)
+{
+        int size = 0;
+        char *c = buf;
+
+        while (count-- > 0) {
+                c[size] = *buf++;
+                if (c[size] == 0x7d)
+                        c[size] = *buf++ ^ 0x20;
+                size++;
+        }
+
+        return probe_kernel_write(mem, c, size);
+}
+
+/* Write memory due to an 'M' or 'X' packet. */
+static int write_mem_msg(int binary)
+{
+        char *ptr = &remcom_in_buffer[1];
+        unsigned long addr;
+        unsigned long length;
+        int err;
+
+        if (kgdb_hex2long(&ptr, &addr) > 0 && *(ptr++) == ',' &&
+            kgdb_hex2long(&ptr, &length) > 0 && *(ptr++) == ':') {
+                if (binary)
+                        err = kgdb_ebin2mem(ptr, (char *)addr, length);
+                else
+                        err = kgdb_hex2mem(ptr, (char *)addr, length);
+                if (err)
+                        return err;
+                if (CACHE_FLUSH_IS_SAFE)
+                        flush_icache_range(addr, addr + length);
+                return 0;
+        }
+
+        return -EINVAL;
+}
+
+static void error_packet(char *pkt, int error)
+{
+        error = -error;
+        pkt[0] = 'E';
+        pkt[1] = hex_asc[(error / 10)];
+        pkt[2] = hex_asc[(error % 10)];
+        pkt[3] = '\0';
+}
+
+/*
+ * Thread ID accessors. We represent a flat TID space to GDB, where
+ * the per CPU idle threads (which under Linux all have PID 0) are
+ * remapped to negative TIDs.
+ */
+
+#define BUF_THREAD_ID_SIZE      16
+
+static char *pack_threadid(char *pkt, unsigned char *id)
+{
+        char *limit;
+
+        limit = pkt + BUF_THREAD_ID_SIZE;
+        while (pkt < limit)
+                pkt = pack_hex_byte(pkt, *id++);
+
+        return pkt;
+}
+
+static void int_to_threadref(unsigned char *id, int value)
+{
+        unsigned char *scan;
+        int i = 4;
+
+        scan = (unsigned char *)id;
+        while (i--)
+                *scan++ = 0;
+        put_unaligned_be32(value, scan);
+}
+
+static struct task_struct *getthread(struct pt_regs *regs, int tid)
+{
+        /*
+         * Non-positive TIDs are remapped to the cpu shadow information
+         */
+        if (tid == 0 || tid == -1)
+                tid = -atomic_read(&kgdb_active) - 2;
+        if (tid < -1 && tid > -NR_CPUS - 2) {
+                if (kgdb_info[-tid - 2].task)
+                        return kgdb_info[-tid - 2].task;
+                else
+                        return idle_task(-tid - 2);
+        }
+        if (tid <= 0) {
+                printk(KERN_ERR "KGDB: Internal thread select error\n");
+                dump_stack();
+                return NULL;
+        }
+
+        /*
+         * find_task_by_pid_ns() does not take the tasklist lock anymore
+         * but is nicely RCU locked - hence is a pretty resilient
+         * thing to use:
+         */
+        return find_task_by_pid_ns(tid, &init_pid_ns);
+}
+
+
+/*
+ * Remap normal tasks to their real PID,
+ * CPU shadow threads are mapped to -CPU - 2
+ */
+static inline int shadow_pid(int realpid)
+{
+        if (realpid)
+                return realpid;
+
+        return -raw_smp_processor_id() - 2;
+}
+
+/*
+ * All the functions that start with gdb_cmd are the various
+ * operations to implement the handlers for the gdbserial protocol
+ * where KGDB is communicating with an external debugger
+ */
+
+/* Handle the '?' status packets */
+static void gdb_cmd_status(struct kgdb_state *ks)
+{
+        /*
+         * We know that this packet is only sent
+         * during initial connect.  So to be safe,
+         * we clear out our breakpoints now in case
+         * GDB is reconnecting.
+         */
+        dbg_remove_all_break();
+
+        remcom_out_buffer[0] = 'S';
+        pack_hex_byte(&remcom_out_buffer[1], ks->signo);
+}
+
+/* Handle the 'g' get registers request */
+static void gdb_cmd_getregs(struct kgdb_state *ks)
+{
+        struct task_struct *thread;
+        void *local_debuggerinfo;
+        int i;
+
+        thread = kgdb_usethread;
+        if (!thread) {
+                thread = kgdb_info[ks->cpu].task;
+                local_debuggerinfo = kgdb_info[ks->cpu].debuggerinfo;
+        } else {
+                local_debuggerinfo = NULL;
+                for_each_online_cpu(i) {
+                        /*
+                         * Try to find the task on some other
+                         * or possibly this node if we do not
+                         * find the matching task then we try
+                         * to approximate the results.
+                         */
+                        if (thread == kgdb_info[i].task)
+                                local_debuggerinfo = kgdb_info[i].debuggerinfo;
+                }
+        }
+
+        /*
+         * All threads that don't have debuggerinfo should be
+         * in schedule() sleeping, since all other CPUs
+         * are in kgdb_wait, and thus have debuggerinfo.
+         */
+        if (local_debuggerinfo) {
+                pt_regs_to_gdb_regs(gdb_regs, local_debuggerinfo);
+        } else {
+                /*
+                 * Pull stuff saved during switch_to; nothing
+                 * else is accessible (or even particularly
+                 * relevant).
+                 *
+                 * This should be enough for a stack trace.
+                 */
+                sleeping_thread_to_gdb_regs(gdb_regs, thread);
+        }
+        kgdb_mem2hex((char *)gdb_regs, remcom_out_buffer, NUMREGBYTES);
+}
+
+/* Handle the 'G' set registers request */
+static void gdb_cmd_setregs(struct kgdb_state *ks)
+{
+        kgdb_hex2mem(&remcom_in_buffer[1], (char *)gdb_regs, NUMREGBYTES);
+
+        if (kgdb_usethread && kgdb_usethread != current) {
+                error_packet(remcom_out_buffer, -EINVAL);
+        } else {
+                gdb_regs_to_pt_regs(gdb_regs, ks->linux_regs);
+                strcpy(remcom_out_buffer, "OK");
+        }
+}
+
+/* Handle the 'm' memory read bytes */
+static void gdb_cmd_memread(struct kgdb_state *ks)
+{
+        char *ptr = &remcom_in_buffer[1];
+        unsigned long length;
+        unsigned long addr;
+        int err;
+
+        if (kgdb_hex2long(&ptr, &addr) > 0 && *ptr++ == ',' &&
+                                        kgdb_hex2long(&ptr, &length) > 0) {
+                err = kgdb_mem2hex((char *)addr, remcom_out_buffer, length);
+                if (err)
+                        error_packet(remcom_out_buffer, err);
+        } else {
+                error_packet(remcom_out_buffer, -EINVAL);
+        }
+}
+
+/* Handle the 'M' memory write bytes */
+static void gdb_cmd_memwrite(struct kgdb_state *ks)
+{
+        int err = write_mem_msg(0);
+
+        if (err)
+                error_packet(remcom_out_buffer, err);
+        else
+                strcpy(remcom_out_buffer, "OK");
+}
+
+/* Handle the 'X' memory binary write bytes */
+static void gdb_cmd_binwrite(struct kgdb_state *ks)
+{
+        int err = write_mem_msg(1);
+
+        if (err)
+                error_packet(remcom_out_buffer, err);
+        else
+                strcpy(remcom_out_buffer, "OK");
+}
+
+/* Handle the 'D' or 'k', detach or kill packets */
+static void gdb_cmd_detachkill(struct kgdb_state *ks)
+{
+        int error;
+
+        /* The detach case */
+        if (remcom_in_buffer[0] == 'D') {
+                error = dbg_remove_all_break();
+                if (error < 0) {
+                        error_packet(remcom_out_buffer, error);
+                } else {
+                        strcpy(remcom_out_buffer, "OK");
+                        kgdb_connected = 0;
+                }
+                put_packet(remcom_out_buffer);
+        } else {
+                /*
+                 * Assume the kill case, with no exit code checking,
+                 * trying to force detach the debugger:
+                 */
+                dbg_remove_all_break();
+                kgdb_connected = 0;
+        }
+}
+
+/* Handle the 'R' reboot packets */
+static int gdb_cmd_reboot(struct kgdb_state *ks)
+{
+        /* For now, only honor R0 */
+        if (strcmp(remcom_in_buffer, "R0") == 0) {
+                printk(KERN_CRIT "Executing emergency reboot\n");
+                strcpy(remcom_out_buffer, "OK");
+                put_packet(remcom_out_buffer);
+
+                /*
+                 * Execution should not return from
+                 * machine_emergency_restart()
+                 */
+                machine_emergency_restart();
+                kgdb_connected = 0;
+
+                return 1;
+        }
+        return 0;
+}
+
+/* Handle the 'q' query packets */
+static void gdb_cmd_query(struct kgdb_state *ks)
+{
+        struct task_struct *g;
+        struct task_struct *p;
+        unsigned char thref[8];
+        char *ptr;
+        int i;
+        int cpu;
+        int finished = 0;
+
+        switch (remcom_in_buffer[1]) {
+        case 's':
+        case 'f':
+                if (memcmp(remcom_in_buffer + 2, "ThreadInfo", 10)) {
+                        error_packet(remcom_out_buffer, -EINVAL);
+                        break;
+                }
+
+                i = 0;
+                remcom_out_buffer[0] = 'm';
+                ptr = remcom_out_buffer + 1;
+                if (remcom_in_buffer[1] == 'f') {
+                        /* Each cpu is a shadow thread */
+                        for_each_online_cpu(cpu) {
+                                ks->thr_query = 0;
+                                int_to_threadref(thref, -cpu - 2);
+                                pack_threadid(ptr, thref);
+                                ptr += BUF_THREAD_ID_SIZE;
+                                *(ptr++) = ',';
+                                i++;
+                        }
+                }
+
+                do_each_thread(g, p) {
+                        if (i >= ks->thr_query && !finished) {
+                                int_to_threadref(thref, p->pid);
+                                pack_threadid(ptr, thref);
+                                ptr += BUF_THREAD_ID_SIZE;
+                                *(ptr++) = ',';
+                                ks->thr_query++;
+                                if (ks->thr_query % KGDB_MAX_THREAD_QUERY == 0)
+                                        finished = 1;
+                        }
+                        i++;
+                } while_each_thread(g, p);
+
+                *(--ptr) = '\0';
+                break;
+
+        case 'C':
+                /* Current thread id */
+                strcpy(remcom_out_buffer, "QC");
+                ks->threadid = shadow_pid(current->pid);
+                int_to_threadref(thref, ks->threadid);
+                pack_threadid(remcom_out_buffer + 2, thref);
+                break;
+        case 'T':
+                if (memcmp(remcom_in_buffer + 1, "ThreadExtraInfo,", 16)) {
+                        error_packet(remcom_out_buffer, -EINVAL);
+                        break;
+                }
+                ks->threadid = 0;
+                ptr = remcom_in_buffer + 17;
+                kgdb_hex2long(&ptr, &ks->threadid);
+                if (!getthread(ks->linux_regs, ks->threadid)) {
+                        error_packet(remcom_out_buffer, -EINVAL);
+                        break;
+                }
+                if ((int)ks->threadid > 0) {
+                        kgdb_mem2hex(getthread(ks->linux_regs,
+                                        ks->threadid)->comm,
+                                        remcom_out_buffer, 16);
+                } else {
+                        static char tmpstr[23 + BUF_THREAD_ID_SIZE];
+
+                        sprintf(tmpstr, "shadowCPU%d",
+                                        (int)(-ks->threadid - 2));
+                        kgdb_mem2hex(tmpstr, remcom_out_buffer, strlen(tmpstr));
+                }
+                break;
+#ifdef CONFIG_KGDB_KDB
+        case 'R':
+                if (strncmp(remcom_in_buffer, "qRcmd,", 6) == 0) {
+                        int len = strlen(remcom_in_buffer + 6);
+
+                        if ((len % 2) != 0) {
+                                strcpy(remcom_out_buffer, "E01");
+                                break;
+                        }
+                        kgdb_hex2mem(remcom_in_buffer + 6,
+                                     remcom_out_buffer, len);
+                        len = len / 2;
+                        remcom_out_buffer[len++] = 0;
+
+                        kdb_parse(remcom_out_buffer);
+                        strcpy(remcom_out_buffer, "OK");
+                }
+                break;
+#endif
+        }
+}
+
+/* Handle the 'H' task query packets */
+static void gdb_cmd_task(struct kgdb_state *ks)
+{
+        struct task_struct *thread;
+        char *ptr;
+
+        switch (remcom_in_buffer[1]) {
+        case 'g':
+                ptr = &remcom_in_buffer[2];
+                kgdb_hex2long(&ptr, &ks->threadid);
+                thread = getthread(ks->linux_regs, ks->threadid);
+                if (!thread && ks->threadid > 0) {
+                        error_packet(remcom_out_buffer, -EINVAL);
+                        break;
+                }
+                kgdb_usethread = thread;
+                ks->kgdb_usethreadid = ks->threadid;
+                strcpy(remcom_out_buffer, "OK");
+                break;
+        case 'c':
+                ptr = &remcom_in_buffer[2];
+                kgdb_hex2long(&ptr, &ks->threadid);
+                if (!ks->threadid) {
+                        kgdb_contthread = NULL;
+                } else {
+                        thread = getthread(ks->linux_regs, ks->threadid);
+                        if (!thread && ks->threadid > 0) {
+                                error_packet(remcom_out_buffer, -EINVAL);
+                                break;
+                        }
+                        kgdb_contthread = thread;
+                }
+                strcpy(remcom_out_buffer, "OK");
+                break;
+        }
+}
+
+/* Handle the 'T' thread query packets */
+static void gdb_cmd_thread(struct kgdb_state *ks)
+{
+        char *ptr = &remcom_in_buffer[1];
+        struct task_struct *thread;
+
+        kgdb_hex2long(&ptr, &ks->threadid);
+        thread = getthread(ks->linux_regs, ks->threadid);
+        if (thread)
+                strcpy(remcom_out_buffer, "OK");
+        else
+                error_packet(remcom_out_buffer, -EINVAL);
+}
+
+/* Handle the 'z' or 'Z' breakpoint remove or set packets */
+static void gdb_cmd_break(struct kgdb_state *ks)
+{
+        /*
+         * Since GDB-5.3, it's been drafted that '0' is a software
+         * breakpoint, '1' is a hardware breakpoint, so let's do that.
+         */
+        char *bpt_type = &remcom_in_buffer[1];
+        char *ptr = &remcom_in_buffer[2];
+        unsigned long addr;
+        unsigned long length;
+        int error = 0;
+
+        if (arch_kgdb_ops.set_hw_breakpoint && *bpt_type >= '1') {
+                /* Unsupported */
+                if (*bpt_type > '4')
+                        return;
+        } else {
+                if (*bpt_type != '0' && *bpt_type != '1')
+                        /* Unsupported. */
+                        return;
+        }
+
+        /*
+         * Test if this is a hardware breakpoint, and
+         * if we support it:
+         */
+        if (*bpt_type == '1' && !(arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT))
+                /* Unsupported. */
+                return;
+
+        if (*(ptr++) != ',') {
+                error_packet(remcom_out_buffer, -EINVAL);
+                return;
+        }
+        if (!kgdb_hex2long(&ptr, &addr)) {
+                error_packet(remcom_out_buffer, -EINVAL);
+                return;
+        }
+        if (*(ptr++) != ',' ||
+                !kgdb_hex2long(&ptr, &length)) {
+                error_packet(remcom_out_buffer, -EINVAL);
+                return;
+        }
+
+        if (remcom_in_buffer[0] == 'Z' && *bpt_type == '0')
+                error = dbg_set_sw_break(addr);
+        else if (remcom_in_buffer[0] == 'z' && *bpt_type == '0')
+                error = dbg_remove_sw_break(addr);
+        else if (remcom_in_buffer[0] == 'Z')
+                error = arch_kgdb_ops.set_hw_breakpoint(addr,
+                        (int)length, *bpt_type - '0');
+        else if (remcom_in_buffer[0] == 'z')
+                error = arch_kgdb_ops.remove_hw_breakpoint(addr,
+                        (int) length, *bpt_type - '0');
+
+        if (error == 0)
+                strcpy(remcom_out_buffer, "OK");
+        else
+                error_packet(remcom_out_buffer, error);
+}
+
+/* Handle the 'C' signal / exception passing packets */
+static int gdb_cmd_exception_pass(struct kgdb_state *ks)
+{
+        /* C09 == pass exception
+         * C15 == detach kgdb, pass exception
+         */
+        if (remcom_in_buffer[1] == '0' && remcom_in_buffer[2] == '9') {
+
+                ks->pass_exception = 1;
+                remcom_in_buffer[0] = 'c';
+
+        } else if (remcom_in_buffer[1] == '1' && remcom_in_buffer[2] == '5') {
+
+                ks->pass_exception = 1;
+                remcom_in_buffer[0] = 'D';
+                dbg_remove_all_break();
+                kgdb_connected = 0;
+                return 1;
+
+        } else {
+                gdbstub_msg_write("KGDB only knows signal 9 (pass)"
+                        " and 15 (pass and disconnect)\n"
+                        "Executing a continue without signal passing\n", 0);
+                remcom_in_buffer[0] = 'c';
+        }
+
+        /* Indicate fall through */
+        return -1;
+}
+
+/*
+ * This function performs all gdbserial command procesing
+ */
+int gdb_serial_stub(struct kgdb_state *ks)
+{
+        int error = 0;
+        int tmp;
+
+        /* Clear the out buffer. */
+        memset(remcom_out_buffer, 0, sizeof(remcom_out_buffer));
+
+        if (kgdb_connected) {
+                unsigned char thref[8];
+                char *ptr;
+
+                /* Reply to host that an exception has occurred */
+                ptr = remcom_out_buffer;
+                *ptr++ = 'T';
+                ptr = pack_hex_byte(ptr, ks->signo);
+                ptr += strlen(strcpy(ptr, "thread:"));
+                int_to_threadref(thref, shadow_pid(current->pid));
+                ptr = pack_threadid(ptr, thref);
+                *ptr++ = ';';
+                put_packet(remcom_out_buffer);
+        }
+
+        kgdb_usethread = kgdb_info[ks->cpu].task;
+        ks->kgdb_usethreadid = shadow_pid(kgdb_info[ks->cpu].task->pid);
+        ks->pass_exception = 0;
+
+        while (1) {
+                error = 0;
+
+                /* Clear the out buffer. */
+                memset(remcom_out_buffer, 0, sizeof(remcom_out_buffer));
+
+                get_packet(remcom_in_buffer);
+
+                switch (remcom_in_buffer[0]) {
+                case '?': /* gdbserial status */
+                        gdb_cmd_status(ks);
+                        break;
+                case 'g': /* return the value of the CPU registers */
+                        gdb_cmd_getregs(ks);
+                        break;
+                case 'G': /* set the value of the CPU registers - return OK */
+                        gdb_cmd_setregs(ks);
+                        break;
+                case 'm': /* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
+                        gdb_cmd_memread(ks);
+                        break;
+                case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA..AA */
+                        gdb_cmd_memwrite(ks);
+                        break;
+                case 'X': /* XAA..AA,LLLL: Write LLLL bytes at address AA..AA */
+                        gdb_cmd_binwrite(ks);
+                        break;
+                        /* kill or detach. KGDB should treat this like a
+                         * continue.
+                         */
+                case 'D': /* Debugger detach */
+                case 'k': /* Debugger detach via kill */
+                        gdb_cmd_detachkill(ks);
+                        goto default_handle;
+                case 'R': /* Reboot */
+                        if (gdb_cmd_reboot(ks))
+                                goto default_handle;
+                        break;
+                case 'q': /* query command */
+                        gdb_cmd_query(ks);
+                        break;
+                case 'H': /* task related */
+                        gdb_cmd_task(ks);
+                        break;
+                case 'T': /* Query thread status */
+                        gdb_cmd_thread(ks);
+                        break;
+                case 'z': /* Break point remove */
+                case 'Z': /* Break point set */
+                        gdb_cmd_break(ks);
+                        break;
+#ifdef CONFIG_KGDB_KDB
+                case '3': /* Escape into back into kdb */
+                        if (remcom_in_buffer[1] == '\0') {
+                                gdb_cmd_detachkill(ks);
+                                return DBG_PASS_EVENT;
+                        }
+#endif
+                case 'C': /* Exception passing */
+                        tmp = gdb_cmd_exception_pass(ks);
+                        if (tmp > 0)
+                                goto default_handle;
+                        if (tmp == 0)
+                                break;
+                        /* Fall through on tmp < 0 */
+                case 'c': /* Continue packet */
+                case 's': /* Single step packet */
+                        if (kgdb_contthread && kgdb_contthread != current) {
+                                /* Can't switch threads in kgdb */
+                                error_packet(remcom_out_buffer, -EINVAL);
+                                break;
+                        }
+                        dbg_activate_sw_breakpoints();
+                        /* Fall through to default processing */
+                default:
+default_handle:
+                        error = kgdb_arch_handle_exception(ks->ex_vector,
+                                                ks->signo,
+                                                ks->err_code,
+                                                remcom_in_buffer,
+                                                remcom_out_buffer,
+                                                ks->linux_regs);
+                        /*
+                         * Leave cmd processing on error, detach,
+                         * kill, continue, or single step.
+                         */
+                        if (error >= 0 || remcom_in_buffer[0] == 'D' ||
+                            remcom_in_buffer[0] == 'k') {
+                                error = 0;
+                                goto kgdb_exit;
+                        }
+
+                }
+
+                /* reply to the request */
+                put_packet(remcom_out_buffer);
+        }
+
+kgdb_exit:
+        if (ks->pass_exception)
+                error = 1;
+        return error;
+}
+
+int gdbstub_state(struct kgdb_state *ks, char *cmd)
+{
+        int error;
+
+        switch (cmd[0]) {
+        case 'e':
+                error = kgdb_arch_handle_exception(ks->ex_vector,
+                                                   ks->signo,
+                                                   ks->err_code,
+                                                   remcom_in_buffer,
+                                                   remcom_out_buffer,
+                                                   ks->linux_regs);
+                return error;
+        case 's':
+        case 'c':
+                strcpy(remcom_in_buffer, cmd);
+                return 0;
+        case '?':
+                gdb_cmd_status(ks);
+                break;
+        case '\0':
+                strcpy(remcom_out_buffer, "");
+                break;
+        }
+        dbg_io_ops->write_char('+');
+        put_packet(remcom_out_buffer);
+        return 0;
+}
diff --git a/kernel/debug/kdb/.gitignore b/kernel/debug/kdb/.gitignore
new file mode 100644
index 000000000000..396d12eda9e8
--- /dev/null
+++ b/kernel/debug/kdb/.gitignore
@@ -0,0 +1 @@
+gen-kdb_cmds.c
diff --git a/kernel/debug/kdb/Makefile b/kernel/debug/kdb/Makefile
new file mode 100644
index 000000000000..d4fc58f4b88d
--- /dev/null
+++ b/kernel/debug/kdb/Makefile
@@ -0,0 +1,25 @@
+# This file is subject to the terms and conditions of the GNU General Public
+# License.  See the file "COPYING" in the main directory of this archive
+# for more details.
+#
+# Copyright (c) 1999-2004 Silicon Graphics, Inc.  All Rights Reserved.
+# Copyright (c) 2009 Wind River Systems, Inc. All Rights Reserved.
+#
+
+CCVERSION       := $(shell $(CC) -v 2>&1 | sed -ne '$$p')
+obj-y := kdb_io.o kdb_main.o kdb_support.o kdb_bt.o gen-kdb_cmds.o kdb_bp.o kdb_debugger.o
+obj-$(CONFIG_KDB_KEYBOARD)    += kdb_keyboard.o
+
+clean-files := gen-kdb_cmds.c
+
+quiet_cmd_gen-kdb = GENKDB  $@
+      cmd_gen-kdb = $(AWK) 'BEGIN {print "\#include <linux/stddef.h>"; print "\#include <linux/init.h>"} \
+                /^\#/{next} \
+                /^[ \t]*$$/{next} \
+                {gsub(/"/, "\\\"", $$0); \
+                  print "static __initdata char kdb_cmd" cmds++ "[] = \"" $$0 "\\n\";"} \
+                END {print "extern char *kdb_cmds[]; char __initdata *kdb_cmds[] = {"; for (i = 0; i < cmds; ++i) {print "  kdb_cmd" i ","}; print("  NULL\n};");}' \
+                $(filter-out %/Makefile,$^) > $@#
+
+$(obj)/gen-kdb_cmds.c:  $(src)/kdb_cmds $(src)/Makefile
+        $(call cmd,gen-kdb)
diff --git a/kernel/debug/kdb/kdb_bp.c b/kernel/debug/kdb/kdb_bp.c
new file mode 100644
index 000000000000..75bd9b3ebbb7
--- /dev/null
+++ b/kernel/debug/kdb/kdb_bp.c
@@ -0,0 +1,564 @@
+/*
+ * Kernel Debugger Architecture Independent Breakpoint Handler
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (c) 1999-2004 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2009 Wind River Systems, Inc.  All Rights Reserved.
+ */
+
+#include <linux/string.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/kdb.h>
+#include <linux/kgdb.h>
+#include <linux/smp.h>
+#include <linux/sched.h>
+#include <linux/interrupt.h>
+#include "kdb_private.h"
+
+/*
+ * Table of kdb_breakpoints
+ */
+kdb_bp_t kdb_breakpoints[KDB_MAXBPT];
+
+static void kdb_setsinglestep(struct pt_regs *regs)
+{
+        KDB_STATE_SET(DOING_SS);
+}
+
+static char *kdb_rwtypes[] = {
+        "Instruction(i)",
+        "Instruction(Register)",
+        "Data Write",
+        "I/O",
+        "Data Access"
+};
+
+static char *kdb_bptype(kdb_bp_t *bp)
+{
+        if (bp->bp_type < 0 || bp->bp_type > 4)
+                return "";
+
+        return kdb_rwtypes[bp->bp_type];
+}
+
+static int kdb_parsebp(int argc, const char **argv, int *nextargp, kdb_bp_t *bp)
+{
+        int nextarg = *nextargp;
+        int diag;
+
+        bp->bph_length = 1;
+        if ((argc + 1) != nextarg) {
+                if (strnicmp(argv[nextarg], "datar", sizeof("datar")) == 0)
+                        bp->bp_type = BP_ACCESS_WATCHPOINT;
+                else if (strnicmp(argv[nextarg], "dataw", sizeof("dataw")) == 0)
+                        bp->bp_type = BP_WRITE_WATCHPOINT;
+                else if (strnicmp(argv[nextarg], "inst", sizeof("inst")) == 0)
+                        bp->bp_type = BP_HARDWARE_BREAKPOINT;
+                else
+                        return KDB_ARGCOUNT;
+
+                bp->bph_length = 1;
+
+                nextarg++;
+
+                if ((argc + 1) != nextarg) {
+                        unsigned long len;
+
+                        diag = kdbgetularg((char *)argv[nextarg],
+                                           &len);
+                        if (diag)
+                                return diag;
+
+
+                        if (len > 8)
+                                return KDB_BADLENGTH;
+
+                        bp->bph_length = len;
+                        nextarg++;
+                }
+
+                if ((argc + 1) != nextarg)
+                        return KDB_ARGCOUNT;
+        }
+
+        *nextargp = nextarg;
+        return 0;
+}
+
+static int _kdb_bp_remove(kdb_bp_t *bp)
+{
+        int ret = 1;
+        if (!bp->bp_installed)
+                return ret;
+        if (!bp->bp_type)
+                ret = dbg_remove_sw_break(bp->bp_addr);
+        else
+                ret = arch_kgdb_ops.remove_hw_breakpoint(bp->bp_addr,
+                         bp->bph_length,
+                         bp->bp_type);
+        if (ret == 0)
+                bp->bp_installed = 0;
+        return ret;
+}
+
+static void kdb_handle_bp(struct pt_regs *regs, kdb_bp_t *bp)
+{
+        if (KDB_DEBUG(BP))
+                kdb_printf("regs->ip = 0x%lx\n", instruction_pointer(regs));
+
+        /*
+         * Setup single step
+         */
+        kdb_setsinglestep(regs);
+
+        /*
+         * Reset delay attribute
+         */
+        bp->bp_delay = 0;
+        bp->bp_delayed = 1;
+}
+
+static int _kdb_bp_install(struct pt_regs *regs, kdb_bp_t *bp)
+{
+        int ret;
+        /*
+         * Install the breakpoint, if it is not already installed.
+         */
+
+        if (KDB_DEBUG(BP))
+                kdb_printf("%s: bp_installed %d\n",
+                           __func__, bp->bp_installed);
+        if (!KDB_STATE(SSBPT))
+                bp->bp_delay = 0;
+        if (bp->bp_installed)
+                return 1;
+        if (bp->bp_delay || (bp->bp_delayed && KDB_STATE(DOING_SS))) {
+                if (KDB_DEBUG(BP))
+                        kdb_printf("%s: delayed bp\n", __func__);
+                kdb_handle_bp(regs, bp);
+                return 0;
+        }
+        if (!bp->bp_type)
+                ret = dbg_set_sw_break(bp->bp_addr);
+        else
+                ret = arch_kgdb_ops.set_hw_breakpoint(bp->bp_addr,
+                         bp->bph_length,
+                         bp->bp_type);
+        if (ret == 0) {
+                bp->bp_installed = 1;
+        } else {
+                kdb_printf("%s: failed to set breakpoint at 0x%lx\n",
+                           __func__, bp->bp_addr);
+                return 1;
+        }
+        return 0;
+}
+
+/*
+ * kdb_bp_install
+ *
+ *      Install kdb_breakpoints prior to returning from the
+ *      kernel debugger.  This allows the kdb_breakpoints to be set
+ *      upon functions that are used internally by kdb, such as
+ *      printk().  This function is only called once per kdb session.
+ */
+void kdb_bp_install(struct pt_regs *regs)
+{
+        int i;
+
+        for (i = 0; i < KDB_MAXBPT; i++) {
+                kdb_bp_t *bp = &kdb_breakpoints[i];
+
+                if (KDB_DEBUG(BP)) {
+                        kdb_printf("%s: bp %d bp_enabled %d\n",
+                                   __func__, i, bp->bp_enabled);
+                }
+                if (bp->bp_enabled)
+                        _kdb_bp_install(regs, bp);
+        }
+}
+
+/*
+ * kdb_bp_remove
+ *
+ *      Remove kdb_breakpoints upon entry to the kernel debugger.
+ *
+ * Parameters:
+ *      None.
+ * Outputs:
+ *      None.
+ * Returns:
+ *      None.
+ * Locking:
+ *      None.
+ * Remarks:
+ */
+void kdb_bp_remove(void)
+{
+        int i;
+
+        for (i = KDB_MAXBPT - 1; i >= 0; i--) {
+                kdb_bp_t *bp = &kdb_breakpoints[i];
+
+                if (KDB_DEBUG(BP)) {
+                        kdb_printf("%s: bp %d bp_enabled %d\n",
+                                   __func__, i, bp->bp_enabled);
+                }
+                if (bp->bp_enabled)
+                        _kdb_bp_remove(bp);
+        }
+}
+
+
+/*
+ * kdb_printbp
+ *
+ *      Internal function to format and print a breakpoint entry.
+ *
+ * Parameters:
+ *      None.
+ * Outputs:
+ *      None.
+ * Returns:
+ *      None.
+ * Locking:
+ *      None.
+ * Remarks:
+ */
+
+static void kdb_printbp(kdb_bp_t *bp, int i)
+{
+        kdb_printf("%s ", kdb_bptype(bp));
+        kdb_printf("BP #%d at ", i);
+        kdb_symbol_print(bp->bp_addr, NULL, KDB_SP_DEFAULT);
+
+        if (bp->bp_enabled)
+                kdb_printf("\n    is enabled");
+        else
+                kdb_printf("\n    is disabled");
+
+        kdb_printf("\taddr at %016lx, hardtype=%d installed=%d\n",
+                   bp->bp_addr, bp->bp_type, bp->bp_installed);
+
+        kdb_printf("\n");
+}
+
+/*
+ * kdb_bp
+ *
+ *      Handle the bp commands.
+ *
+ *      [bp|bph] <addr-expression> [DATAR|DATAW]
+ *
+ * Parameters:
+ *      argc    Count of arguments in argv
+ *      argv    Space delimited command line arguments
+ * Outputs:
+ *      None.
+ * Returns:
+ *      Zero for success, a kdb diagnostic if failure.
+ * Locking:
+ *      None.
+ * Remarks:
+ *
+ *      bp      Set breakpoint on all cpus.  Only use hardware assist if need.
+ *      bph     Set breakpoint on all cpus.  Force hardware register
+ */
+
+static int kdb_bp(int argc, const char **argv)
+{
+        int i, bpno;
+        kdb_bp_t *bp, *bp_check;
+        int diag;
+        int free;
+        char *symname = NULL;
+        long offset = 0ul;
+        int nextarg;
+        kdb_bp_t template = {0};
+
+        if (argc == 0) {
+                /*
+                 * Display breakpoint table
+                 */
+                for (bpno = 0, bp = kdb_breakpoints; bpno < KDB_MAXBPT;
+                     bpno++, bp++) {
+                        if (bp->bp_free)
+                                continue;
+                        kdb_printbp(bp, bpno);
+                }
+
+                return 0;
+        }
+
+        nextarg = 1;
+        diag = kdbgetaddrarg(argc, argv, &nextarg, &template.bp_addr,
+                             &offset, &symname);
+        if (diag)
+                return diag;
+        if (!template.bp_addr)
+                return KDB_BADINT;
+
+        /*
+         * Find an empty bp structure to allocate
+         */
+        free = KDB_MAXBPT;
+        for (bpno = 0, bp = kdb_breakpoints; bpno < KDB_MAXBPT; bpno++, bp++) {
+                if (bp->bp_free)
+                        break;
+        }
+
+        if (bpno == KDB_MAXBPT)
+                return KDB_TOOMANYBPT;
+
+        if (strcmp(argv[0], "bph") == 0) {
+                template.bp_type = BP_HARDWARE_BREAKPOINT;
+                diag = kdb_parsebp(argc, argv, &nextarg, &template);
+                if (diag)
+                        return diag;
+        } else {
+                template.bp_type = BP_BREAKPOINT;
+        }
+
+        /*
+         * Check for clashing breakpoints.
+         *
+         * Note, in this design we can't have hardware breakpoints
+         * enabled for both read and write on the same address.
+         */
+        for (i = 0, bp_check = kdb_breakpoints; i < KDB_MAXBPT;
+             i++, bp_check++) {
+                if (!bp_check->bp_free &&
+                    bp_check->bp_addr == template.bp_addr) {
+                        kdb_printf("You already have a breakpoint at "
+                                   kdb_bfd_vma_fmt0 "\n", template.bp_addr);
+                        return KDB_DUPBPT;
+                }
+        }
+
+        template.bp_enabled = 1;
+
+        /*
+         * Actually allocate the breakpoint found earlier
+         */
+        *bp = template;
+        bp->bp_free = 0;
+
+        kdb_printbp(bp, bpno);
+
+        return 0;
+}
+
+/*
+ * kdb_bc
+ *
+ *      Handles the 'bc', 'be', and 'bd' commands
+ *
+ *      [bd|bc|be] <breakpoint-number>
+ *      [bd|bc|be] *
+ *
+ * Parameters:
+ *      argc    Count of arguments in argv
+ *      argv    Space delimited command line arguments
+ * Outputs:
+ *      None.
+ * Returns:
+ *      Zero for success, a kdb diagnostic for failure
+ * Locking:
+ *      None.
+ * Remarks:
+ */
+static int kdb_bc(int argc, const char **argv)
+{
+        unsigned long addr;
+        kdb_bp_t *bp = NULL;
+        int lowbp = KDB_MAXBPT;
+        int highbp = 0;
+        int done = 0;
+        int i;
+        int diag = 0;
+
+        int cmd;                        /* KDBCMD_B? */
+#define KDBCMD_BC       0
+#define KDBCMD_BE       1
+#define KDBCMD_BD       2
+
+        if (strcmp(argv[0], "be") == 0)
+                cmd = KDBCMD_BE;
+        else if (strcmp(argv[0], "bd") == 0)
+                cmd = KDBCMD_BD;
+        else
+                cmd = KDBCMD_BC;
+
+        if (argc != 1)
+                return KDB_ARGCOUNT;
+
+        if (strcmp(argv[1], "*") == 0) {
+                lowbp = 0;
+                highbp = KDB_MAXBPT;
+        } else {
+                diag = kdbgetularg(argv[1], &addr);
+                if (diag)
+                        return diag;
+
+                /*
+                 * For addresses less than the maximum breakpoint number,
+                 * assume that the breakpoint number is desired.
+                 */
+                if (addr < KDB_MAXBPT) {
+                        bp = &kdb_breakpoints[addr];
+                        lowbp = highbp = addr;
+                        highbp++;
+                } else {
+                        for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT;
+                            i++, bp++) {
+                                if (bp->bp_addr == addr) {
+                                        lowbp = highbp = i;
+                                        highbp++;
+                                        break;
+                                }
+                        }
+                }
+        }
+
+        /*
+         * Now operate on the set of breakpoints matching the input
+         * criteria (either '*' for all, or an individual breakpoint).
+         */
+        for (bp = &kdb_breakpoints[lowbp], i = lowbp;
+            i < highbp;
+            i++, bp++) {
+                if (bp->bp_free)
+                        continue;
+
+                done++;
+
+                switch (cmd) {
+                case KDBCMD_BC:
+                        bp->bp_enabled = 0;
+
+                        kdb_printf("Breakpoint %d at "
+                                   kdb_bfd_vma_fmt " cleared\n",
+                                   i, bp->bp_addr);
+
+                        bp->bp_addr = 0;
+                        bp->bp_free = 1;
+
+                        break;
+                case KDBCMD_BE:
+                        bp->bp_enabled = 1;
+
+                        kdb_printf("Breakpoint %d at "
+                                   kdb_bfd_vma_fmt " enabled",
+                                   i, bp->bp_addr);
+
+                        kdb_printf("\n");
+                        break;
+                case KDBCMD_BD:
+                        if (!bp->bp_enabled)
+                                break;
+
+                        bp->bp_enabled = 0;
+
+                        kdb_printf("Breakpoint %d at "
+                                   kdb_bfd_vma_fmt " disabled\n",
+                                   i, bp->bp_addr);
+
+                        break;
+                }
+                if (bp->bp_delay && (cmd == KDBCMD_BC || cmd == KDBCMD_BD)) {
+                        bp->bp_delay = 0;
+                        KDB_STATE_CLEAR(SSBPT);
+                }
+        }
+
+        return (!done) ? KDB_BPTNOTFOUND : 0;
+}
+
+/*
+ * kdb_ss
+ *
+ *      Process the 'ss' (Single Step) and 'ssb' (Single Step to Branch)
+ *      commands.
+ *
+ *      ss
+ *      ssb
+ *
+ * Parameters:
+ *      argc    Argument count
+ *      argv    Argument vector
+ * Outputs:
+ *      None.
+ * Returns:
+ *      KDB_CMD_SS[B] for success, a kdb error if failure.
+ * Locking:
+ *      None.
+ * Remarks:
+ *
+ *      Set the arch specific option to trigger a debug trap after the next
+ *      instruction.
+ *
+ *      For 'ssb', set the trace flag in the debug trap handler
+ *      after printing the current insn and return directly without
+ *      invoking the kdb command processor, until a branch instruction
+ *      is encountered.
+ */
+
+static int kdb_ss(int argc, const char **argv)
+{
+        int ssb = 0;
+
+        ssb = (strcmp(argv[0], "ssb") == 0);
+        if (argc != 0)
+                return KDB_ARGCOUNT;
+        /*
+         * Set trace flag and go.
+         */
+        KDB_STATE_SET(DOING_SS);
+        if (ssb) {
+                KDB_STATE_SET(DOING_SSB);
+                return KDB_CMD_SSB;
+        }
+        return KDB_CMD_SS;
+}
+
+/* Initialize the breakpoint table and register breakpoint commands. */
+
+void __init kdb_initbptab(void)
+{
+        int i;
+        kdb_bp_t *bp;
+
+        /*
+         * First time initialization.
+         */
+        memset(&kdb_breakpoints, '\0', sizeof(kdb_breakpoints));
+
+        for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; i++, bp++)
+                bp->bp_free = 1;
+
+        kdb_register_repeat("bp", kdb_bp, "[<vaddr>]",
+                "Set/Display breakpoints", 0, KDB_REPEAT_NO_ARGS);
+        kdb_register_repeat("bl", kdb_bp, "[<vaddr>]",
+                "Display breakpoints", 0, KDB_REPEAT_NO_ARGS);
+        if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT)
+                kdb_register_repeat("bph", kdb_bp, "[<vaddr>]",
+                "[datar [length]|dataw [length]]   Set hw brk", 0, KDB_REPEAT_NO_ARGS);
+        kdb_register_repeat("bc", kdb_bc, "<bpnum>",
+                "Clear Breakpoint", 0, KDB_REPEAT_NONE);
+        kdb_register_repeat("be", kdb_bc, "<bpnum>",
+                "Enable Breakpoint", 0, KDB_REPEAT_NONE);
+        kdb_register_repeat("bd", kdb_bc, "<bpnum>",
+                "Disable Breakpoint", 0, KDB_REPEAT_NONE);
+
+        kdb_register_repeat("ss", kdb_ss, "",
+                "Single Step", 1, KDB_REPEAT_NO_ARGS);
+        kdb_register_repeat("ssb", kdb_ss, "",
+                "Single step to branch/call", 0, KDB_REPEAT_NO_ARGS);
+        /*
+         * Architecture dependent initialization.
+         */
+}
diff --git a/kernel/debug/kdb/kdb_bt.c b/kernel/debug/kdb/kdb_bt.c
new file mode 100644
index 000000000000..2f62fe85f16a
--- /dev/null
+++ b/kernel/debug/kdb/kdb_bt.c
@@ -0,0 +1,210 @@
+/*
+ * Kernel Debugger Architecture Independent Stack Traceback
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (c) 1999-2004 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2009 Wind River Systems, Inc.  All Rights Reserved.
+ */
+
+#include <linux/ctype.h>
+#include <linux/string.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/kdb.h>
+#include <linux/nmi.h>
+#include <asm/system.h>
+#include "kdb_private.h"
+
+
+static void kdb_show_stack(struct task_struct *p, void *addr)
+{
+        int old_lvl = console_loglevel;
+        console_loglevel = 15;
+        kdb_trap_printk++;
+        kdb_set_current_task(p);
+        if (addr) {
+                show_stack((struct task_struct *)p, addr);
+        } else if (kdb_current_regs) {
+#ifdef CONFIG_X86
+                show_stack(p, &kdb_current_regs->sp);
+#else
+                show_stack(p, NULL);
+#endif
+        } else {
+                show_stack(p, NULL);
+        }
+        console_loglevel = old_lvl;
+        kdb_trap_printk--;
+}
+
+/*
+ * kdb_bt
+ *
+ *      This function implements the 'bt' command.  Print a stack
+ *      traceback.
+ *
+ *      bt [<address-expression>]       (addr-exp is for alternate stacks)
+ *      btp <pid>                       Kernel stack for <pid>
+ *      btt <address-expression>        Kernel stack for task structure at
+ *                                      <address-expression>
+ *      bta [DRSTCZEUIMA]               All useful processes, optionally
+ *                                      filtered by state
+ *      btc [<cpu>]                     The current process on one cpu,
+ *                                      default is all cpus
+ *
+ *      bt <address-expression> refers to a address on the stack, that location
+ *      is assumed to contain a return address.
+ *
+ *      btt <address-expression> refers to the address of a struct task.
+ *
+ * Inputs:
+ *      argc    argument count
+ *      argv    argument vector
+ * Outputs:
+ *      None.
+ * Returns:
+ *      zero for success, a kdb diagnostic if error
+ * Locking:
+ *      none.
+ * Remarks:
+ *      Backtrack works best when the code uses frame pointers.  But even
+ *      without frame pointers we should get a reasonable trace.
+ *
+ *      mds comes in handy when examining the stack to do a manual traceback or
+ *      to get a starting point for bt <address-expression>.
+ */
+
+static int
+kdb_bt1(struct task_struct *p, unsigned long mask,
+        int argcount, int btaprompt)
+{
+        char buffer[2];
+        if (kdb_getarea(buffer[0], (unsigned long)p) ||
+            kdb_getarea(buffer[0], (unsigned long)(p+1)-1))
+                return KDB_BADADDR;
+        if (!kdb_task_state(p, mask))
+                return 0;
+        kdb_printf("Stack traceback for pid %d\n", p->pid);
+        kdb_ps1(p);
+        kdb_show_stack(p, NULL);
+        if (btaprompt) {
+                kdb_getstr(buffer, sizeof(buffer),
+                           "Enter <q> to end, <cr> to continue:");
+                if (buffer[0] == 'q') {
+                        kdb_printf("\n");
+                        return 1;
+                }
+        }
+        touch_nmi_watchdog();
+        return 0;
+}
+
+int
+kdb_bt(int argc, const char **argv)
+{
+        int diag;
+        int argcount = 5;
+        int btaprompt = 1;
+        int nextarg;
+        unsigned long addr;
+        long offset;
+
+        kdbgetintenv("BTARGS", &argcount);      /* Arguments to print */
+        kdbgetintenv("BTAPROMPT", &btaprompt);  /* Prompt after each
+                                                 * proc in bta */
+
+        if (strcmp(argv[0], "bta") == 0) {
+                struct task_struct *g, *p;
+                unsigned long cpu;
+                unsigned long mask = kdb_task_state_string(argc ? argv[1] :
+                                                           NULL);
+                if (argc == 0)
+                        kdb_ps_suppressed();
+                /* Run the active tasks first */
+                for_each_online_cpu(cpu) {
+                        p = kdb_curr_task(cpu);
+                        if (kdb_bt1(p, mask, argcount, btaprompt))
+                                return 0;
+                }
+                /* Now the inactive tasks */
+                kdb_do_each_thread(g, p) {
+                        if (task_curr(p))
+                                continue;
+                        if (kdb_bt1(p, mask, argcount, btaprompt))
+                                return 0;
+                } kdb_while_each_thread(g, p);
+        } else if (strcmp(argv[0], "btp") == 0) {
+                struct task_struct *p;
+                unsigned long pid;
+                if (argc != 1)
+                        return KDB_ARGCOUNT;
+                diag = kdbgetularg((char *)argv[1], &pid);
+                if (diag)
+                        return diag;
+                p = find_task_by_pid_ns(pid, &init_pid_ns);
+                if (p) {
+                        kdb_set_current_task(p);
+                        return kdb_bt1(p, ~0UL, argcount, 0);
+                }
+                kdb_printf("No process with pid == %ld found\n", pid);
+                return 0;
+        } else if (strcmp(argv[0], "btt") == 0) {
+                if (argc != 1)
+                        return KDB_ARGCOUNT;
+                diag = kdbgetularg((char *)argv[1], &addr);
+                if (diag)
+                        return diag;
+                kdb_set_current_task((struct task_struct *)addr);
+                return kdb_bt1((struct task_struct *)addr, ~0UL, argcount, 0);
+        } else if (strcmp(argv[0], "btc") == 0) {
+                unsigned long cpu = ~0;
+                struct task_struct *save_current_task = kdb_current_task;
+                char buf[80];
+                if (argc > 1)
+                        return KDB_ARGCOUNT;
+                if (argc == 1) {
+                        diag = kdbgetularg((char *)argv[1], &cpu);
+                        if (diag)
+                                return diag;
+                }
+                /* Recursive use of kdb_parse, do not use argv after
+                 * this point */
+                argv = NULL;
+                if (cpu != ~0) {
+                        if (cpu >= num_possible_cpus() || !cpu_online(cpu)) {
+                                kdb_printf("no process for cpu %ld\n", cpu);
+                                return 0;
+                        }
+                        sprintf(buf, "btt 0x%p\n", KDB_TSK(cpu));
+                        kdb_parse(buf);
+                        return 0;
+                }
+                kdb_printf("btc: cpu status: ");
+                kdb_parse("cpu\n");
+                for_each_online_cpu(cpu) {
+                        sprintf(buf, "btt 0x%p\n", KDB_TSK(cpu));
+                        kdb_parse(buf);
+                        touch_nmi_watchdog();
+                }
+                kdb_set_current_task(save_current_task);
+                return 0;
+        } else {
+                if (argc) {
+                        nextarg = 1;
+                        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
+                                             &offset, NULL);
+                        if (diag)
+                                return diag;
+                        kdb_show_stack(kdb_current_task, (void *)addr);
+                        return 0;
+                } else {
+                        return kdb_bt1(kdb_current_task, ~0UL, argcount, 0);
+                }
+        }
+
+        /* NOTREACHED */
+        return 0;
+}
diff --git a/kernel/debug/kdb/kdb_cmds b/kernel/debug/kdb/kdb_cmds
new file mode 100644
index 000000000000..56c88e4db309
--- /dev/null
+++ b/kernel/debug/kdb/kdb_cmds
@@ -0,0 +1,35 @@
+# Initial commands for kdb, alter to suit your needs.
+# These commands are executed in kdb_init() context, no SMP, no
+# processes.  Commands that require process data (including stack or
+# registers) are not reliable this early.  set and bp commands should
+# be safe.  Global breakpoint commands affect each cpu as it is booted.
+
+# Standard debugging information for first level support, just type archkdb
+# or archkdbcpu or archkdbshort at the kdb prompt.
+
+defcmd dumpcommon "" "Common kdb debugging"
+  set BTAPROMPT 0
+  set LINES 10000
+  -summary
+  -cpu
+  -ps
+  -dmesg 600
+  -bt
+endefcmd
+
+defcmd dumpall "" "First line debugging"
+  set BTSYMARG 1
+  set BTARGS 9
+  pid R
+  -dumpcommon
+  -bta
+endefcmd
+
+defcmd dumpcpu "" "Same as dumpall but only tasks on cpus"
+  set BTSYMARG 1
+  set BTARGS 9
+  pid R
+  -dumpcommon
+  -btc
+endefcmd
+
diff --git a/kernel/debug/kdb/kdb_debugger.c b/kernel/debug/kdb/kdb_debugger.c
new file mode 100644
index 000000000000..bf6e8270e957
--- /dev/null
+++ b/kernel/debug/kdb/kdb_debugger.c
@@ -0,0 +1,169 @@
+/*
+ * Created by: Jason Wessel <jason.wessel@windriver.com>
+ *
+ * Copyright (c) 2009 Wind River Systems, Inc.  All Rights Reserved.
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include <linux/kgdb.h>
+#include <linux/kdb.h>
+#include <linux/kdebug.h>
+#include "kdb_private.h"
+#include "../debug_core.h"
+
+/*
+ * KDB interface to KGDB internals
+ */
+get_char_func kdb_poll_funcs[] = {
+        dbg_io_get_char,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+};
+EXPORT_SYMBOL_GPL(kdb_poll_funcs);
+
+int kdb_poll_idx = 1;
+EXPORT_SYMBOL_GPL(kdb_poll_idx);
+
+int kdb_stub(struct kgdb_state *ks)
+{
+        int error = 0;
+        kdb_bp_t *bp;
+        unsigned long addr = kgdb_arch_pc(ks->ex_vector, ks->linux_regs);
+        kdb_reason_t reason = KDB_REASON_OOPS;
+        kdb_dbtrap_t db_result = KDB_DB_NOBPT;
+        int i;
+
+        if (KDB_STATE(REENTRY)) {
+                reason = KDB_REASON_SWITCH;
+                KDB_STATE_CLEAR(REENTRY);
+                addr = instruction_pointer(ks->linux_regs);
+        }
+        ks->pass_exception = 0;
+        if (atomic_read(&kgdb_setting_breakpoint))
+                reason = KDB_REASON_KEYBOARD;
+
+        for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; i++, bp++) {
+                if ((bp->bp_enabled) && (bp->bp_addr == addr)) {
+                        reason = KDB_REASON_BREAK;
+                        db_result = KDB_DB_BPT;
+                        if (addr != instruction_pointer(ks->linux_regs))
+                                kgdb_arch_set_pc(ks->linux_regs, addr);
+                        break;
+                }
+        }
+        if (reason == KDB_REASON_BREAK || reason == KDB_REASON_SWITCH) {
+                for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; i++, bp++) {
+                        if (bp->bp_free)
+                                continue;
+                        if (bp->bp_addr == addr) {
+                                bp->bp_delay = 1;
+                                bp->bp_delayed = 1;
+        /*
+         * SSBPT is set when the kernel debugger must single step a
+         * task in order to re-establish an instruction breakpoint
+         * which uses the instruction replacement mechanism.  It is
+         * cleared by any action that removes the need to single-step
+         * the breakpoint.
+         */
+                                reason = KDB_REASON_BREAK;
+                                db_result = KDB_DB_BPT;
+                                KDB_STATE_SET(SSBPT);
+                                break;
+                        }
+                }
+        }
+
+        if (reason != KDB_REASON_BREAK && ks->ex_vector == 0 &&
+                ks->signo == SIGTRAP) {
+                reason = KDB_REASON_SSTEP;
+                db_result = KDB_DB_BPT;
+        }
+        /* Set initial kdb state variables */
+        KDB_STATE_CLEAR(KGDB_TRANS);
+        kdb_initial_cpu = ks->cpu;
+        kdb_current_task = kgdb_info[ks->cpu].task;
+        kdb_current_regs = kgdb_info[ks->cpu].debuggerinfo;
+        /* Remove any breakpoints as needed by kdb and clear single step */
+        kdb_bp_remove();
+        KDB_STATE_CLEAR(DOING_SS);
+        KDB_STATE_CLEAR(DOING_SSB);
+        KDB_STATE_SET(PAGER);
+        /* zero out any offline cpu data */
+        for_each_present_cpu(i) {
+                if (!cpu_online(i)) {
+                        kgdb_info[i].debuggerinfo = NULL;
+                        kgdb_info[i].task = NULL;
+                }
+        }
+        if (ks->err_code == DIE_OOPS || reason == KDB_REASON_OOPS) {
+                ks->pass_exception = 1;
+                KDB_FLAG_SET(CATASTROPHIC);
+        }
+        kdb_initial_cpu = ks->cpu;
+        if (KDB_STATE(SSBPT) && reason == KDB_REASON_SSTEP) {
+                KDB_STATE_CLEAR(SSBPT);
+                KDB_STATE_CLEAR(DOING_SS);
+        } else {
+                /* Start kdb main loop */
+                error = kdb_main_loop(KDB_REASON_ENTER, reason,
+                                      ks->err_code, db_result, ks->linux_regs);
+        }
+        /*
+         * Upon exit from the kdb main loop setup break points and restart
+         * the system based on the requested continue state
+         */
+        kdb_initial_cpu = -1;
+        kdb_current_task = NULL;
+        kdb_current_regs = NULL;
+        KDB_STATE_CLEAR(PAGER);
+        kdbnearsym_cleanup();
+        if (error == KDB_CMD_KGDB) {
+                if (KDB_STATE(DOING_KGDB) || KDB_STATE(DOING_KGDB2)) {
+        /*
+         * This inteface glue which allows kdb to transition in into
+         * the gdb stub.  In order to do this the '?' or '' gdb serial
+         * packet response is processed here.  And then control is
+         * passed to the gdbstub.
+         */
+                        if (KDB_STATE(DOING_KGDB))
+                                gdbstub_state(ks, "?");
+                        else
+                                gdbstub_state(ks, "");
+                        KDB_STATE_CLEAR(DOING_KGDB);
+                        KDB_STATE_CLEAR(DOING_KGDB2);
+                }
+                return DBG_PASS_EVENT;
+        }
+        kdb_bp_install(ks->linux_regs);
+        dbg_activate_sw_breakpoints();
+        /* Set the exit state to a single step or a continue */
+        if (KDB_STATE(DOING_SS))
+                gdbstub_state(ks, "s");
+        else
+                gdbstub_state(ks, "c");
+
+        KDB_FLAG_CLEAR(CATASTROPHIC);
+
+        /* Invoke arch specific exception handling prior to system resume */
+        kgdb_info[ks->cpu].ret_state = gdbstub_state(ks, "e");
+        if (ks->pass_exception)
+                kgdb_info[ks->cpu].ret_state = 1;
+        if (error == KDB_CMD_CPU) {
+                KDB_STATE_SET(REENTRY);
+                /*
+                 * Force clear the single step bit because kdb emulates this
+                 * differently vs the gdbstub
+                 */
+                kgdb_single_step = 0;
+                dbg_deactivate_sw_breakpoints();
+                return DBG_SWITCH_CPU_EVENT;
+        }
+        return kgdb_info[ks->cpu].ret_state;
+}
+
diff --git a/kernel/debug/kdb/kdb_io.c b/kernel/debug/kdb/kdb_io.c
new file mode 100644
index 000000000000..c9b7f4f90bba
--- /dev/null
+++ b/kernel/debug/kdb/kdb_io.c
@@ -0,0 +1,826 @@
+/*
+ * Kernel Debugger Architecture Independent Console I/O handler
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (c) 1999-2006 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2009 Wind River Systems, Inc.  All Rights Reserved.
+ */
+
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/ctype.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/kdev_t.h>
+#include <linux/console.h>
+#include <linux/string.h>
+#include <linux/sched.h>
+#include <linux/smp.h>
+#include <linux/nmi.h>
+#include <linux/delay.h>
+#include <linux/kgdb.h>
+#include <linux/kdb.h>
+#include <linux/kallsyms.h>
+#include "kdb_private.h"
+
+#define CMD_BUFLEN 256
+char kdb_prompt_str[CMD_BUFLEN];
+
+int kdb_trap_printk;
+
+static void kgdb_transition_check(char *buffer)
+{
+        int slen = strlen(buffer);
+        if (strncmp(buffer, "$?#3f", slen) != 0 &&
+            strncmp(buffer, "$qSupported#37", slen) != 0 &&
+            strncmp(buffer, "+$qSupported#37", slen) != 0) {
+                KDB_STATE_SET(KGDB_TRANS);
+                kdb_printf("%s", buffer);
+        }
+}
+
+static int kdb_read_get_key(char *buffer, size_t bufsize)
+{
+#define ESCAPE_UDELAY 1000
+#define ESCAPE_DELAY (2*1000000/ESCAPE_UDELAY) /* 2 seconds worth of udelays */
+        char escape_data[5];    /* longest vt100 escape sequence is 4 bytes */
+        char *ped = escape_data;
+        int escape_delay = 0;
+        get_char_func *f, *f_escape = NULL;
+        int key;
+
+        for (f = &kdb_poll_funcs[0]; ; ++f) {
+                if (*f == NULL) {
+                        /* Reset NMI watchdog once per poll loop */
+                        touch_nmi_watchdog();
+                        f = &kdb_poll_funcs[0];
+                }
+                if (escape_delay == 2) {
+                        *ped = '\0';
+                        ped = escape_data;
+                        --escape_delay;
+                }
+                if (escape_delay == 1) {
+                        key = *ped++;
+                        if (!*ped)
+                                --escape_delay;
+                        break;
+                }
+                key = (*f)();
+                if (key == -1) {
+                        if (escape_delay) {
+                                udelay(ESCAPE_UDELAY);
+                                --escape_delay;
+                        }
+                        continue;
+                }
+                if (bufsize <= 2) {
+                        if (key == '\r')
+                                key = '\n';
+                        *buffer++ = key;
+                        *buffer = '\0';
+                        return -1;
+                }
+                if (escape_delay == 0 && key == '\e') {
+                        escape_delay = ESCAPE_DELAY;
+                        ped = escape_data;
+                        f_escape = f;
+                }
+                if (escape_delay) {
+                        *ped++ = key;
+                        if (f_escape != f) {
+                                escape_delay = 2;
+                                continue;
+                        }
+                        if (ped - escape_data == 1) {
+                                /* \e */
+                                continue;
+                        } else if (ped - escape_data == 2) {
+                                /* \e<something> */
+                                if (key != '[')
+                                        escape_delay = 2;
+                                continue;
+                        } else if (ped - escape_data == 3) {
+                                /* \e[<something> */
+                                int mapkey = 0;
+                                switch (key) {
+                                case 'A': /* \e[A, up arrow */
+                                        mapkey = 16;
+                                        break;
+                                case 'B': /* \e[B, down arrow */
+                                        mapkey = 14;
+                                        break;
+                                case 'C': /* \e[C, right arrow */
+                                        mapkey = 6;
+                                        break;
+                                case 'D': /* \e[D, left arrow */
+                                        mapkey = 2;
+                                        break;
+                                case '1': /* dropthrough */
+                                case '3': /* dropthrough */
+                                /* \e[<1,3,4>], may be home, del, end */
+                                case '4':
+                                        mapkey = -1;
+                                        break;
+                                }
+                                if (mapkey != -1) {
+                                        if (mapkey > 0) {
+                                                escape_data[0] = mapkey;
+                                                escape_data[1] = '\0';
+                                        }
+                                        escape_delay = 2;
+                                }
+                                continue;
+                        } else if (ped - escape_data == 4) {
+                                /* \e[<1,3,4><something> */
+                                int mapkey = 0;
+                                if (key == '~') {
+                                        switch (escape_data[2]) {
+                                        case '1': /* \e[1~, home */
+                                                mapkey = 1;
+                                                break;
+                                        case '3': /* \e[3~, del */
+                                                mapkey = 4;
+                                                break;
+                                        case '4': /* \e[4~, end */
+                                                mapkey = 5;
+                                                break;
+                                        }
+                                }
+                                if (mapkey > 0) {
+                                        escape_data[0] = mapkey;
+                                        escape_data[1] = '\0';
+                                }
+                                escape_delay = 2;
+                                continue;
+                        }
+                }
+                break;  /* A key to process */
+        }
+        return key;
+}
+
+/*
+ * kdb_read
+ *
+ *      This function reads a string of characters, terminated by
+ *      a newline, or by reaching the end of the supplied buffer,
+ *      from the current kernel debugger console device.
+ * Parameters:
+ *      buffer  - Address of character buffer to receive input characters.
+ *      bufsize - size, in bytes, of the character buffer
+ * Returns:
+ *      Returns a pointer to the buffer containing the received
+ *      character string.  This string will be terminated by a
+ *      newline character.
+ * Locking:
+ *      No locks are required to be held upon entry to this
+ *      function.  It is not reentrant - it relies on the fact
+ *      that while kdb is running on only one "master debug" cpu.
+ * Remarks:
+ *
+ * The buffer size must be >= 2.  A buffer size of 2 means that the caller only
+ * wants a single key.
+ *
+ * An escape key could be the start of a vt100 control sequence such as \e[D
+ * (left arrow) or it could be a character in its own right.  The standard
+ * method for detecting the difference is to wait for 2 seconds to see if there
+ * are any other characters.  kdb is complicated by the lack of a timer service
+ * (interrupts are off), by multiple input sources and by the need to sometimes
+ * return after just one key.  Escape sequence processing has to be done as
+ * states in the polling loop.
+ */
+
+static char *kdb_read(char *buffer, size_t bufsize)
+{
+        char *cp = buffer;
+        char *bufend = buffer+bufsize-2;        /* Reserve space for newline
+                                                 * and null byte */
+        char *lastchar;
+        char *p_tmp;
+        char tmp;
+        static char tmpbuffer[CMD_BUFLEN];
+        int len = strlen(buffer);
+        int len_tmp;
+        int tab = 0;
+        int count;
+        int i;
+        int diag, dtab_count;
+        int key;
+
+
+        diag = kdbgetintenv("DTABCOUNT", &dtab_count);
+        if (diag)
+                dtab_count = 30;
+
+        if (len > 0) {
+                cp += len;
+                if (*(buffer+len-1) == '\n')
+                        cp--;
+        }
+
+        lastchar = cp;
+        *cp = '\0';
+        kdb_printf("%s", buffer);
+poll_again:
+        key = kdb_read_get_key(buffer, bufsize);
+        if (key == -1)
+                return buffer;
+        if (key != 9)
+                tab = 0;
+        switch (key) {
+        case 8: /* backspace */
+                if (cp > buffer) {
+                        if (cp < lastchar) {
+                                memcpy(tmpbuffer, cp, lastchar - cp);
+                                memcpy(cp-1, tmpbuffer, lastchar - cp);
+                        }
+                        *(--lastchar) = '\0';
+                        --cp;
+                        kdb_printf("\b%s \r", cp);
+                        tmp = *cp;
+                        *cp = '\0';
+                        kdb_printf(kdb_prompt_str);
+                        kdb_printf("%s", buffer);
+                        *cp = tmp;
+                }
+                break;
+        case 13: /* enter */
+                *lastchar++ = '\n';
+                *lastchar++ = '\0';
+                kdb_printf("\n");
+                return buffer;
+        case 4: /* Del */
+                if (cp < lastchar) {
+                        memcpy(tmpbuffer, cp+1, lastchar - cp - 1);
+                        memcpy(cp, tmpbuffer, lastchar - cp - 1);
+                        *(--lastchar) = '\0';
+                        kdb_printf("%s \r", cp);
+                        tmp = *cp;
+                        *cp = '\0';
+                        kdb_printf(kdb_prompt_str);
+                        kdb_printf("%s", buffer);
+                        *cp = tmp;
+                }
+                break;
+        case 1: /* Home */
+                if (cp > buffer) {
+                        kdb_printf("\r");
+                        kdb_printf(kdb_prompt_str);
+                        cp = buffer;
+                }
+                break;
+        case 5: /* End */
+                if (cp < lastchar) {
+                        kdb_printf("%s", cp);
+                        cp = lastchar;
+                }
+                break;
+        case 2: /* Left */
+                if (cp > buffer) {
+                        kdb_printf("\b");
+                        --cp;
+                }
+                break;
+        case 14: /* Down */
+                memset(tmpbuffer, ' ',
+                       strlen(kdb_prompt_str) + (lastchar-buffer));
+                *(tmpbuffer+strlen(kdb_prompt_str) +
+                  (lastchar-buffer)) = '\0';
+                kdb_printf("\r%s\r", tmpbuffer);
+                *lastchar = (char)key;
+                *(lastchar+1) = '\0';
+                return lastchar;
+        case 6: /* Right */
+                if (cp < lastchar) {
+                        kdb_printf("%c", *cp);
+                        ++cp;
+                }
+                break;
+        case 16: /* Up */
+                memset(tmpbuffer, ' ',
+                       strlen(kdb_prompt_str) + (lastchar-buffer));
+                *(tmpbuffer+strlen(kdb_prompt_str) +
+                  (lastchar-buffer)) = '\0';
+                kdb_printf("\r%s\r", tmpbuffer);
+                *lastchar = (char)key;
+                *(lastchar+1) = '\0';
+                return lastchar;
+        case 9: /* Tab */
+                if (tab < 2)
+                        ++tab;
+                p_tmp = buffer;
+                while (*p_tmp == ' ')
+                        p_tmp++;
+                if (p_tmp > cp)
+                        break;
+                memcpy(tmpbuffer, p_tmp, cp-p_tmp);
+                *(tmpbuffer + (cp-p_tmp)) = '\0';
+                p_tmp = strrchr(tmpbuffer, ' ');
+                if (p_tmp)
+                        ++p_tmp;
+                else
+                        p_tmp = tmpbuffer;
+                len = strlen(p_tmp);
+                count = kallsyms_symbol_complete(p_tmp,
+                                                 sizeof(tmpbuffer) -
+                                                 (p_tmp - tmpbuffer));
+                if (tab == 2 && count > 0) {
+                        kdb_printf("\n%d symbols are found.", count);
+                        if (count > dtab_count) {
+                                count = dtab_count;
+                                kdb_printf(" But only first %d symbols will"
+                                           " be printed.\nYou can change the"
+                                           " environment variable DTABCOUNT.",
+                                           count);
+                        }
+                        kdb_printf("\n");
+                        for (i = 0; i < count; i++) {
+                                if (kallsyms_symbol_next(p_tmp, i) < 0)
+                                        break;
+                                kdb_printf("%s ", p_tmp);
+                                *(p_tmp + len) = '\0';
+                        }
+                        if (i >= dtab_count)
+                                kdb_printf("...");
+                        kdb_printf("\n");
+                        kdb_printf(kdb_prompt_str);
+                        kdb_printf("%s", buffer);
+                } else if (tab != 2 && count > 0) {
+                        len_tmp = strlen(p_tmp);
+                        strncpy(p_tmp+len_tmp, cp, lastchar-cp+1);
+                        len_tmp = strlen(p_tmp);
+                        strncpy(cp, p_tmp+len, len_tmp-len + 1);
+                        len = len_tmp - len;
+                        kdb_printf("%s", cp);
+                        cp += len;
+                        lastchar += len;
+                }
+                kdb_nextline = 1; /* reset output line number */
+                break;
+        default:
+                if (key >= 32 && lastchar < bufend) {
+                        if (cp < lastchar) {
+                                memcpy(tmpbuffer, cp, lastchar - cp);
+                                memcpy(cp+1, tmpbuffer, lastchar - cp);
+                                *++lastchar = '\0';
+                                *cp = key;
+                                kdb_printf("%s\r", cp);
+                                ++cp;
+                                tmp = *cp;
+                                *cp = '\0';
+                                kdb_printf(kdb_prompt_str);
+                                kdb_printf("%s", buffer);
+                                *cp = tmp;
+                        } else {
+                                *++lastchar = '\0';
+                                *cp++ = key;
+                                /* The kgdb transition check will hide
+                                 * printed characters if we think that
+                                 * kgdb is connecting, until the check
+                                 * fails */
+                                if (!KDB_STATE(KGDB_TRANS))
+                                        kgdb_transition_check(buffer);
+                                else
+                                        kdb_printf("%c", key);
+                        }
+                        /* Special escape to kgdb */
+                        if (lastchar - buffer >= 5 &&
+                            strcmp(lastchar - 5, "$?#3f") == 0) {
+                                strcpy(buffer, "kgdb");
+                                KDB_STATE_SET(DOING_KGDB);
+                                return buffer;
+                        }
+                        if (lastchar - buffer >= 14 &&
+                            strcmp(lastchar - 14, "$qSupported#37") == 0) {
+                                strcpy(buffer, "kgdb");
+                                KDB_STATE_SET(DOING_KGDB2);
+                                return buffer;
+                        }
+                }
+                break;
+        }
+        goto poll_again;
+}
+
+/*
+ * kdb_getstr
+ *
+ *      Print the prompt string and read a command from the
+ *      input device.
+ *
+ * Parameters:
+ *      buffer  Address of buffer to receive command
+ *      bufsize Size of buffer in bytes
+ *      prompt  Pointer to string to use as prompt string
+ * Returns:
+ *      Pointer to command buffer.
+ * Locking:
+ *      None.
+ * Remarks:
+ *      For SMP kernels, the processor number will be
+ *      substituted for %d, %x or %o in the prompt.
+ */
+
+char *kdb_getstr(char *buffer, size_t bufsize, char *prompt)
+{
+        if (prompt && kdb_prompt_str != prompt)
+                strncpy(kdb_prompt_str, prompt, CMD_BUFLEN);
+        kdb_printf(kdb_prompt_str);
+        kdb_nextline = 1;       /* Prompt and input resets line number */
+        return kdb_read(buffer, bufsize);
+}
+
+/*
+ * kdb_input_flush
+ *
+ *      Get rid of any buffered console input.
+ *
+ * Parameters:
+ *      none
+ * Returns:
+ *      nothing
+ * Locking:
+ *      none
+ * Remarks:
+ *      Call this function whenever you want to flush input.  If there is any
+ *      outstanding input, it ignores all characters until there has been no
+ *      data for approximately 1ms.
+ */
+
+static void kdb_input_flush(void)
+{
+        get_char_func *f;
+        int res;
+        int flush_delay = 1;
+        while (flush_delay) {
+                flush_delay--;
+empty:
+                touch_nmi_watchdog();
+                for (f = &kdb_poll_funcs[0]; *f; ++f) {
+                        res = (*f)();
+                        if (res != -1) {
+                                flush_delay = 1;
+                                goto empty;
+                        }
+                }
+                if (flush_delay)
+                        mdelay(1);
+        }
+}
+
+/*
+ * kdb_printf
+ *
+ *      Print a string to the output device(s).
+ *
+ * Parameters:
+ *      printf-like format and optional args.
+ * Returns:
+ *      0
+ * Locking:
+ *      None.
+ * Remarks:
+ *      use 'kdbcons->write()' to avoid polluting 'log_buf' with
+ *      kdb output.
+ *
+ *  If the user is doing a cmd args | grep srch
+ *  then kdb_grepping_flag is set.
+ *  In that case we need to accumulate full lines (ending in \n) before
+ *  searching for the pattern.
+ */
+
+static char kdb_buffer[256];    /* A bit too big to go on stack */
+static char *next_avail = kdb_buffer;
+static int  size_avail;
+static int  suspend_grep;
+
+/*
+ * search arg1 to see if it contains arg2
+ * (kdmain.c provides flags for ^pat and pat$)
+ *
+ * return 1 for found, 0 for not found
+ */
+static int kdb_search_string(char *searched, char *searchfor)
+{
+        char firstchar, *cp;
+        int len1, len2;
+
+        /* not counting the newline at the end of "searched" */
+        len1 = strlen(searched)-1;
+        len2 = strlen(searchfor);
+        if (len1 < len2)
+                return 0;
+        if (kdb_grep_leading && kdb_grep_trailing && len1 != len2)
+                return 0;
+        if (kdb_grep_leading) {
+                if (!strncmp(searched, searchfor, len2))
+                        return 1;
+        } else if (kdb_grep_trailing) {
+                if (!strncmp(searched+len1-len2, searchfor, len2))
+                        return 1;
+        } else {
+                firstchar = *searchfor;
+                cp = searched;
+                while ((cp = strchr(cp, firstchar))) {
+                        if (!strncmp(cp, searchfor, len2))
+                                return 1;
+                        cp++;
+                }
+        }
+        return 0;
+}
+
+int vkdb_printf(const char *fmt, va_list ap)
+{
+        int diag;
+        int linecount;
+        int logging, saved_loglevel = 0;
+        int saved_trap_printk;
+        int got_printf_lock = 0;
+        int retlen = 0;
+        int fnd, len;
+        char *cp, *cp2, *cphold = NULL, replaced_byte = ' ';
+        char *moreprompt = "more> ";
+        struct console *c = console_drivers;
+        static DEFINE_SPINLOCK(kdb_printf_lock);
+        unsigned long uninitialized_var(flags);
+
+        preempt_disable();
+        saved_trap_printk = kdb_trap_printk;
+        kdb_trap_printk = 0;
+
+        /* Serialize kdb_printf if multiple cpus try to write at once.
+         * But if any cpu goes recursive in kdb, just print the output,
+         * even if it is interleaved with any other text.
+         */
+        if (!KDB_STATE(PRINTF_LOCK)) {
+                KDB_STATE_SET(PRINTF_LOCK);
+                spin_lock_irqsave(&kdb_printf_lock, flags);
+                got_printf_lock = 1;
+                atomic_inc(&kdb_event);
+        } else {
+                __acquire(kdb_printf_lock);
+        }
+
+        diag = kdbgetintenv("LINES", &linecount);
+        if (diag || linecount <= 1)
+                linecount = 24;
+
+        diag = kdbgetintenv("LOGGING", &logging);
+        if (diag)
+                logging = 0;
+
+        if (!kdb_grepping_flag || suspend_grep) {
+                /* normally, every vsnprintf starts a new buffer */
+                next_avail = kdb_buffer;
+                size_avail = sizeof(kdb_buffer);
+        }
+        vsnprintf(next_avail, size_avail, fmt, ap);
+
+        /*
+         * If kdb_parse() found that the command was cmd xxx | grep yyy
+         * then kdb_grepping_flag is set, and kdb_grep_string contains yyy
+         *
+         * Accumulate the print data up to a newline before searching it.
+         * (vsnprintf does null-terminate the string that it generates)
+         */
+
+        /* skip the search if prints are temporarily unconditional */
+        if (!suspend_grep && kdb_grepping_flag) {
+                cp = strchr(kdb_buffer, '\n');
+                if (!cp) {
+                        /*
+                         * Special cases that don't end with newlines
+                         * but should be written without one:
+                         *   The "[nn]kdb> " prompt should
+                         *   appear at the front of the buffer.
+                         *
+                         *   The "[nn]more " prompt should also be
+                         *     (MOREPROMPT -> moreprompt)
+                         *   written *   but we print that ourselves,
+                         *   we set the suspend_grep flag to make
+                         *   it unconditional.
+                         *
+                         */
+                        if (next_avail == kdb_buffer) {
+                                /*
+                                 * these should occur after a newline,
+                                 * so they will be at the front of the
+                                 * buffer
+                                 */
+                                cp2 = kdb_buffer;
+                                len = strlen(kdb_prompt_str);
+                                if (!strncmp(cp2, kdb_prompt_str, len)) {
+                                        /*
+                                         * We're about to start a new
+                                         * command, so we can go back
+                                         * to normal mode.
+                                         */
+                                        kdb_grepping_flag = 0;
+                                        goto kdb_printit;
+                                }
+                        }
+                        /* no newline; don't search/write the buffer
+                           until one is there */
+                        len = strlen(kdb_buffer);
+                        next_avail = kdb_buffer + len;
+                        size_avail = sizeof(kdb_buffer) - len;
+                        goto kdb_print_out;
+                }
+
+                /*
+                 * The newline is present; print through it or discard
+                 * it, depending on the results of the search.
+                 */
+                cp++;                /* to byte after the newline */
+                replaced_byte = *cp; /* remember what/where it was */
+                cphold = cp;
+                *cp = '\0';          /* end the string for our search */
+
+                /*
+                 * We now have a newline at the end of the string
+                 * Only continue with this output if it contains the
+                 * search string.
+                 */
+                fnd = kdb_search_string(kdb_buffer, kdb_grep_string);
+                if (!fnd) {
+                        /*
+                         * At this point the complete line at the start
+                         * of kdb_buffer can be discarded, as it does
+                         * not contain what the user is looking for.
+                         * Shift the buffer left.
+                         */
+                        *cphold = replaced_byte;
+                        strcpy(kdb_buffer, cphold);
+                        len = strlen(kdb_buffer);
+                        next_avail = kdb_buffer + len;
+                        size_avail = sizeof(kdb_buffer) - len;
+                        goto kdb_print_out;
+                }
+                /*
+                 * at this point the string is a full line and
+                 * should be printed, up to the null.
+                 */
+        }
+kdb_printit:
+
+        /*
+         * Write to all consoles.
+         */
+        retlen = strlen(kdb_buffer);
+        if (!dbg_kdb_mode && kgdb_connected) {
+                gdbstub_msg_write(kdb_buffer, retlen);
+        } else {
+                if (!dbg_io_ops->is_console) {
+                        len = strlen(kdb_buffer);
+                        cp = kdb_buffer;
+                        while (len--) {
+                                dbg_io_ops->write_char(*cp);
+                                cp++;
+                        }
+                }
+                while (c) {
+                        c->write(c, kdb_buffer, retlen);
+                        touch_nmi_watchdog();
+                        c = c->next;
+                }
+        }
+        if (logging) {
+                saved_loglevel = console_loglevel;
+                console_loglevel = 0;
+                printk(KERN_INFO "%s", kdb_buffer);
+        }
+
+        if (KDB_STATE(PAGER) && strchr(kdb_buffer, '\n'))
+                kdb_nextline++;
+
+        /* check for having reached the LINES number of printed lines */
+        if (kdb_nextline == linecount) {
+                char buf1[16] = "";
+#if defined(CONFIG_SMP)
+                char buf2[32];
+#endif
+
+                /* Watch out for recursion here.  Any routine that calls
+                 * kdb_printf will come back through here.  And kdb_read
+                 * uses kdb_printf to echo on serial consoles ...
+                 */
+                kdb_nextline = 1;       /* In case of recursion */
+
+                /*
+                 * Pause until cr.
+                 */
+                moreprompt = kdbgetenv("MOREPROMPT");
+                if (moreprompt == NULL)
+                        moreprompt = "more> ";
+
+#if defined(CONFIG_SMP)
+                if (strchr(moreprompt, '%')) {
+                        sprintf(buf2, moreprompt, get_cpu());
+                        put_cpu();
+                        moreprompt = buf2;
+                }
+#endif
+
+                kdb_input_flush();
+                c = console_drivers;
+
+                if (!dbg_io_ops->is_console) {
+                        len = strlen(moreprompt);
+                        cp = moreprompt;
+                        while (len--) {
+                                dbg_io_ops->write_char(*cp);
+                                cp++;
+                        }
+                }
+                while (c) {
+                        c->write(c, moreprompt, strlen(moreprompt));
+                        touch_nmi_watchdog();
+                        c = c->next;
+                }
+
+                if (logging)
+                        printk("%s", moreprompt);
+
+                kdb_read(buf1, 2); /* '2' indicates to return
+                                    * immediately after getting one key. */
+                kdb_nextline = 1;       /* Really set output line 1 */
+
+                /* empty and reset the buffer: */
+                kdb_buffer[0] = '\0';
+                next_avail = kdb_buffer;
+                size_avail = sizeof(kdb_buffer);
+                if ((buf1[0] == 'q') || (buf1[0] == 'Q')) {
+                        /* user hit q or Q */
+                        KDB_FLAG_SET(CMD_INTERRUPT); /* command interrupted */
+                        KDB_STATE_CLEAR(PAGER);
+                        /* end of command output; back to normal mode */
+                        kdb_grepping_flag = 0;
+                        kdb_printf("\n");
+                } else if (buf1[0] == ' ') {
+                        kdb_printf("\n");
+                        suspend_grep = 1; /* for this recursion */
+                } else if (buf1[0] == '\n') {
+                        kdb_nextline = linecount - 1;
+                        kdb_printf("\r");
+                        suspend_grep = 1; /* for this recursion */
+                } else if (buf1[0] && buf1[0] != '\n') {
+                        /* user hit something other than enter */
+                        suspend_grep = 1; /* for this recursion */
+                        kdb_printf("\nOnly 'q' or 'Q' are processed at more "
+                                   "prompt, input ignored\n");
+                } else if (kdb_grepping_flag) {
+                        /* user hit enter */
+                        suspend_grep = 1; /* for this recursion */
+                        kdb_printf("\n");
+                }
+                kdb_input_flush();
+        }
+
+        /*
+         * For grep searches, shift the printed string left.
+         *  replaced_byte contains the character that was overwritten with
+         *  the terminating null, and cphold points to the null.
+         * Then adjust the notion of available space in the buffer.
+         */
+        if (kdb_grepping_flag && !suspend_grep) {
+                *cphold = replaced_byte;
+                strcpy(kdb_buffer, cphold);
+                len = strlen(kdb_buffer);
+                next_avail = kdb_buffer + len;
+                size_avail = sizeof(kdb_buffer) - len;
+        }
+
+kdb_print_out:
+        suspend_grep = 0; /* end of what may have been a recursive call */
+        if (logging)
+                console_loglevel = saved_loglevel;
+        if (KDB_STATE(PRINTF_LOCK) && got_printf_lock) {
+                got_printf_lock = 0;
+                spin_unlock_irqrestore(&kdb_printf_lock, flags);
+                KDB_STATE_CLEAR(PRINTF_LOCK);
+                atomic_dec(&kdb_event);
+        } else {
+                __release(kdb_printf_lock);
+        }
+        kdb_trap_printk = saved_trap_printk;
+        preempt_enable();
+        return retlen;
+}
+
+int kdb_printf(const char *fmt, ...)
+{
+        va_list ap;
+        int r;
+
+        va_start(ap, fmt);
+        r = vkdb_printf(fmt, ap);
+        va_end(ap);
+
+        return r;
+}
+
diff --git a/kernel/debug/kdb/kdb_keyboard.c b/kernel/debug/kdb/kdb_keyboard.c
new file mode 100644
index 000000000000..4bca634975c0
--- /dev/null
+++ b/kernel/debug/kdb/kdb_keyboard.c
@@ -0,0 +1,212 @@
+/*
+ * Kernel Debugger Architecture Dependent Console I/O handler
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.
+ *
+ * Copyright (c) 1999-2006 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2009 Wind River Systems, Inc.  All Rights Reserved.
+ */
+
+#include <linux/kdb.h>
+#include <linux/keyboard.h>
+#include <linux/ctype.h>
+#include <linux/module.h>
+#include <linux/io.h>
+
+/* Keyboard Controller Registers on normal PCs. */
+
+#define KBD_STATUS_REG          0x64    /* Status register (R) */
+#define KBD_DATA_REG            0x60    /* Keyboard data register (R/W) */
+
+/* Status Register Bits */
+
+#define KBD_STAT_OBF            0x01    /* Keyboard output buffer full */
+#define KBD_STAT_MOUSE_OBF      0x20    /* Mouse output buffer full */
+
+static int kbd_exists;
+
+/*
+ * Check if the keyboard controller has a keypress for us.
+ * Some parts (Enter Release, LED change) are still blocking polled here,
+ * but hopefully they are all short.
+ */
+int kdb_get_kbd_char(void)
+{
+        int scancode, scanstatus;
+        static int shift_lock;  /* CAPS LOCK state (0-off, 1-on) */
+        static int shift_key;   /* Shift next keypress */
+        static int ctrl_key;
+        u_short keychar;
+
+        if (KDB_FLAG(NO_I8042) || KDB_FLAG(NO_VT_CONSOLE) ||
+            (inb(KBD_STATUS_REG) == 0xff && inb(KBD_DATA_REG) == 0xff)) {
+                kbd_exists = 0;
+                return -1;
+        }
+        kbd_exists = 1;
+
+        if ((inb(KBD_STATUS_REG) & KBD_STAT_OBF) == 0)
+                return -1;
+
+        /*
+         * Fetch the scancode
+         */
+        scancode = inb(KBD_DATA_REG);
+        scanstatus = inb(KBD_STATUS_REG);
+
+        /*
+         * Ignore mouse events.
+         */
+        if (scanstatus & KBD_STAT_MOUSE_OBF)
+                return -1;
+
+        /*
+         * Ignore release, trigger on make
+         * (except for shift keys, where we want to
+         *  keep the shift state so long as the key is
+         *  held down).
+         */
+
+        if (((scancode&0x7f) == 0x2a) || ((scancode&0x7f) == 0x36)) {
+                /*
+                 * Next key may use shift table
+                 */
+                if ((scancode & 0x80) == 0)
+                        shift_key = 1;
+                else
+                        shift_key = 0;
+                return -1;
+        }
+
+        if ((scancode&0x7f) == 0x1d) {
+                /*
+                 * Left ctrl key
+                 */
+                if ((scancode & 0x80) == 0)
+                        ctrl_key = 1;
+                else
+                        ctrl_key = 0;
+                return -1;
+        }
+
+        if ((scancode & 0x80) != 0)
+                return -1;
+
+        scancode &= 0x7f;
+
+        /*
+         * Translate scancode
+         */
+
+        if (scancode == 0x3a) {
+                /*
+                 * Toggle caps lock
+                 */
+                shift_lock ^= 1;
+
+#ifdef  KDB_BLINK_LED
+                kdb_toggleled(0x4);
+#endif
+                return -1;
+        }
+
+        if (scancode == 0x0e) {
+                /*
+                 * Backspace
+                 */
+                return 8;
+        }
+
+        /* Special Key */
+        switch (scancode) {
+        case 0xF: /* Tab */
+                return 9;
+        case 0x53: /* Del */
+                return 4;
+        case 0x47: /* Home */
+                return 1;
+        case 0x4F: /* End */
+                return 5;
+        case 0x4B: /* Left */
+                return 2;
+        case 0x48: /* Up */
+                return 16;
+        case 0x50: /* Down */
+                return 14;
+        case 0x4D: /* Right */
+                return 6;
+        }
+
+        if (scancode == 0xe0)
+                return -1;
+
+        /*
+         * For Japanese 86/106 keyboards
+         *      See comment in drivers/char/pc_keyb.c.
+         *      - Masahiro Adegawa
+         */
+        if (scancode == 0x73)
+                scancode = 0x59;
+        else if (scancode == 0x7d)
+                scancode = 0x7c;
+
+        if (!shift_lock && !shift_key && !ctrl_key) {
+                keychar = plain_map[scancode];
+        } else if ((shift_lock || shift_key) && key_maps[1]) {
+                keychar = key_maps[1][scancode];
+        } else if (ctrl_key && key_maps[4]) {
+                keychar = key_maps[4][scancode];
+        } else {
+                keychar = 0x0020;
+                kdb_printf("Unknown state/scancode (%d)\n", scancode);
+        }
+        keychar &= 0x0fff;
+        if (keychar == '\t')
+                keychar = ' ';
+        switch (KTYP(keychar)) {
+        case KT_LETTER:
+        case KT_LATIN:
+                if (isprint(keychar))
+                        break;          /* printable characters */
+                /* drop through */
+        case KT_SPEC:
+                if (keychar == K_ENTER)
+                        break;
+                /* drop through */
+        default:
+                return -1;      /* ignore unprintables */
+        }
+
+        if ((scancode & 0x7f) == 0x1c) {
+                /*
+                 * enter key.  All done.  Absorb the release scancode.
+                 */
+                while ((inb(KBD_STATUS_REG) & KBD_STAT_OBF) == 0)
+                        ;
+
+                /*
+                 * Fetch the scancode
+                 */
+                scancode = inb(KBD_DATA_REG);
+                scanstatus = inb(KBD_STATUS_REG);
+
+                while (scanstatus & KBD_STAT_MOUSE_OBF) {
+                        scancode = inb(KBD_DATA_REG);
+                        scanstatus = inb(KBD_STATUS_REG);
+                }
+
+                if (scancode != 0x9c) {
+                        /*
+                         * Wasn't an enter-release,  why not?
+                         */
+                        kdb_printf("kdb: expected enter got 0x%x status 0x%x\n",
+                               scancode, scanstatus);
+                }
+
+                return 13;
+        }
+
+        return keychar & 0xff;
+}
+EXPORT_SYMBOL_GPL(kdb_get_kbd_char);
diff --git a/kernel/debug/kdb/kdb_main.c b/kernel/debug/kdb/kdb_main.c
new file mode 100644
index 000000000000..b724c791b6d4
--- /dev/null
+++ b/kernel/debug/kdb/kdb_main.c
@@ -0,0 +1,2849 @@
+/*
+ * Kernel Debugger Architecture Independent Main Code
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 1999-2004 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (C) 2000 Stephane Eranian <eranian@hpl.hp.com>
+ * Xscale (R) modifications copyright (C) 2003 Intel Corporation.
+ * Copyright (c) 2009 Wind River Systems, Inc.  All Rights Reserved.
+ */
+
+#include <linux/ctype.h>
+#include <linux/string.h>
+#include <linux/kernel.h>
+#include <linux/reboot.h>
+#include <linux/sched.h>
+#include <linux/sysrq.h>
+#include <linux/smp.h>
+#include <linux/utsname.h>
+#include <linux/vmalloc.h>
+#include <linux/module.h>
+#include <linux/mm.h>
+#include <linux/init.h>
+#include <linux/kallsyms.h>
+#include <linux/kgdb.h>
+#include <linux/kdb.h>
+#include <linux/notifier.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/nmi.h>
+#include <linux/time.h>
+#include <linux/ptrace.h>
+#include <linux/sysctl.h>
+#include <linux/cpu.h>
+#include <linux/kdebug.h>
+#include <linux/proc_fs.h>
+#include <linux/uaccess.h>
+#include <linux/slab.h>
+#include "kdb_private.h"
+
+#define GREP_LEN 256
+char kdb_grep_string[GREP_LEN];
+int kdb_grepping_flag;
+EXPORT_SYMBOL(kdb_grepping_flag);
+int kdb_grep_leading;
+int kdb_grep_trailing;
+
+/*
+ * Kernel debugger state flags
+ */
+int kdb_flags;
+atomic_t kdb_event;
+
+/*
+ * kdb_lock protects updates to kdb_initial_cpu.  Used to
+ * single thread processors through the kernel debugger.
+ */
+int kdb_initial_cpu = -1;       /* cpu number that owns kdb */
+int kdb_nextline = 1;
+int kdb_state;                  /* General KDB state */
+
+struct task_struct *kdb_current_task;
+EXPORT_SYMBOL(kdb_current_task);
+struct pt_regs *kdb_current_regs;
+
+const char *kdb_diemsg;
+static int kdb_go_count;
+#ifdef CONFIG_KDB_CONTINUE_CATASTROPHIC
+static unsigned int kdb_continue_catastrophic =
+        CONFIG_KDB_CONTINUE_CATASTROPHIC;
+#else
+static unsigned int kdb_continue_catastrophic;
+#endif
+
+/* kdb_commands describes the available commands. */
+static kdbtab_t *kdb_commands;
+#define KDB_BASE_CMD_MAX 50
+static int kdb_max_commands = KDB_BASE_CMD_MAX;
+static kdbtab_t kdb_base_commands[50];
+#define for_each_kdbcmd(cmd, num)                                       \
+        for ((cmd) = kdb_base_commands, (num) = 0;                      \
+             num < kdb_max_commands;                                    \
+             num == KDB_BASE_CMD_MAX ? cmd = kdb_commands : cmd++, num++)
+
+typedef struct _kdbmsg {
+        int     km_diag;        /* kdb diagnostic */
+        char    *km_msg;        /* Corresponding message text */
+} kdbmsg_t;
+
+#define KDBMSG(msgnum, text) \
+        { KDB_##msgnum, text }
+
+static kdbmsg_t kdbmsgs[] = {
+        KDBMSG(NOTFOUND, "Command Not Found"),
+        KDBMSG(ARGCOUNT, "Improper argument count, see usage."),
+        KDBMSG(BADWIDTH, "Illegal value for BYTESPERWORD use 1, 2, 4 or 8, "
+               "8 is only allowed on 64 bit systems"),
+        KDBMSG(BADRADIX, "Illegal value for RADIX use 8, 10 or 16"),
+        KDBMSG(NOTENV, "Cannot find environment variable"),
+        KDBMSG(NOENVVALUE, "Environment variable should have value"),
+        KDBMSG(NOTIMP, "Command not implemented"),
+        KDBMSG(ENVFULL, "Environment full"),
+        KDBMSG(ENVBUFFULL, "Environment buffer full"),
+        KDBMSG(TOOMANYBPT, "Too many breakpoints defined"),
+#ifdef CONFIG_CPU_XSCALE
+        KDBMSG(TOOMANYDBREGS, "More breakpoints than ibcr registers defined"),
+#else
+        KDBMSG(TOOMANYDBREGS, "More breakpoints than db registers defined"),
+#endif
+        KDBMSG(DUPBPT, "Duplicate breakpoint address"),
+        KDBMSG(BPTNOTFOUND, "Breakpoint not found"),
+        KDBMSG(BADMODE, "Invalid IDMODE"),
+        KDBMSG(BADINT, "Illegal numeric value"),
+        KDBMSG(INVADDRFMT, "Invalid symbolic address format"),
+        KDBMSG(BADREG, "Invalid register name"),
+        KDBMSG(BADCPUNUM, "Invalid cpu number"),
+        KDBMSG(BADLENGTH, "Invalid length field"),
+        KDBMSG(NOBP, "No Breakpoint exists"),
+        KDBMSG(BADADDR, "Invalid address"),
+};
+#undef KDBMSG
+
+static const int __nkdb_err = sizeof(kdbmsgs) / sizeof(kdbmsg_t);
+
+
+/*
+ * Initial environment.   This is all kept static and local to
+ * this file.   We don't want to rely on the memory allocation
+ * mechanisms in the kernel, so we use a very limited allocate-only
+ * heap for new and altered environment variables.  The entire
+ * environment is limited to a fixed number of entries (add more
+ * to __env[] if required) and a fixed amount of heap (add more to
+ * KDB_ENVBUFSIZE if required).
+ */
+
+static char *__env[] = {
+#if defined(CONFIG_SMP)
+ "PROMPT=[%d]kdb> ",
+ "MOREPROMPT=[%d]more> ",
+#else
+ "PROMPT=kdb> ",
+ "MOREPROMPT=more> ",
+#endif
+ "RADIX=16",
+ "MDCOUNT=8",                   /* lines of md output */
+ "BTARGS=9",                    /* 9 possible args in bt */
+ KDB_PLATFORM_ENV,
+ "DTABCOUNT=30",
+ "NOSECT=1",
+ (char *)0,
+ (char *)0,
+ (char *)0,
+ (char *)0,
+ (char *)0,
+ (char *)0,
+ (char *)0,
+ (char *)0,
+ (char *)0,
+ (char *)0,
+ (char *)0,
+ (char *)0,
+ (char *)0,
+ (char *)0,
+ (char *)0,
+ (char *)0,
+ (char *)0,
+ (char *)0,
+ (char *)0,
+ (char *)0,
+ (char *)0,
+ (char *)0,
+ (char *)0,
+};
+
+static const int __nenv = (sizeof(__env) / sizeof(char *));
+
+struct task_struct *kdb_curr_task(int cpu)
+{
+        struct task_struct *p = curr_task(cpu);
+#ifdef  _TIF_MCA_INIT
+        if ((task_thread_info(p)->flags & _TIF_MCA_INIT) && KDB_TSK(cpu))
+                p = krp->p;
+#endif
+        return p;
+}
+
+/*
+ * kdbgetenv - This function will return the character string value of
+ *      an environment variable.
+ * Parameters:
+ *      match   A character string representing an environment variable.
+ * Returns:
+ *      NULL    No environment variable matches 'match'
+ *      char*   Pointer to string value of environment variable.
+ */
+char *kdbgetenv(const char *match)
+{
+        char **ep = __env;
+        int matchlen = strlen(match);
+        int i;
+
+        for (i = 0; i < __nenv; i++) {
+                char *e = *ep++;
+
+                if (!e)
+                        continue;
+
+                if ((strncmp(match, e, matchlen) == 0)
+                 && ((e[matchlen] == '\0')
+                   || (e[matchlen] == '='))) {
+                        char *cp = strchr(e, '=');
+                        return cp ? ++cp : "";
+                }
+        }
+        return NULL;
+}
+
+/*
+ * kdballocenv - This function is used to allocate bytes for
+ *      environment entries.
+ * Parameters:
+ *      match   A character string representing a numeric value
+ * Outputs:
+ *      *value  the unsigned long representation of the env variable 'match'
+ * Returns:
+ *      Zero on success, a kdb diagnostic on failure.
+ * Remarks:
+ *      We use a static environment buffer (envbuffer) to hold the values
+ *      of dynamically generated environment variables (see kdb_set).  Buffer
+ *      space once allocated is never free'd, so over time, the amount of space
+ *      (currently 512 bytes) will be exhausted if env variables are changed
+ *      frequently.
+ */
+static char *kdballocenv(size_t bytes)
+{
+#define KDB_ENVBUFSIZE  512
+        static char envbuffer[KDB_ENVBUFSIZE];
+        static int envbufsize;
+        char *ep = NULL;
+
+        if ((KDB_ENVBUFSIZE - envbufsize) >= bytes) {
+                ep = &envbuffer[envbufsize];
+                envbufsize += bytes;
+        }
+        return ep;
+}
+
+/*
+ * kdbgetulenv - This function will return the value of an unsigned
+ *      long-valued environment variable.
+ * Parameters:
+ *      match   A character string representing a numeric value
+ * Outputs:
+ *      *value  the unsigned long represntation of the env variable 'match'
+ * Returns:
+ *      Zero on success, a kdb diagnostic on failure.
+ */
+static int kdbgetulenv(const char *match, unsigned long *value)
+{
+        char *ep;
+
+        ep = kdbgetenv(match);
+        if (!ep)
+                return KDB_NOTENV;
+        if (strlen(ep) == 0)
+                return KDB_NOENVVALUE;
+
+        *value = simple_strtoul(ep, NULL, 0);
+
+        return 0;
+}
+
+/*
+ * kdbgetintenv - This function will return the value of an
+ *      integer-valued environment variable.
+ * Parameters:
+ *      match   A character string representing an integer-valued env variable
+ * Outputs:
+ *      *value  the integer representation of the environment variable 'match'
+ * Returns:
+ *      Zero on success, a kdb diagnostic on failure.
+ */
+int kdbgetintenv(const char *match, int *value)
+{
+        unsigned long val;
+        int diag;
+
+        diag = kdbgetulenv(match, &val);
+        if (!diag)
+                *value = (int) val;
+        return diag;
+}
+
+/*
+ * kdbgetularg - This function will convert a numeric string into an
+ *      unsigned long value.
+ * Parameters:
+ *      arg     A character string representing a numeric value
+ * Outputs:
+ *      *value  the unsigned long represntation of arg.
+ * Returns:
+ *      Zero on success, a kdb diagnostic on failure.
+ */
+int kdbgetularg(const char *arg, unsigned long *value)
+{
+        char *endp;
+        unsigned long val;
+
+        val = simple_strtoul(arg, &endp, 0);
+
+        if (endp == arg) {
+                /*
+                 * Try base 16, for us folks too lazy to type the
+                 * leading 0x...
+                 */
+                val = simple_strtoul(arg, &endp, 16);
+                if (endp == arg)
+                        return KDB_BADINT;
+        }
+
+        *value = val;
+
+        return 0;
+}
+
+/*
+ * kdb_set - This function implements the 'set' command.  Alter an
+ *      existing environment variable or create a new one.
+ */
+int kdb_set(int argc, const char **argv)
+{
+        int i;
+        char *ep;
+        size_t varlen, vallen;
+
+        /*
+         * we can be invoked two ways:
+         *   set var=value    argv[1]="var", argv[2]="value"
+         *   set var = value  argv[1]="var", argv[2]="=", argv[3]="value"
+         * - if the latter, shift 'em down.
+         */
+        if (argc == 3) {
+                argv[2] = argv[3];
+                argc--;
+        }
+
+        if (argc != 2)
+                return KDB_ARGCOUNT;
+
+        /*
+         * Check for internal variables
+         */
+        if (strcmp(argv[1], "KDBDEBUG") == 0) {
+                unsigned int debugflags;
+                char *cp;
+
+                debugflags = simple_strtoul(argv[2], &cp, 0);
+                if (cp == argv[2] || debugflags & ~KDB_DEBUG_FLAG_MASK) {
+                        kdb_printf("kdb: illegal debug flags '%s'\n",
+                                    argv[2]);
+                        return 0;
+                }
+                kdb_flags = (kdb_flags &
+                             ~(KDB_DEBUG_FLAG_MASK << KDB_DEBUG_FLAG_SHIFT))
+                        | (debugflags << KDB_DEBUG_FLAG_SHIFT);
+
+                return 0;
+        }
+
+        /*
+         * Tokenizer squashed the '=' sign.  argv[1] is variable
+         * name, argv[2] = value.
+         */
+        varlen = strlen(argv[1]);
+        vallen = strlen(argv[2]);
+        ep = kdballocenv(varlen + vallen + 2);
+        if (ep == (char *)0)
+                return KDB_ENVBUFFULL;
+
+        sprintf(ep, "%s=%s", argv[1], argv[2]);
+
+        ep[varlen+vallen+1] = '\0';
+
+        for (i = 0; i < __nenv; i++) {
+                if (__env[i]
+                 && ((strncmp(__env[i], argv[1], varlen) == 0)
+                   && ((__env[i][varlen] == '\0')
+                    || (__env[i][varlen] == '=')))) {
+                        __env[i] = ep;
+                        return 0;
+                }
+        }
+
+        /*
+         * Wasn't existing variable.  Fit into slot.
+         */
+        for (i = 0; i < __nenv-1; i++) {
+                if (__env[i] == (char *)0) {
+                        __env[i] = ep;
+                        return 0;
+                }
+        }
+
+        return KDB_ENVFULL;
+}
+
+static int kdb_check_regs(void)
+{
+        if (!kdb_current_regs) {
+                kdb_printf("No current kdb registers."
+                           "  You may need to select another task\n");
+                return KDB_BADREG;
+        }
+        return 0;
+}
+
+/*
+ * kdbgetaddrarg - This function is responsible for parsing an
+ *      address-expression and returning the value of the expression,
+ *      symbol name, and offset to the caller.
+ *
+ *      The argument may consist of a numeric value (decimal or
+ *      hexidecimal), a symbol name, a register name (preceeded by the
+ *      percent sign), an environment variable with a numeric value
+ *      (preceeded by a dollar sign) or a simple arithmetic expression
+ *      consisting of a symbol name, +/-, and a numeric constant value
+ *      (offset).
+ * Parameters:
+ *      argc    - count of arguments in argv
+ *      argv    - argument vector
+ *      *nextarg - index to next unparsed argument in argv[]
+ *      regs    - Register state at time of KDB entry
+ * Outputs:
+ *      *value  - receives the value of the address-expression
+ *      *offset - receives the offset specified, if any
+ *      *name   - receives the symbol name, if any
+ *      *nextarg - index to next unparsed argument in argv[]
+ * Returns:
+ *      zero is returned on success, a kdb diagnostic code is
+ *      returned on error.
+ */
+int kdbgetaddrarg(int argc, const char **argv, int *nextarg,
+                  unsigned long *value,  long *offset,
+                  char **name)
+{
+        unsigned long addr;
+        unsigned long off = 0;
+        int positive;
+        int diag;
+        int found = 0;
+        char *symname;
+        char symbol = '\0';
+        char *cp;
+        kdb_symtab_t symtab;
+
+        /*
+         * Process arguments which follow the following syntax:
+         *
+         *  symbol | numeric-address [+/- numeric-offset]
+         *  %register
+         *  $environment-variable
+         */
+
+        if (*nextarg > argc)
+                return KDB_ARGCOUNT;
+
+        symname = (char *)argv[*nextarg];
+
+        /*
+         * If there is no whitespace between the symbol
+         * or address and the '+' or '-' symbols, we
+         * remember the character and replace it with a
+         * null so the symbol/value can be properly parsed
+         */
+        cp = strpbrk(symname, "+-");
+        if (cp != NULL) {
+                symbol = *cp;
+                *cp++ = '\0';
+        }
+
+        if (symname[0] == '$') {
+                diag = kdbgetulenv(&symname[1], &addr);
+                if (diag)
+                        return diag;
+        } else if (symname[0] == '%') {
+                diag = kdb_check_regs();
+                if (diag)
+                        return diag;
+                /* Implement register values with % at a later time as it is
+                 * arch optional.
+                 */
+                return KDB_NOTIMP;
+        } else {
+                found = kdbgetsymval(symname, &symtab);
+                if (found) {
+                        addr = symtab.sym_start;
+                } else {
+                        diag = kdbgetularg(argv[*nextarg], &addr);
+                        if (diag)
+                                return diag;
+                }
+        }
+
+        if (!found)
+                found = kdbnearsym(addr, &symtab);
+
+        (*nextarg)++;
+
+        if (name)
+                *name = symname;
+        if (value)
+                *value = addr;
+        if (offset && name && *name)
+                *offset = addr - symtab.sym_start;
+
+        if ((*nextarg > argc)
+         && (symbol == '\0'))
+                return 0;
+
+        /*
+         * check for +/- and offset
+         */
+
+        if (symbol == '\0') {
+                if ((argv[*nextarg][0] != '+')
+                 && (argv[*nextarg][0] != '-')) {
+                        /*
+                         * Not our argument.  Return.
+                         */
+                        return 0;
+                } else {
+                        positive = (argv[*nextarg][0] == '+');
+                        (*nextarg)++;
+                }
+        } else
+                positive = (symbol == '+');
+
+        /*
+         * Now there must be an offset!
+         */
+        if ((*nextarg > argc)
+         && (symbol == '\0')) {
+                return KDB_INVADDRFMT;
+        }
+
+        if (!symbol) {
+                cp = (char *)argv[*nextarg];
+                (*nextarg)++;
+        }
+
+        diag = kdbgetularg(cp, &off);
+        if (diag)
+                return diag;
+
+        if (!positive)
+                off = -off;
+
+        if (offset)
+                *offset += off;
+
+        if (value)
+                *value += off;
+
+        return 0;
+}
+
+static void kdb_cmderror(int diag)
+{
+        int i;
+
+        if (diag >= 0) {
+                kdb_printf("no error detected (diagnostic is %d)\n", diag);
+                return;
+        }
+
+        for (i = 0; i < __nkdb_err; i++) {
+                if (kdbmsgs[i].km_diag == diag) {
+                        kdb_printf("diag: %d: %s\n", diag, kdbmsgs[i].km_msg);
+                        return;
+                }
+        }
+
+        kdb_printf("Unknown diag %d\n", -diag);
+}
+
+/*
+ * kdb_defcmd, kdb_defcmd2 - This function implements the 'defcmd'
+ *      command which defines one command as a set of other commands,
+ *      terminated by endefcmd.  kdb_defcmd processes the initial
+ *      'defcmd' command, kdb_defcmd2 is invoked from kdb_parse for
+ *      the following commands until 'endefcmd'.
+ * Inputs:
+ *      argc    argument count
+ *      argv    argument vector
+ * Returns:
+ *      zero for success, a kdb diagnostic if error
+ */
+struct defcmd_set {
+        int count;
+        int usable;
+        char *name;
+        char *usage;
+        char *help;
+        char **command;
+};
+static struct defcmd_set *defcmd_set;
+static int defcmd_set_count;
+static int defcmd_in_progress;
+
+/* Forward references */
+static int kdb_exec_defcmd(int argc, const char **argv);
+
+static int kdb_defcmd2(const char *cmdstr, const char *argv0)
+{
+        struct defcmd_set *s = defcmd_set + defcmd_set_count - 1;
+        char **save_command = s->command;
+        if (strcmp(argv0, "endefcmd") == 0) {
+                defcmd_in_progress = 0;
+                if (!s->count)
+                        s->usable = 0;
+                if (s->usable)
+                        kdb_register(s->name, kdb_exec_defcmd,
+                                     s->usage, s->help, 0);
+                return 0;
+        }
+        if (!s->usable)
+                return KDB_NOTIMP;
+        s->command = kmalloc((s->count + 1) * sizeof(*(s->command)), GFP_KDB);
+        if (!s->command) {
+                kdb_printf("Could not allocate new kdb_defcmd table for %s\n",
+                           cmdstr);
+                s->usable = 0;
+                return KDB_NOTIMP;
+        }
+        memcpy(s->command, save_command, s->count * sizeof(*(s->command)));
+        s->command[s->count++] = kdb_strdup(cmdstr, GFP_KDB);
+        kfree(save_command);
+        return 0;
+}
+
+static int kdb_defcmd(int argc, const char **argv)
+{
+        struct defcmd_set *save_defcmd_set = defcmd_set, *s;
+        if (defcmd_in_progress) {
+                kdb_printf("kdb: nested defcmd detected, assuming missing "
+                           "endefcmd\n");
+                kdb_defcmd2("endefcmd", "endefcmd");
+        }
+        if (argc == 0) {
+                int i;
+                for (s = defcmd_set; s < defcmd_set + defcmd_set_count; ++s) {
+                        kdb_printf("defcmd %s \"%s\" \"%s\"\n", s->name,
+                                   s->usage, s->help);
+                        for (i = 0; i < s->count; ++i)
+                                kdb_printf("%s", s->command[i]);
+                        kdb_printf("endefcmd\n");
+                }
+                return 0;
+        }
+        if (argc != 3)
+                return KDB_ARGCOUNT;
+        defcmd_set = kmalloc((defcmd_set_count + 1) * sizeof(*defcmd_set),
+                             GFP_KDB);
+        if (!defcmd_set) {
+                kdb_printf("Could not allocate new defcmd_set entry for %s\n",
+                           argv[1]);
+                defcmd_set = save_defcmd_set;
+                return KDB_NOTIMP;
+        }
+        memcpy(defcmd_set, save_defcmd_set,
+               defcmd_set_count * sizeof(*defcmd_set));
+        kfree(save_defcmd_set);
+        s = defcmd_set + defcmd_set_count;
+        memset(s, 0, sizeof(*s));
+        s->usable = 1;
+        s->name = kdb_strdup(argv[1], GFP_KDB);
+        s->usage = kdb_strdup(argv[2], GFP_KDB);
+        s->help = kdb_strdup(argv[3], GFP_KDB);
+        if (s->usage[0] == '"') {
+                strcpy(s->usage, s->usage+1);
+                s->usage[strlen(s->usage)-1] = '\0';
+        }
+        if (s->help[0] == '"') {
+                strcpy(s->help, s->help+1);
+                s->help[strlen(s->help)-1] = '\0';
+        }
+        ++defcmd_set_count;
+        defcmd_in_progress = 1;
+        return 0;
+}
+
+/*
+ * kdb_exec_defcmd - Execute the set of commands associated with this
+ *      defcmd name.
+ * Inputs:
+ *      argc    argument count
+ *      argv    argument vector
+ * Returns:
+ *      zero for success, a kdb diagnostic if error
+ */
+static int kdb_exec_defcmd(int argc, const char **argv)
+{
+        int i, ret;
+        struct defcmd_set *s;
+        if (argc != 0)
+                return KDB_ARGCOUNT;
+        for (s = defcmd_set, i = 0; i < defcmd_set_count; ++i, ++s) {
+                if (strcmp(s->name, argv[0]) == 0)
+                        break;
+        }
+        if (i == defcmd_set_count) {
+                kdb_printf("kdb_exec_defcmd: could not find commands for %s\n",
+                           argv[0]);
+                return KDB_NOTIMP;
+        }
+        for (i = 0; i < s->count; ++i) {
+                /* Recursive use of kdb_parse, do not use argv after
+                 * this point */
+                argv = NULL;
+                kdb_printf("[%s]kdb> %s\n", s->name, s->command[i]);
+                ret = kdb_parse(s->command[i]);
+                if (ret)
+                        return ret;
+        }
+        return 0;
+}
+
+/* Command history */
+#define KDB_CMD_HISTORY_COUNT   32
+#define CMD_BUFLEN              200     /* kdb_printf: max printline
+                                         * size == 256 */
+static unsigned int cmd_head, cmd_tail;
+static unsigned int cmdptr;
+static char cmd_hist[KDB_CMD_HISTORY_COUNT][CMD_BUFLEN];
+static char cmd_cur[CMD_BUFLEN];
+
+/*
+ * The "str" argument may point to something like  | grep xyz
+ */
+static void parse_grep(const char *str)
+{
+        int     len;
+        char    *cp = (char *)str, *cp2;
+
+        /* sanity check: we should have been called with the \ first */
+        if (*cp != '|')
+                return;
+        cp++;
+        while (isspace(*cp))
+                cp++;
+        if (strncmp(cp, "grep ", 5)) {
+                kdb_printf("invalid 'pipe', see grephelp\n");
+                return;
+        }
+        cp += 5;
+        while (isspace(*cp))
+                cp++;
+        cp2 = strchr(cp, '\n');
+        if (cp2)
+                *cp2 = '\0'; /* remove the trailing newline */
+        len = strlen(cp);
+        if (len == 0) {
+                kdb_printf("invalid 'pipe', see grephelp\n");
+                return;
+        }
+        /* now cp points to a nonzero length search string */
+        if (*cp == '"') {
+                /* allow it be "x y z" by removing the "'s - there must
+                   be two of them */
+                cp++;
+                cp2 = strchr(cp, '"');
+                if (!cp2) {
+                        kdb_printf("invalid quoted string, see grephelp\n");
+                        return;
+                }
+                *cp2 = '\0'; /* end the string where the 2nd " was */
+        }
+        kdb_grep_leading = 0;
+        if (*cp == '^') {
+                kdb_grep_leading = 1;
+                cp++;
+        }
+        len = strlen(cp);
+        kdb_grep_trailing = 0;
+        if (*(cp+len-1) == '$') {
+                kdb_grep_trailing = 1;
+                *(cp+len-1) = '\0';
+        }
+        len = strlen(cp);
+        if (!len)
+                return;
+        if (len >= GREP_LEN) {
+                kdb_printf("search string too long\n");
+                return;
+        }
+        strcpy(kdb_grep_string, cp);
+        kdb_grepping_flag++;
+        return;
+}
+
+/*
+ * kdb_parse - Parse the command line, search the command table for a
+ *      matching command and invoke the command function.  This
+ *      function may be called recursively, if it is, the second call
+ *      will overwrite argv and cbuf.  It is the caller's
+ *      responsibility to save their argv if they recursively call
+ *      kdb_parse().
+ * Parameters:
+ *      cmdstr  The input command line to be parsed.
+ *      regs    The registers at the time kdb was entered.
+ * Returns:
+ *      Zero for success, a kdb diagnostic if failure.
+ * Remarks:
+ *      Limited to 20 tokens.
+ *
+ *      Real rudimentary tokenization. Basically only whitespace
+ *      is considered a token delimeter (but special consideration
+ *      is taken of the '=' sign as used by the 'set' command).
+ *
+ *      The algorithm used to tokenize the input string relies on
+ *      there being at least one whitespace (or otherwise useless)
+ *      character between tokens as the character immediately following
+ *      the token is altered in-place to a null-byte to terminate the
+ *      token string.
+ */
+
+#define MAXARGC 20
+
+int kdb_parse(const char *cmdstr)
+{
+        static char *argv[MAXARGC];
+        static int argc;
+        static char cbuf[CMD_BUFLEN+2];
+        char *cp;
+        char *cpp, quoted;
+        kdbtab_t *tp;
+        int i, escaped, ignore_errors = 0, check_grep;
+
+        /*
+         * First tokenize the command string.
+         */
+        cp = (char *)cmdstr;
+        kdb_grepping_flag = check_grep = 0;
+
+        if (KDB_FLAG(CMD_INTERRUPT)) {
+                /* Previous command was interrupted, newline must not
+                 * repeat the command */
+                KDB_FLAG_CLEAR(CMD_INTERRUPT);
+                KDB_STATE_SET(PAGER);
+                argc = 0;       /* no repeat */
+        }
+
+        if (*cp != '\n' && *cp != '\0') {
+                argc = 0;
+                cpp = cbuf;
+                while (*cp) {
+                        /* skip whitespace */
+                        while (isspace(*cp))
+                                cp++;
+                        if ((*cp == '\0') || (*cp == '\n') ||
+                            (*cp == '#' && !defcmd_in_progress))
+                                break;
+                        /* special case: check for | grep pattern */
+                        if (*cp == '|') {
+                                check_grep++;
+                                break;
+                        }
+                        if (cpp >= cbuf + CMD_BUFLEN) {
+                                kdb_printf("kdb_parse: command buffer "
+                                           "overflow, command ignored\n%s\n",
+                                           cmdstr);
+                                return KDB_NOTFOUND;
+                        }
+                        if (argc >= MAXARGC - 1) {
+                                kdb_printf("kdb_parse: too many arguments, "
+                                           "command ignored\n%s\n", cmdstr);
+                                return KDB_NOTFOUND;
+                        }
+                        argv[argc++] = cpp;
+                        escaped = 0;
+                        quoted = '\0';
+                        /* Copy to next unquoted and unescaped
+                         * whitespace or '=' */
+                        while (*cp && *cp != '\n' &&
+                               (escaped || quoted || !isspace(*cp))) {
+                                if (cpp >= cbuf + CMD_BUFLEN)
+                                        break;
+                                if (escaped) {
+                                        escaped = 0;
+                                        *cpp++ = *cp++;
+                                        continue;
+                                }
+                                if (*cp == '\\') {
+                                        escaped = 1;
+                                        ++cp;
+                                        continue;
+                                }
+                                if (*cp == quoted)
+                                        quoted = '\0';
+                                else if (*cp == '\'' || *cp == '"')
+                                        quoted = *cp;
+                                *cpp = *cp++;
+                                if (*cpp == '=' && !quoted)
+                                        break;
+                                ++cpp;
+                        }
+                        *cpp++ = '\0';  /* Squash a ws or '=' character */
+                }
+        }
+        if (!argc)
+                return 0;
+        if (check_grep)
+                parse_grep(cp);
+        if (defcmd_in_progress) {
+                int result = kdb_defcmd2(cmdstr, argv[0]);
+                if (!defcmd_in_progress) {
+                        argc = 0;       /* avoid repeat on endefcmd */
+                        *(argv[0]) = '\0';
+                }
+                return result;
+        }
+        if (argv[0][0] == '-' && argv[0][1] &&
+            (argv[0][1] < '0' || argv[0][1] > '9')) {
+                ignore_errors = 1;
+                ++argv[0];
+        }
+
+        for_each_kdbcmd(tp, i) {
+                if (tp->cmd_name) {
+                        /*
+                         * If this command is allowed to be abbreviated,
+                         * check to see if this is it.
+                         */
+
+                        if (tp->cmd_minlen
+                         && (strlen(argv[0]) <= tp->cmd_minlen)) {
+                                if (strncmp(argv[0],
+                                            tp->cmd_name,
+                                            tp->cmd_minlen) == 0) {
+                                        break;
+                                }
+                        }
+
+                        if (strcmp(argv[0], tp->cmd_name) == 0)
+                                break;
+                }
+        }
+
+        /*
+         * If we don't find a command by this name, see if the first
+         * few characters of this match any of the known commands.
+         * e.g., md1c20 should match md.
+         */
+        if (i == kdb_max_commands) {
+                for_each_kdbcmd(tp, i) {
+                        if (tp->cmd_name) {
+                                if (strncmp(argv[0],
+                                            tp->cmd_name,
+                                            strlen(tp->cmd_name)) == 0) {
+                                        break;
+                                }
+                        }
+                }
+        }
+
+        if (i < kdb_max_commands) {
+                int result;
+                KDB_STATE_SET(CMD);
+                result = (*tp->cmd_func)(argc-1, (const char **)argv);
+                if (result && ignore_errors && result > KDB_CMD_GO)
+                        result = 0;
+                KDB_STATE_CLEAR(CMD);
+                switch (tp->cmd_repeat) {
+                case KDB_REPEAT_NONE:
+                        argc = 0;
+                        if (argv[0])
+                                *(argv[0]) = '\0';
+                        break;
+                case KDB_REPEAT_NO_ARGS:
+                        argc = 1;
+                        if (argv[1])
+                                *(argv[1]) = '\0';
+                        break;
+                case KDB_REPEAT_WITH_ARGS:
+                        break;
+                }
+                return result;
+        }
+
+        /*
+         * If the input with which we were presented does not
+         * map to an existing command, attempt to parse it as an
+         * address argument and display the result.   Useful for
+         * obtaining the address of a variable, or the nearest symbol
+         * to an address contained in a register.
+         */
+        {
+                unsigned long value;
+                char *name = NULL;
+                long offset;
+                int nextarg = 0;
+
+                if (kdbgetaddrarg(0, (const char **)argv, &nextarg,
+                                  &value, &offset, &name)) {
+                        return KDB_NOTFOUND;
+                }
+
+                kdb_printf("%s = ", argv[0]);
+                kdb_symbol_print(value, NULL, KDB_SP_DEFAULT);
+                kdb_printf("\n");
+                return 0;
+        }
+}
+
+
+static int handle_ctrl_cmd(char *cmd)
+{
+#define CTRL_P  16
+#define CTRL_N  14
+
+        /* initial situation */
+        if (cmd_head == cmd_tail)
+                return 0;
+        switch (*cmd) {
+        case CTRL_P:
+                if (cmdptr != cmd_tail)
+                        cmdptr = (cmdptr-1) % KDB_CMD_HISTORY_COUNT;
+                strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
+                return 1;
+        case CTRL_N:
+                if (cmdptr != cmd_head)
+                        cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT;
+                strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
+                return 1;
+        }
+        return 0;
+}
+
+/*
+ * kdb_reboot - This function implements the 'reboot' command.  Reboot
+ *      the system immediately, or loop for ever on failure.
+ */
+static int kdb_reboot(int argc, const char **argv)
+{
+        emergency_restart();
+        kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
+        while (1)
+                cpu_relax();
+        /* NOTREACHED */
+        return 0;
+}
+
+static void kdb_dumpregs(struct pt_regs *regs)
+{
+        int old_lvl = console_loglevel;
+        console_loglevel = 15;
+        kdb_trap_printk++;
+        show_regs(regs);
+        kdb_trap_printk--;
+        kdb_printf("\n");
+        console_loglevel = old_lvl;
+}
+
+void kdb_set_current_task(struct task_struct *p)
+{
+        kdb_current_task = p;
+
+        if (kdb_task_has_cpu(p)) {
+                kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p));
+                return;
+        }
+        kdb_current_regs = NULL;
+}
+
+/*
+ * kdb_local - The main code for kdb.  This routine is invoked on a
+ *      specific processor, it is not global.  The main kdb() routine
+ *      ensures that only one processor at a time is in this routine.
+ *      This code is called with the real reason code on the first
+ *      entry to a kdb session, thereafter it is called with reason
+ *      SWITCH, even if the user goes back to the original cpu.
+ * Inputs:
+ *      reason          The reason KDB was invoked
+ *      error           The hardware-defined error code
+ *      regs            The exception frame at time of fault/breakpoint.
+ *      db_result       Result code from the break or debug point.
+ * Returns:
+ *      0       KDB was invoked for an event which it wasn't responsible
+ *      1       KDB handled the event for which it was invoked.
+ *      KDB_CMD_GO      User typed 'go'.
+ *      KDB_CMD_CPU     User switched to another cpu.
+ *      KDB_CMD_SS      Single step.
+ *      KDB_CMD_SSB     Single step until branch.
+ */
+static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs,
+                     kdb_dbtrap_t db_result)
+{
+        char *cmdbuf;
+        int diag;
+        struct task_struct *kdb_current =
+                kdb_curr_task(raw_smp_processor_id());
+
+        KDB_DEBUG_STATE("kdb_local 1", reason);
+        kdb_go_count = 0;
+        if (reason == KDB_REASON_DEBUG) {
+                /* special case below */
+        } else {
+                kdb_printf("\nEntering kdb (current=0x%p, pid %d) ",
+                           kdb_current, kdb_current->pid);
+#if defined(CONFIG_SMP)
+                kdb_printf("on processor %d ", raw_smp_processor_id());
+#endif
+        }
+
+        switch (reason) {
+        case KDB_REASON_DEBUG:
+        {
+                /*
+                 * If re-entering kdb after a single step
+                 * command, don't print the message.
+                 */
+                switch (db_result) {
+                case KDB_DB_BPT:
+                        kdb_printf("\nEntering kdb (0x%p, pid %d) ",
+                                   kdb_current, kdb_current->pid);
+#if defined(CONFIG_SMP)
+                        kdb_printf("on processor %d ", raw_smp_processor_id());
+#endif
+                        kdb_printf("due to Debug @ " kdb_machreg_fmt "\n",
+                                   instruction_pointer(regs));
+                        break;
+                case KDB_DB_SSB:
+                        /*
+                         * In the midst of ssb command. Just return.
+                         */
+                        KDB_DEBUG_STATE("kdb_local 3", reason);
+                        return KDB_CMD_SSB;     /* Continue with SSB command */
+
+                        break;
+                case KDB_DB_SS:
+                        break;
+                case KDB_DB_SSBPT:
+                        KDB_DEBUG_STATE("kdb_local 4", reason);
+                        return 1;       /* kdba_db_trap did the work */
+                default:
+                        kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
+                                   db_result);
+                        break;
+                }
+
+        }
+                break;
+        case KDB_REASON_ENTER:
+                if (KDB_STATE(KEYBOARD))
+                        kdb_printf("due to Keyboard Entry\n");
+                else
+                        kdb_printf("due to KDB_ENTER()\n");
+                break;
+        case KDB_REASON_KEYBOARD:
+                KDB_STATE_SET(KEYBOARD);
+                kdb_printf("due to Keyboard Entry\n");
+                break;
+        case KDB_REASON_ENTER_SLAVE:
+                /* drop through, slaves only get released via cpu switch */
+        case KDB_REASON_SWITCH:
+                kdb_printf("due to cpu switch\n");
+                break;
+        case KDB_REASON_OOPS:
+                kdb_printf("Oops: %s\n", kdb_diemsg);
+                kdb_printf("due to oops @ " kdb_machreg_fmt "\n",
+                           instruction_pointer(regs));
+                kdb_dumpregs(regs);
+                break;
+        case KDB_REASON_NMI:
+                kdb_printf("due to NonMaskable Interrupt @ "
+                           kdb_machreg_fmt "\n",
+                           instruction_pointer(regs));
+                kdb_dumpregs(regs);
+                break;
+        case KDB_REASON_SSTEP:
+        case KDB_REASON_BREAK:
+                kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
+                           reason == KDB_REASON_BREAK ?
+                           "Breakpoint" : "SS trap", instruction_pointer(regs));
+                /*
+                 * Determine if this breakpoint is one that we
+                 * are interested in.
+                 */
+                if (db_result != KDB_DB_BPT) {
+                        kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
+                                   db_result);
+                        KDB_DEBUG_STATE("kdb_local 6", reason);
+                        return 0;       /* Not for us, dismiss it */
+                }
+                break;
+        case KDB_REASON_RECURSE:
+                kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
+                           instruction_pointer(regs));
+                break;
+        default:
+                kdb_printf("kdb: unexpected reason code: %d\n", reason);
+                KDB_DEBUG_STATE("kdb_local 8", reason);
+                return 0;       /* Not for us, dismiss it */
+        }
+
+        while (1) {
+                /*
+                 * Initialize pager context.
+                 */
+                kdb_nextline = 1;
+                KDB_STATE_CLEAR(SUPPRESS);
+
+                cmdbuf = cmd_cur;
+                *cmdbuf = '\0';
+                *(cmd_hist[cmd_head]) = '\0';
+
+                if (KDB_FLAG(ONLY_DO_DUMP)) {
+                        /* kdb is off but a catastrophic error requires a dump.
+                         * Take the dump and reboot.
+                         * Turn on logging so the kdb output appears in the log
+                         * buffer in the dump.
+                         */
+                        const char *setargs[] = { "set", "LOGGING", "1" };
+                        kdb_set(2, setargs);
+                        kdb_reboot(0, NULL);
+                        /*NOTREACHED*/
+                }
+
+do_full_getstr:
+#if defined(CONFIG_SMP)
+                snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
+                         raw_smp_processor_id());
+#else
+                snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"));
+#endif
+                if (defcmd_in_progress)
+                        strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
+
+                /*
+                 * Fetch command from keyboard
+                 */
+                cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
+                if (*cmdbuf != '\n') {
+                        if (*cmdbuf < 32) {
+                                if (cmdptr == cmd_head) {
+                                        strncpy(cmd_hist[cmd_head], cmd_cur,
+                                                CMD_BUFLEN);
+                                        *(cmd_hist[cmd_head] +
+                                          strlen(cmd_hist[cmd_head])-1) = '\0';
+                                }
+                                if (!handle_ctrl_cmd(cmdbuf))
+                                        *(cmd_cur+strlen(cmd_cur)-1) = '\0';
+                                cmdbuf = cmd_cur;
+                                goto do_full_getstr;
+                        } else {
+                                strncpy(cmd_hist[cmd_head], cmd_cur,
+                                        CMD_BUFLEN);
+                        }
+
+                        cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
+                        if (cmd_head == cmd_tail)
+                                cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
+                }
+
+                cmdptr = cmd_head;
+                diag = kdb_parse(cmdbuf);
+                if (diag == KDB_NOTFOUND) {
+                        kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
+                        diag = 0;
+                }
+                if (diag == KDB_CMD_GO
+                 || diag == KDB_CMD_CPU
+                 || diag == KDB_CMD_SS
+                 || diag == KDB_CMD_SSB
+                 || diag == KDB_CMD_KGDB)
+                        break;
+
+                if (diag)
+                        kdb_cmderror(diag);
+        }
+        KDB_DEBUG_STATE("kdb_local 9", diag);
+        return diag;
+}
+
+
+/*
+ * kdb_print_state - Print the state data for the current processor
+ *      for debugging.
+ * Inputs:
+ *      text            Identifies the debug point
+ *      value           Any integer value to be printed, e.g. reason code.
+ */
+void kdb_print_state(const char *text, int value)
+{
+        kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
+                   text, raw_smp_processor_id(), value, kdb_initial_cpu,
+                   kdb_state);
+}
+
+/*
+ * kdb_main_loop - After initial setup and assignment of the
+ *      controlling cpu, all cpus are in this loop.  One cpu is in
+ *      control and will issue the kdb prompt, the others will spin
+ *      until 'go' or cpu switch.
+ *
+ *      To get a consistent view of the kernel stacks for all
+ *      processes, this routine is invoked from the main kdb code via
+ *      an architecture specific routine.  kdba_main_loop is
+ *      responsible for making the kernel stacks consistent for all
+ *      processes, there should be no difference between a blocked
+ *      process and a running process as far as kdb is concerned.
+ * Inputs:
+ *      reason          The reason KDB was invoked
+ *      error           The hardware-defined error code
+ *      reason2         kdb's current reason code.
+ *                      Initially error but can change
+ *                      acording to kdb state.
+ *      db_result       Result code from break or debug point.
+ *      regs            The exception frame at time of fault/breakpoint.
+ *                      should always be valid.
+ * Returns:
+ *      0       KDB was invoked for an event which it wasn't responsible
+ *      1       KDB handled the event for which it was invoked.
+ */
+int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
+              kdb_dbtrap_t db_result, struct pt_regs *regs)
+{
+        int result = 1;
+        /* Stay in kdb() until 'go', 'ss[b]' or an error */
+        while (1) {
+                /*
+                 * All processors except the one that is in control
+                 * will spin here.
+                 */
+                KDB_DEBUG_STATE("kdb_main_loop 1", reason);
+                while (KDB_STATE(HOLD_CPU)) {
+                        /* state KDB is turned off by kdb_cpu to see if the
+                         * other cpus are still live, each cpu in this loop
+                         * turns it back on.
+                         */
+                        if (!KDB_STATE(KDB))
+                                KDB_STATE_SET(KDB);
+                }
+
+                KDB_STATE_CLEAR(SUPPRESS);
+                KDB_DEBUG_STATE("kdb_main_loop 2", reason);
+                if (KDB_STATE(LEAVING))
+                        break;  /* Another cpu said 'go' */
+                /* Still using kdb, this processor is in control */
+                result = kdb_local(reason2, error, regs, db_result);
+                KDB_DEBUG_STATE("kdb_main_loop 3", result);
+
+                if (result == KDB_CMD_CPU)
+                        break;
+
+                if (result == KDB_CMD_SS) {
+                        KDB_STATE_SET(DOING_SS);
+                        break;
+                }
+
+                if (result == KDB_CMD_SSB) {
+                        KDB_STATE_SET(DOING_SS);
+                        KDB_STATE_SET(DOING_SSB);
+                        break;
+                }
+
+                if (result == KDB_CMD_KGDB) {
+                        if (!(KDB_STATE(DOING_KGDB) || KDB_STATE(DOING_KGDB2)))
+                                kdb_printf("Entering please attach debugger "
+                                           "or use $D#44+ or $3#33\n");
+                        break;
+                }
+                if (result && result != 1 && result != KDB_CMD_GO)
+                        kdb_printf("\nUnexpected kdb_local return code %d\n",
+                                   result);
+                KDB_DEBUG_STATE("kdb_main_loop 4", reason);
+                break;
+        }
+        if (KDB_STATE(DOING_SS))
+                KDB_STATE_CLEAR(SSBPT);
+
+        return result;
+}
+
+/*
+ * kdb_mdr - This function implements the guts of the 'mdr', memory
+ * read command.
+ *      mdr  <addr arg>,<byte count>
+ * Inputs:
+ *      addr    Start address
+ *      count   Number of bytes
+ * Returns:
+ *      Always 0.  Any errors are detected and printed by kdb_getarea.
+ */
+static int kdb_mdr(unsigned long addr, unsigned int count)
+{
+        unsigned char c;
+        while (count--) {
+                if (kdb_getarea(c, addr))
+                        return 0;
+                kdb_printf("%02x", c);
+                addr++;
+        }
+        kdb_printf("\n");
+        return 0;
+}
+
+/*
+ * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
+ *      'md8' 'mdr' and 'mds' commands.
+ *
+ *      md|mds  [<addr arg> [<line count> [<radix>]]]
+ *      mdWcN   [<addr arg> [<line count> [<radix>]]]
+ *              where W = is the width (1, 2, 4 or 8) and N is the count.
+ *              for eg., md1c20 reads 20 bytes, 1 at a time.
+ *      mdr  <addr arg>,<byte count>
+ */
+static void kdb_md_line(const char *fmtstr, unsigned long addr,
+                        int symbolic, int nosect, int bytesperword,
+                        int num, int repeat, int phys)
+{
+        /* print just one line of data */
+        kdb_symtab_t symtab;
+        char cbuf[32];
+        char *c = cbuf;
+        int i;
+        unsigned long word;
+
+        memset(cbuf, '\0', sizeof(cbuf));
+        if (phys)
+                kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
+        else
+                kdb_printf(kdb_machreg_fmt0 " ", addr);
+
+        for (i = 0; i < num && repeat--; i++) {
+                if (phys) {
+                        if (kdb_getphysword(&word, addr, bytesperword))
+                                break;
+                } else if (kdb_getword(&word, addr, bytesperword))
+                        break;
+                kdb_printf(fmtstr, word);
+                if (symbolic)
+                        kdbnearsym(word, &symtab);
+                else
+                        memset(&symtab, 0, sizeof(symtab));
+                if (symtab.sym_name) {
+                        kdb_symbol_print(word, &symtab, 0);
+                        if (!nosect) {
+                                kdb_printf("\n");
+                                kdb_printf("                       %s %s "
+                                           kdb_machreg_fmt " "
+                                           kdb_machreg_fmt " "
+                                           kdb_machreg_fmt, symtab.mod_name,
+                                           symtab.sec_name, symtab.sec_start,
+                                           symtab.sym_start, symtab.sym_end);
+                        }
+                        addr += bytesperword;
+                } else {
+                        union {
+                                u64 word;
+                                unsigned char c[8];
+                        } wc;
+                        unsigned char *cp;
+#ifdef  __BIG_ENDIAN
+                        cp = wc.c + 8 - bytesperword;
+#else
+                        cp = wc.c;
+#endif
+                        wc.word = word;
+#define printable_char(c) \
+        ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
+                        switch (bytesperword) {
+                        case 8:
+                                *c++ = printable_char(*cp++);
+                                *c++ = printable_char(*cp++);
+                                *c++ = printable_char(*cp++);
+                                *c++ = printable_char(*cp++);
+                                addr += 4;
+                        case 4:
+                                *c++ = printable_char(*cp++);
+                                *c++ = printable_char(*cp++);
+                                addr += 2;
+                        case 2:
+                                *c++ = printable_char(*cp++);
+                                addr++;
+                        case 1:
+                                *c++ = printable_char(*cp++);
+                                addr++;
+                                break;
+                        }
+#undef printable_char
+                }
+        }
+        kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
+                   " ", cbuf);
+}
+
+static int kdb_md(int argc, const char **argv)
+{
+        static unsigned long last_addr;
+        static int last_radix, last_bytesperword, last_repeat;
+        int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
+        int nosect = 0;
+        char fmtchar, fmtstr[64];
+        unsigned long addr;
+        unsigned long word;
+        long offset = 0;
+        int symbolic = 0;
+        int valid = 0;
+        int phys = 0;
+
+        kdbgetintenv("MDCOUNT", &mdcount);
+        kdbgetintenv("RADIX", &radix);
+        kdbgetintenv("BYTESPERWORD", &bytesperword);
+
+        /* Assume 'md <addr>' and start with environment values */
+        repeat = mdcount * 16 / bytesperword;
+
+        if (strcmp(argv[0], "mdr") == 0) {
+                if (argc != 2)
+                        return KDB_ARGCOUNT;
+                valid = 1;
+        } else if (isdigit(argv[0][2])) {
+                bytesperword = (int)(argv[0][2] - '0');
+                if (bytesperword == 0) {
+                        bytesperword = last_bytesperword;
+                        if (bytesperword == 0)
+                                bytesperword = 4;
+                }
+                last_bytesperword = bytesperword;
+                repeat = mdcount * 16 / bytesperword;
+                if (!argv[0][3])
+                        valid = 1;
+                else if (argv[0][3] == 'c' && argv[0][4]) {
+                        char *p;
+                        repeat = simple_strtoul(argv[0] + 4, &p, 10);
+                        mdcount = ((repeat * bytesperword) + 15) / 16;
+                        valid = !*p;
+                }
+                last_repeat = repeat;
+        } else if (strcmp(argv[0], "md") == 0)
+                valid = 1;
+        else if (strcmp(argv[0], "mds") == 0)
+                valid = 1;
+        else if (strcmp(argv[0], "mdp") == 0) {
+                phys = valid = 1;
+        }
+        if (!valid)
+                return KDB_NOTFOUND;
+
+        if (argc == 0) {
+                if (last_addr == 0)
+                        return KDB_ARGCOUNT;
+                addr = last_addr;
+                radix = last_radix;
+                bytesperword = last_bytesperword;
+                repeat = last_repeat;
+                mdcount = ((repeat * bytesperword) + 15) / 16;
+        }
+
+        if (argc) {
+                unsigned long val;
+                int diag, nextarg = 1;
+                diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
+                                     &offset, NULL);
+                if (diag)
+                        return diag;
+                if (argc > nextarg+2)
+                        return KDB_ARGCOUNT;
+
+                if (argc >= nextarg) {
+                        diag = kdbgetularg(argv[nextarg], &val);
+                        if (!diag) {
+                                mdcount = (int) val;
+                                repeat = mdcount * 16 / bytesperword;
+                        }
+                }
+                if (argc >= nextarg+1) {
+                        diag = kdbgetularg(argv[nextarg+1], &val);
+                        if (!diag)
+                                radix = (int) val;
+                }
+        }
+
+        if (strcmp(argv[0], "mdr") == 0)
+                return kdb_mdr(addr, mdcount);
+
+        switch (radix) {
+        case 10:
+                fmtchar = 'd';
+                break;
+        case 16:
+                fmtchar = 'x';
+                break;
+        case 8:
+                fmtchar = 'o';
+                break;
+        default:
+                return KDB_BADRADIX;
+        }
+
+        last_radix = radix;
+
+        if (bytesperword > KDB_WORD_SIZE)
+                return KDB_BADWIDTH;
+
+        switch (bytesperword) {
+        case 8:
+                sprintf(fmtstr, "%%16.16l%c ", fmtchar);
+                break;
+        case 4:
+                sprintf(fmtstr, "%%8.8l%c ", fmtchar);
+                break;
+        case 2:
+                sprintf(fmtstr, "%%4.4l%c ", fmtchar);
+                break;
+        case 1:
+                sprintf(fmtstr, "%%2.2l%c ", fmtchar);
+                break;
+        default:
+                return KDB_BADWIDTH;
+        }
+
+        last_repeat = repeat;
+        last_bytesperword = bytesperword;
+
+        if (strcmp(argv[0], "mds") == 0) {
+                symbolic = 1;
+                /* Do not save these changes as last_*, they are temporary mds
+                 * overrides.
+                 */
+                bytesperword = KDB_WORD_SIZE;
+                repeat = mdcount;
+                kdbgetintenv("NOSECT", &nosect);
+        }
+
+        /* Round address down modulo BYTESPERWORD */
+
+        addr &= ~(bytesperword-1);
+
+        while (repeat > 0) {
+                unsigned long a;
+                int n, z, num = (symbolic ? 1 : (16 / bytesperword));
+
+                if (KDB_FLAG(CMD_INTERRUPT))
+                        return 0;
+                for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
+                        if (phys) {
+                                if (kdb_getphysword(&word, a, bytesperword)
+                                                || word)
+                                        break;
+                        } else if (kdb_getword(&word, a, bytesperword) || word)
+                                break;
+                }
+                n = min(num, repeat);
+                kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
+                            num, repeat, phys);
+                addr += bytesperword * n;
+                repeat -= n;
+                z = (z + num - 1) / num;
+                if (z > 2) {
+                        int s = num * (z-2);
+                        kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
+                                   " zero suppressed\n",
+                                addr, addr + bytesperword * s - 1);
+                        addr += bytesperword * s;
+                        repeat -= s;
+                }
+        }
+        last_addr = addr;
+
+        return 0;
+}
+
+/*
+ * kdb_mm - This function implements the 'mm' command.
+ *      mm address-expression new-value
+ * Remarks:
+ *      mm works on machine words, mmW works on bytes.
+ */
+static int kdb_mm(int argc, const char **argv)
+{
+        int diag;
+        unsigned long addr;
+        long offset = 0;
+        unsigned long contents;
+        int nextarg;
+        int width;
+
+        if (argv[0][2] && !isdigit(argv[0][2]))
+                return KDB_NOTFOUND;
+
+        if (argc < 2)
+                return KDB_ARGCOUNT;
+
+        nextarg = 1;
+        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
+        if (diag)
+                return diag;
+
+        if (nextarg > argc)
+                return KDB_ARGCOUNT;
+        diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
+        if (diag)
+                return diag;
+
+        if (nextarg != argc + 1)
+                return KDB_ARGCOUNT;
+
+        width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
+        diag = kdb_putword(addr, contents, width);
+        if (diag)
+                return diag;
+
+        kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
+
+        return 0;
+}
+
+/*
+ * kdb_go - This function implements the 'go' command.
+ *      go [address-expression]
+ */
+static int kdb_go(int argc, const char **argv)
+{
+        unsigned long addr;
+        int diag;
+        int nextarg;
+        long offset;
+
+        if (argc == 1) {
+                if (raw_smp_processor_id() != kdb_initial_cpu) {
+                        kdb_printf("go <address> must be issued from the "
+                                   "initial cpu, do cpu %d first\n",
+                                   kdb_initial_cpu);
+                        return KDB_ARGCOUNT;
+                }
+                nextarg = 1;
+                diag = kdbgetaddrarg(argc, argv, &nextarg,
+                                     &addr, &offset, NULL);
+                if (diag)
+                        return diag;
+        } else if (argc) {
+                return KDB_ARGCOUNT;
+        }
+
+        diag = KDB_CMD_GO;
+        if (KDB_FLAG(CATASTROPHIC)) {
+                kdb_printf("Catastrophic error detected\n");
+                kdb_printf("kdb_continue_catastrophic=%d, ",
+                        kdb_continue_catastrophic);
+                if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
+                        kdb_printf("type go a second time if you really want "
+                                   "to continue\n");
+                        return 0;
+                }
+                if (kdb_continue_catastrophic == 2) {
+                        kdb_printf("forcing reboot\n");
+                        kdb_reboot(0, NULL);
+                }
+                kdb_printf("attempting to continue\n");
+        }
+        return diag;
+}
+
+/*
+ * kdb_rd - This function implements the 'rd' command.
+ */
+static int kdb_rd(int argc, const char **argv)
+{
+        int diag = kdb_check_regs();
+        if (diag)
+                return diag;
+
+        kdb_dumpregs(kdb_current_regs);
+        return 0;
+}
+
+/*
+ * kdb_rm - This function implements the 'rm' (register modify)  command.
+ *      rm register-name new-contents
+ * Remarks:
+ *      Currently doesn't allow modification of control or
+ *      debug registers.
+ */
+static int kdb_rm(int argc, const char **argv)
+{
+        int diag;
+        int ind = 0;
+        unsigned long contents;
+
+        if (argc != 2)
+                return KDB_ARGCOUNT;
+        /*
+         * Allow presence or absence of leading '%' symbol.
+         */
+        if (argv[1][0] == '%')
+                ind = 1;
+
+        diag = kdbgetularg(argv[2], &contents);
+        if (diag)
+                return diag;
+
+        diag = kdb_check_regs();
+        if (diag)
+                return diag;
+        kdb_printf("ERROR: Register set currently not implemented\n");
+        return 0;
+}
+
+#if defined(CONFIG_MAGIC_SYSRQ)
+/*
+ * kdb_sr - This function implements the 'sr' (SYSRQ key) command
+ *      which interfaces to the soi-disant MAGIC SYSRQ functionality.
+ *              sr <magic-sysrq-code>
+ */
+static int kdb_sr(int argc, const char **argv)
+{
+        if (argc != 1)
+                return KDB_ARGCOUNT;
+        sysrq_toggle_support(1);
+        kdb_trap_printk++;
+        handle_sysrq(*argv[1], NULL);
+        kdb_trap_printk--;
+
+        return 0;
+}
+#endif  /* CONFIG_MAGIC_SYSRQ */
+
+/*
+ * kdb_ef - This function implements the 'regs' (display exception
+ *      frame) command.  This command takes an address and expects to
+ *      find an exception frame at that address, formats and prints
+ *      it.
+ *              regs address-expression
+ * Remarks:
+ *      Not done yet.
+ */
+static int kdb_ef(int argc, const char **argv)
+{
+        int diag;
+        unsigned long addr;
+        long offset;
+        int nextarg;
+
+        if (argc != 1)
+                return KDB_ARGCOUNT;
+
+        nextarg = 1;
+        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
+        if (diag)
+                return diag;
+        show_regs((struct pt_regs *)addr);
+        return 0;
+}
+
+#if defined(CONFIG_MODULES)
+/* modules using other modules */
+struct module_use {
+        struct list_head list;
+        struct module *module_which_uses;
+};
+
+/*
+ * kdb_lsmod - This function implements the 'lsmod' command.  Lists
+ *      currently loaded kernel modules.
+ *      Mostly taken from userland lsmod.
+ */
+static int kdb_lsmod(int argc, const char **argv)
+{
+        struct module *mod;
+
+        if (argc != 0)
+                return KDB_ARGCOUNT;
+
+        kdb_printf("Module                  Size  modstruct     Used by\n");
+        list_for_each_entry(mod, kdb_modules, list) {
+
+                kdb_printf("%-20s%8u  0x%p ", mod->name,
+                           mod->core_size, (void *)mod);
+#ifdef CONFIG_MODULE_UNLOAD
+                kdb_printf("%4d ", module_refcount(mod));
+#endif
+                if (mod->state == MODULE_STATE_GOING)
+                        kdb_printf(" (Unloading)");
+                else if (mod->state == MODULE_STATE_COMING)
+                        kdb_printf(" (Loading)");
+                else
+                        kdb_printf(" (Live)");
+
+#ifdef CONFIG_MODULE_UNLOAD
+                {
+                        struct module_use *use;
+                        kdb_printf(" [ ");
+                        list_for_each_entry(use, &mod->modules_which_use_me,
+                                            list)
+                                kdb_printf("%s ", use->module_which_uses->name);
+                        kdb_printf("]\n");
+                }
+#endif
+        }
+
+        return 0;
+}
+
+#endif  /* CONFIG_MODULES */
+
+/*
+ * kdb_env - This function implements the 'env' command.  Display the
+ *      current environment variables.
+ */
+
+static int kdb_env(int argc, const char **argv)
+{
+        int i;
+
+        for (i = 0; i < __nenv; i++) {
+                if (__env[i])
+                        kdb_printf("%s\n", __env[i]);
+        }
+
+        if (KDB_DEBUG(MASK))
+                kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
+
+        return 0;
+}
+
+#ifdef CONFIG_PRINTK
+/*
+ * kdb_dmesg - This function implements the 'dmesg' command to display
+ *      the contents of the syslog buffer.
+ *              dmesg [lines] [adjust]
+ */
+static int kdb_dmesg(int argc, const char **argv)
+{
+        char *syslog_data[4], *start, *end, c = '\0', *p;
+        int diag, logging, logsize, lines = 0, adjust = 0, n;
+
+        if (argc > 2)
+                return KDB_ARGCOUNT;
+        if (argc) {
+                char *cp;
+                lines = simple_strtol(argv[1], &cp, 0);
+                if (*cp)
+                        lines = 0;
+                if (argc > 1) {
+                        adjust = simple_strtoul(argv[2], &cp, 0);
+                        if (*cp || adjust < 0)
+                                adjust = 0;
+                }
+        }
+
+        /* disable LOGGING if set */
+        diag = kdbgetintenv("LOGGING", &logging);
+        if (!diag && logging) {
+                const char *setargs[] = { "set", "LOGGING", "0" };
+                kdb_set(2, setargs);
+        }
+
+        /* syslog_data[0,1] physical start, end+1.  syslog_data[2,3]
+         * logical start, end+1. */
+        kdb_syslog_data(syslog_data);
+        if (syslog_data[2] == syslog_data[3])
+                return 0;
+        logsize = syslog_data[1] - syslog_data[0];
+        start = syslog_data[2];
+        end = syslog_data[3];
+#define KDB_WRAP(p) (((p - syslog_data[0]) % logsize) + syslog_data[0])
+        for (n = 0, p = start; p < end; ++p) {
+                c = *KDB_WRAP(p);
+                if (c == '\n')
+                        ++n;
+        }
+        if (c != '\n')
+                ++n;
+        if (lines < 0) {
+                if (adjust >= n)
+                        kdb_printf("buffer only contains %d lines, nothing "
+                                   "printed\n", n);
+                else if (adjust - lines >= n)
+                        kdb_printf("buffer only contains %d lines, last %d "
+                                   "lines printed\n", n, n - adjust);
+                if (adjust) {
+                        for (; start < end && adjust; ++start) {
+                                if (*KDB_WRAP(start) == '\n')
+                                        --adjust;
+                        }
+                        if (start < end)
+                                ++start;
+                }
+                for (p = start; p < end && lines; ++p) {
+                        if (*KDB_WRAP(p) == '\n')
+                                ++lines;
+                }
+                end = p;
+        } else if (lines > 0) {
+                int skip = n - (adjust + lines);
+                if (adjust >= n) {
+                        kdb_printf("buffer only contains %d lines, "
+                                   "nothing printed\n", n);
+                        skip = n;
+                } else if (skip < 0) {
+                        lines += skip;
+                        skip = 0;
+                        kdb_printf("buffer only contains %d lines, first "
+                                   "%d lines printed\n", n, lines);
+                }
+                for (; start < end && skip; ++start) {
+                        if (*KDB_WRAP(start) == '\n')
+                                --skip;
+                }
+                for (p = start; p < end && lines; ++p) {
+                        if (*KDB_WRAP(p) == '\n')
+                                --lines;
+                }
+                end = p;
+        }
+        /* Do a line at a time (max 200 chars) to reduce protocol overhead */
+        c = '\n';
+        while (start != end) {
+                char buf[201];
+                p = buf;
+                if (KDB_FLAG(CMD_INTERRUPT))
+                        return 0;
+                while (start < end && (c = *KDB_WRAP(start)) &&
+                       (p - buf) < sizeof(buf)-1) {
+                        ++start;
+                        *p++ = c;
+                        if (c == '\n')
+                                break;
+                }
+                *p = '\0';
+                kdb_printf("%s", buf);
+        }
+        if (c != '\n')
+                kdb_printf("\n");
+
+        return 0;
+}
+#endif /* CONFIG_PRINTK */
+/*
+ * kdb_cpu - This function implements the 'cpu' command.
+ *      cpu     [<cpunum>]
+ * Returns:
+ *      KDB_CMD_CPU for success, a kdb diagnostic if error
+ */
+static void kdb_cpu_status(void)
+{
+        int i, start_cpu, first_print = 1;
+        char state, prev_state = '?';
+
+        kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
+        kdb_printf("Available cpus: ");
+        for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
+                if (!cpu_online(i)) {
+                        state = 'F';    /* cpu is offline */
+                } else {
+                        state = ' ';    /* cpu is responding to kdb */
+                        if (kdb_task_state_char(KDB_TSK(i)) == 'I')
+                                state = 'I';    /* idle task */
+                }
+                if (state != prev_state) {
+                        if (prev_state != '?') {
+                                if (!first_print)
+                                        kdb_printf(", ");
+                                first_print = 0;
+                                kdb_printf("%d", start_cpu);
+                                if (start_cpu < i-1)
+                                        kdb_printf("-%d", i-1);
+                                if (prev_state != ' ')
+                                        kdb_printf("(%c)", prev_state);
+                        }
+                        prev_state = state;
+                        start_cpu = i;
+                }
+        }
+        /* print the trailing cpus, ignoring them if they are all offline */
+        if (prev_state != 'F') {
+                if (!first_print)
+                        kdb_printf(", ");
+                kdb_printf("%d", start_cpu);
+                if (start_cpu < i-1)
+                        kdb_printf("-%d", i-1);
+                if (prev_state != ' ')
+                        kdb_printf("(%c)", prev_state);
+        }
+        kdb_printf("\n");
+}
+
+static int kdb_cpu(int argc, const char **argv)
+{
+        unsigned long cpunum;
+        int diag;
+
+        if (argc == 0) {
+                kdb_cpu_status();
+                return 0;
+        }
+
+        if (argc != 1)
+                return KDB_ARGCOUNT;
+
+        diag = kdbgetularg(argv[1], &cpunum);
+        if (diag)
+                return diag;
+
+        /*
+         * Validate cpunum
+         */
+        if ((cpunum > NR_CPUS) || !cpu_online(cpunum))
+                return KDB_BADCPUNUM;
+
+        dbg_switch_cpu = cpunum;
+
+        /*
+         * Switch to other cpu
+         */
+        return KDB_CMD_CPU;
+}
+
+/* The user may not realize that ps/bta with no parameters does not print idle
+ * or sleeping system daemon processes, so tell them how many were suppressed.
+ */
+void kdb_ps_suppressed(void)
+{
+        int idle = 0, daemon = 0;
+        unsigned long mask_I = kdb_task_state_string("I"),
+                      mask_M = kdb_task_state_string("M");
+        unsigned long cpu;
+        const struct task_struct *p, *g;
+        for_each_online_cpu(cpu) {
+                p = kdb_curr_task(cpu);
+                if (kdb_task_state(p, mask_I))
+                        ++idle;
+        }
+        kdb_do_each_thread(g, p) {
+                if (kdb_task_state(p, mask_M))
+                        ++daemon;
+        } kdb_while_each_thread(g, p);
+        if (idle || daemon) {
+                if (idle)
+                        kdb_printf("%d idle process%s (state I)%s\n",
+                                   idle, idle == 1 ? "" : "es",
+                                   daemon ? " and " : "");
+                if (daemon)
+                        kdb_printf("%d sleeping system daemon (state M) "
+                                   "process%s", daemon,
+                                   daemon == 1 ? "" : "es");
+                kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
+        }
+}
+
+/*
+ * kdb_ps - This function implements the 'ps' command which shows a
+ *      list of the active processes.
+ *              ps [DRSTCZEUIMA]   All processes, optionally filtered by state
+ */
+void kdb_ps1(const struct task_struct *p)
+{
+        int cpu;
+        unsigned long tmp;
+
+        if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
+                return;
+
+        cpu = kdb_process_cpu(p);
+        kdb_printf("0x%p %8d %8d  %d %4d   %c  0x%p %c%s\n",
+                   (void *)p, p->pid, p->parent->pid,
+                   kdb_task_has_cpu(p), kdb_process_cpu(p),
+                   kdb_task_state_char(p),
+                   (void *)(&p->thread),
+                   p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
+                   p->comm);
+        if (kdb_task_has_cpu(p)) {
+                if (!KDB_TSK(cpu)) {
+                        kdb_printf("  Error: no saved data for this cpu\n");
+                } else {
+                        if (KDB_TSK(cpu) != p)
+                                kdb_printf("  Error: does not match running "
+                                   "process table (0x%p)\n", KDB_TSK(cpu));
+                }
+        }
+}
+
+static int kdb_ps(int argc, const char **argv)
+{
+        struct task_struct *g, *p;
+        unsigned long mask, cpu;
+
+        if (argc == 0)
+                kdb_ps_suppressed();
+        kdb_printf("%-*s      Pid   Parent [*] cpu State %-*s Command\n",
+                (int)(2*sizeof(void *))+2, "Task Addr",
+                (int)(2*sizeof(void *))+2, "Thread");
+        mask = kdb_task_state_string(argc ? argv[1] : NULL);
+        /* Run the active tasks first */
+        for_each_online_cpu(cpu) {
+                if (KDB_FLAG(CMD_INTERRUPT))
+                        return 0;
+                p = kdb_curr_task(cpu);
+                if (kdb_task_state(p, mask))
+                        kdb_ps1(p);
+        }
+        kdb_printf("\n");
+        /* Now the real tasks */
+        kdb_do_each_thread(g, p) {
+                if (KDB_FLAG(CMD_INTERRUPT))
+                        return 0;
+                if (kdb_task_state(p, mask))
+                        kdb_ps1(p);
+        } kdb_while_each_thread(g, p);
+
+        return 0;
+}
+
+/*
+ * kdb_pid - This function implements the 'pid' command which switches
+ *      the currently active process.
+ *              pid [<pid> | R]
+ */
+static int kdb_pid(int argc, const char **argv)
+{
+        struct task_struct *p;
+        unsigned long val;
+        int diag;
+
+        if (argc > 1)
+                return KDB_ARGCOUNT;
+
+        if (argc) {
+                if (strcmp(argv[1], "R") == 0) {
+                        p = KDB_TSK(kdb_initial_cpu);
+                } else {
+                        diag = kdbgetularg(argv[1], &val);
+                        if (diag)
+                                return KDB_BADINT;
+
+                        p = find_task_by_pid_ns((pid_t)val,     &init_pid_ns);
+                        if (!p) {
+                                kdb_printf("No task with pid=%d\n", (pid_t)val);
+                                return 0;
+                        }
+                }
+                kdb_set_current_task(p);
+        }
+        kdb_printf("KDB current process is %s(pid=%d)\n",
+                   kdb_current_task->comm,
+                   kdb_current_task->pid);
+
+        return 0;
+}
+
+/*
+ * kdb_ll - This function implements the 'll' command which follows a
+ *      linked list and executes an arbitrary command for each
+ *      element.
+ */
+static int kdb_ll(int argc, const char **argv)
+{
+        int diag;
+        unsigned long addr;
+        long offset = 0;
+        unsigned long va;
+        unsigned long linkoffset;
+        int nextarg;
+        const char *command;
+
+        if (argc != 3)
+                return KDB_ARGCOUNT;
+
+        nextarg = 1;
+        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
+        if (diag)
+                return diag;
+
+        diag = kdbgetularg(argv[2], &linkoffset);
+        if (diag)
+                return diag;
+
+        /*
+         * Using the starting address as
+         * the first element in the list, and assuming that
+         * the list ends with a null pointer.
+         */
+
+        va = addr;
+        command = kdb_strdup(argv[3], GFP_KDB);
+        if (!command) {
+                kdb_printf("%s: cannot duplicate command\n", __func__);
+                return 0;
+        }
+        /* Recursive use of kdb_parse, do not use argv after this point */
+        argv = NULL;
+
+        while (va) {
+                char buf[80];
+
+                sprintf(buf, "%s " kdb_machreg_fmt "\n", command, va);
+                diag = kdb_parse(buf);
+                if (diag)
+                        return diag;
+
+                addr = va + linkoffset;
+                if (kdb_getword(&va, addr, sizeof(va)))
+                        return 0;
+        }
+        kfree(command);
+
+        return 0;
+}
+
+static int kdb_kgdb(int argc, const char **argv)
+{
+        return KDB_CMD_KGDB;
+}
+
+/*
+ * kdb_help - This function implements the 'help' and '?' commands.
+ */
+static int kdb_help(int argc, const char **argv)
+{
+        kdbtab_t *kt;
+        int i;
+
+        kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
+        kdb_printf("-----------------------------"
+                   "-----------------------------\n");
+        for_each_kdbcmd(kt, i) {
+                if (kt->cmd_name)
+                        kdb_printf("%-15.15s %-20.20s %s\n", kt->cmd_name,
+                                   kt->cmd_usage, kt->cmd_help);
+                if (KDB_FLAG(CMD_INTERRUPT))
+                        return 0;
+        }
+        return 0;
+}
+
+/*
+ * kdb_kill - This function implements the 'kill' commands.
+ */
+static int kdb_kill(int argc, const char **argv)
+{
+        long sig, pid;
+        char *endp;
+        struct task_struct *p;
+        struct siginfo info;
+
+        if (argc != 2)
+                return KDB_ARGCOUNT;
+
+        sig = simple_strtol(argv[1], &endp, 0);
+        if (*endp)
+                return KDB_BADINT;
+        if (sig >= 0) {
+                kdb_printf("Invalid signal parameter.<-signal>\n");
+                return 0;
+        }
+        sig = -sig;
+
+        pid = simple_strtol(argv[2], &endp, 0);
+        if (*endp)
+                return KDB_BADINT;
+        if (pid <= 0) {
+                kdb_printf("Process ID must be large than 0.\n");
+                return 0;
+        }
+
+        /* Find the process. */
+        p = find_task_by_pid_ns(pid, &init_pid_ns);
+        if (!p) {
+                kdb_printf("The specified process isn't found.\n");
+                return 0;
+        }
+        p = p->group_leader;
+        info.si_signo = sig;
+        info.si_errno = 0;
+        info.si_code = SI_USER;
+        info.si_pid = pid;  /* same capabilities as process being signalled */
+        info.si_uid = 0;    /* kdb has root authority */
+        kdb_send_sig_info(p, &info);
+        return 0;
+}
+
+struct kdb_tm {
+        int tm_sec;     /* seconds */
+        int tm_min;     /* minutes */
+        int tm_hour;    /* hours */
+        int tm_mday;    /* day of the month */
+        int tm_mon;     /* month */
+        int tm_year;    /* year */
+};
+
+static void kdb_gmtime(struct timespec *tv, struct kdb_tm *tm)
+{
+        /* This will work from 1970-2099, 2100 is not a leap year */
+        static int mon_day[] = { 31, 29, 31, 30, 31, 30, 31,
+                                 31, 30, 31, 30, 31 };
+        memset(tm, 0, sizeof(*tm));
+        tm->tm_sec  = tv->tv_sec % (24 * 60 * 60);
+        tm->tm_mday = tv->tv_sec / (24 * 60 * 60) +
+                (2 * 365 + 1); /* shift base from 1970 to 1968 */
+        tm->tm_min =  tm->tm_sec / 60 % 60;
+        tm->tm_hour = tm->tm_sec / 60 / 60;
+        tm->tm_sec =  tm->tm_sec % 60;
+        tm->tm_year = 68 + 4*(tm->tm_mday / (4*365+1));
+        tm->tm_mday %= (4*365+1);
+        mon_day[1] = 29;
+        while (tm->tm_mday >= mon_day[tm->tm_mon]) {
+                tm->tm_mday -= mon_day[tm->tm_mon];
+                if (++tm->tm_mon == 12) {
+                        tm->tm_mon = 0;
+                        ++tm->tm_year;
+                        mon_day[1] = 28;
+                }
+        }
+        ++tm->tm_mday;
+}
+
+/*
+ * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
+ * I cannot call that code directly from kdb, it has an unconditional
+ * cli()/sti() and calls routines that take locks which can stop the debugger.
+ */
+static void kdb_sysinfo(struct sysinfo *val)
+{
+        struct timespec uptime;
+        do_posix_clock_monotonic_gettime(&uptime);
+        memset(val, 0, sizeof(*val));
+        val->uptime = uptime.tv_sec;
+        val->loads[0] = avenrun[0];
+        val->loads[1] = avenrun[1];
+        val->loads[2] = avenrun[2];
+        val->procs = nr_threads-1;
+        si_meminfo(val);
+
+        return;
+}
+
+/*
+ * kdb_summary - This function implements the 'summary' command.
+ */
+static int kdb_summary(int argc, const char **argv)
+{
+        struct kdb_tm tm;
+        struct sysinfo val;
+
+        if (argc)
+                return KDB_ARGCOUNT;
+
+        kdb_printf("sysname    %s\n", init_uts_ns.name.sysname);
+        kdb_printf("release    %s\n", init_uts_ns.name.release);
+        kdb_printf("version    %s\n", init_uts_ns.name.version);
+        kdb_printf("machine    %s\n", init_uts_ns.name.machine);
+        kdb_printf("nodename   %s\n", init_uts_ns.name.nodename);
+        kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
+        kdb_printf("ccversion  %s\n", __stringify(CCVERSION));
+
+        kdb_gmtime(&xtime, &tm);
+        kdb_printf("date       %04d-%02d-%02d %02d:%02d:%02d "
+                   "tz_minuteswest %d\n",
+                1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
+                tm.tm_hour, tm.tm_min, tm.tm_sec,
+                sys_tz.tz_minuteswest);
+
+        kdb_sysinfo(&val);
+        kdb_printf("uptime     ");
+        if (val.uptime > (24*60*60)) {
+                int days = val.uptime / (24*60*60);
+                val.uptime %= (24*60*60);
+                kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
+        }
+        kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
+
+        /* lifted from fs/proc/proc_misc.c::loadavg_read_proc() */
+
+#define LOAD_INT(x) ((x) >> FSHIFT)
+#define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
+        kdb_printf("load avg   %ld.%02ld %ld.%02ld %ld.%02ld\n",
+                LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
+                LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
+                LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
+#undef LOAD_INT
+#undef LOAD_FRAC
+        /* Display in kilobytes */
+#define K(x) ((x) << (PAGE_SHIFT - 10))
+        kdb_printf("\nMemTotal:       %8lu kB\nMemFree:        %8lu kB\n"
+                   "Buffers:        %8lu kB\n",
+                   val.totalram, val.freeram, val.bufferram);
+        return 0;
+}
+
+/*
+ * kdb_per_cpu - This function implements the 'per_cpu' command.
+ */
+static int kdb_per_cpu(int argc, const char **argv)
+{
+        char buf[256], fmtstr[64];
+        kdb_symtab_t symtab;
+        cpumask_t suppress = CPU_MASK_NONE;
+        int cpu, diag;
+        unsigned long addr, val, bytesperword = 0, whichcpu = ~0UL;
+
+        if (argc < 1 || argc > 3)
+                return KDB_ARGCOUNT;
+
+        snprintf(buf, sizeof(buf), "per_cpu__%s", argv[1]);
+        if (!kdbgetsymval(buf, &symtab)) {
+                kdb_printf("%s is not a per_cpu variable\n", argv[1]);
+                return KDB_BADADDR;
+        }
+        if (argc >= 2) {
+                diag = kdbgetularg(argv[2], &bytesperword);
+                if (diag)
+                        return diag;
+        }
+        if (!bytesperword)
+                bytesperword = KDB_WORD_SIZE;
+        else if (bytesperword > KDB_WORD_SIZE)
+                return KDB_BADWIDTH;
+        sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
+        if (argc >= 3) {
+                diag = kdbgetularg(argv[3], &whichcpu);
+                if (diag)
+                        return diag;
+                if (!cpu_online(whichcpu)) {
+                        kdb_printf("cpu %ld is not online\n", whichcpu);
+                        return KDB_BADCPUNUM;
+                }
+        }
+
+        /* Most architectures use __per_cpu_offset[cpu], some use
+         * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
+         */
+#ifdef  __per_cpu_offset
+#define KDB_PCU(cpu) __per_cpu_offset(cpu)
+#else
+#ifdef  CONFIG_SMP
+#define KDB_PCU(cpu) __per_cpu_offset[cpu]
+#else
+#define KDB_PCU(cpu) 0
+#endif
+#endif
+
+        for_each_online_cpu(cpu) {
+                if (whichcpu != ~0UL && whichcpu != cpu)
+                        continue;
+                addr = symtab.sym_start + KDB_PCU(cpu);
+                diag = kdb_getword(&val, addr, bytesperword);
+                if (diag) {
+                        kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
+                                   "read, diag=%d\n", cpu, addr, diag);
+                        continue;
+                }
+#ifdef  CONFIG_SMP
+                if (!val) {
+                        cpu_set(cpu, suppress);
+                        continue;
+                }
+#endif  /* CONFIG_SMP */
+                kdb_printf("%5d ", cpu);
+                kdb_md_line(fmtstr, addr,
+                        bytesperword == KDB_WORD_SIZE,
+                        1, bytesperword, 1, 1, 0);
+        }
+        if (cpus_weight(suppress) == 0)
+                return 0;
+        kdb_printf("Zero suppressed cpu(s):");
+        for (cpu = first_cpu(suppress); cpu < num_possible_cpus();
+             cpu = next_cpu(cpu, suppress)) {
+                kdb_printf(" %d", cpu);
+                if (cpu == num_possible_cpus() - 1 ||
+                    next_cpu(cpu, suppress) != cpu + 1)
+                        continue;
+                while (cpu < num_possible_cpus() &&
+                       next_cpu(cpu, suppress) == cpu + 1)
+                        ++cpu;
+                kdb_printf("-%d", cpu);
+        }
+        kdb_printf("\n");
+
+#undef KDB_PCU
+
+        return 0;
+}
+
+/*
+ * display help for the use of cmd | grep pattern
+ */
+static int kdb_grep_help(int argc, const char **argv)
+{
+        kdb_printf("Usage of  cmd args | grep pattern:\n");
+        kdb_printf("  Any command's output may be filtered through an ");
+        kdb_printf("emulated 'pipe'.\n");
+        kdb_printf("  'grep' is just a key word.\n");
+        kdb_printf("  The pattern may include a very limited set of "
+                   "metacharacters:\n");
+        kdb_printf("   pattern or ^pattern or pattern$ or ^pattern$\n");
+        kdb_printf("  And if there are spaces in the pattern, you may "
+                   "quote it:\n");
+        kdb_printf("   \"pat tern\" or \"^pat tern\" or \"pat tern$\""
+                   " or \"^pat tern$\"\n");
+        return 0;
+}
+
+/*
+ * kdb_register_repeat - This function is used to register a kernel
+ *      debugger command.
+ * Inputs:
+ *      cmd     Command name
+ *      func    Function to execute the command
+ *      usage   A simple usage string showing arguments
+ *      help    A simple help string describing command
+ *      repeat  Does the command auto repeat on enter?
+ * Returns:
+ *      zero for success, one if a duplicate command.
+ */
+#define kdb_command_extend 50   /* arbitrary */
+int kdb_register_repeat(char *cmd,
+                        kdb_func_t func,
+                        char *usage,
+                        char *help,
+                        short minlen,
+                        kdb_repeat_t repeat)
+{
+        int i;
+        kdbtab_t *kp;
+
+        /*
+         *  Brute force method to determine duplicates
+         */
+        for_each_kdbcmd(kp, i) {
+                if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
+                        kdb_printf("Duplicate kdb command registered: "
+                                "%s, func %p help %s\n", cmd, func, help);
+                        return 1;
+                }
+        }
+
+        /*
+         * Insert command into first available location in table
+         */
+        for_each_kdbcmd(kp, i) {
+                if (kp->cmd_name == NULL)
+                        break;
+        }
+
+        if (i >= kdb_max_commands) {
+                kdbtab_t *new = kmalloc((kdb_max_commands - KDB_BASE_CMD_MAX +
+                         kdb_command_extend) * sizeof(*new), GFP_KDB);
+                if (!new) {
+                        kdb_printf("Could not allocate new kdb_command "
+                                   "table\n");
+                        return 1;
+                }
+                if (kdb_commands) {
+                        memcpy(new, kdb_commands,
+                               kdb_max_commands * sizeof(*new));
+                        kfree(kdb_commands);
+                }
+                memset(new + kdb_max_commands, 0,
+                       kdb_command_extend * sizeof(*new));
+                kdb_commands = new;
+                kp = kdb_commands + kdb_max_commands;
+                kdb_max_commands += kdb_command_extend;
+        }
+
+        kp->cmd_name   = cmd;
+        kp->cmd_func   = func;
+        kp->cmd_usage  = usage;
+        kp->cmd_help   = help;
+        kp->cmd_flags  = 0;
+        kp->cmd_minlen = minlen;
+        kp->cmd_repeat = repeat;
+
+        return 0;
+}
+
+/*
+ * kdb_register - Compatibility register function for commands that do
+ *      not need to specify a repeat state.  Equivalent to
+ *      kdb_register_repeat with KDB_REPEAT_NONE.
+ * Inputs:
+ *      cmd     Command name
+ *      func    Function to execute the command
+ *      usage   A simple usage string showing arguments
+ *      help    A simple help string describing command
+ * Returns:
+ *      zero for success, one if a duplicate command.
+ */
+int kdb_register(char *cmd,
+             kdb_func_t func,
+             char *usage,
+             char *help,
+             short minlen)
+{
+        return kdb_register_repeat(cmd, func, usage, help, minlen,
+                                   KDB_REPEAT_NONE);
+}
+
+/*
+ * kdb_unregister - This function is used to unregister a kernel
+ *      debugger command.  It is generally called when a module which
+ *      implements kdb commands is unloaded.
+ * Inputs:
+ *      cmd     Command name
+ * Returns:
+ *      zero for success, one command not registered.
+ */
+int kdb_unregister(char *cmd)
+{
+        int i;
+        kdbtab_t *kp;
+
+        /*
+         *  find the command.
+         */
+        for (i = 0, kp = kdb_commands; i < kdb_max_commands; i++, kp++) {
+                if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
+                        kp->cmd_name = NULL;
+                        return 0;
+                }
+        }
+
+        /* Couldn't find it.  */
+        return 1;
+}
+
+/* Initialize the kdb command table. */
+static void __init kdb_inittab(void)
+{
+        int i;
+        kdbtab_t *kp;
+
+        for_each_kdbcmd(kp, i)
+                kp->cmd_name = NULL;
+
+        kdb_register_repeat("md", kdb_md, "<vaddr>",
+          "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
+                            KDB_REPEAT_NO_ARGS);
+        kdb_register_repeat("mdr", kdb_md, "<vaddr> <bytes>",
+          "Display Raw Memory", 0, KDB_REPEAT_NO_ARGS);
+        kdb_register_repeat("mdp", kdb_md, "<paddr> <bytes>",
+          "Display Physical Memory", 0, KDB_REPEAT_NO_ARGS);
+        kdb_register_repeat("mds", kdb_md, "<vaddr>",
+          "Display Memory Symbolically", 0, KDB_REPEAT_NO_ARGS);
+        kdb_register_repeat("mm", kdb_mm, "<vaddr> <contents>",
+          "Modify Memory Contents", 0, KDB_REPEAT_NO_ARGS);
+        kdb_register_repeat("go", kdb_go, "[<vaddr>]",
+          "Continue Execution", 1, KDB_REPEAT_NONE);
+        kdb_register_repeat("rd", kdb_rd, "",
+          "Display Registers", 0, KDB_REPEAT_NONE);
+        kdb_register_repeat("rm", kdb_rm, "<reg> <contents>",
+          "Modify Registers", 0, KDB_REPEAT_NONE);
+        kdb_register_repeat("ef", kdb_ef, "<vaddr>",
+          "Display exception frame", 0, KDB_REPEAT_NONE);
+        kdb_register_repeat("bt", kdb_bt, "[<vaddr>]",
+          "Stack traceback", 1, KDB_REPEAT_NONE);
+        kdb_register_repeat("btp", kdb_bt, "<pid>",
+          "Display stack for process <pid>", 0, KDB_REPEAT_NONE);
+        kdb_register_repeat("bta", kdb_bt, "[DRSTCZEUIMA]",
+          "Display stack all processes", 0, KDB_REPEAT_NONE);
+        kdb_register_repeat("btc", kdb_bt, "",
+          "Backtrace current process on each cpu", 0, KDB_REPEAT_NONE);
+        kdb_register_repeat("btt", kdb_bt, "<vaddr>",
+          "Backtrace process given its struct task address", 0,
+                            KDB_REPEAT_NONE);
+        kdb_register_repeat("ll", kdb_ll, "<first-element> <linkoffset> <cmd>",
+          "Execute cmd for each element in linked list", 0, KDB_REPEAT_NONE);
+        kdb_register_repeat("env", kdb_env, "",
+          "Show environment variables", 0, KDB_REPEAT_NONE);
+        kdb_register_repeat("set", kdb_set, "",
+          "Set environment variables", 0, KDB_REPEAT_NONE);
+        kdb_register_repeat("help", kdb_help, "",
+          "Display Help Message", 1, KDB_REPEAT_NONE);
+        kdb_register_repeat("?", kdb_help, "",
+          "Display Help Message", 0, KDB_REPEAT_NONE);
+        kdb_register_repeat("cpu", kdb_cpu, "<cpunum>",
+          "Switch to new cpu", 0, KDB_REPEAT_NONE);
+        kdb_register_repeat("kgdb", kdb_kgdb, "",
+          "Enter kgdb mode", 0, KDB_REPEAT_NONE);
+        kdb_register_repeat("ps", kdb_ps, "[<flags>|A]",
+          "Display active task list", 0, KDB_REPEAT_NONE);
+        kdb_register_repeat("pid", kdb_pid, "<pidnum>",
+          "Switch to another task", 0, KDB_REPEAT_NONE);
+        kdb_register_repeat("reboot", kdb_reboot, "",
+          "Reboot the machine immediately", 0, KDB_REPEAT_NONE);
+#if defined(CONFIG_MODULES)
+        kdb_register_repeat("lsmod", kdb_lsmod, "",
+          "List loaded kernel modules", 0, KDB_REPEAT_NONE);
+#endif
+#if defined(CONFIG_MAGIC_SYSRQ)
+        kdb_register_repeat("sr", kdb_sr, "<key>",
+          "Magic SysRq key", 0, KDB_REPEAT_NONE);
+#endif
+#if defined(CONFIG_PRINTK)
+        kdb_register_repeat("dmesg", kdb_dmesg, "[lines]",
+          "Display syslog buffer", 0, KDB_REPEAT_NONE);
+#endif
+        kdb_register_repeat("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
+          "Define a set of commands, down to endefcmd", 0, KDB_REPEAT_NONE);
+        kdb_register_repeat("kill", kdb_kill, "<-signal> <pid>",
+          "Send a signal to a process", 0, KDB_REPEAT_NONE);
+        kdb_register_repeat("summary", kdb_summary, "",
+          "Summarize the system", 4, KDB_REPEAT_NONE);
+        kdb_register_repeat("per_cpu", kdb_per_cpu, "",
+          "Display per_cpu variables", 3, KDB_REPEAT_NONE);
+        kdb_register_repeat("grephelp", kdb_grep_help, "",
+          "Display help on | grep", 0, KDB_REPEAT_NONE);
+}
+
+/* Execute any commands defined in kdb_cmds.  */
+static void __init kdb_cmd_init(void)
+{
+        int i, diag;
+        for (i = 0; kdb_cmds[i]; ++i) {
+                diag = kdb_parse(kdb_cmds[i]);
+                if (diag)
+                        kdb_printf("kdb command %s failed, kdb diag %d\n",
+                                kdb_cmds[i], diag);
+        }
+        if (defcmd_in_progress) {
+                kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
+                kdb_parse("endefcmd");
+        }
+}
+
+/* Intialize kdb_printf, breakpoint tables and kdb state */
+void __init kdb_init(int lvl)
+{
+        static int kdb_init_lvl = KDB_NOT_INITIALIZED;
+        int i;
+
+        if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
+                return;
+        for (i = kdb_init_lvl; i < lvl; i++) {
+                switch (i) {
+                case KDB_NOT_INITIALIZED:
+                        kdb_inittab();          /* Initialize Command Table */
+                        kdb_initbptab();        /* Initialize Breakpoints */
+                        break;
+                case KDB_INIT_EARLY:
+                        kdb_cmd_init();         /* Build kdb_cmds tables */
+                        break;
+                }
+        }
+        kdb_init_lvl = lvl;
+}
diff --git a/kernel/debug/kdb/kdb_private.h b/kernel/debug/kdb/kdb_private.h
new file mode 100644
index 000000000000..97d3ba69775d
--- /dev/null
+++ b/kernel/debug/kdb/kdb_private.h
@@ -0,0 +1,300 @@
+#ifndef _KDBPRIVATE_H
+#define _KDBPRIVATE_H
+
+/*
+ * Kernel Debugger Architecture Independent Private Headers
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (c) 2000-2004 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2009 Wind River Systems, Inc.  All Rights Reserved.
+ */
+
+#include <linux/kgdb.h>
+#include "../debug_core.h"
+
+/* Kernel Debugger Error codes.  Must not overlap with command codes. */
+#define KDB_NOTFOUND    (-1)
+#define KDB_ARGCOUNT    (-2)
+#define KDB_BADWIDTH    (-3)
+#define KDB_BADRADIX    (-4)
+#define KDB_NOTENV      (-5)
+#define KDB_NOENVVALUE  (-6)
+#define KDB_NOTIMP      (-7)
+#define KDB_ENVFULL     (-8)
+#define KDB_ENVBUFFULL  (-9)
+#define KDB_TOOMANYBPT  (-10)
+#define KDB_TOOMANYDBREGS (-11)
+#define KDB_DUPBPT      (-12)
+#define KDB_BPTNOTFOUND (-13)
+#define KDB_BADMODE     (-14)
+#define KDB_BADINT      (-15)
+#define KDB_INVADDRFMT  (-16)
+#define KDB_BADREG      (-17)
+#define KDB_BADCPUNUM   (-18)
+#define KDB_BADLENGTH   (-19)
+#define KDB_NOBP        (-20)
+#define KDB_BADADDR     (-21)
+
+/* Kernel Debugger Command codes.  Must not overlap with error codes. */
+#define KDB_CMD_GO      (-1001)
+#define KDB_CMD_CPU     (-1002)
+#define KDB_CMD_SS      (-1003)
+#define KDB_CMD_SSB     (-1004)
+#define KDB_CMD_KGDB (-1005)
+#define KDB_CMD_KGDB2 (-1006)
+
+/* Internal debug flags */
+#define KDB_DEBUG_FLAG_BP       0x0002  /* Breakpoint subsystem debug */
+#define KDB_DEBUG_FLAG_BB_SUMM  0x0004  /* Basic block analysis, summary only */
+#define KDB_DEBUG_FLAG_AR       0x0008  /* Activation record, generic */
+#define KDB_DEBUG_FLAG_ARA      0x0010  /* Activation record, arch specific */
+#define KDB_DEBUG_FLAG_BB       0x0020  /* All basic block analysis */
+#define KDB_DEBUG_FLAG_STATE    0x0040  /* State flags */
+#define KDB_DEBUG_FLAG_MASK     0xffff  /* All debug flags */
+#define KDB_DEBUG_FLAG_SHIFT    16      /* Shift factor for dbflags */
+
+#define KDB_DEBUG(flag) (kdb_flags & \
+        (KDB_DEBUG_FLAG_##flag << KDB_DEBUG_FLAG_SHIFT))
+#define KDB_DEBUG_STATE(text, value) if (KDB_DEBUG(STATE)) \
+                kdb_print_state(text, value)
+
+#if BITS_PER_LONG == 32
+
+#define KDB_PLATFORM_ENV        "BYTESPERWORD=4"
+
+#define kdb_machreg_fmt         "0x%lx"
+#define kdb_machreg_fmt0        "0x%08lx"
+#define kdb_bfd_vma_fmt         "0x%lx"
+#define kdb_bfd_vma_fmt0        "0x%08lx"
+#define kdb_elfw_addr_fmt       "0x%x"
+#define kdb_elfw_addr_fmt0      "0x%08x"
+#define kdb_f_count_fmt         "%d"
+
+#elif BITS_PER_LONG == 64
+
+#define KDB_PLATFORM_ENV        "BYTESPERWORD=8"
+
+#define kdb_machreg_fmt         "0x%lx"
+#define kdb_machreg_fmt0        "0x%016lx"
+#define kdb_bfd_vma_fmt         "0x%lx"
+#define kdb_bfd_vma_fmt0        "0x%016lx"
+#define kdb_elfw_addr_fmt       "0x%x"
+#define kdb_elfw_addr_fmt0      "0x%016x"
+#define kdb_f_count_fmt         "%ld"
+
+#endif
+
+/*
+ * KDB_MAXBPT describes the total number of breakpoints
+ * supported by this architecure.
+ */
+#define KDB_MAXBPT      16
+
+/* Maximum number of arguments to a function  */
+#define KDB_MAXARGS    16
+
+typedef enum {
+        KDB_REPEAT_NONE = 0,    /* Do not repeat this command */
+        KDB_REPEAT_NO_ARGS,     /* Repeat the command without arguments */
+        KDB_REPEAT_WITH_ARGS,   /* Repeat the command including its arguments */
+} kdb_repeat_t;
+
+typedef int (*kdb_func_t)(int, const char **);
+
+/* Symbol table format returned by kallsyms. */
+typedef struct __ksymtab {
+                unsigned long value;    /* Address of symbol */
+                const char *mod_name;   /* Module containing symbol or
+                                         * "kernel" */
+                unsigned long mod_start;
+                unsigned long mod_end;
+                const char *sec_name;   /* Section containing symbol */
+                unsigned long sec_start;
+                unsigned long sec_end;
+                const char *sym_name;   /* Full symbol name, including
+                                         * any version */
+                unsigned long sym_start;
+                unsigned long sym_end;
+                } kdb_symtab_t;
+extern int kallsyms_symbol_next(char *prefix_name, int flag);
+extern int kallsyms_symbol_complete(char *prefix_name, int max_len);
+
+/* Exported Symbols for kernel loadable modules to use. */
+extern int kdb_register(char *, kdb_func_t, char *, char *, short);
+extern int kdb_register_repeat(char *, kdb_func_t, char *, char *,
+                               short, kdb_repeat_t);
+extern int kdb_unregister(char *);
+
+extern int kdb_getarea_size(void *, unsigned long, size_t);
+extern int kdb_putarea_size(unsigned long, void *, size_t);
+
+/*
+ * Like get_user and put_user, kdb_getarea and kdb_putarea take variable
+ * names, not pointers.  The underlying *_size functions take pointers.
+ */
+#define kdb_getarea(x, addr) kdb_getarea_size(&(x), addr, sizeof((x)))
+#define kdb_putarea(addr, x) kdb_putarea_size(addr, &(x), sizeof((x)))
+
+extern int kdb_getphysword(unsigned long *word,
+                        unsigned long addr, size_t size);
+extern int kdb_getword(unsigned long *, unsigned long, size_t);
+extern int kdb_putword(unsigned long, unsigned long, size_t);
+
+extern int kdbgetularg(const char *, unsigned long *);
+extern int kdb_set(int, const char **);
+extern char *kdbgetenv(const char *);
+extern int kdbgetintenv(const char *, int *);
+extern int kdbgetaddrarg(int, const char **, int*, unsigned long *,
+                         long *, char **);
+extern int kdbgetsymval(const char *, kdb_symtab_t *);
+extern int kdbnearsym(unsigned long, kdb_symtab_t *);
+extern void kdbnearsym_cleanup(void);
+extern char *kdb_strdup(const char *str, gfp_t type);
+extern void kdb_symbol_print(unsigned long, const kdb_symtab_t *, unsigned int);
+
+/* Routine for debugging the debugger state. */
+extern void kdb_print_state(const char *, int);
+
+extern int kdb_state;
+#define KDB_STATE_KDB           0x00000001      /* Cpu is inside kdb */
+#define KDB_STATE_LEAVING       0x00000002      /* Cpu is leaving kdb */
+#define KDB_STATE_CMD           0x00000004      /* Running a kdb command */
+#define KDB_STATE_KDB_CONTROL   0x00000008      /* This cpu is under
+                                                 * kdb control */
+#define KDB_STATE_HOLD_CPU      0x00000010      /* Hold this cpu inside kdb */
+#define KDB_STATE_DOING_SS      0x00000020      /* Doing ss command */
+#define KDB_STATE_DOING_SSB     0x00000040      /* Doing ssb command,
+                                                 * DOING_SS is also set */
+#define KDB_STATE_SSBPT         0x00000080      /* Install breakpoint
+                                                 * after one ss, independent of
+                                                 * DOING_SS */
+#define KDB_STATE_REENTRY       0x00000100      /* Valid re-entry into kdb */
+#define KDB_STATE_SUPPRESS      0x00000200      /* Suppress error messages */
+#define KDB_STATE_PAGER         0x00000400      /* pager is available */
+#define KDB_STATE_GO_SWITCH     0x00000800      /* go is switching
+                                                 * back to initial cpu */
+#define KDB_STATE_PRINTF_LOCK   0x00001000      /* Holds kdb_printf lock */
+#define KDB_STATE_WAIT_IPI      0x00002000      /* Waiting for kdb_ipi() NMI */
+#define KDB_STATE_RECURSE       0x00004000      /* Recursive entry to kdb */
+#define KDB_STATE_IP_ADJUSTED   0x00008000      /* Restart IP has been
+                                                 * adjusted */
+#define KDB_STATE_GO1           0x00010000      /* go only releases one cpu */
+#define KDB_STATE_KEYBOARD      0x00020000      /* kdb entered via
+                                                 * keyboard on this cpu */
+#define KDB_STATE_KEXEC         0x00040000      /* kexec issued */
+#define KDB_STATE_DOING_KGDB    0x00080000      /* kgdb enter now issued */
+#define KDB_STATE_DOING_KGDB2   0x00100000      /* kgdb enter now issued */
+#define KDB_STATE_KGDB_TRANS    0x00200000      /* Transition to kgdb */
+#define KDB_STATE_ARCH          0xff000000      /* Reserved for arch
+                                                 * specific use */
+
+#define KDB_STATE(flag) (kdb_state & KDB_STATE_##flag)
+#define KDB_STATE_SET(flag) ((void)(kdb_state |= KDB_STATE_##flag))
+#define KDB_STATE_CLEAR(flag) ((void)(kdb_state &= ~KDB_STATE_##flag))
+
+extern int kdb_nextline; /* Current number of lines displayed */
+
+typedef struct _kdb_bp {
+        unsigned long   bp_addr;        /* Address breakpoint is present at */
+        unsigned int    bp_free:1;      /* This entry is available */
+        unsigned int    bp_enabled:1;   /* Breakpoint is active in register */
+        unsigned int    bp_type:4;      /* Uses hardware register */
+        unsigned int    bp_installed:1; /* Breakpoint is installed */
+        unsigned int    bp_delay:1;     /* Do delayed bp handling */
+        unsigned int    bp_delayed:1;   /* Delayed breakpoint */
+        unsigned int    bph_length;     /* HW break length */
+} kdb_bp_t;
+
+#ifdef CONFIG_KGDB_KDB
+extern kdb_bp_t kdb_breakpoints[/* KDB_MAXBPT */];
+
+/* The KDB shell command table */
+typedef struct _kdbtab {
+        char    *cmd_name;              /* Command name */
+        kdb_func_t cmd_func;            /* Function to execute command */
+        char    *cmd_usage;             /* Usage String for this command */
+        char    *cmd_help;              /* Help message for this command */
+        short    cmd_flags;             /* Parsing flags */
+        short    cmd_minlen;            /* Minimum legal # command
+                                         * chars required */
+        kdb_repeat_t cmd_repeat;        /* Does command auto repeat on enter? */
+} kdbtab_t;
+
+extern int kdb_bt(int, const char **);  /* KDB display back trace */
+
+/* KDB breakpoint management functions */
+extern void kdb_initbptab(void);
+extern void kdb_bp_install(struct pt_regs *);
+extern void kdb_bp_remove(void);
+
+typedef enum {
+        KDB_DB_BPT,     /* Breakpoint */
+        KDB_DB_SS,      /* Single-step trap */
+        KDB_DB_SSB,     /* Single step to branch */
+        KDB_DB_SSBPT,   /* Single step over breakpoint */
+        KDB_DB_NOBPT    /* Spurious breakpoint */
+} kdb_dbtrap_t;
+
+extern int kdb_main_loop(kdb_reason_t, kdb_reason_t,
+                         int, kdb_dbtrap_t, struct pt_regs *);
+
+/* Miscellaneous functions and data areas */
+extern int kdb_grepping_flag;
+extern char kdb_grep_string[];
+extern int kdb_grep_leading;
+extern int kdb_grep_trailing;
+extern char *kdb_cmds[];
+extern void kdb_syslog_data(char *syslog_data[]);
+extern unsigned long kdb_task_state_string(const char *);
+extern char kdb_task_state_char (const struct task_struct *);
+extern unsigned long kdb_task_state(const struct task_struct *p,
+                                    unsigned long mask);
+extern void kdb_ps_suppressed(void);
+extern void kdb_ps1(const struct task_struct *p);
+extern void kdb_print_nameval(const char *name, unsigned long val);
+extern void kdb_send_sig_info(struct task_struct *p, struct siginfo *info);
+extern void kdb_meminfo_proc_show(void);
+extern const char *kdb_walk_kallsyms(loff_t *pos);
+extern char *kdb_getstr(char *, size_t, char *);
+
+/* Defines for kdb_symbol_print */
+#define KDB_SP_SPACEB   0x0001          /* Space before string */
+#define KDB_SP_SPACEA   0x0002          /* Space after string */
+#define KDB_SP_PAREN    0x0004          /* Parenthesis around string */
+#define KDB_SP_VALUE    0x0008          /* Print the value of the address */
+#define KDB_SP_SYMSIZE  0x0010          /* Print the size of the symbol */
+#define KDB_SP_NEWLINE  0x0020          /* Newline after string */
+#define KDB_SP_DEFAULT (KDB_SP_VALUE|KDB_SP_PAREN)
+
+#define KDB_TSK(cpu) kgdb_info[cpu].task
+#define KDB_TSKREGS(cpu) kgdb_info[cpu].debuggerinfo
+
+extern struct task_struct *kdb_curr_task(int);
+
+#define kdb_task_has_cpu(p) (task_curr(p))
+
+/* Simplify coexistence with NPTL */
+#define kdb_do_each_thread(g, p) do_each_thread(g, p)
+#define kdb_while_each_thread(g, p) while_each_thread(g, p)
+
+#define GFP_KDB (in_interrupt() ? GFP_ATOMIC : GFP_KERNEL)
+
+extern void *debug_kmalloc(size_t size, gfp_t flags);
+extern void debug_kfree(void *);
+extern void debug_kusage(void);
+
+extern void kdb_set_current_task(struct task_struct *);
+extern struct task_struct *kdb_current_task;
+#ifdef CONFIG_MODULES
+extern struct list_head *kdb_modules;
+#endif /* CONFIG_MODULES */
+
+extern char kdb_prompt_str[];
+
+#define KDB_WORD_SIZE   ((int)sizeof(unsigned long))
+
+#endif /* CONFIG_KGDB_KDB */
+#endif  /* !_KDBPRIVATE_H */
diff --git a/kernel/debug/kdb/kdb_support.c b/kernel/debug/kdb/kdb_support.c
new file mode 100644
index 000000000000..45344d5c53dd
--- /dev/null
+++ b/kernel/debug/kdb/kdb_support.c
@@ -0,0 +1,927 @@
+/*
+ * Kernel Debugger Architecture Independent Support Functions
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (c) 1999-2004 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2009 Wind River Systems, Inc.  All Rights Reserved.
+ * 03/02/13    added new 2.5 kallsyms <xavier.bru@bull.net>
+ */
+
+#include <stdarg.h>
+#include <linux/types.h>
+#include <linux/sched.h>
+#include <linux/mm.h>
+#include <linux/kallsyms.h>
+#include <linux/stddef.h>
+#include <linux/vmalloc.h>
+#include <linux/ptrace.h>
+#include <linux/module.h>
+#include <linux/highmem.h>
+#include <linux/hardirq.h>
+#include <linux/delay.h>
+#include <linux/uaccess.h>
+#include <linux/kdb.h>
+#include <linux/slab.h>
+#include "kdb_private.h"
+
+/*
+ * kdbgetsymval - Return the address of the given symbol.
+ *
+ * Parameters:
+ *      symname Character string containing symbol name
+ *      symtab  Structure to receive results
+ * Returns:
+ *      0       Symbol not found, symtab zero filled
+ *      1       Symbol mapped to module/symbol/section, data in symtab
+ */
+int kdbgetsymval(const char *symname, kdb_symtab_t *symtab)
+{
+        if (KDB_DEBUG(AR))
+                kdb_printf("kdbgetsymval: symname=%s, symtab=%p\n", symname,
+                           symtab);
+        memset(symtab, 0, sizeof(*symtab));
+        symtab->sym_start = kallsyms_lookup_name(symname);
+        if (symtab->sym_start) {
+                if (KDB_DEBUG(AR))
+                        kdb_printf("kdbgetsymval: returns 1, "
+                                   "symtab->sym_start=0x%lx\n",
+                                   symtab->sym_start);
+                return 1;
+        }
+        if (KDB_DEBUG(AR))
+                kdb_printf("kdbgetsymval: returns 0\n");
+        return 0;
+}
+EXPORT_SYMBOL(kdbgetsymval);
+
+static char *kdb_name_table[100];       /* arbitrary size */
+
+/*
+ * kdbnearsym - Return the name of the symbol with the nearest address
+ *      less than 'addr'.
+ *
+ * Parameters:
+ *      addr    Address to check for symbol near
+ *      symtab  Structure to receive results
+ * Returns:
+ *      0       No sections contain this address, symtab zero filled
+ *      1       Address mapped to module/symbol/section, data in symtab
+ * Remarks:
+ *      2.6 kallsyms has a "feature" where it unpacks the name into a
+ *      string.  If that string is reused before the caller expects it
+ *      then the caller sees its string change without warning.  To
+ *      avoid cluttering up the main kdb code with lots of kdb_strdup,
+ *      tests and kfree calls, kdbnearsym maintains an LRU list of the
+ *      last few unique strings.  The list is sized large enough to
+ *      hold active strings, no kdb caller of kdbnearsym makes more
+ *      than ~20 later calls before using a saved value.
+ */
+int kdbnearsym(unsigned long addr, kdb_symtab_t *symtab)
+{
+        int ret = 0;
+        unsigned long symbolsize;
+        unsigned long offset;
+#define knt1_size 128           /* must be >= kallsyms table size */
+        char *knt1 = NULL;
+
+        if (KDB_DEBUG(AR))
+                kdb_printf("kdbnearsym: addr=0x%lx, symtab=%p\n", addr, symtab);
+        memset(symtab, 0, sizeof(*symtab));
+
+        if (addr < 4096)
+                goto out;
+        knt1 = debug_kmalloc(knt1_size, GFP_ATOMIC);
+        if (!knt1) {
+                kdb_printf("kdbnearsym: addr=0x%lx cannot kmalloc knt1\n",
+                           addr);
+                goto out;
+        }
+        symtab->sym_name = kallsyms_lookup(addr, &symbolsize , &offset,
+                                (char **)(&symtab->mod_name), knt1);
+        if (offset > 8*1024*1024) {
+                symtab->sym_name = NULL;
+                addr = offset = symbolsize = 0;
+        }
+        symtab->sym_start = addr - offset;
+        symtab->sym_end = symtab->sym_start + symbolsize;
+        ret = symtab->sym_name != NULL && *(symtab->sym_name) != '\0';
+
+        if (ret) {
+                int i;
+                /* Another 2.6 kallsyms "feature".  Sometimes the sym_name is
+                 * set but the buffer passed into kallsyms_lookup is not used,
+                 * so it contains garbage.  The caller has to work out which
+                 * buffer needs to be saved.
+                 *
+                 * What was Rusty smoking when he wrote that code?
+                 */
+                if (symtab->sym_name != knt1) {
+                        strncpy(knt1, symtab->sym_name, knt1_size);
+                        knt1[knt1_size-1] = '\0';
+                }
+                for (i = 0; i < ARRAY_SIZE(kdb_name_table); ++i) {
+                        if (kdb_name_table[i] &&
+                            strcmp(kdb_name_table[i], knt1) == 0)
+                                break;
+                }
+                if (i >= ARRAY_SIZE(kdb_name_table)) {
+                        debug_kfree(kdb_name_table[0]);
+                        memcpy(kdb_name_table, kdb_name_table+1,
+                               sizeof(kdb_name_table[0]) *
+                               (ARRAY_SIZE(kdb_name_table)-1));
+                } else {
+                        debug_kfree(knt1);
+                        knt1 = kdb_name_table[i];
+                        memcpy(kdb_name_table+i, kdb_name_table+i+1,
+                               sizeof(kdb_name_table[0]) *
+                               (ARRAY_SIZE(kdb_name_table)-i-1));
+                }
+                i = ARRAY_SIZE(kdb_name_table) - 1;
+                kdb_name_table[i] = knt1;
+                symtab->sym_name = kdb_name_table[i];
+                knt1 = NULL;
+        }
+
+        if (symtab->mod_name == NULL)
+                symtab->mod_name = "kernel";
+        if (KDB_DEBUG(AR))
+                kdb_printf("kdbnearsym: returns %d symtab->sym_start=0x%lx, "
+                   "symtab->mod_name=%p, symtab->sym_name=%p (%s)\n", ret,
+                   symtab->sym_start, symtab->mod_name, symtab->sym_name,
+                   symtab->sym_name);
+
+out:
+        debug_kfree(knt1);
+        return ret;
+}
+
+void kdbnearsym_cleanup(void)
+{
+        int i;
+        for (i = 0; i < ARRAY_SIZE(kdb_name_table); ++i) {
+                if (kdb_name_table[i]) {
+                        debug_kfree(kdb_name_table[i]);
+                        kdb_name_table[i] = NULL;
+                }
+        }
+}
+
+static char ks_namebuf[KSYM_NAME_LEN+1], ks_namebuf_prev[KSYM_NAME_LEN+1];
+
+/*
+ * kallsyms_symbol_complete
+ *
+ * Parameters:
+ *      prefix_name     prefix of a symbol name to lookup
+ *      max_len         maximum length that can be returned
+ * Returns:
+ *      Number of symbols which match the given prefix.
+ * Notes:
+ *      prefix_name is changed to contain the longest unique prefix that
+ *      starts with this prefix (tab completion).
+ */
+int kallsyms_symbol_complete(char *prefix_name, int max_len)
+{
+        loff_t pos = 0;
+        int prefix_len = strlen(prefix_name), prev_len = 0;
+        int i, number = 0;
+        const char *name;
+
+        while ((name = kdb_walk_kallsyms(&pos))) {
+                if (strncmp(name, prefix_name, prefix_len) == 0) {
+                        strcpy(ks_namebuf, name);
+                        /* Work out the longest name that matches the prefix */
+                        if (++number == 1) {
+                                prev_len = min_t(int, max_len-1,
+                                                 strlen(ks_namebuf));
+                                memcpy(ks_namebuf_prev, ks_namebuf, prev_len);
+                                ks_namebuf_prev[prev_len] = '\0';
+                                continue;
+                        }
+                        for (i = 0; i < prev_len; i++) {
+                                if (ks_namebuf[i] != ks_namebuf_prev[i]) {
+                                        prev_len = i;
+                                        ks_namebuf_prev[i] = '\0';
+                                        break;
+                                }
+                        }
+                }
+        }
+        if (prev_len > prefix_len)
+                memcpy(prefix_name, ks_namebuf_prev, prev_len+1);
+        return number;
+}
+
+/*
+ * kallsyms_symbol_next
+ *
+ * Parameters:
+ *      prefix_name     prefix of a symbol name to lookup
+ *      flag    0 means search from the head, 1 means continue search.
+ * Returns:
+ *      1 if a symbol matches the given prefix.
+ *      0 if no string found
+ */
+int kallsyms_symbol_next(char *prefix_name, int flag)
+{
+        int prefix_len = strlen(prefix_name);
+        static loff_t pos;
+        const char *name;
+
+        if (!flag)
+                pos = 0;
+
+        while ((name = kdb_walk_kallsyms(&pos))) {
+                if (strncmp(name, prefix_name, prefix_len) == 0) {
+                        strncpy(prefix_name, name, strlen(name)+1);
+                        return 1;
+                }
+        }
+        return 0;
+}
+
+/*
+ * kdb_symbol_print - Standard method for printing a symbol name and offset.
+ * Inputs:
+ *      addr    Address to be printed.
+ *      symtab  Address of symbol data, if NULL this routine does its
+ *              own lookup.
+ *      punc    Punctuation for string, bit field.
+ * Remarks:
+ *      The string and its punctuation is only printed if the address
+ *      is inside the kernel, except that the value is always printed
+ *      when requested.
+ */
+void kdb_symbol_print(unsigned long addr, const kdb_symtab_t *symtab_p,
+                      unsigned int punc)
+{
+        kdb_symtab_t symtab, *symtab_p2;
+        if (symtab_p) {
+                symtab_p2 = (kdb_symtab_t *)symtab_p;
+        } else {
+                symtab_p2 = &symtab;
+                kdbnearsym(addr, symtab_p2);
+        }
+        if (!(symtab_p2->sym_name || (punc & KDB_SP_VALUE)))
+                return;
+        if (punc & KDB_SP_SPACEB)
+                kdb_printf(" ");
+        if (punc & KDB_SP_VALUE)
+                kdb_printf(kdb_machreg_fmt0, addr);
+        if (symtab_p2->sym_name) {
+                if (punc & KDB_SP_VALUE)
+                        kdb_printf(" ");
+                if (punc & KDB_SP_PAREN)
+                        kdb_printf("(");
+                if (strcmp(symtab_p2->mod_name, "kernel"))
+                        kdb_printf("[%s]", symtab_p2->mod_name);
+                kdb_printf("%s", symtab_p2->sym_name);
+                if (addr != symtab_p2->sym_start)
+                        kdb_printf("+0x%lx", addr - symtab_p2->sym_start);
+                if (punc & KDB_SP_SYMSIZE)
+                        kdb_printf("/0x%lx",
+                                   symtab_p2->sym_end - symtab_p2->sym_start);
+                if (punc & KDB_SP_PAREN)
+                        kdb_printf(")");
+        }
+        if (punc & KDB_SP_SPACEA)
+                kdb_printf(" ");
+        if (punc & KDB_SP_NEWLINE)
+                kdb_printf("\n");
+}
+
+/*
+ * kdb_strdup - kdb equivalent of strdup, for disasm code.
+ * Inputs:
+ *      str     The string to duplicate.
+ *      type    Flags to kmalloc for the new string.
+ * Returns:
+ *      Address of the new string, NULL if storage could not be allocated.
+ * Remarks:
+ *      This is not in lib/string.c because it uses kmalloc which is not
+ *      available when string.o is used in boot loaders.
+ */
+char *kdb_strdup(const char *str, gfp_t type)
+{
+        int n = strlen(str)+1;
+        char *s = kmalloc(n, type);
+        if (!s)
+                return NULL;
+        return strcpy(s, str);
+}
+
+/*
+ * kdb_getarea_size - Read an area of data.  The kdb equivalent of
+ *      copy_from_user, with kdb messages for invalid addresses.
+ * Inputs:
+ *      res     Pointer to the area to receive the result.
+ *      addr    Address of the area to copy.
+ *      size    Size of the area.
+ * Returns:
+ *      0 for success, < 0 for error.
+ */
+int kdb_getarea_size(void *res, unsigned long addr, size_t size)
+{
+        int ret = probe_kernel_read((char *)res, (char *)addr, size);
+        if (ret) {
+                if (!KDB_STATE(SUPPRESS)) {
+                        kdb_printf("kdb_getarea: Bad address 0x%lx\n", addr);
+                        KDB_STATE_SET(SUPPRESS);
+                }
+                ret = KDB_BADADDR;
+        } else {
+                KDB_STATE_CLEAR(SUPPRESS);
+        }
+        return ret;
+}
+
+/*
+ * kdb_putarea_size - Write an area of data.  The kdb equivalent of
+ *      copy_to_user, with kdb messages for invalid addresses.
+ * Inputs:
+ *      addr    Address of the area to write to.
+ *      res     Pointer to the area holding the data.
+ *      size    Size of the area.
+ * Returns:
+ *      0 for success, < 0 for error.
+ */
+int kdb_putarea_size(unsigned long addr, void *res, size_t size)
+{
+        int ret = probe_kernel_read((char *)addr, (char *)res, size);
+        if (ret) {
+                if (!KDB_STATE(SUPPRESS)) {
+                        kdb_printf("kdb_putarea: Bad address 0x%lx\n", addr);
+                        KDB_STATE_SET(SUPPRESS);
+                }
+                ret = KDB_BADADDR;
+        } else {
+                KDB_STATE_CLEAR(SUPPRESS);
+        }
+        return ret;
+}
+
+/*
+ * kdb_getphys - Read data from a physical address. Validate the
+ *      address is in range, use kmap_atomic() to get data
+ *      similar to kdb_getarea() - but for phys addresses
+ * Inputs:
+ *      res     Pointer to the word to receive the result
+ *      addr    Physical address of the area to copy
+ *      size    Size of the area
+ * Returns:
+ *      0 for success, < 0 for error.
+ */
+static int kdb_getphys(void *res, unsigned long addr, size_t size)
+{
+        unsigned long pfn;
+        void *vaddr;
+        struct page *page;
+
+        pfn = (addr >> PAGE_SHIFT);
+        if (!pfn_valid(pfn))
+                return 1;
+        page = pfn_to_page(pfn);
+        vaddr = kmap_atomic(page, KM_KDB);
+        memcpy(res, vaddr + (addr & (PAGE_SIZE - 1)), size);
+        kunmap_atomic(vaddr, KM_KDB);
+
+        return 0;
+}
+
+/*
+ * kdb_getphysword
+ * Inputs:
+ *      word    Pointer to the word to receive the result.
+ *      addr    Address of the area to copy.
+ *      size    Size of the area.
+ * Returns:
+ *      0 for success, < 0 for error.
+ */
+int kdb_getphysword(unsigned long *word, unsigned long addr, size_t size)
+{
+        int diag;
+        __u8  w1;
+        __u16 w2;
+        __u32 w4;
+        __u64 w8;
+        *word = 0;      /* Default value if addr or size is invalid */
+
+        switch (size) {
+        case 1:
+                diag = kdb_getphys(&w1, addr, sizeof(w1));
+                if (!diag)
+                        *word = w1;
+                break;
+        case 2:
+                diag = kdb_getphys(&w2, addr, sizeof(w2));
+                if (!diag)
+                        *word = w2;
+                break;
+        case 4:
+                diag = kdb_getphys(&w4, addr, sizeof(w4));
+                if (!diag)
+                        *word = w4;
+                break;
+        case 8:
+                if (size <= sizeof(*word)) {
+                        diag = kdb_getphys(&w8, addr, sizeof(w8));
+                        if (!diag)
+                                *word = w8;
+                        break;
+                }
+                /* drop through */
+        default:
+                diag = KDB_BADWIDTH;
+                kdb_printf("kdb_getphysword: bad width %ld\n", (long) size);
+        }
+        return diag;
+}
+
+/*
+ * kdb_getword - Read a binary value.  Unlike kdb_getarea, this treats
+ *      data as numbers.
+ * Inputs:
+ *      word    Pointer to the word to receive the result.
+ *      addr    Address of the area to copy.
+ *      size    Size of the area.
+ * Returns:
+ *      0 for success, < 0 for error.
+ */
+int kdb_getword(unsigned long *word, unsigned long addr, size_t size)
+{
+        int diag;
+        __u8  w1;
+        __u16 w2;
+        __u32 w4;
+        __u64 w8;
+        *word = 0;      /* Default value if addr or size is invalid */
+        switch (size) {
+        case 1:
+                diag = kdb_getarea(w1, addr);
+                if (!diag)
+                        *word = w1;
+                break;
+        case 2:
+                diag = kdb_getarea(w2, addr);
+                if (!diag)
+                        *word = w2;
+                break;
+        case 4:
+                diag = kdb_getarea(w4, addr);
+                if (!diag)
+                        *word = w4;
+                break;
+        case 8:
+                if (size <= sizeof(*word)) {
+                        diag = kdb_getarea(w8, addr);
+                        if (!diag)
+                                *word = w8;
+                        break;
+                }
+                /* drop through */
+        default:
+                diag = KDB_BADWIDTH;
+                kdb_printf("kdb_getword: bad width %ld\n", (long) size);
+        }
+        return diag;
+}
+
+/*
+ * kdb_putword - Write a binary value.  Unlike kdb_putarea, this
+ *      treats data as numbers.
+ * Inputs:
+ *      addr    Address of the area to write to..
+ *      word    The value to set.
+ *      size    Size of the area.
+ * Returns:
+ *      0 for success, < 0 for error.
+ */
+int kdb_putword(unsigned long addr, unsigned long word, size_t size)
+{
+        int diag;
+        __u8  w1;
+        __u16 w2;
+        __u32 w4;
+        __u64 w8;
+        switch (size) {
+        case 1:
+                w1 = word;
+                diag = kdb_putarea(addr, w1);
+                break;
+        case 2:
+                w2 = word;
+                diag = kdb_putarea(addr, w2);
+                break;
+        case 4:
+                w4 = word;
+                diag = kdb_putarea(addr, w4);
+                break;
+        case 8:
+                if (size <= sizeof(word)) {
+                        w8 = word;
+                        diag = kdb_putarea(addr, w8);
+                        break;
+                }
+                /* drop through */
+        default:
+                diag = KDB_BADWIDTH;
+                kdb_printf("kdb_putword: bad width %ld\n", (long) size);
+        }
+        return diag;
+}
+
+/*
+ * kdb_task_state_string - Convert a string containing any of the
+ *      letters DRSTCZEUIMA to a mask for the process state field and
+ *      return the value.  If no argument is supplied, return the mask
+ *      that corresponds to environment variable PS, DRSTCZEU by
+ *      default.
+ * Inputs:
+ *      s       String to convert
+ * Returns:
+ *      Mask for process state.
+ * Notes:
+ *      The mask folds data from several sources into a single long value, so
+ *      be carefull not to overlap the bits.  TASK_* bits are in the LSB,
+ *      special cases like UNRUNNABLE are in the MSB.  As of 2.6.10-rc1 there
+ *      is no overlap between TASK_* and EXIT_* but that may not always be
+ *      true, so EXIT_* bits are shifted left 16 bits before being stored in
+ *      the mask.
+ */
+
+/* unrunnable is < 0 */
+#define UNRUNNABLE      (1UL << (8*sizeof(unsigned long) - 1))
+#define RUNNING         (1UL << (8*sizeof(unsigned long) - 2))
+#define IDLE            (1UL << (8*sizeof(unsigned long) - 3))
+#define DAEMON          (1UL << (8*sizeof(unsigned long) - 4))
+
+unsigned long kdb_task_state_string(const char *s)
+{
+        long res = 0;
+        if (!s) {
+                s = kdbgetenv("PS");
+                if (!s)
+                        s = "DRSTCZEU"; /* default value for ps */
+        }
+        while (*s) {
+                switch (*s) {
+                case 'D':
+                        res |= TASK_UNINTERRUPTIBLE;
+                        break;
+                case 'R':
+                        res |= RUNNING;
+                        break;
+                case 'S':
+                        res |= TASK_INTERRUPTIBLE;
+                        break;
+                case 'T':
+                        res |= TASK_STOPPED;
+                        break;
+                case 'C':
+                        res |= TASK_TRACED;
+                        break;
+                case 'Z':
+                        res |= EXIT_ZOMBIE << 16;
+                        break;
+                case 'E':
+                        res |= EXIT_DEAD << 16;
+                        break;
+                case 'U':
+                        res |= UNRUNNABLE;
+                        break;
+                case 'I':
+                        res |= IDLE;
+                        break;
+                case 'M':
+                        res |= DAEMON;
+                        break;
+                case 'A':
+                        res = ~0UL;
+                        break;
+                default:
+                          kdb_printf("%s: unknown flag '%c' ignored\n",
+                                     __func__, *s);
+                          break;
+                }
+                ++s;
+        }
+        return res;
+}
+
+/*
+ * kdb_task_state_char - Return the character that represents the task state.
+ * Inputs:
+ *      p       struct task for the process
+ * Returns:
+ *      One character to represent the task state.
+ */
+char kdb_task_state_char (const struct task_struct *p)
+{
+        int cpu;
+        char state;
+        unsigned long tmp;
+
+        if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
+                return 'E';
+
+        cpu = kdb_process_cpu(p);
+        state = (p->state == 0) ? 'R' :
+                (p->state < 0) ? 'U' :
+                (p->state & TASK_UNINTERRUPTIBLE) ? 'D' :
+                (p->state & TASK_STOPPED) ? 'T' :
+                (p->state & TASK_TRACED) ? 'C' :
+                (p->exit_state & EXIT_ZOMBIE) ? 'Z' :
+                (p->exit_state & EXIT_DEAD) ? 'E' :
+                (p->state & TASK_INTERRUPTIBLE) ? 'S' : '?';
+        if (p->pid == 0) {
+                /* Idle task.  Is it really idle, apart from the kdb
+                 * interrupt? */
+                if (!kdb_task_has_cpu(p) || kgdb_info[cpu].irq_depth == 1) {
+                        if (cpu != kdb_initial_cpu)
+                                state = 'I';    /* idle task */
+                }
+        } else if (!p->mm && state == 'S') {
+                state = 'M';    /* sleeping system daemon */
+        }
+        return state;
+}
+
+/*
+ * kdb_task_state - Return true if a process has the desired state
+ *      given by the mask.
+ * Inputs:
+ *      p       struct task for the process
+ *      mask    mask from kdb_task_state_string to select processes
+ * Returns:
+ *      True if the process matches at least one criteria defined by the mask.
+ */
+unsigned long kdb_task_state(const struct task_struct *p, unsigned long mask)
+{
+        char state[] = { kdb_task_state_char(p), '\0' };
+        return (mask & kdb_task_state_string(state)) != 0;
+}
+
+/*
+ * kdb_print_nameval - Print a name and its value, converting the
+ *      value to a symbol lookup if possible.
+ * Inputs:
+ *      name    field name to print
+ *      val     value of field
+ */
+void kdb_print_nameval(const char *name, unsigned long val)
+{
+        kdb_symtab_t symtab;
+        kdb_printf("  %-11.11s ", name);
+        if (kdbnearsym(val, &symtab))
+                kdb_symbol_print(val, &symtab,
+                                 KDB_SP_VALUE|KDB_SP_SYMSIZE|KDB_SP_NEWLINE);
+        else
+                kdb_printf("0x%lx\n", val);
+}
+
+/* Last ditch allocator for debugging, so we can still debug even when
+ * the GFP_ATOMIC pool has been exhausted.  The algorithms are tuned
+ * for space usage, not for speed.  One smallish memory pool, the free
+ * chain is always in ascending address order to allow coalescing,
+ * allocations are done in brute force best fit.
+ */
+
+struct debug_alloc_header {
+        u32 next;       /* offset of next header from start of pool */
+        u32 size;
+        void *caller;
+};
+
+/* The memory returned by this allocator must be aligned, which means
+ * so must the header size.  Do not assume that sizeof(struct
+ * debug_alloc_header) is a multiple of the alignment, explicitly
+ * calculate the overhead of this header, including the alignment.
+ * The rest of this code must not use sizeof() on any header or
+ * pointer to a header.
+ */
+#define dah_align 8
+#define dah_overhead ALIGN(sizeof(struct debug_alloc_header), dah_align)
+
+static u64 debug_alloc_pool_aligned[256*1024/dah_align];        /* 256K pool */
+static char *debug_alloc_pool = (char *)debug_alloc_pool_aligned;
+static u32 dah_first, dah_first_call = 1, dah_used, dah_used_max;
+
+/* Locking is awkward.  The debug code is called from all contexts,
+ * including non maskable interrupts.  A normal spinlock is not safe
+ * in NMI context.  Try to get the debug allocator lock, if it cannot
+ * be obtained after a second then give up.  If the lock could not be
+ * previously obtained on this cpu then only try once.
+ *
+ * sparse has no annotation for "this function _sometimes_ acquires a
+ * lock", so fudge the acquire/release notation.
+ */
+static DEFINE_SPINLOCK(dap_lock);
+static int get_dap_lock(void)
+        __acquires(dap_lock)
+{
+        static int dap_locked = -1;
+        int count;
+        if (dap_locked == smp_processor_id())
+                count = 1;
+        else
+                count = 1000;
+        while (1) {
+                if (spin_trylock(&dap_lock)) {
+                        dap_locked = -1;
+                        return 1;
+                }
+                if (!count--)
+                        break;
+                udelay(1000);
+        }
+        dap_locked = smp_processor_id();
+        __acquire(dap_lock);
+        return 0;
+}
+
+void *debug_kmalloc(size_t size, gfp_t flags)
+{
+        unsigned int rem, h_offset;
+        struct debug_alloc_header *best, *bestprev, *prev, *h;
+        void *p = NULL;
+        if (!get_dap_lock()) {
+                __release(dap_lock);    /* we never actually got it */
+                return NULL;
+        }
+        h = (struct debug_alloc_header *)(debug_alloc_pool + dah_first);
+        if (dah_first_call) {
+                h->size = sizeof(debug_alloc_pool_aligned) - dah_overhead;
+                dah_first_call = 0;
+        }
+        size = ALIGN(size, dah_align);
+        prev = best = bestprev = NULL;
+        while (1) {
+                if (h->size >= size && (!best || h->size < best->size)) {
+                        best = h;
+                        bestprev = prev;
+                        if (h->size == size)
+                                break;
+                }
+                if (!h->next)
+                        break;
+                prev = h;
+                h = (struct debug_alloc_header *)(debug_alloc_pool + h->next);
+        }
+        if (!best)
+                goto out;
+        rem = best->size - size;
+        /* The pool must always contain at least one header */
+        if (best->next == 0 && bestprev == NULL && rem < dah_overhead)
+                goto out;
+        if (rem >= dah_overhead) {
+                best->size = size;
+                h_offset = ((char *)best - debug_alloc_pool) +
+                           dah_overhead + best->size;
+                h = (struct debug_alloc_header *)(debug_alloc_pool + h_offset);
+                h->size = rem - dah_overhead;
+                h->next = best->next;
+        } else
+                h_offset = best->next;
+        best->caller = __builtin_return_address(0);
+        dah_used += best->size;
+        dah_used_max = max(dah_used, dah_used_max);
+        if (bestprev)
+                bestprev->next = h_offset;
+        else
+                dah_first = h_offset;
+        p = (char *)best + dah_overhead;
+        memset(p, POISON_INUSE, best->size - 1);
+        *((char *)p + best->size - 1) = POISON_END;
+out:
+        spin_unlock(&dap_lock);
+        return p;
+}
+
+void debug_kfree(void *p)
+{
+        struct debug_alloc_header *h;
+        unsigned int h_offset;
+        if (!p)
+                return;
+        if ((char *)p < debug_alloc_pool ||
+            (char *)p >= debug_alloc_pool + sizeof(debug_alloc_pool_aligned)) {
+                kfree(p);
+                return;
+        }
+        if (!get_dap_lock()) {
+                __release(dap_lock);    /* we never actually got it */
+                return;         /* memory leak, cannot be helped */
+        }
+        h = (struct debug_alloc_header *)((char *)p - dah_overhead);
+        memset(p, POISON_FREE, h->size - 1);
+        *((char *)p + h->size - 1) = POISON_END;
+        h->caller = NULL;
+        dah_used -= h->size;
+        h_offset = (char *)h - debug_alloc_pool;
+        if (h_offset < dah_first) {
+                h->next = dah_first;
+                dah_first = h_offset;
+        } else {
+                struct debug_alloc_header *prev;
+                unsigned int prev_offset;
+                prev = (struct debug_alloc_header *)(debug_alloc_pool +
+                                                     dah_first);
+                while (1) {
+                        if (!prev->next || prev->next > h_offset)
+                                break;
+                        prev = (struct debug_alloc_header *)
+                                (debug_alloc_pool + prev->next);
+                }
+                prev_offset = (char *)prev - debug_alloc_pool;
+                if (prev_offset + dah_overhead + prev->size == h_offset) {
+                        prev->size += dah_overhead + h->size;
+                        memset(h, POISON_FREE, dah_overhead - 1);
+                        *((char *)h + dah_overhead - 1) = POISON_END;
+                        h = prev;
+                        h_offset = prev_offset;
+                } else {
+                        h->next = prev->next;
+                        prev->next = h_offset;
+                }
+        }
+        if (h_offset + dah_overhead + h->size == h->next) {
+                struct debug_alloc_header *next;
+                next = (struct debug_alloc_header *)
+                        (debug_alloc_pool + h->next);
+                h->size += dah_overhead + next->size;
+                h->next = next->next;
+                memset(next, POISON_FREE, dah_overhead - 1);
+                *((char *)next + dah_overhead - 1) = POISON_END;
+        }
+        spin_unlock(&dap_lock);
+}
+
+void debug_kusage(void)
+{
+        struct debug_alloc_header *h_free, *h_used;
+#ifdef  CONFIG_IA64
+        /* FIXME: using dah for ia64 unwind always results in a memory leak.
+         * Fix that memory leak first, then set debug_kusage_one_time = 1 for
+         * all architectures.
+         */
+        static int debug_kusage_one_time;
+#else
+        static int debug_kusage_one_time = 1;
+#endif
+        if (!get_dap_lock()) {
+                __release(dap_lock);    /* we never actually got it */
+                return;
+        }
+        h_free = (struct debug_alloc_header *)(debug_alloc_pool + dah_first);
+        if (dah_first == 0 &&
+            (h_free->size == sizeof(debug_alloc_pool_aligned) - dah_overhead ||
+             dah_first_call))
+                goto out;
+        if (!debug_kusage_one_time)
+                goto out;
+        debug_kusage_one_time = 0;
+        kdb_printf("%s: debug_kmalloc memory leak dah_first %d\n",
+                   __func__, dah_first);
+        if (dah_first) {
+                h_used = (struct debug_alloc_header *)debug_alloc_pool;
+                kdb_printf("%s: h_used %p size %d\n", __func__, h_used,
+                           h_used->size);
+        }
+        do {
+                h_used = (struct debug_alloc_header *)
+                          ((char *)h_free + dah_overhead + h_free->size);
+                kdb_printf("%s: h_used %p size %d caller %p\n",
+                           __func__, h_used, h_used->size, h_used->caller);
+                h_free = (struct debug_alloc_header *)
+                          (debug_alloc_pool + h_free->next);
+        } while (h_free->next);
+        h_used = (struct debug_alloc_header *)
+                  ((char *)h_free + dah_overhead + h_free->size);
+        if ((char *)h_used - debug_alloc_pool !=
+            sizeof(debug_alloc_pool_aligned))
+                kdb_printf("%s: h_used %p size %d caller %p\n",
+                           __func__, h_used, h_used->size, h_used->caller);
+out:
+        spin_unlock(&dap_lock);
+}
+
+/* Maintain a small stack of kdb_flags to allow recursion without disturbing
+ * the global kdb state.
+ */
+
+static int kdb_flags_stack[4], kdb_flags_index;
+
+void kdb_save_flags(void)
+{
+        BUG_ON(kdb_flags_index >= ARRAY_SIZE(kdb_flags_stack));
+        kdb_flags_stack[kdb_flags_index++] = kdb_flags;
+}
+
+void kdb_restore_flags(void)
+{
+        BUG_ON(kdb_flags_index <= 0);
+        kdb_flags = kdb_flags_stack[--kdb_flags_index];
+}
diff --git a/kernel/exit.c b/kernel/exit.c
index eabca5a73a85..ceffc67b564a 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -58,11 +58,11 @@
 
 static void exit_mm(struct task_struct * tsk);
 
-static void __unhash_process(struct task_struct *p)
+static void __unhash_process(struct task_struct *p, bool group_dead)
 {
         nr_threads--;
         detach_pid(p, PIDTYPE_PID);
-        if (thread_group_leader(p)) {
+        if (group_dead) {
                 detach_pid(p, PIDTYPE_PGID);
                 detach_pid(p, PIDTYPE_SID);
 
@@ -79,10 +79,9 @@ static void __unhash_process(struct task_struct *p)
 static void __exit_signal(struct task_struct *tsk)
 {
         struct signal_struct *sig = tsk->signal;
+        bool group_dead = thread_group_leader(tsk);
         struct sighand_struct *sighand;
-
-        BUG_ON(!sig);
-        BUG_ON(!atomic_read(&sig->count));
+        struct tty_struct *uninitialized_var(tty);
 
         sighand = rcu_dereference_check(tsk->sighand,
                                         rcu_read_lock_held() ||
@@ -90,14 +89,16 @@ static void __exit_signal(struct task_struct *tsk)
         spin_lock(&sighand->siglock);
 
         posix_cpu_timers_exit(tsk);
-        if (atomic_dec_and_test(&sig->count))
+        if (group_dead) {
                 posix_cpu_timers_exit_group(tsk);
-        else {
+                tty = sig->tty;
+                sig->tty = NULL;
+        } else {
                 /*
                  * If there is any task waiting for the group exit
                  * then notify it:
                  */
-                if (sig->group_exit_task && atomic_read(&sig->count) == sig->notify_count)
+                if (sig->notify_count > 0 && !--sig->notify_count)
                         wake_up_process(sig->group_exit_task);
 
                 if (tsk == sig->curr_target)
@@ -123,32 +124,24 @@ static void __exit_signal(struct task_struct *tsk)
                 sig->oublock += task_io_get_oublock(tsk);
                 task_io_accounting_add(&sig->ioac, &tsk->ioac);
                 sig->sum_sched_runtime += tsk->se.sum_exec_runtime;
-                sig = NULL; /* Marker for below. */
         }
 
-        __unhash_process(tsk);
+        sig->nr_threads--;
+        __unhash_process(tsk, group_dead);
 
         /*
          * Do this under ->siglock, we can race with another thread
          * doing sigqueue_free() if we have SIGQUEUE_PREALLOC signals.
          */
         flush_sigqueue(&tsk->pending);
-
-        tsk->signal = NULL;
         tsk->sighand = NULL;
         spin_unlock(&sighand->siglock);
 
         __cleanup_sighand(sighand);
         clear_tsk_thread_flag(tsk,TIF_SIGPENDING);
-        if (sig) {
+        if (group_dead) {
                 flush_sigqueue(&sig->shared_pending);
-                taskstats_tgid_free(sig);
-                /*
-                 * Make sure ->signal can't go away under rq->lock,
-                 * see account_group_exec_runtime().
-                 */
-                task_rq_unlock_wait(tsk);
-                __cleanup_signal(sig);
+                tty_kref_put(tty);
         }
 }
 
@@ -856,12 +849,9 @@ static void exit_notify(struct task_struct *tsk, int group_dead)
 
         tsk->exit_state = signal == DEATH_REAP ? EXIT_DEAD : EXIT_ZOMBIE;
 
-        /* mt-exec, de_thread() is waiting for us */
-        if (thread_group_leader(tsk) &&
-            tsk->signal->group_exit_task &&
-            tsk->signal->notify_count < 0)
+        /* mt-exec, de_thread() is waiting for group leader */
+        if (unlikely(tsk->signal->notify_count < 0))
                 wake_up_process(tsk->signal->group_exit_task);
-
         write_unlock_irq(&tasklist_lock);
 
         tracehook_report_death(tsk, signal, cookie, group_dead);
@@ -1002,8 +992,10 @@ NORET_TYPE void do_exit(long code)
 
         exit_notify(tsk, group_dead);
 #ifdef CONFIG_NUMA
+        task_lock(tsk);
         mpol_put(tsk->mempolicy);
         tsk->mempolicy = NULL;
+        task_unlock(tsk);
 #endif
 #ifdef CONFIG_FUTEX
         if (unlikely(current->pi_state_cache))
diff --git a/kernel/fork.c b/kernel/fork.c
index 4d57d9e3a6e9..b6cce14ba047 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -165,6 +165,18 @@ void free_task(struct task_struct *tsk)
 }
 EXPORT_SYMBOL(free_task);
 
+static inline void free_signal_struct(struct signal_struct *sig)
+{
+        taskstats_tgid_free(sig);
+        kmem_cache_free(signal_cachep, sig);
+}
+
+static inline void put_signal_struct(struct signal_struct *sig)
+{
+        if (atomic_dec_and_test(&sig->sigcnt))
+                free_signal_struct(sig);
+}
+
 void __put_task_struct(struct task_struct *tsk)
 {
         WARN_ON(!tsk->exit_state);
@@ -173,6 +185,7 @@ void __put_task_struct(struct task_struct *tsk)
 
         exit_creds(tsk);
         delayacct_tsk_free(tsk);
+        put_signal_struct(tsk->signal);
 
         if (!profile_handoff_task(tsk))
                 free_task(tsk);
@@ -864,8 +877,9 @@ static int copy_signal(unsigned long clone_flags, struct task_struct *tsk)
         if (!sig)
                 return -ENOMEM;
 
-        atomic_set(&sig->count, 1);
+        sig->nr_threads = 1;
         atomic_set(&sig->live, 1);
+        atomic_set(&sig->sigcnt, 1);
         init_waitqueue_head(&sig->wait_chldexit);
         if (clone_flags & CLONE_NEWPID)
                 sig->flags |= SIGNAL_UNKILLABLE;
@@ -889,13 +903,6 @@ static int copy_signal(unsigned long clone_flags, struct task_struct *tsk)
         return 0;
 }
 
-void __cleanup_signal(struct signal_struct *sig)
-{
-        thread_group_cputime_free(sig);
-        tty_kref_put(sig->tty);
-        kmem_cache_free(signal_cachep, sig);
-}
-
 static void copy_flags(unsigned long clone_flags, struct task_struct *p)
 {
         unsigned long new_flags = p->flags;
@@ -1245,8 +1252,9 @@ static struct task_struct *copy_process(unsigned long clone_flags,
         }
 
         if (clone_flags & CLONE_THREAD) {
-                atomic_inc(&current->signal->count);
+                current->signal->nr_threads++;
                 atomic_inc(&current->signal->live);
+                atomic_inc(&current->signal->sigcnt);
                 p->group_leader = current->group_leader;
                 list_add_tail_rcu(&p->thread_group, &p->group_leader->thread_group);
         }
@@ -1259,7 +1267,6 @@ static struct task_struct *copy_process(unsigned long clone_flags,
                                 p->nsproxy->pid_ns->child_reaper = p;
 
                         p->signal->leader_pid = pid;
-                        tty_kref_put(p->signal->tty);
                         p->signal->tty = tty_kref_get(current->signal->tty);
                         attach_pid(p, PIDTYPE_PGID, task_pgrp(current));
                         attach_pid(p, PIDTYPE_SID, task_session(current));
@@ -1292,7 +1299,7 @@ bad_fork_cleanup_mm:
                 mmput(p->mm);
 bad_fork_cleanup_signal:
         if (!(clone_flags & CLONE_THREAD))
-                __cleanup_signal(p->signal);
+                free_signal_struct(p->signal);
 bad_fork_cleanup_sighand:
         __cleanup_sighand(p->sighand);
 bad_fork_cleanup_fs:
@@ -1327,6 +1334,16 @@ noinline struct pt_regs * __cpuinit __attribute__((weak)) idle_regs(struct pt_re
         return regs;
 }
 
+static inline void init_idle_pids(struct pid_link *links)
+{
+        enum pid_type type;
+
+        for (type = PIDTYPE_PID; type < PIDTYPE_MAX; ++type) {
+                INIT_HLIST_NODE(&links[type].node); /* not really needed */
+                links[type].pid = &init_struct_pid;
+        }
+}
+
 struct task_struct * __cpuinit fork_idle(int cpu)
 {
         struct task_struct *task;
@@ -1334,8 +1351,10 @@ struct task_struct * __cpuinit fork_idle(int cpu)
 
         task = copy_process(CLONE_VM, 0, idle_regs(&regs), 0, NULL,
                             &init_struct_pid, 0);
-        if (!IS_ERR(task))
+        if (!IS_ERR(task)) {
+                init_idle_pids(task->pids);
                 init_idle(task, cpu);
+        }
 
         return task;
 }
@@ -1507,14 +1526,6 @@ static void check_unshare_flags(unsigned long *flags_ptr)
                 *flags_ptr |= CLONE_SIGHAND;
 
         /*
-         * If unsharing signal handlers and the task was created
-         * using CLONE_THREAD, then must unshare the thread
-         */
-        if ((*flags_ptr & CLONE_SIGHAND) &&
-            (atomic_read(&current->signal->count) > 1))
-                *flags_ptr |= CLONE_THREAD;
-
-        /*
          * If unsharing namespace, must also unshare filesystem information.
          */
         if (*flags_ptr & CLONE_NEWNS)
diff --git a/kernel/hrtimer.c b/kernel/hrtimer.c
index b9b134b35088..5c69e996bd0f 100644
--- a/kernel/hrtimer.c
+++ b/kernel/hrtimer.c
@@ -89,7 +89,7 @@ static void hrtimer_get_softirq_time(struct hrtimer_cpu_base *base)
 
         do {
                 seq = read_seqbegin(&xtime_lock);
-                xts = current_kernel_time();
+                xts = __current_kernel_time();
                 tom = wall_to_monotonic;
         } while (read_seqretry(&xtime_lock, seq));
 
diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
index 13aff293f4de..6f6d091b5757 100644
--- a/kernel/kallsyms.c
+++ b/kernel/kallsyms.c
@@ -16,6 +16,7 @@
 #include <linux/init.h>
 #include <linux/seq_file.h>
 #include <linux/fs.h>
+#include <linux/kdb.h>
 #include <linux/err.h>
 #include <linux/proc_fs.h>
 #include <linux/sched.h>        /* for cond_resched */
@@ -516,6 +517,26 @@ static int kallsyms_open(struct inode *inode, struct file *file)
         return ret;
 }
 
+#ifdef  CONFIG_KGDB_KDB
+const char *kdb_walk_kallsyms(loff_t *pos)
+{
+        static struct kallsym_iter kdb_walk_kallsyms_iter;
+        if (*pos == 0) {
+                memset(&kdb_walk_kallsyms_iter, 0,
+                       sizeof(kdb_walk_kallsyms_iter));
+                reset_iter(&kdb_walk_kallsyms_iter, 0);
+        }
+        while (1) {
+                if (!update_iter(&kdb_walk_kallsyms_iter, *pos))
+                        return NULL;
+                ++*pos;
+                /* Some debugging symbols have no name.  Ignore them. */
+                if (kdb_walk_kallsyms_iter.name[0])
+                        return kdb_walk_kallsyms_iter.name;
+        }
+}
+#endif  /* CONFIG_KGDB_KDB */
+
 static const struct file_operations kallsyms_operations = {
         .open = kallsyms_open,
         .read = seq_read,
diff --git a/kernel/kgdb.c b/kernel/kgdb.c
deleted file mode 100644
index 11f3515ca83f..000000000000
--- a/kernel/kgdb.c
+++ /dev/null
@@ -1,1764 +0,0 @@
-/*
- * KGDB stub.
- *
- * Maintainer: Jason Wessel <jason.wessel@windriver.com>
- *
- * Copyright (C) 2000-2001 VERITAS Software Corporation.
- * Copyright (C) 2002-2004 Timesys Corporation
- * Copyright (C) 2003-2004 Amit S. Kale <amitkale@linsyssoft.com>
- * Copyright (C) 2004 Pavel Machek <pavel@suse.cz>
- * Copyright (C) 2004-2006 Tom Rini <trini@kernel.crashing.org>
- * Copyright (C) 2004-2006 LinSysSoft Technologies Pvt. Ltd.
- * Copyright (C) 2005-2008 Wind River Systems, Inc.
- * Copyright (C) 2007 MontaVista Software, Inc.
- * Copyright (C) 2008 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
- *
- * Contributors at various stages not listed above:
- *  Jason Wessel ( jason.wessel@windriver.com )
- *  George Anzinger <george@mvista.com>
- *  Anurekh Saxena (anurekh.saxena@timesys.com)
- *  Lake Stevens Instrument Division (Glenn Engel)
- *  Jim Kingdon, Cygnus Support.
- *
- * Original KGDB stub: David Grothe <dave@gcom.com>,
- * Tigran Aivazian <tigran@sco.com>
- *
- * This file is licensed under the terms of the GNU General Public License
- * version 2. This program is licensed "as is" without any warranty of any
- * kind, whether express or implied.
- */
-#include <linux/pid_namespace.h>
-#include <linux/clocksource.h>
-#include <linux/interrupt.h>
-#include <linux/spinlock.h>
-#include <linux/console.h>
-#include <linux/threads.h>
-#include <linux/uaccess.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/ptrace.h>
-#include <linux/reboot.h>
-#include <linux/string.h>
-#include <linux/delay.h>
-#include <linux/sched.h>
-#include <linux/sysrq.h>
-#include <linux/init.h>
-#include <linux/kgdb.h>
-#include <linux/pid.h>
-#include <linux/smp.h>
-#include <linux/mm.h>
-
-#include <asm/cacheflush.h>
-#include <asm/byteorder.h>
-#include <asm/atomic.h>
-#include <asm/system.h>
-#include <asm/unaligned.h>
-
-static int kgdb_break_asap;
-
-#define KGDB_MAX_THREAD_QUERY 17
-struct kgdb_state {
-        int                     ex_vector;
-        int                     signo;
-        int                     err_code;
-        int                     cpu;
-        int                     pass_exception;
-        unsigned long           thr_query;
-        unsigned long           threadid;
-        long                    kgdb_usethreadid;
-        struct pt_regs          *linux_regs;
-};
-
-/* Exception state values */
-#define DCPU_WANT_MASTER 0x1 /* Waiting to become a master kgdb cpu */
-#define DCPU_NEXT_MASTER 0x2 /* Transition from one master cpu to another */
-#define DCPU_IS_SLAVE    0x4 /* Slave cpu enter exception */
-#define DCPU_SSTEP       0x8 /* CPU is single stepping */
-
-static struct debuggerinfo_struct {
-        void                    *debuggerinfo;
-        struct task_struct      *task;
-        int                     exception_state;
-} kgdb_info[NR_CPUS];
-
-/**
- * kgdb_connected - Is a host GDB connected to us?
- */
-int                             kgdb_connected;
-EXPORT_SYMBOL_GPL(kgdb_connected);
-
-/* All the KGDB handlers are installed */
-static int                      kgdb_io_module_registered;
-
-/* Guard for recursive entry */
-static int                      exception_level;
-
-static struct kgdb_io           *kgdb_io_ops;
-static DEFINE_SPINLOCK(kgdb_registration_lock);
-
-/* kgdb console driver is loaded */
-static int kgdb_con_registered;
-/* determine if kgdb console output should be used */
-static int kgdb_use_con;
-
-static int __init opt_kgdb_con(char *str)
-{
-        kgdb_use_con = 1;
-        return 0;
-}
-
-early_param("kgdbcon", opt_kgdb_con);
-
-module_param(kgdb_use_con, int, 0644);
-
-/*
- * Holds information about breakpoints in a kernel. These breakpoints are
- * added and removed by gdb.
- */
-static struct kgdb_bkpt         kgdb_break[KGDB_MAX_BREAKPOINTS] = {
-        [0 ... KGDB_MAX_BREAKPOINTS-1] = { .state = BP_UNDEFINED }
-};
-
-/*
- * The CPU# of the active CPU, or -1 if none:
- */
-atomic_t                        kgdb_active = ATOMIC_INIT(-1);
-
-/*
- * We use NR_CPUs not PERCPU, in case kgdb is used to debug early
- * bootup code (which might not have percpu set up yet):
- */
-static atomic_t                 passive_cpu_wait[NR_CPUS];
-static atomic_t                 cpu_in_kgdb[NR_CPUS];
-atomic_t                        kgdb_setting_breakpoint;
-
-struct task_struct              *kgdb_usethread;
-struct task_struct              *kgdb_contthread;
-
-int                             kgdb_single_step;
-pid_t                           kgdb_sstep_pid;
-
-/* Our I/O buffers. */
-static char                     remcom_in_buffer[BUFMAX];
-static char                     remcom_out_buffer[BUFMAX];
-
-/* Storage for the registers, in GDB format. */
-static unsigned long            gdb_regs[(NUMREGBYTES +
-                                        sizeof(unsigned long) - 1) /
-                                        sizeof(unsigned long)];
-
-/* to keep track of the CPU which is doing the single stepping*/
-atomic_t                        kgdb_cpu_doing_single_step = ATOMIC_INIT(-1);
-
-/*
- * If you are debugging a problem where roundup (the collection of
- * all other CPUs) is a problem [this should be extremely rare],
- * then use the nokgdbroundup option to avoid roundup. In that case
- * the other CPUs might interfere with your debugging context, so
- * use this with care:
- */
-static int kgdb_do_roundup = 1;
-
-static int __init opt_nokgdbroundup(char *str)
-{
-        kgdb_do_roundup = 0;
-
-        return 0;
-}
-
-early_param("nokgdbroundup", opt_nokgdbroundup);
-
-/*
- * Finally, some KGDB code :-)
- */
-
-/*
- * Weak aliases for breakpoint management,
- * can be overriden by architectures when needed:
- */
-int __weak kgdb_arch_set_breakpoint(unsigned long addr, char *saved_instr)
-{
-        int err;
-
-        err = probe_kernel_read(saved_instr, (char *)addr, BREAK_INSTR_SIZE);
-        if (err)
-                return err;
-
-        return probe_kernel_write((char *)addr, arch_kgdb_ops.gdb_bpt_instr,
-                                  BREAK_INSTR_SIZE);
-}
-
-int __weak kgdb_arch_remove_breakpoint(unsigned long addr, char *bundle)
-{
-        return probe_kernel_write((char *)addr,
-                                  (char *)bundle, BREAK_INSTR_SIZE);
-}
-
-int __weak kgdb_validate_break_address(unsigned long addr)
-{
-        char tmp_variable[BREAK_INSTR_SIZE];
-        int err;
-        /* Validate setting the breakpoint and then removing it.  In the
-         * remove fails, the kernel needs to emit a bad message because we
-         * are deep trouble not being able to put things back the way we
-         * found them.
-         */
-        err = kgdb_arch_set_breakpoint(addr, tmp_variable);
-        if (err)
-                return err;
-        err = kgdb_arch_remove_breakpoint(addr, tmp_variable);
-        if (err)
-                printk(KERN_ERR "KGDB: Critical breakpoint error, kernel "
-                   "memory destroyed at: %lx", addr);
-        return err;
-}
-
-unsigned long __weak kgdb_arch_pc(int exception, struct pt_regs *regs)
-{
-        return instruction_pointer(regs);
-}
-
-int __weak kgdb_arch_init(void)
-{
-        return 0;
-}
-
-int __weak kgdb_skipexception(int exception, struct pt_regs *regs)
-{
-        return 0;
-}
-
-void __weak
-kgdb_post_primary_code(struct pt_regs *regs, int e_vector, int err_code)
-{
-        return;
-}
-
-/**
- *      kgdb_disable_hw_debug - Disable hardware debugging while we in kgdb.
- *      @regs: Current &struct pt_regs.
- *
- *      This function will be called if the particular architecture must
- *      disable hardware debugging while it is processing gdb packets or
- *      handling exception.
- */
-void __weak kgdb_disable_hw_debug(struct pt_regs *regs)
-{
-}
-
-/*
- * GDB remote protocol parser:
- */
-
-static int hex(char ch)
-{
-        if ((ch >= 'a') && (ch <= 'f'))
-                return ch - 'a' + 10;
-        if ((ch >= '0') && (ch <= '9'))
-                return ch - '0';
-        if ((ch >= 'A') && (ch <= 'F'))
-                return ch - 'A' + 10;
-        return -1;
-}
-
-/* scan for the sequence $<data>#<checksum> */
-static void get_packet(char *buffer)
-{
-        unsigned char checksum;
-        unsigned char xmitcsum;
-        int count;
-        char ch;
-
-        do {
-                /*
-                 * Spin and wait around for the start character, ignore all
-                 * other characters:
-                 */
-                while ((ch = (kgdb_io_ops->read_char())) != '$')
-                        /* nothing */;
-
-                kgdb_connected = 1;
-                checksum = 0;
-                xmitcsum = -1;
-
-                count = 0;
-
-                /*
-                 * now, read until a # or end of buffer is found:
-                 */
-                while (count < (BUFMAX - 1)) {
-                        ch = kgdb_io_ops->read_char();
-                        if (ch == '#')
-                                break;
-                        checksum = checksum + ch;
-                        buffer[count] = ch;
-                        count = count + 1;
-                }
-                buffer[count] = 0;
-
-                if (ch == '#') {
-                        xmitcsum = hex(kgdb_io_ops->read_char()) << 4;
-                        xmitcsum += hex(kgdb_io_ops->read_char());
-
-                        if (checksum != xmitcsum)
-                                /* failed checksum */
-                                kgdb_io_ops->write_char('-');
-                        else
-                                /* successful transfer */
-                                kgdb_io_ops->write_char('+');
-                        if (kgdb_io_ops->flush)
-                                kgdb_io_ops->flush();
-                }
-        } while (checksum != xmitcsum);
-}
-
-/*
- * Send the packet in buffer.
- * Check for gdb connection if asked for.
- */
-static void put_packet(char *buffer)
-{
-        unsigned char checksum;
-        int count;
-        char ch;
-
-        /*
-         * $<packet info>#<checksum>.
-         */
-        while (1) {
-                kgdb_io_ops->write_char('$');
-                checksum = 0;
-                count = 0;
-
-                while ((ch = buffer[count])) {
-                        kgdb_io_ops->write_char(ch);
-                        checksum += ch;
-                        count++;
-                }
-
-                kgdb_io_ops->write_char('#');
-                kgdb_io_ops->write_char(hex_asc_hi(checksum));
-                kgdb_io_ops->write_char(hex_asc_lo(checksum));
-                if (kgdb_io_ops->flush)
-                        kgdb_io_ops->flush();
-
-                /* Now see what we get in reply. */
-                ch = kgdb_io_ops->read_char();
-
-                if (ch == 3)
-                        ch = kgdb_io_ops->read_char();
-
-                /* If we get an ACK, we are done. */
-                if (ch == '+')
-                        return;
-
-                /*
-                 * If we get the start of another packet, this means
-                 * that GDB is attempting to reconnect.  We will NAK
-                 * the packet being sent, and stop trying to send this
-                 * packet.
-                 */
-                if (ch == '$') {
-                        kgdb_io_ops->write_char('-');
-                        if (kgdb_io_ops->flush)
-                                kgdb_io_ops->flush();
-                        return;
-                }
-        }
-}
-
-/*
- * Convert the memory pointed to by mem into hex, placing result in buf.
- * Return a pointer to the last char put in buf (null). May return an error.
- */
-int kgdb_mem2hex(char *mem, char *buf, int count)
-{
-        char *tmp;
-        int err;
-
-        /*
-         * We use the upper half of buf as an intermediate buffer for the
-         * raw memory copy.  Hex conversion will work against this one.
-         */
-        tmp = buf + count;
-
-        err = probe_kernel_read(tmp, mem, count);
-        if (!err) {
-                while (count > 0) {
-                        buf = pack_hex_byte(buf, *tmp);
-                        tmp++;
-                        count--;
-                }
-
-                *buf = 0;
-        }
-
-        return err;
-}
-
-/*
- * Copy the binary array pointed to by buf into mem.  Fix $, #, and
- * 0x7d escaped with 0x7d. Return -EFAULT on failure or 0 on success.
- * The input buf is overwitten with the result to write to mem.
- */
-static int kgdb_ebin2mem(char *buf, char *mem, int count)
-{
-        int size = 0;
-        char *c = buf;
-
-        while (count-- > 0) {
-                c[size] = *buf++;
-                if (c[size] == 0x7d)
-                        c[size] = *buf++ ^ 0x20;
-                size++;
-        }
-
-        return probe_kernel_write(mem, c, size);
-}
-
-/*
- * Convert the hex array pointed to by buf into binary to be placed in mem.
- * Return a pointer to the character AFTER the last byte written.
- * May return an error.
- */
-int kgdb_hex2mem(char *buf, char *mem, int count)
-{
-        char *tmp_raw;
-        char *tmp_hex;
-
-        /*
-         * We use the upper half of buf as an intermediate buffer for the
-         * raw memory that is converted from hex.
-         */
-        tmp_raw = buf + count * 2;
-
-        tmp_hex = tmp_raw - 1;
-        while (tmp_hex >= buf) {
-                tmp_raw--;
-                *tmp_raw = hex(*tmp_hex--);
-                *tmp_raw |= hex(*tmp_hex--) << 4;
-        }
-
-        return probe_kernel_write(mem, tmp_raw, count);
-}
-
-/*
- * While we find nice hex chars, build a long_val.
- * Return number of chars processed.
- */
-int kgdb_hex2long(char **ptr, unsigned long *long_val)
-{
-        int hex_val;
-        int num = 0;
-        int negate = 0;
-
-        *long_val = 0;
-
-        if (**ptr == '-') {
-                negate = 1;
-                (*ptr)++;
-        }
-        while (**ptr) {
-                hex_val = hex(**ptr);
-                if (hex_val < 0)
-                        break;
-
-                *long_val = (*long_val << 4) | hex_val;
-                num++;
-                (*ptr)++;
-        }
-
-        if (negate)
-                *long_val = -*long_val;
-
-        return num;
-}
-
-/* Write memory due to an 'M' or 'X' packet. */
-static int write_mem_msg(int binary)
-{
-        char *ptr = &remcom_in_buffer[1];
-        unsigned long addr;
-        unsigned long length;
-        int err;
-
-        if (kgdb_hex2long(&ptr, &addr) > 0 && *(ptr++) == ',' &&
-            kgdb_hex2long(&ptr, &length) > 0 && *(ptr++) == ':') {
-                if (binary)
-                        err = kgdb_ebin2mem(ptr, (char *)addr, length);
-                else
-                        err = kgdb_hex2mem(ptr, (char *)addr, length);
-                if (err)
-                        return err;
-                if (CACHE_FLUSH_IS_SAFE)
-                        flush_icache_range(addr, addr + length);
-                return 0;
-        }
-
-        return -EINVAL;
-}
-
-static void error_packet(char *pkt, int error)
-{
-        error = -error;
-        pkt[0] = 'E';
-        pkt[1] = hex_asc[(error / 10)];
-        pkt[2] = hex_asc[(error % 10)];
-        pkt[3] = '\0';
-}
-
-/*
- * Thread ID accessors. We represent a flat TID space to GDB, where
- * the per CPU idle threads (which under Linux all have PID 0) are
- * remapped to negative TIDs.
- */
-
-#define BUF_THREAD_ID_SIZE      16
-
-static char *pack_threadid(char *pkt, unsigned char *id)
-{
-        char *limit;
-
-        limit = pkt + BUF_THREAD_ID_SIZE;
-        while (pkt < limit)
-                pkt = pack_hex_byte(pkt, *id++);
-
-        return pkt;
-}
-
-static void int_to_threadref(unsigned char *id, int value)
-{
-        unsigned char *scan;
-        int i = 4;
-
-        scan = (unsigned char *)id;
-        while (i--)
-                *scan++ = 0;
-        put_unaligned_be32(value, scan);
-}
-
-static struct task_struct *getthread(struct pt_regs *regs, int tid)
-{
-        /*
-         * Non-positive TIDs are remapped to the cpu shadow information
-         */
-        if (tid == 0 || tid == -1)
-                tid = -atomic_read(&kgdb_active) - 2;
-        if (tid < -1 && tid > -NR_CPUS - 2) {
-                if (kgdb_info[-tid - 2].task)
-                        return kgdb_info[-tid - 2].task;
-                else
-                        return idle_task(-tid - 2);
-        }
-        if (tid <= 0) {
-                printk(KERN_ERR "KGDB: Internal thread select error\n");
-                dump_stack();
-                return NULL;
-        }
-
-        /*
-         * find_task_by_pid_ns() does not take the tasklist lock anymore
-         * but is nicely RCU locked - hence is a pretty resilient
-         * thing to use:
-         */
-        return find_task_by_pid_ns(tid, &init_pid_ns);
-}
-
-/*
- * Some architectures need cache flushes when we set/clear a
- * breakpoint:
- */
-static void kgdb_flush_swbreak_addr(unsigned long addr)
-{
-        if (!CACHE_FLUSH_IS_SAFE)
-                return;
-
-        if (current->mm && current->mm->mmap_cache) {
-                flush_cache_range(current->mm->mmap_cache,
-                                  addr, addr + BREAK_INSTR_SIZE);
-        }
-        /* Force flush instruction cache if it was outside the mm */
-        flush_icache_range(addr, addr + BREAK_INSTR_SIZE);
-}
-
-/*
- * SW breakpoint management:
- */
-static int kgdb_activate_sw_breakpoints(void)
-{
-        unsigned long addr;
-        int error;
-        int ret = 0;
-        int i;
-
-        for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
-                if (kgdb_break[i].state != BP_SET)
-                        continue;
-
-                addr = kgdb_break[i].bpt_addr;
-                error = kgdb_arch_set_breakpoint(addr,
-                                kgdb_break[i].saved_instr);
-                if (error) {
-                        ret = error;
-                        printk(KERN_INFO "KGDB: BP install failed: %lx", addr);
-                        continue;
-                }
-
-                kgdb_flush_swbreak_addr(addr);
-                kgdb_break[i].state = BP_ACTIVE;
-        }
-        return ret;
-}
-
-static int kgdb_set_sw_break(unsigned long addr)
-{
-        int err = kgdb_validate_break_address(addr);
-        int breakno = -1;
-        int i;
-
-        if (err)
-                return err;
-
-        for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
-                if ((kgdb_break[i].state == BP_SET) &&
-                                        (kgdb_break[i].bpt_addr == addr))
-                        return -EEXIST;
-        }
-        for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
-                if (kgdb_break[i].state == BP_REMOVED &&
-                                        kgdb_break[i].bpt_addr == addr) {
-                        breakno = i;
-                        break;
-                }
-        }
-
-        if (breakno == -1) {
-                for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
-                        if (kgdb_break[i].state == BP_UNDEFINED) {
-                                breakno = i;
-                                break;
-                        }
-                }
-        }
-
-        if (breakno == -1)
-                return -E2BIG;
-
-        kgdb_break[breakno].state = BP_SET;
-        kgdb_break[breakno].type = BP_BREAKPOINT;
-        kgdb_break[breakno].bpt_addr = addr;
-
-        return 0;
-}
-
-static int kgdb_deactivate_sw_breakpoints(void)
-{
-        unsigned long addr;
-        int error;
-        int ret = 0;
-        int i;
-
-        for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
-                if (kgdb_break[i].state != BP_ACTIVE)
-                        continue;
-                addr = kgdb_break[i].bpt_addr;
-                error = kgdb_arch_remove_breakpoint(addr,
-                                        kgdb_break[i].saved_instr);
-                if (error) {
-                        printk(KERN_INFO "KGDB: BP remove failed: %lx\n", addr);
-                        ret = error;
-                }
-
-                kgdb_flush_swbreak_addr(addr);
-                kgdb_break[i].state = BP_SET;
-        }
-        return ret;
-}
-
-static int kgdb_remove_sw_break(unsigned long addr)
-{
-        int i;
-
-        for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
-                if ((kgdb_break[i].state == BP_SET) &&
-                                (kgdb_break[i].bpt_addr == addr)) {
-                        kgdb_break[i].state = BP_REMOVED;
-                        return 0;
-                }
-        }
-        return -ENOENT;
-}
-
-int kgdb_isremovedbreak(unsigned long addr)
-{
-        int i;
-
-        for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
-                if ((kgdb_break[i].state == BP_REMOVED) &&
-                                        (kgdb_break[i].bpt_addr == addr))
-                        return 1;
-        }
-        return 0;
-}
-
-static int remove_all_break(void)
-{
-        unsigned long addr;
-        int error;
-        int i;
-
-        /* Clear memory breakpoints. */
-        for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
-                if (kgdb_break[i].state != BP_ACTIVE)
-                        goto setundefined;
-                addr = kgdb_break[i].bpt_addr;
-                error = kgdb_arch_remove_breakpoint(addr,
-                                kgdb_break[i].saved_instr);
-                if (error)
-                        printk(KERN_ERR "KGDB: breakpoint remove failed: %lx\n",
-                           addr);
-setundefined:
-                kgdb_break[i].state = BP_UNDEFINED;
-        }
-
-        /* Clear hardware breakpoints. */
-        if (arch_kgdb_ops.remove_all_hw_break)
-                arch_kgdb_ops.remove_all_hw_break();
-
-        return 0;
-}
-
-/*
- * Remap normal tasks to their real PID,
- * CPU shadow threads are mapped to -CPU - 2
- */
-static inline int shadow_pid(int realpid)
-{
-        if (realpid)
-                return realpid;
-
-        return -raw_smp_processor_id() - 2;
-}
-
-static char gdbmsgbuf[BUFMAX + 1];
-
-static void kgdb_msg_write(const char *s, int len)
-{
-        char *bufptr;
-        int wcount;
-        int i;
-
-        /* 'O'utput */
-        gdbmsgbuf[0] = 'O';
-
-        /* Fill and send buffers... */
-        while (len > 0) {
-                bufptr = gdbmsgbuf + 1;
-
-                /* Calculate how many this time */
-                if ((len << 1) > (BUFMAX - 2))
-                        wcount = (BUFMAX - 2) >> 1;
-                else
-                        wcount = len;
-
-                /* Pack in hex chars */
-                for (i = 0; i < wcount; i++)
-                        bufptr = pack_hex_byte(bufptr, s[i]);
-                *bufptr = '\0';
-
-                /* Move up */
-                s += wcount;
-                len -= wcount;
-
-                /* Write packet */
-                put_packet(gdbmsgbuf);
-        }
-}
-
-/*
- * Return true if there is a valid kgdb I/O module.  Also if no
- * debugger is attached a message can be printed to the console about
- * waiting for the debugger to attach.
- *
- * The print_wait argument is only to be true when called from inside
- * the core kgdb_handle_exception, because it will wait for the
- * debugger to attach.
- */
-static int kgdb_io_ready(int print_wait)
-{
-        if (!kgdb_io_ops)
-                return 0;
-        if (kgdb_connected)
-                return 1;
-        if (atomic_read(&kgdb_setting_breakpoint))
-                return 1;
-        if (print_wait)
-                printk(KERN_CRIT "KGDB: Waiting for remote debugger\n");
-        return 1;
-}
-
-/*
- * All the functions that start with gdb_cmd are the various
- * operations to implement the handlers for the gdbserial protocol
- * where KGDB is communicating with an external debugger
- */
-
-/* Handle the '?' status packets */
-static void gdb_cmd_status(struct kgdb_state *ks)
-{
-        /*
-         * We know that this packet is only sent
-         * during initial connect.  So to be safe,
-         * we clear out our breakpoints now in case
-         * GDB is reconnecting.
-         */
-        remove_all_break();
-
-        remcom_out_buffer[0] = 'S';
-        pack_hex_byte(&remcom_out_buffer[1], ks->signo);
-}
-
-/* Handle the 'g' get registers request */
-static void gdb_cmd_getregs(struct kgdb_state *ks)
-{
-        struct task_struct *thread;
-        void *local_debuggerinfo;
-        int i;
-
-        thread = kgdb_usethread;
-        if (!thread) {
-                thread = kgdb_info[ks->cpu].task;
-                local_debuggerinfo = kgdb_info[ks->cpu].debuggerinfo;
-        } else {
-                local_debuggerinfo = NULL;
-                for_each_online_cpu(i) {
-                        /*
-                         * Try to find the task on some other
-                         * or possibly this node if we do not
-                         * find the matching task then we try
-                         * to approximate the results.
-                         */
-                        if (thread == kgdb_info[i].task)
-                                local_debuggerinfo = kgdb_info[i].debuggerinfo;
-                }
-        }
-
-        /*
-         * All threads that don't have debuggerinfo should be
-         * in schedule() sleeping, since all other CPUs
-         * are in kgdb_wait, and thus have debuggerinfo.
-         */
-        if (local_debuggerinfo) {
-                pt_regs_to_gdb_regs(gdb_regs, local_debuggerinfo);
-        } else {
-                /*
-                 * Pull stuff saved during switch_to; nothing
-                 * else is accessible (or even particularly
-                 * relevant).
-                 *
-                 * This should be enough for a stack trace.
-                 */
-                sleeping_thread_to_gdb_regs(gdb_regs, thread);
-        }
-        kgdb_mem2hex((char *)gdb_regs, remcom_out_buffer, NUMREGBYTES);
-}
-
-/* Handle the 'G' set registers request */
-static void gdb_cmd_setregs(struct kgdb_state *ks)
-{
-        kgdb_hex2mem(&remcom_in_buffer[1], (char *)gdb_regs, NUMREGBYTES);
-
-        if (kgdb_usethread && kgdb_usethread != current) {
-                error_packet(remcom_out_buffer, -EINVAL);
-        } else {
-                gdb_regs_to_pt_regs(gdb_regs, ks->linux_regs);
-                strcpy(remcom_out_buffer, "OK");
-        }
-}
-
-/* Handle the 'm' memory read bytes */
-static void gdb_cmd_memread(struct kgdb_state *ks)
-{
-        char *ptr = &remcom_in_buffer[1];
-        unsigned long length;
-        unsigned long addr;
-        int err;
-
-        if (kgdb_hex2long(&ptr, &addr) > 0 && *ptr++ == ',' &&
-                                        kgdb_hex2long(&ptr, &length) > 0) {
-                err = kgdb_mem2hex((char *)addr, remcom_out_buffer, length);
-                if (err)
-                        error_packet(remcom_out_buffer, err);
-        } else {
-                error_packet(remcom_out_buffer, -EINVAL);
-        }
-}
-
-/* Handle the 'M' memory write bytes */
-static void gdb_cmd_memwrite(struct kgdb_state *ks)
-{
-        int err = write_mem_msg(0);
-
-        if (err)
-                error_packet(remcom_out_buffer, err);
-        else
-                strcpy(remcom_out_buffer, "OK");
-}
-
-/* Handle the 'X' memory binary write bytes */
-static void gdb_cmd_binwrite(struct kgdb_state *ks)
-{
-        int err = write_mem_msg(1);
-
-        if (err)
-                error_packet(remcom_out_buffer, err);
-        else
-                strcpy(remcom_out_buffer, "OK");
-}
-
-/* Handle the 'D' or 'k', detach or kill packets */
-static void gdb_cmd_detachkill(struct kgdb_state *ks)
-{
-        int error;
-
-        /* The detach case */
-        if (remcom_in_buffer[0] == 'D') {
-                error = remove_all_break();
-                if (error < 0) {
-                        error_packet(remcom_out_buffer, error);
-                } else {
-                        strcpy(remcom_out_buffer, "OK");
-                        kgdb_connected = 0;
-                }
-                put_packet(remcom_out_buffer);
-        } else {
-                /*
-                 * Assume the kill case, with no exit code checking,
-                 * trying to force detach the debugger:
-                 */
-                remove_all_break();
-                kgdb_connected = 0;
-        }
-}
-
-/* Handle the 'R' reboot packets */
-static int gdb_cmd_reboot(struct kgdb_state *ks)
-{
-        /* For now, only honor R0 */
-        if (strcmp(remcom_in_buffer, "R0") == 0) {
-                printk(KERN_CRIT "Executing emergency reboot\n");
-                strcpy(remcom_out_buffer, "OK");
-                put_packet(remcom_out_buffer);
-
-                /*
-                 * Execution should not return from
-                 * machine_emergency_restart()
-                 */
-                machine_emergency_restart();
-                kgdb_connected = 0;
-
-                return 1;
-        }
-        return 0;
-}
-
-/* Handle the 'q' query packets */
-static void gdb_cmd_query(struct kgdb_state *ks)
-{
-        struct task_struct *g;
-        struct task_struct *p;
-        unsigned char thref[8];
-        char *ptr;
-        int i;
-        int cpu;
-        int finished = 0;
-
-        switch (remcom_in_buffer[1]) {
-        case 's':
-        case 'f':
-                if (memcmp(remcom_in_buffer + 2, "ThreadInfo", 10)) {
-                        error_packet(remcom_out_buffer, -EINVAL);
-                        break;
-                }
-
-                i = 0;
-                remcom_out_buffer[0] = 'm';
-                ptr = remcom_out_buffer + 1;
-                if (remcom_in_buffer[1] == 'f') {
-                        /* Each cpu is a shadow thread */
-                        for_each_online_cpu(cpu) {
-                                ks->thr_query = 0;
-                                int_to_threadref(thref, -cpu - 2);
-                                pack_threadid(ptr, thref);
-                                ptr += BUF_THREAD_ID_SIZE;
-                                *(ptr++) = ',';
-                                i++;
-                        }
-                }
-
-                do_each_thread(g, p) {
-                        if (i >= ks->thr_query && !finished) {
-                                int_to_threadref(thref, p->pid);
-                                pack_threadid(ptr, thref);
-                                ptr += BUF_THREAD_ID_SIZE;
-                                *(ptr++) = ',';
-                                ks->thr_query++;
-                                if (ks->thr_query % KGDB_MAX_THREAD_QUERY == 0)
-                                        finished = 1;
-                        }
-                        i++;
-                } while_each_thread(g, p);
-
-                *(--ptr) = '\0';
-                break;
-
-        case 'C':
-                /* Current thread id */
-                strcpy(remcom_out_buffer, "QC");
-                ks->threadid = shadow_pid(current->pid);
-                int_to_threadref(thref, ks->threadid);
-                pack_threadid(remcom_out_buffer + 2, thref);
-                break;
-        case 'T':
-                if (memcmp(remcom_in_buffer + 1, "ThreadExtraInfo,", 16)) {
-                        error_packet(remcom_out_buffer, -EINVAL);
-                        break;
-                }
-                ks->threadid = 0;
-                ptr = remcom_in_buffer + 17;
-                kgdb_hex2long(&ptr, &ks->threadid);
-                if (!getthread(ks->linux_regs, ks->threadid)) {
-                        error_packet(remcom_out_buffer, -EINVAL);
-                        break;
-                }
-                if ((int)ks->threadid > 0) {
-                        kgdb_mem2hex(getthread(ks->linux_regs,
-                                        ks->threadid)->comm,
-                                        remcom_out_buffer, 16);
-                } else {
-                        static char tmpstr[23 + BUF_THREAD_ID_SIZE];
-
-                        sprintf(tmpstr, "shadowCPU%d",
-                                        (int)(-ks->threadid - 2));
-                        kgdb_mem2hex(tmpstr, remcom_out_buffer, strlen(tmpstr));
-                }
-                break;
-        }
-}
-
-/* Handle the 'H' task query packets */
-static void gdb_cmd_task(struct kgdb_state *ks)
-{
-        struct task_struct *thread;
-        char *ptr;
-
-        switch (remcom_in_buffer[1]) {
-        case 'g':
-                ptr = &remcom_in_buffer[2];
-                kgdb_hex2long(&ptr, &ks->threadid);
-                thread = getthread(ks->linux_regs, ks->threadid);
-                if (!thread && ks->threadid > 0) {
-                        error_packet(remcom_out_buffer, -EINVAL);
-                        break;
-                }
-                kgdb_usethread = thread;
-                ks->kgdb_usethreadid = ks->threadid;
-                strcpy(remcom_out_buffer, "OK");
-                break;
-        case 'c':
-                ptr = &remcom_in_buffer[2];
-                kgdb_hex2long(&ptr, &ks->threadid);
-                if (!ks->threadid) {
-                        kgdb_contthread = NULL;
-                } else {
-                        thread = getthread(ks->linux_regs, ks->threadid);
-                        if (!thread && ks->threadid > 0) {
-                                error_packet(remcom_out_buffer, -EINVAL);
-                                break;
-                        }
-                        kgdb_contthread = thread;
-                }
-                strcpy(remcom_out_buffer, "OK");
-                break;
-        }
-}
-
-/* Handle the 'T' thread query packets */
-static void gdb_cmd_thread(struct kgdb_state *ks)
-{
-        char *ptr = &remcom_in_buffer[1];
-        struct task_struct *thread;
-
-        kgdb_hex2long(&ptr, &ks->threadid);
-        thread = getthread(ks->linux_regs, ks->threadid);
-        if (thread)
-                strcpy(remcom_out_buffer, "OK");
-        else
-                error_packet(remcom_out_buffer, -EINVAL);
-}
-
-/* Handle the 'z' or 'Z' breakpoint remove or set packets */
-static void gdb_cmd_break(struct kgdb_state *ks)
-{
-        /*
-         * Since GDB-5.3, it's been drafted that '0' is a software
-         * breakpoint, '1' is a hardware breakpoint, so let's do that.
-         */
-        char *bpt_type = &remcom_in_buffer[1];
-        char *ptr = &remcom_in_buffer[2];
-        unsigned long addr;
-        unsigned long length;
-        int error = 0;
-
-        if (arch_kgdb_ops.set_hw_breakpoint && *bpt_type >= '1') {
-                /* Unsupported */
-                if (*bpt_type > '4')
-                        return;
-        } else {
-                if (*bpt_type != '0' && *bpt_type != '1')
-                        /* Unsupported. */
-                        return;
-        }
-
-        /*
-         * Test if this is a hardware breakpoint, and
-         * if we support it:
-         */
-        if (*bpt_type == '1' && !(arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT))
-                /* Unsupported. */
-                return;
-
-        if (*(ptr++) != ',') {
-                error_packet(remcom_out_buffer, -EINVAL);
-                return;
-        }
-        if (!kgdb_hex2long(&ptr, &addr)) {
-                error_packet(remcom_out_buffer, -EINVAL);
-                return;
-        }
-        if (*(ptr++) != ',' ||
-                !kgdb_hex2long(&ptr, &length)) {
-                error_packet(remcom_out_buffer, -EINVAL);
-                return;
-        }
-
-        if (remcom_in_buffer[0] == 'Z' && *bpt_type == '0')
-                error = kgdb_set_sw_break(addr);
-        else if (remcom_in_buffer[0] == 'z' && *bpt_type == '0')
-                error = kgdb_remove_sw_break(addr);
-        else if (remcom_in_buffer[0] == 'Z')
-                error = arch_kgdb_ops.set_hw_breakpoint(addr,
-                        (int)length, *bpt_type - '0');
-        else if (remcom_in_buffer[0] == 'z')
-                error = arch_kgdb_ops.remove_hw_breakpoint(addr,
-                        (int) length, *bpt_type - '0');
-
-        if (error == 0)
-                strcpy(remcom_out_buffer, "OK");
-        else
-                error_packet(remcom_out_buffer, error);
-}
-
-/* Handle the 'C' signal / exception passing packets */
-static int gdb_cmd_exception_pass(struct kgdb_state *ks)
-{
-        /* C09 == pass exception
-         * C15 == detach kgdb, pass exception
-         */
-        if (remcom_in_buffer[1] == '0' && remcom_in_buffer[2] == '9') {
-
-                ks->pass_exception = 1;
-                remcom_in_buffer[0] = 'c';
-
-        } else if (remcom_in_buffer[1] == '1' && remcom_in_buffer[2] == '5') {
-
-                ks->pass_exception = 1;
-                remcom_in_buffer[0] = 'D';
-                remove_all_break();
-                kgdb_connected = 0;
-                return 1;
-
-        } else {
-                kgdb_msg_write("KGDB only knows signal 9 (pass)"
-                        " and 15 (pass and disconnect)\n"
-                        "Executing a continue without signal passing\n", 0);
-                remcom_in_buffer[0] = 'c';
-        }
-
-        /* Indicate fall through */
-        return -1;
-}
-
-/*
- * This function performs all gdbserial command procesing
- */
-static int gdb_serial_stub(struct kgdb_state *ks)
-{
-        int error = 0;
-        int tmp;
-
-        /* Clear the out buffer. */
-        memset(remcom_out_buffer, 0, sizeof(remcom_out_buffer));
-
-        if (kgdb_connected) {
-                unsigned char thref[8];
-                char *ptr;
-
-                /* Reply to host that an exception has occurred */
-                ptr = remcom_out_buffer;
-                *ptr++ = 'T';
-                ptr = pack_hex_byte(ptr, ks->signo);
-                ptr += strlen(strcpy(ptr, "thread:"));
-                int_to_threadref(thref, shadow_pid(current->pid));
-                ptr = pack_threadid(ptr, thref);
-                *ptr++ = ';';
-                put_packet(remcom_out_buffer);
-        }
-
-        kgdb_usethread = kgdb_info[ks->cpu].task;
-        ks->kgdb_usethreadid = shadow_pid(kgdb_info[ks->cpu].task->pid);
-        ks->pass_exception = 0;
-
-        while (1) {
-                error = 0;
-
-                /* Clear the out buffer. */
-                memset(remcom_out_buffer, 0, sizeof(remcom_out_buffer));
-
-                get_packet(remcom_in_buffer);
-
-                switch (remcom_in_buffer[0]) {
-                case '?': /* gdbserial status */
-                        gdb_cmd_status(ks);
-                        break;
-                case 'g': /* return the value of the CPU registers */
-                        gdb_cmd_getregs(ks);
-                        break;
-                case 'G': /* set the value of the CPU registers - return OK */
-                        gdb_cmd_setregs(ks);
-                        break;
-                case 'm': /* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
-                        gdb_cmd_memread(ks);
-                        break;
-                case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA..AA */
-                        gdb_cmd_memwrite(ks);
-                        break;
-                case 'X': /* XAA..AA,LLLL: Write LLLL bytes at address AA..AA */
-                        gdb_cmd_binwrite(ks);
-                        break;
-                        /* kill or detach. KGDB should treat this like a
-                         * continue.
-                         */
-                case 'D': /* Debugger detach */
-                case 'k': /* Debugger detach via kill */
-                        gdb_cmd_detachkill(ks);
-                        goto default_handle;
-                case 'R': /* Reboot */
-                        if (gdb_cmd_reboot(ks))
-                                goto default_handle;
-                        break;
-                case 'q': /* query command */
-                        gdb_cmd_query(ks);
-                        break;
-                case 'H': /* task related */
-                        gdb_cmd_task(ks);
-                        break;
-                case 'T': /* Query thread status */
-                        gdb_cmd_thread(ks);
-                        break;
-                case 'z': /* Break point remove */
-                case 'Z': /* Break point set */
-                        gdb_cmd_break(ks);
-                        break;
-                case 'C': /* Exception passing */
-                        tmp = gdb_cmd_exception_pass(ks);
-                        if (tmp > 0)
-                                goto default_handle;
-                        if (tmp == 0)
-                                break;
-                        /* Fall through on tmp < 0 */
-                case 'c': /* Continue packet */
-                case 's': /* Single step packet */
-                        if (kgdb_contthread && kgdb_contthread != current) {
-                                /* Can't switch threads in kgdb */
-                                error_packet(remcom_out_buffer, -EINVAL);
-                                break;
-                        }
-                        kgdb_activate_sw_breakpoints();
-                        /* Fall through to default processing */
-                default:
-default_handle:
-                        error = kgdb_arch_handle_exception(ks->ex_vector,
-                                                ks->signo,
-                                                ks->err_code,
-                                                remcom_in_buffer,
-                                                remcom_out_buffer,
-                                                ks->linux_regs);
-                        /*
-                         * Leave cmd processing on error, detach,
-                         * kill, continue, or single step.
-                         */
-                        if (error >= 0 || remcom_in_buffer[0] == 'D' ||
-                            remcom_in_buffer[0] == 'k') {
-                                error = 0;
-                                goto kgdb_exit;
-                        }
-
-                }
-
-                /* reply to the request */
-                put_packet(remcom_out_buffer);
-        }
-
-kgdb_exit:
-        if (ks->pass_exception)
-                error = 1;
-        return error;
-}
-
-static int kgdb_reenter_check(struct kgdb_state *ks)
-{
-        unsigned long addr;
-
-        if (atomic_read(&kgdb_active) != raw_smp_processor_id())
-                return 0;
-
-        /* Panic on recursive debugger calls: */
-        exception_level++;
-        addr = kgdb_arch_pc(ks->ex_vector, ks->linux_regs);
-        kgdb_deactivate_sw_breakpoints();
-
-        /*
-         * If the break point removed ok at the place exception
-         * occurred, try to recover and print a warning to the end
-         * user because the user planted a breakpoint in a place that
-         * KGDB needs in order to function.
-         */
-        if (kgdb_remove_sw_break(addr) == 0) {
-                exception_level = 0;
-                kgdb_skipexception(ks->ex_vector, ks->linux_regs);
-                kgdb_activate_sw_breakpoints();
-                printk(KERN_CRIT "KGDB: re-enter error: breakpoint removed %lx\n",
-                        addr);
-                WARN_ON_ONCE(1);
-
-                return 1;
-        }
-        remove_all_break();
-        kgdb_skipexception(ks->ex_vector, ks->linux_regs);
-
-        if (exception_level > 1) {
-                dump_stack();
-                panic("Recursive entry to debugger");
-        }
-
-        printk(KERN_CRIT "KGDB: re-enter exception: ALL breakpoints killed\n");
-        dump_stack();
-        panic("Recursive entry to debugger");
-
-        return 1;
-}
-
-static int kgdb_cpu_enter(struct kgdb_state *ks, struct pt_regs *regs)
-{
-        unsigned long flags;
-        int sstep_tries = 100;
-        int error = 0;
-        int i, cpu;
-        int trace_on = 0;
-acquirelock:
-        /*
-         * Interrupts will be restored by the 'trap return' code, except when
-         * single stepping.
-         */
-        local_irq_save(flags);
-
-        cpu = ks->cpu;
-        kgdb_info[cpu].debuggerinfo = regs;
-        kgdb_info[cpu].task = current;
-        /*
-         * Make sure the above info reaches the primary CPU before
-         * our cpu_in_kgdb[] flag setting does:
-         */
-        atomic_inc(&cpu_in_kgdb[cpu]);
-
-        /*
-         * CPU will loop if it is a slave or request to become a kgdb
-         * master cpu and acquire the kgdb_active lock:
-         */
-        while (1) {
-                if (kgdb_info[cpu].exception_state & DCPU_WANT_MASTER) {
-                        if (atomic_cmpxchg(&kgdb_active, -1, cpu) == cpu)
-                                break;
-                } else if (kgdb_info[cpu].exception_state & DCPU_IS_SLAVE) {
-                        if (!atomic_read(&passive_cpu_wait[cpu]))
-                                goto return_normal;
-                } else {
-return_normal:
-                        /* Return to normal operation by executing any
-                         * hw breakpoint fixup.
-                         */
-                        if (arch_kgdb_ops.correct_hw_break)
-                                arch_kgdb_ops.correct_hw_break();
-                        if (trace_on)
-                                tracing_on();
-                        atomic_dec(&cpu_in_kgdb[cpu]);
-                        touch_softlockup_watchdog_sync();
-                        clocksource_touch_watchdog();
-                        local_irq_restore(flags);
-                        return 0;
-                }
-                cpu_relax();
-        }
-
-        /*
-         * For single stepping, try to only enter on the processor
-         * that was single stepping.  To gaurd against a deadlock, the
-         * kernel will only try for the value of sstep_tries before
-         * giving up and continuing on.
-         */
-        if (atomic_read(&kgdb_cpu_doing_single_step) != -1 &&
-            (kgdb_info[cpu].task &&
-             kgdb_info[cpu].task->pid != kgdb_sstep_pid) && --sstep_tries) {
-                atomic_set(&kgdb_active, -1);
-                touch_softlockup_watchdog_sync();
-                clocksource_touch_watchdog();
-                local_irq_restore(flags);
-
-                goto acquirelock;
-        }
-
-        if (!kgdb_io_ready(1)) {
-                error = 1;
-                goto kgdb_restore; /* No I/O connection, so resume the system */
-        }
-
-        /*
-         * Don't enter if we have hit a removed breakpoint.
-         */
-        if (kgdb_skipexception(ks->ex_vector, ks->linux_regs))
-                goto kgdb_restore;
-
-        /* Call the I/O driver's pre_exception routine */
-        if (kgdb_io_ops->pre_exception)
-                kgdb_io_ops->pre_exception();
-
-        kgdb_disable_hw_debug(ks->linux_regs);
-
-        /*
-         * Get the passive CPU lock which will hold all the non-primary
-         * CPU in a spin state while the debugger is active
-         */
-        if (!kgdb_single_step) {
-                for (i = 0; i < NR_CPUS; i++)
-                        atomic_inc(&passive_cpu_wait[i]);
-        }
-
-#ifdef CONFIG_SMP
-        /* Signal the other CPUs to enter kgdb_wait() */
-        if ((!kgdb_single_step) && kgdb_do_roundup)
-                kgdb_roundup_cpus(flags);
-#endif
-
-        /*
-         * Wait for the other CPUs to be notified and be waiting for us:
-         */
-        for_each_online_cpu(i) {
-                while (!atomic_read(&cpu_in_kgdb[i]))
-                        cpu_relax();
-        }
-
-        /*
-         * At this point the primary processor is completely
-         * in the debugger and all secondary CPUs are quiescent
-         */
-        kgdb_post_primary_code(ks->linux_regs, ks->ex_vector, ks->err_code);
-        kgdb_deactivate_sw_breakpoints();
-        kgdb_single_step = 0;
-        kgdb_contthread = current;
-        exception_level = 0;
-        trace_on = tracing_is_on();
-        if (trace_on)
-                tracing_off();
-
-        /* Talk to debugger with gdbserial protocol */
-        error = gdb_serial_stub(ks);
-
-        /* Call the I/O driver's post_exception routine */
-        if (kgdb_io_ops->post_exception)
-                kgdb_io_ops->post_exception();
-
-        atomic_dec(&cpu_in_kgdb[ks->cpu]);
-
-        if (!kgdb_single_step) {
-                for (i = NR_CPUS-1; i >= 0; i--)
-                        atomic_dec(&passive_cpu_wait[i]);
-                /*
-                 * Wait till all the CPUs have quit
-                 * from the debugger.
-                 */
-                for_each_online_cpu(i) {
-                        while (atomic_read(&cpu_in_kgdb[i]))
-                                cpu_relax();
-                }
-        }
-
-kgdb_restore:
-        if (atomic_read(&kgdb_cpu_doing_single_step) != -1) {
-                int sstep_cpu = atomic_read(&kgdb_cpu_doing_single_step);
-                if (kgdb_info[sstep_cpu].task)
-                        kgdb_sstep_pid = kgdb_info[sstep_cpu].task->pid;
-                else
-                        kgdb_sstep_pid = 0;
-        }
-        if (trace_on)
-                tracing_on();
-        /* Free kgdb_active */
-        atomic_set(&kgdb_active, -1);
-        touch_softlockup_watchdog_sync();
-        clocksource_touch_watchdog();
-        local_irq_restore(flags);
-
-        return error;
-}
-
-/*
- * kgdb_handle_exception() - main entry point from a kernel exception
- *
- * Locking hierarchy:
- *      interface locks, if any (begin_session)
- *      kgdb lock (kgdb_active)
- */
-int
-kgdb_handle_exception(int evector, int signo, int ecode, struct pt_regs *regs)
-{
-        struct kgdb_state kgdb_var;
-        struct kgdb_state *ks = &kgdb_var;
-        int ret;
-
-        ks->cpu                 = raw_smp_processor_id();
-        ks->ex_vector           = evector;
-        ks->signo               = signo;
-        ks->ex_vector           = evector;
-        ks->err_code            = ecode;
-        ks->kgdb_usethreadid    = 0;
-        ks->linux_regs          = regs;
-
-        if (kgdb_reenter_check(ks))
-                return 0; /* Ouch, double exception ! */
-        kgdb_info[ks->cpu].exception_state |= DCPU_WANT_MASTER;
-        ret = kgdb_cpu_enter(ks, regs);
-        kgdb_info[ks->cpu].exception_state &= ~DCPU_WANT_MASTER;
-        return ret;
-}
-
-int kgdb_nmicallback(int cpu, void *regs)
-{
-#ifdef CONFIG_SMP
-        struct kgdb_state kgdb_var;
-        struct kgdb_state *ks = &kgdb_var;
-
-        memset(ks, 0, sizeof(struct kgdb_state));
-        ks->cpu                 = cpu;
-        ks->linux_regs          = regs;
-
-        if (!atomic_read(&cpu_in_kgdb[cpu]) &&
-            atomic_read(&kgdb_active) != -1 &&
-            atomic_read(&kgdb_active) != cpu) {
-                kgdb_info[cpu].exception_state |= DCPU_IS_SLAVE;
-                kgdb_cpu_enter(ks, regs);
-                kgdb_info[cpu].exception_state &= ~DCPU_IS_SLAVE;
-                return 0;
-        }
-#endif
-        return 1;
-}
-
-static void kgdb_console_write(struct console *co, const char *s,
-   unsigned count)
-{
-        unsigned long flags;
-
-        /* If we're debugging, or KGDB has not connected, don't try
-         * and print. */
-        if (!kgdb_connected || atomic_read(&kgdb_active) != -1)
-                return;
-
-        local_irq_save(flags);
-        kgdb_msg_write(s, count);
-        local_irq_restore(flags);
-}
-
-static struct console kgdbcons = {
-        .name           = "kgdb",
-        .write          = kgdb_console_write,
-        .flags          = CON_PRINTBUFFER | CON_ENABLED,
-        .index          = -1,
-};
-
-#ifdef CONFIG_MAGIC_SYSRQ
-static void sysrq_handle_gdb(int key, struct tty_struct *tty)
-{
-        if (!kgdb_io_ops) {
-                printk(KERN_CRIT "ERROR: No KGDB I/O module available\n");
-                return;
-        }
-        if (!kgdb_connected)
-                printk(KERN_CRIT "Entering KGDB\n");
-
-        kgdb_breakpoint();
-}
-
-static struct sysrq_key_op sysrq_gdb_op = {
-        .handler        = sysrq_handle_gdb,
-        .help_msg       = "debug(G)",
-        .action_msg     = "DEBUG",
-};
-#endif
-
-static void kgdb_register_callbacks(void)
-{
-        if (!kgdb_io_module_registered) {
-                kgdb_io_module_registered = 1;
-                kgdb_arch_init();
-#ifdef CONFIG_MAGIC_SYSRQ
-                register_sysrq_key('g', &sysrq_gdb_op);
-#endif
-                if (kgdb_use_con && !kgdb_con_registered) {
-                        register_console(&kgdbcons);
-                        kgdb_con_registered = 1;
-                }
-        }
-}
-
-static void kgdb_unregister_callbacks(void)
-{
-        /*
-         * When this routine is called KGDB should unregister from the
-         * panic handler and clean up, making sure it is not handling any
-         * break exceptions at the time.
-         */
-        if (kgdb_io_module_registered) {
-                kgdb_io_module_registered = 0;
-                kgdb_arch_exit();
-#ifdef CONFIG_MAGIC_SYSRQ
-                unregister_sysrq_key('g', &sysrq_gdb_op);
-#endif
-                if (kgdb_con_registered) {
-                        unregister_console(&kgdbcons);
-                        kgdb_con_registered = 0;
-                }
-        }
-}
-
-static void kgdb_initial_breakpoint(void)
-{
-        kgdb_break_asap = 0;
-
-        printk(KERN_CRIT "kgdb: Waiting for connection from remote gdb...\n");
-        kgdb_breakpoint();
-}
-
-/**
- *      kgdb_register_io_module - register KGDB IO module
- *      @new_kgdb_io_ops: the io ops vector
- *
- *      Register it with the KGDB core.
- */
-int kgdb_register_io_module(struct kgdb_io *new_kgdb_io_ops)
-{
-        int err;
-
-        spin_lock(&kgdb_registration_lock);
-
-        if (kgdb_io_ops) {
-                spin_unlock(&kgdb_registration_lock);
-
-                printk(KERN_ERR "kgdb: Another I/O driver is already "
-                                "registered with KGDB.\n");
-                return -EBUSY;
-        }
-
-        if (new_kgdb_io_ops->init) {
-                err = new_kgdb_io_ops->init();
-                if (err) {
-                        spin_unlock(&kgdb_registration_lock);
-                        return err;
-                }
-        }
-
-        kgdb_io_ops = new_kgdb_io_ops;
-
-        spin_unlock(&kgdb_registration_lock);
-
-        printk(KERN_INFO "kgdb: Registered I/O driver %s.\n",
-               new_kgdb_io_ops->name);
-
-        /* Arm KGDB now. */
-        kgdb_register_callbacks();
-
-        if (kgdb_break_asap)
-                kgdb_initial_breakpoint();
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(kgdb_register_io_module);
-
-/**
- *      kkgdb_unregister_io_module - unregister KGDB IO module
- *      @old_kgdb_io_ops: the io ops vector
- *
- *      Unregister it with the KGDB core.
- */
-void kgdb_unregister_io_module(struct kgdb_io *old_kgdb_io_ops)
-{
-        BUG_ON(kgdb_connected);
-
-        /*
-         * KGDB is no longer able to communicate out, so
-         * unregister our callbacks and reset state.
-         */
-        kgdb_unregister_callbacks();
-
-        spin_lock(&kgdb_registration_lock);
-
-        WARN_ON_ONCE(kgdb_io_ops != old_kgdb_io_ops);
-        kgdb_io_ops = NULL;
-
-        spin_unlock(&kgdb_registration_lock);
-
-        printk(KERN_INFO
-                "kgdb: Unregistered I/O driver %s, debugger disabled.\n",
-                old_kgdb_io_ops->name);
-}
-EXPORT_SYMBOL_GPL(kgdb_unregister_io_module);
-
-/**
- * kgdb_breakpoint - generate breakpoint exception
- *
- * This function will generate a breakpoint exception.  It is used at the
- * beginning of a program to sync up with a debugger and can be used
- * otherwise as a quick means to stop program execution and "break" into
- * the debugger.
- */
-void kgdb_breakpoint(void)
-{
-        atomic_inc(&kgdb_setting_breakpoint);
-        wmb(); /* Sync point before breakpoint */
-        arch_kgdb_breakpoint();
-        wmb(); /* Sync point after breakpoint */
-        atomic_dec(&kgdb_setting_breakpoint);
-}
-EXPORT_SYMBOL_GPL(kgdb_breakpoint);
-
-static int __init opt_kgdb_wait(char *str)
-{
-        kgdb_break_asap = 1;
-
-        if (kgdb_io_module_registered)
-                kgdb_initial_breakpoint();
-
-        return 0;
-}
-
-early_param("kgdbwait", opt_kgdb_wait);
diff --git a/kernel/kmod.c b/kernel/kmod.c
index bf0e231d9702..6e9b19667a8d 100644
--- a/kernel/kmod.c
+++ b/kernel/kmod.c
@@ -116,27 +116,16 @@ int __request_module(bool wait, const char *fmt, ...)
 
         trace_module_request(module_name, wait, _RET_IP_);
 
-        ret = call_usermodehelper(modprobe_path, argv, envp,
-                        wait ? UMH_WAIT_PROC : UMH_WAIT_EXEC);
+        ret = call_usermodehelper_fns(modprobe_path, argv, envp,
+                        wait ? UMH_WAIT_PROC : UMH_WAIT_EXEC,
+                        NULL, NULL, NULL);
+
         atomic_dec(&kmod_concurrent);
         return ret;
 }
 EXPORT_SYMBOL(__request_module);
 #endif /* CONFIG_MODULES */
 
-struct subprocess_info {
-        struct work_struct work;
-        struct completion *complete;
-        struct cred *cred;
-        char *path;
-        char **argv;
-        char **envp;
-        enum umh_wait wait;
-        int retval;
-        struct file *stdin;
-        void (*cleanup)(char **argv, char **envp);
-};
-
 /*
  * This is the task which runs the usermode application
  */
@@ -145,36 +134,10 @@ static int ____call_usermodehelper(void *data)
         struct subprocess_info *sub_info = data;
         int retval;
 
-        BUG_ON(atomic_read(&sub_info->cred->usage) != 1);
-
-        /* Unblock all signals */
         spin_lock_irq(&current->sighand->siglock);
         flush_signal_handlers(current, 1);
-        sigemptyset(&current->blocked);
-        recalc_sigpending();
         spin_unlock_irq(&current->sighand->siglock);
 
-        /* Install the credentials */
-        commit_creds(sub_info->cred);
-        sub_info->cred = NULL;
-
-        /* Install input pipe when needed */
-        if (sub_info->stdin) {
-                struct files_struct *f = current->files;
-                struct fdtable *fdt;
-                /* no races because files should be private here */
-                sys_close(0);
-                fd_install(0, sub_info->stdin);
-                spin_lock(&f->file_lock);
-                fdt = files_fdtable(f);
-                FD_SET(0, fdt->open_fds);
-                FD_CLR(0, fdt->close_on_exec);
-                spin_unlock(&f->file_lock);
-
-                /* and disallow core files too */
-                current->signal->rlim[RLIMIT_CORE] = (struct rlimit){0, 0};
-        }
-
         /* We can run anywhere, unlike our parent keventd(). */
         set_cpus_allowed_ptr(current, cpu_all_mask);
 
@@ -184,9 +147,16 @@ static int ____call_usermodehelper(void *data)
          */
         set_user_nice(current, 0);
 
+        if (sub_info->init) {
+                retval = sub_info->init(sub_info);
+                if (retval)
+                        goto fail;
+        }
+
         retval = kernel_execve(sub_info->path, sub_info->argv, sub_info->envp);
 
         /* Exec failed? */
+fail:
         sub_info->retval = retval;
         do_exit(0);
 }
@@ -194,9 +164,7 @@ static int ____call_usermodehelper(void *data)
 void call_usermodehelper_freeinfo(struct subprocess_info *info)
 {
         if (info->cleanup)
-                (*info->cleanup)(info->argv, info->envp);
-        if (info->cred)
-                put_cred(info->cred);
+                (*info->cleanup)(info);
         kfree(info);
 }
 EXPORT_SYMBOL(call_usermodehelper_freeinfo);
@@ -207,16 +175,16 @@ static int wait_for_helper(void *data)
         struct subprocess_info *sub_info = data;
         pid_t pid;
 
-        /* Install a handler: if SIGCLD isn't handled sys_wait4 won't
-         * populate the status, but will return -ECHILD. */
-        allow_signal(SIGCHLD);
+        /* If SIGCLD is ignored sys_wait4 won't populate the status. */
+        spin_lock_irq(&current->sighand->siglock);
+        current->sighand->action[SIGCHLD-1].sa.sa_handler = SIG_DFL;
+        spin_unlock_irq(&current->sighand->siglock);
 
         pid = kernel_thread(____call_usermodehelper, sub_info, SIGCHLD);
         if (pid < 0) {
                 sub_info->retval = pid;
         } else {
-                int ret;
-
+                int ret = -ECHILD;
                 /*
                  * Normally it is bogus to call wait4() from in-kernel because
                  * wait4() wants to write the exit code to a userspace address.
@@ -237,10 +205,7 @@ static int wait_for_helper(void *data)
                         sub_info->retval = ret;
         }
 
-        if (sub_info->wait == UMH_NO_WAIT)
-                call_usermodehelper_freeinfo(sub_info);
-        else
-                complete(sub_info->complete);
+        complete(sub_info->complete);
         return 0;
 }
 
@@ -249,15 +214,13 @@ static void __call_usermodehelper(struct work_struct *work)
 {
         struct subprocess_info *sub_info =
                 container_of(work, struct subprocess_info, work);
-        pid_t pid;
         enum umh_wait wait = sub_info->wait;
-
-        BUG_ON(atomic_read(&sub_info->cred->usage) != 1);
+        pid_t pid;
 
         /* CLONE_VFORK: wait until the usermode helper has execve'd
          * successfully We need the data structures to stay around
          * until that is done.  */
-        if (wait == UMH_WAIT_PROC || wait == UMH_NO_WAIT)
+        if (wait == UMH_WAIT_PROC)
                 pid = kernel_thread(wait_for_helper, sub_info,
                                     CLONE_FS | CLONE_FILES | SIGCHLD);
         else
@@ -266,15 +229,16 @@ static void __call_usermodehelper(struct work_struct *work)
 
         switch (wait) {
         case UMH_NO_WAIT:
+                call_usermodehelper_freeinfo(sub_info);
                 break;
 
         case UMH_WAIT_PROC:
                 if (pid > 0)
                         break;
-                sub_info->retval = pid;
                 /* FALLTHROUGH */
-
         case UMH_WAIT_EXEC:
+                if (pid < 0)
+                        sub_info->retval = pid;
                 complete(sub_info->complete);
         }
 }
@@ -376,80 +340,37 @@ struct subprocess_info *call_usermodehelper_setup(char *path, char **argv,
         sub_info->path = path;
         sub_info->argv = argv;
         sub_info->envp = envp;
-        sub_info->cred = prepare_usermodehelper_creds();
-        if (!sub_info->cred) {
-                kfree(sub_info);
-                return NULL;
-        }
-
   out:
         return sub_info;
 }
 EXPORT_SYMBOL(call_usermodehelper_setup);
 
 /**
- * call_usermodehelper_setkeys - set the session keys for usermode helper
- * @info: a subprocess_info returned by call_usermodehelper_setup
- * @session_keyring: the session keyring for the process
- */
-void call_usermodehelper_setkeys(struct subprocess_info *info,
-                                 struct key *session_keyring)
-{
-#ifdef CONFIG_KEYS
-        struct thread_group_cred *tgcred = info->cred->tgcred;
-        key_put(tgcred->session_keyring);
-        tgcred->session_keyring = key_get(session_keyring);
-#else
-        BUG();
-#endif
-}
-EXPORT_SYMBOL(call_usermodehelper_setkeys);
-
-/**
- * call_usermodehelper_setcleanup - set a cleanup function
+ * call_usermodehelper_setfns - set a cleanup/init function
  * @info: a subprocess_info returned by call_usermodehelper_setup
  * @cleanup: a cleanup function
+ * @init: an init function
+ * @data: arbitrary context sensitive data
  *
- * The cleanup function is just befor ethe subprocess_info is about to
+ * The init function is used to customize the helper process prior to
+ * exec.  A non-zero return code causes the process to error out, exit,
+ * and return the failure to the calling process
+ *
+ * The cleanup function is just before ethe subprocess_info is about to
  * be freed.  This can be used for freeing the argv and envp.  The
  * Function must be runnable in either a process context or the
  * context in which call_usermodehelper_exec is called.
  */
-void call_usermodehelper_setcleanup(struct subprocess_info *info,
-                                    void (*cleanup)(char **argv, char **envp))
+void call_usermodehelper_setfns(struct subprocess_info *info,
+                    int (*init)(struct subprocess_info *info),
+                    void (*cleanup)(struct subprocess_info *info),
+                    void *data)
 {
         info->cleanup = cleanup;
+        info->init = init;
+        info->data = data;
 }
-EXPORT_SYMBOL(call_usermodehelper_setcleanup);
-
-/**
- * call_usermodehelper_stdinpipe - set up a pipe to be used for stdin
- * @sub_info: a subprocess_info returned by call_usermodehelper_setup
- * @filp: set to the write-end of a pipe
- *
- * This constructs a pipe, and sets the read end to be the stdin of the
- * subprocess, and returns the write-end in *@filp.
- */
-int call_usermodehelper_stdinpipe(struct subprocess_info *sub_info,
-                                  struct file **filp)
-{
-        struct file *f;
-
-        f = create_write_pipe(0);
-        if (IS_ERR(f))
-                return PTR_ERR(f);
-        *filp = f;
-
-        f = create_read_pipe(f, 0);
-        if (IS_ERR(f)) {
-                free_write_pipe(*filp);
-                return PTR_ERR(f);
-        }
-        sub_info->stdin = f;
-
-        return 0;
-}
-EXPORT_SYMBOL(call_usermodehelper_stdinpipe);
+EXPORT_SYMBOL(call_usermodehelper_setfns);
 
 /**
  * call_usermodehelper_exec - start a usermode application
@@ -469,9 +390,6 @@ int call_usermodehelper_exec(struct subprocess_info *sub_info,
         DECLARE_COMPLETION_ONSTACK(done);
         int retval = 0;
 
-        BUG_ON(atomic_read(&sub_info->cred->usage) != 1);
-        validate_creds(sub_info->cred);
-
         helper_lock();
         if (sub_info->path[0] == '\0')
                 goto out;
@@ -498,41 +416,6 @@ unlock:
 }
 EXPORT_SYMBOL(call_usermodehelper_exec);
 
-/**
- * call_usermodehelper_pipe - call a usermode helper process with a pipe stdin
- * @path: path to usermode executable
- * @argv: arg vector for process
- * @envp: environment for process
- * @filp: set to the write-end of a pipe
- *
- * This is a simple wrapper which executes a usermode-helper function
- * with a pipe as stdin.  It is implemented entirely in terms of
- * lower-level call_usermodehelper_* functions.
- */
-int call_usermodehelper_pipe(char *path, char **argv, char **envp,
-                             struct file **filp)
-{
-        struct subprocess_info *sub_info;
-        int ret;
-
-        sub_info = call_usermodehelper_setup(path, argv, envp, GFP_KERNEL);
-        if (sub_info == NULL)
-                return -ENOMEM;
-
-        ret = call_usermodehelper_stdinpipe(sub_info, filp);
-        if (ret < 0) {
-                call_usermodehelper_freeinfo(sub_info);
-                return ret;
-        }
-
-        ret = call_usermodehelper_exec(sub_info, UMH_WAIT_EXEC);
-        if (ret < 0)    /* Failed to execute helper, close pipe */
-                filp_close(*filp, NULL);
-
-        return ret;
-}
-EXPORT_SYMBOL(call_usermodehelper_pipe);
-
 void __init usermodehelper_init(void)
 {
         khelper_wq = create_singlethread_workqueue("khelper");
diff --git a/kernel/ksysfs.c b/kernel/ksysfs.c
index 21fe3c426948..0b624e791805 100644
--- a/kernel/ksysfs.c
+++ b/kernel/ksysfs.c
@@ -138,7 +138,8 @@ extern const void __start_notes __attribute__((weak));
 extern const void __stop_notes __attribute__((weak));
 #define notes_size (&__stop_notes - &__start_notes)
 
-static ssize_t notes_read(struct kobject *kobj, struct bin_attribute *bin_attr,
+static ssize_t notes_read(struct file *filp, struct kobject *kobj,
+                          struct bin_attribute *bin_attr,
                           char *buf, loff_t off, size_t count)
 {
         memcpy(buf, &__start_notes + off, count);
diff --git a/kernel/lockdep.c b/kernel/lockdep.c
index ec21304856d1..54286798c37b 100644
--- a/kernel/lockdep.c
+++ b/kernel/lockdep.c
@@ -2711,6 +2711,8 @@ void lockdep_init_map(struct lockdep_map *lock, const char *name,
 }
 EXPORT_SYMBOL_GPL(lockdep_init_map);
 
+struct lock_class_key __lockdep_no_validate__;
+
 /*
  * This gets called for every mutex_lock*()/spin_lock*() operation.
  * We maintain the dependency maps and validate the locking attempt:
@@ -2745,6 +2747,9 @@ static int __lock_acquire(struct lockdep_map *lock, unsigned int subclass,
                 return 0;
         }
 
+        if (lock->key == &__lockdep_no_validate__)
+                check = 1;
+
         if (!subclass)
                 class = lock->class_cache;
         /*
diff --git a/kernel/module.c b/kernel/module.c
index e2564580f3f1..333fbcc96978 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -77,6 +77,10 @@
 DEFINE_MUTEX(module_mutex);
 EXPORT_SYMBOL_GPL(module_mutex);
 static LIST_HEAD(modules);
+#ifdef CONFIG_KGDB_KDB
+struct list_head *kdb_modules = &modules; /* kdb needs the list of modules */
+#endif /* CONFIG_KGDB_KDB */
+
 
 /* Block module loading/unloading? */
 int modules_disabled = 0;
@@ -176,8 +180,6 @@ extern const struct kernel_symbol __start___ksymtab_gpl[];
 extern const struct kernel_symbol __stop___ksymtab_gpl[];
 extern const struct kernel_symbol __start___ksymtab_gpl_future[];
 extern const struct kernel_symbol __stop___ksymtab_gpl_future[];
-extern const struct kernel_symbol __start___ksymtab_gpl_future[];
-extern const struct kernel_symbol __stop___ksymtab_gpl_future[];
 extern const unsigned long __start___kcrctab[];
 extern const unsigned long __start___kcrctab_gpl[];
 extern const unsigned long __start___kcrctab_gpl_future[];
@@ -1182,7 +1184,7 @@ struct module_notes_attrs {
         struct bin_attribute attrs[0];
 };
 
-static ssize_t module_notes_read(struct kobject *kobj,
+static ssize_t module_notes_read(struct file *filp, struct kobject *kobj,
                                  struct bin_attribute *bin_attr,
                                  char *buf, loff_t pos, size_t count)
 {
diff --git a/kernel/mutex.c b/kernel/mutex.c
index 632f04c57d82..4c0b7b3e6d2e 100644
--- a/kernel/mutex.c
+++ b/kernel/mutex.c
@@ -172,6 +172,13 @@ __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
                 struct thread_info *owner;
 
                 /*
+                 * If we own the BKL, then don't spin. The owner of
+                 * the mutex might be waiting on us to release the BKL.
+                 */
+                if (unlikely(current->lock_depth >= 0))
+                        break;
+
+                /*
                  * If there's an owner, wait for it to either
                  * release the lock or go to sleep.
                  */
diff --git a/kernel/padata.c b/kernel/padata.c
index fd03513c7327..fdd8ae609ce3 100644
--- a/kernel/padata.c
+++ b/kernel/padata.c
@@ -29,7 +29,7 @@
 #include <linux/rcupdate.h>
 
 #define MAX_SEQ_NR INT_MAX - NR_CPUS
-#define MAX_OBJ_NUM 10000 * NR_CPUS
+#define MAX_OBJ_NUM 1000
 
 static int padata_index_to_cpu(struct parallel_data *pd, int cpu_index)
 {
@@ -88,7 +88,7 @@ static void padata_parallel_worker(struct work_struct *work)
         local_bh_enable();
 }
 
-/*
+/**
  * padata_do_parallel - padata parallelization function
  *
  * @pinst: padata instance
@@ -152,6 +152,23 @@ out:
 }
 EXPORT_SYMBOL(padata_do_parallel);
 
+/*
+ * padata_get_next - Get the next object that needs serialization.
+ *
+ * Return values are:
+ *
+ * A pointer to the control struct of the next object that needs
+ * serialization, if present in one of the percpu reorder queues.
+ *
+ * NULL, if all percpu reorder queues are empty.
+ *
+ * -EINPROGRESS, if the next object that needs serialization will
+ *  be parallel processed by another cpu and is not yet present in
+ *  the cpu's reorder queue.
+ *
+ * -ENODATA, if this cpu has to do the parallel processing for
+ *  the next object.
+ */
 static struct padata_priv *padata_get_next(struct parallel_data *pd)
 {
         int cpu, num_cpus, empty, calc_seq_nr;
@@ -173,7 +190,7 @@ static struct padata_priv *padata_get_next(struct parallel_data *pd)
 
                 /*
                  * Calculate the seq_nr of the object that should be
-                 * next in this queue.
+                 * next in this reorder queue.
                  */
                 overrun = 0;
                 calc_seq_nr = (atomic_read(&queue->num_obj) * num_cpus)
@@ -231,7 +248,8 @@ static struct padata_priv *padata_get_next(struct parallel_data *pd)
                 goto out;
         }
 
-        if (next_nr % num_cpus == next_queue->cpu_index) {
+        queue = per_cpu_ptr(pd->queue, smp_processor_id());
+        if (queue->cpu_index == next_queue->cpu_index) {
                 padata = ERR_PTR(-ENODATA);
                 goto out;
         }
@@ -247,19 +265,40 @@ static void padata_reorder(struct parallel_data *pd)
         struct padata_queue *queue;
         struct padata_instance *pinst = pd->pinst;
 
-try_again:
+        /*
+         * We need to ensure that only one cpu can work on dequeueing of
+         * the reorder queue the time. Calculating in which percpu reorder
+         * queue the next object will arrive takes some time. A spinlock
+         * would be highly contended. Also it is not clear in which order
+         * the objects arrive to the reorder queues. So a cpu could wait to
+         * get the lock just to notice that there is nothing to do at the
+         * moment. Therefore we use a trylock and let the holder of the lock
+         * care for all the objects enqueued during the holdtime of the lock.
+         */
         if (!spin_trylock_bh(&pd->lock))
-                goto out;
+                return;
 
         while (1) {
                 padata = padata_get_next(pd);
 
+                /*
+                 * All reorder queues are empty, or the next object that needs
+                 * serialization is parallel processed by another cpu and is
+                 * still on it's way to the cpu's reorder queue, nothing to
+                 * do for now.
+                 */
                 if (!padata || PTR_ERR(padata) == -EINPROGRESS)
                         break;
 
+                /*
+                 * This cpu has to do the parallel processing of the next
+                 * object. It's waiting in the cpu's parallelization queue,
+                 * so exit imediately.
+                 */
                 if (PTR_ERR(padata) == -ENODATA) {
+                        del_timer(&pd->timer);
                         spin_unlock_bh(&pd->lock);
-                        goto out;
+                        return;
                 }
 
                 queue = per_cpu_ptr(pd->queue, padata->cb_cpu);
@@ -273,13 +312,27 @@ try_again:
 
         spin_unlock_bh(&pd->lock);
 
-        if (atomic_read(&pd->reorder_objects))
-                goto try_again;
+        /*
+         * The next object that needs serialization might have arrived to
+         * the reorder queues in the meantime, we will be called again
+         * from the timer function if noone else cares for it.
+         */
+        if (atomic_read(&pd->reorder_objects)
+                        && !(pinst->flags & PADATA_RESET))
+                mod_timer(&pd->timer, jiffies + HZ);
+        else
+                del_timer(&pd->timer);
 
-out:
         return;
 }
 
+static void padata_reorder_timer(unsigned long arg)
+{
+        struct parallel_data *pd = (struct parallel_data *)arg;
+
+        padata_reorder(pd);
+}
+
 static void padata_serial_worker(struct work_struct *work)
 {
         struct padata_queue *queue;
@@ -308,7 +361,7 @@ static void padata_serial_worker(struct work_struct *work)
         local_bh_enable();
 }
 
-/*
+/**
  * padata_do_serial - padata serialization function
  *
  * @padata: object to be serialized.
@@ -338,6 +391,7 @@ void padata_do_serial(struct padata_priv *padata)
 }
 EXPORT_SYMBOL(padata_do_serial);
 
+/* Allocate and initialize the internal cpumask dependend resources. */
 static struct parallel_data *padata_alloc_pd(struct padata_instance *pinst,
                                              const struct cpumask *cpumask)
 {
@@ -358,17 +412,15 @@ static struct parallel_data *padata_alloc_pd(struct padata_instance *pinst,
         if (!alloc_cpumask_var(&pd->cpumask, GFP_KERNEL))
                 goto err_free_queue;
 
-        for_each_possible_cpu(cpu) {
+        cpumask_and(pd->cpumask, cpumask, cpu_active_mask);
+
+        for_each_cpu(cpu, pd->cpumask) {
                 queue = per_cpu_ptr(pd->queue, cpu);
 
                 queue->pd = pd;
 
-                if (cpumask_test_cpu(cpu, cpumask)
-                    && cpumask_test_cpu(cpu, cpu_active_mask)) {
-                        queue->cpu_index = cpu_index;
-                        cpu_index++;
-                } else
-                        queue->cpu_index = -1;
+                queue->cpu_index = cpu_index;
+                cpu_index++;
 
                 INIT_LIST_HEAD(&queue->reorder.list);
                 INIT_LIST_HEAD(&queue->parallel.list);
@@ -382,11 +434,10 @@ static struct parallel_data *padata_alloc_pd(struct padata_instance *pinst,
                 atomic_set(&queue->num_obj, 0);
         }
 
-        cpumask_and(pd->cpumask, cpumask, cpu_active_mask);
-
         num_cpus = cpumask_weight(pd->cpumask);
         pd->max_seq_nr = (MAX_SEQ_NR / num_cpus) * num_cpus - 1;
 
+        setup_timer(&pd->timer, padata_reorder_timer, (unsigned long)pd);
         atomic_set(&pd->seq_nr, -1);
         atomic_set(&pd->reorder_objects, 0);
         atomic_set(&pd->refcnt, 0);
@@ -410,6 +461,31 @@ static void padata_free_pd(struct parallel_data *pd)
         kfree(pd);
 }
 
+/* Flush all objects out of the padata queues. */
+static void padata_flush_queues(struct parallel_data *pd)
+{
+        int cpu;
+        struct padata_queue *queue;
+
+        for_each_cpu(cpu, pd->cpumask) {
+                queue = per_cpu_ptr(pd->queue, cpu);
+                flush_work(&queue->pwork);
+        }
+
+        del_timer_sync(&pd->timer);
+
+        if (atomic_read(&pd->reorder_objects))
+                padata_reorder(pd);
+
+        for_each_cpu(cpu, pd->cpumask) {
+                queue = per_cpu_ptr(pd->queue, cpu);
+                flush_work(&queue->swork);
+        }
+
+        BUG_ON(atomic_read(&pd->refcnt) != 0);
+}
+
+/* Replace the internal control stucture with a new one. */
 static void padata_replace(struct padata_instance *pinst,
                            struct parallel_data *pd_new)
 {
@@ -421,17 +497,13 @@ static void padata_replace(struct padata_instance *pinst,
 
         synchronize_rcu();
 
-        while (atomic_read(&pd_old->refcnt) != 0)
-                yield();
-
-        flush_workqueue(pinst->wq);
-
+        padata_flush_queues(pd_old);
         padata_free_pd(pd_old);
 
         pinst->flags &= ~PADATA_RESET;
 }
 
-/*
+/**
  * padata_set_cpumask - set the cpumask that padata should use
  *
  * @pinst: padata instance
@@ -443,10 +515,10 @@ int padata_set_cpumask(struct padata_instance *pinst,
         struct parallel_data *pd;
         int err = 0;
 
-        might_sleep();
-
         mutex_lock(&pinst->lock);
 
+        get_online_cpus();
+
         pd = padata_alloc_pd(pinst, cpumask);
         if (!pd) {
                 err = -ENOMEM;
@@ -458,6 +530,8 @@ int padata_set_cpumask(struct padata_instance *pinst,
         padata_replace(pinst, pd);
 
 out:
+        put_online_cpus();
+
         mutex_unlock(&pinst->lock);
 
         return err;
@@ -479,7 +553,7 @@ static int __padata_add_cpu(struct padata_instance *pinst, int cpu)
         return 0;
 }
 
-/*
+/**
  * padata_add_cpu - add a cpu to the padata cpumask
  *
  * @pinst: padata instance
@@ -489,12 +563,12 @@ int padata_add_cpu(struct padata_instance *pinst, int cpu)
 {
         int err;
 
-        might_sleep();
-
         mutex_lock(&pinst->lock);
 
+        get_online_cpus();
         cpumask_set_cpu(cpu, pinst->cpumask);
         err = __padata_add_cpu(pinst, cpu);
+        put_online_cpus();
 
         mutex_unlock(&pinst->lock);
 
@@ -517,7 +591,7 @@ static int __padata_remove_cpu(struct padata_instance *pinst, int cpu)
         return 0;
 }
 
-/*
+/**
  * padata_remove_cpu - remove a cpu from the padata cpumask
  *
  * @pinst: padata instance
@@ -527,12 +601,12 @@ int padata_remove_cpu(struct padata_instance *pinst, int cpu)
 {
         int err;
 
-        might_sleep();
-
         mutex_lock(&pinst->lock);
 
+        get_online_cpus();
         cpumask_clear_cpu(cpu, pinst->cpumask);
         err = __padata_remove_cpu(pinst, cpu);
+        put_online_cpus();
 
         mutex_unlock(&pinst->lock);
 
@@ -540,38 +614,35 @@ int padata_remove_cpu(struct padata_instance *pinst, int cpu)
 }
 EXPORT_SYMBOL(padata_remove_cpu);
 
-/*
+/**
  * padata_start - start the parallel processing
  *
  * @pinst: padata instance to start
  */
 void padata_start(struct padata_instance *pinst)
 {
-        might_sleep();
-
         mutex_lock(&pinst->lock);
         pinst->flags |= PADATA_INIT;
         mutex_unlock(&pinst->lock);
 }
 EXPORT_SYMBOL(padata_start);
 
-/*
+/**
  * padata_stop - stop the parallel processing
  *
  * @pinst: padata instance to stop
  */
 void padata_stop(struct padata_instance *pinst)
 {
-        might_sleep();
-
         mutex_lock(&pinst->lock);
         pinst->flags &= ~PADATA_INIT;
         mutex_unlock(&pinst->lock);
 }
 EXPORT_SYMBOL(padata_stop);
 
-static int __cpuinit padata_cpu_callback(struct notifier_block *nfb,
-                                         unsigned long action, void *hcpu)
+#ifdef CONFIG_HOTPLUG_CPU
+static int padata_cpu_callback(struct notifier_block *nfb,
+                               unsigned long action, void *hcpu)
 {
         int err;
         struct padata_instance *pinst;
@@ -588,7 +659,7 @@ static int __cpuinit padata_cpu_callback(struct notifier_block *nfb,
                 err = __padata_add_cpu(pinst, cpu);
                 mutex_unlock(&pinst->lock);
                 if (err)
-                        return NOTIFY_BAD;
+                        return notifier_from_errno(err);
                 break;
 
         case CPU_DOWN_PREPARE:
@@ -599,7 +670,7 @@ static int __cpuinit padata_cpu_callback(struct notifier_block *nfb,
                 err = __padata_remove_cpu(pinst, cpu);
                 mutex_unlock(&pinst->lock);
                 if (err)
-                        return NOTIFY_BAD;
+                        return notifier_from_errno(err);
                 break;
 
         case CPU_UP_CANCELED:
@@ -621,8 +692,9 @@ static int __cpuinit padata_cpu_callback(struct notifier_block *nfb,
 
         return NOTIFY_OK;
 }
+#endif
 
-/*
+/**
  * padata_alloc - allocate and initialize a padata instance
  *
  * @cpumask: cpumask that padata uses for parallelization
@@ -631,7 +703,6 @@ static int __cpuinit padata_cpu_callback(struct notifier_block *nfb,
 struct padata_instance *padata_alloc(const struct cpumask *cpumask,
                                      struct workqueue_struct *wq)
 {
-        int err;
         struct padata_instance *pinst;
         struct parallel_data *pd;
 
@@ -639,6 +710,8 @@ struct padata_instance *padata_alloc(const struct cpumask *cpumask,
         if (!pinst)
                 goto err;
 
+        get_online_cpus();
+
         pd = padata_alloc_pd(pinst, cpumask);
         if (!pd)
                 goto err_free_inst;
@@ -654,31 +727,32 @@ struct padata_instance *padata_alloc(const struct cpumask *cpumask,
 
         pinst->flags = 0;
 
+#ifdef CONFIG_HOTPLUG_CPU
         pinst->cpu_notifier.notifier_call = padata_cpu_callback;
         pinst->cpu_notifier.priority = 0;
-        err = register_hotcpu_notifier(&pinst->cpu_notifier);
-        if (err)
-                goto err_free_cpumask;
+        register_hotcpu_notifier(&pinst->cpu_notifier);
+#endif
+
+        put_online_cpus();
 
         mutex_init(&pinst->lock);
 
         return pinst;
 
-err_free_cpumask:
-        free_cpumask_var(pinst->cpumask);
 err_free_pd:
         padata_free_pd(pd);
 err_free_inst:
         kfree(pinst);
+        put_online_cpus();
 err:
         return NULL;
 }
 EXPORT_SYMBOL(padata_alloc);
 
-/*
+/**
  * padata_free - free a padata instance
  *
- * @ padata_inst: padata instance to free
+ * @padata_inst: padata instance to free
  */
 void padata_free(struct padata_instance *pinst)
 {
@@ -686,10 +760,13 @@ void padata_free(struct padata_instance *pinst)
 
         synchronize_rcu();
 
-        while (atomic_read(&pinst->pd->refcnt) != 0)
-                yield();
-
+#ifdef CONFIG_HOTPLUG_CPU
         unregister_hotcpu_notifier(&pinst->cpu_notifier);
+#endif
+        get_online_cpus();
+        padata_flush_queues(pinst->pd);
+        put_online_cpus();
+
         padata_free_pd(pinst->pd);
         free_cpumask_var(pinst->cpumask);
         kfree(pinst);
diff --git a/kernel/panic.c b/kernel/panic.c
index 13d966b4c14a..3b16cd93fa7d 100644
--- a/kernel/panic.c
+++ b/kernel/panic.c
@@ -87,6 +87,7 @@ NORET_TYPE void panic(const char * fmt, ...)
          */
         preempt_disable();
 
+        console_verbose();
         bust_spinlocks(1);
         va_start(args, fmt);
         vsnprintf(buf, sizeof(buf), fmt, args);
@@ -178,6 +179,7 @@ static const struct tnt tnts[] = {
         { TAINT_OVERRIDDEN_ACPI_TABLE,  'A', ' ' },
         { TAINT_WARN,                   'W', ' ' },
         { TAINT_CRAP,                   'C', ' ' },
+        { TAINT_FIRMWARE_WORKAROUND,    'I', ' ' },
 };
 
 /**
@@ -194,6 +196,7 @@ static const struct tnt tnts[] = {
  *  'A' - ACPI table overridden.
  *  'W' - Taint on warning.
  *  'C' - modules from drivers/staging are loaded.
+ *  'I' - Working around severe firmware bug.
  *
  *      The string is overwritten by the next call to print_tainted().
  */
@@ -365,7 +368,8 @@ struct slowpath_args {
         va_list args;
 };
 
-static void warn_slowpath_common(const char *file, int line, void *caller, struct slowpath_args *args)
+static void warn_slowpath_common(const char *file, int line, void *caller,
+                                 unsigned taint, struct slowpath_args *args)
 {
         const char *board;
 
@@ -381,7 +385,7 @@ static void warn_slowpath_common(const char *file, int line, void *caller, struc
         print_modules();
         dump_stack();
         print_oops_end_marker();
-        add_taint(TAINT_WARN);
+        add_taint(taint);
 }
 
 void warn_slowpath_fmt(const char *file, int line, const char *fmt, ...)
@@ -390,14 +394,29 @@ void warn_slowpath_fmt(const char *file, int line, const char *fmt, ...)
 
         args.fmt = fmt;
         va_start(args.args, fmt);
-        warn_slowpath_common(file, line, __builtin_return_address(0), &args);
+        warn_slowpath_common(file, line, __builtin_return_address(0),
+                             TAINT_WARN, &args);
         va_end(args.args);
 }
 EXPORT_SYMBOL(warn_slowpath_fmt);
 
+void warn_slowpath_fmt_taint(const char *file, int line,
+                             unsigned taint, const char *fmt, ...)
+{
+        struct slowpath_args args;
+
+        args.fmt = fmt;
+        va_start(args.args, fmt);
+        warn_slowpath_common(file, line, __builtin_return_address(0),
+                             taint, &args);
+        va_end(args.args);
+}
+EXPORT_SYMBOL(warn_slowpath_fmt_taint);
+
 void warn_slowpath_null(const char *file, int line)
 {
-        warn_slowpath_common(file, line, __builtin_return_address(0), NULL);
+        warn_slowpath_common(file, line, __builtin_return_address(0),
+                             TAINT_WARN, NULL);
 }
 EXPORT_SYMBOL(warn_slowpath_null);
 #endif
diff --git a/kernel/perf_event.c b/kernel/perf_event.c
index a4fa381db3c2..bd7ce8ca5bb9 100644
--- a/kernel/perf_event.c
+++ b/kernel/perf_event.c
@@ -2297,11 +2297,6 @@ unlock:
         rcu_read_unlock();
 }
 
-static unsigned long perf_data_size(struct perf_mmap_data *data)
-{
-        return data->nr_pages << (PAGE_SHIFT + data->data_order);
-}
-
 #ifndef CONFIG_PERF_USE_VMALLOC
 
 /*
@@ -2320,6 +2315,19 @@ perf_mmap_to_page(struct perf_mmap_data *data, unsigned long pgoff)
         return virt_to_page(data->data_pages[pgoff - 1]);
 }
 
+static void *perf_mmap_alloc_page(int cpu)
+{
+        struct page *page;
+        int node;
+
+        node = (cpu == -1) ? cpu : cpu_to_node(cpu);
+        page = alloc_pages_node(node, GFP_KERNEL | __GFP_ZERO, 0);
+        if (!page)
+                return NULL;
+
+        return page_address(page);
+}
+
 static struct perf_mmap_data *
 perf_mmap_data_alloc(struct perf_event *event, int nr_pages)
 {
@@ -2336,17 +2344,16 @@ perf_mmap_data_alloc(struct perf_event *event, int nr_pages)
         if (!data)
                 goto fail;
 
-        data->user_page = (void *)get_zeroed_page(GFP_KERNEL);
+        data->user_page = perf_mmap_alloc_page(event->cpu);
         if (!data->user_page)
                 goto fail_user_page;
 
         for (i = 0; i < nr_pages; i++) {
-                data->data_pages[i] = (void *)get_zeroed_page(GFP_KERNEL);
+                data->data_pages[i] = perf_mmap_alloc_page(event->cpu);
                 if (!data->data_pages[i])
                         goto fail_data_pages;
         }
 
-        data->data_order = 0;
         data->nr_pages = nr_pages;
 
         return data;
@@ -2382,6 +2389,11 @@ static void perf_mmap_data_free(struct perf_mmap_data *data)
         kfree(data);
 }
 
+static inline int page_order(struct perf_mmap_data *data)
+{
+        return 0;
+}
+
 #else
 
 /*
@@ -2390,10 +2402,15 @@ static void perf_mmap_data_free(struct perf_mmap_data *data)
  * Required for architectures that have d-cache aliasing issues.
  */
 
+static inline int page_order(struct perf_mmap_data *data)
+{
+        return data->page_order;
+}
+
 static struct page *
 perf_mmap_to_page(struct perf_mmap_data *data, unsigned long pgoff)
 {
-        if (pgoff > (1UL << data->data_order))
+        if (pgoff > (1UL << page_order(data)))
                 return NULL;
 
         return vmalloc_to_page((void *)data->user_page + pgoff * PAGE_SIZE);
@@ -2413,7 +2430,7 @@ static void perf_mmap_data_free_work(struct work_struct *work)
         int i, nr;
 
         data = container_of(work, struct perf_mmap_data, work);
-        nr = 1 << data->data_order;
+        nr = 1 << page_order(data);
 
         base = data->user_page;
         for (i = 0; i < nr + 1; i++)
@@ -2452,7 +2469,7 @@ perf_mmap_data_alloc(struct perf_event *event, int nr_pages)
 
         data->user_page = all_buf;
         data->data_pages[0] = all_buf + PAGE_SIZE;
-        data->data_order = ilog2(nr_pages);
+        data->page_order = ilog2(nr_pages);
         data->nr_pages = 1;
 
         return data;
@@ -2466,6 +2483,11 @@ fail:
 
 #endif
 
+static unsigned long perf_data_size(struct perf_mmap_data *data)
+{
+        return data->nr_pages << (PAGE_SHIFT + page_order(data));
+}
+
 static int perf_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
         struct perf_event *event = vma->vm_file->private_data;
@@ -2506,8 +2528,6 @@ perf_mmap_data_init(struct perf_event *event, struct perf_mmap_data *data)
 {
         long max_size = perf_data_size(data);
 
-        atomic_set(&data->lock, -1);
-
         if (event->attr.watermark) {
                 data->watermark = min_t(long, max_size,
                                         event->attr.wakeup_watermark);
@@ -2580,6 +2600,14 @@ static int perf_mmap(struct file *file, struct vm_area_struct *vma)
         long user_extra, extra;
         int ret = 0;
 
+        /*
+         * Don't allow mmap() of inherited per-task counters. This would
+         * create a performance issue due to all children writing to the
+         * same buffer.
+         */
+        if (event->cpu == -1 && event->attr.inherit)
+                return -EINVAL;
+
         if (!(vma->vm_flags & VM_SHARED))
                 return -EINVAL;
 
@@ -2885,120 +2913,80 @@ static void perf_output_wakeup(struct perf_output_handle *handle)
 }
 
 /*
- * Curious locking construct.
- *
  * We need to ensure a later event_id doesn't publish a head when a former
- * event_id isn't done writing. However since we need to deal with NMIs we
+ * event isn't done writing. However since we need to deal with NMIs we
  * cannot fully serialize things.
  *
- * What we do is serialize between CPUs so we only have to deal with NMI
- * nesting on a single CPU.
- *
  * We only publish the head (and generate a wakeup) when the outer-most
- * event_id completes.
+ * event completes.
  */
-static void perf_output_lock(struct perf_output_handle *handle)
+static void perf_output_get_handle(struct perf_output_handle *handle)
 {
         struct perf_mmap_data *data = handle->data;
-        int cur, cpu = get_cpu();
-
-        handle->locked = 0;
 
-        for (;;) {
-                cur = atomic_cmpxchg(&data->lock, -1, cpu);
-                if (cur == -1) {
-                        handle->locked = 1;
-                        break;
-                }
-                if (cur == cpu)
-                        break;
-
-                cpu_relax();
-        }
+        preempt_disable();
+        local_inc(&data->nest);
+        handle->wakeup = local_read(&data->wakeup);
 }
 
-static void perf_output_unlock(struct perf_output_handle *handle)
+static void perf_output_put_handle(struct perf_output_handle *handle)
 {
         struct perf_mmap_data *data = handle->data;
         unsigned long head;
-        int cpu;
-
-        data->done_head = data->head;
-
-        if (!handle->locked)
-                goto out;
 
 again:
-        /*
-         * The xchg implies a full barrier that ensures all writes are done
-         * before we publish the new head, matched by a rmb() in userspace when
-         * reading this position.
-         */
-        while ((head = atomic_long_xchg(&data->done_head, 0)))
-                data->user_page->data_head = head;
+        head = local_read(&data->head);
 
         /*
-         * NMI can happen here, which means we can miss a done_head update.
+         * IRQ/NMI can happen here, which means we can miss a head update.
          */
 
-        cpu = atomic_xchg(&data->lock, -1);
-        WARN_ON_ONCE(cpu != smp_processor_id());
+        if (!local_dec_and_test(&data->nest))
+                goto out;
 
         /*
-         * Therefore we have to validate we did not indeed do so.
+         * Publish the known good head. Rely on the full barrier implied
+         * by atomic_dec_and_test() order the data->head read and this
+         * write.
          */
-        if (unlikely(atomic_long_read(&data->done_head))) {
-                /*
-                 * Since we had it locked, we can lock it again.
-                 */
-                while (atomic_cmpxchg(&data->lock, -1, cpu) != -1)
-                        cpu_relax();
+        data->user_page->data_head = head;
 
+        /*
+         * Now check if we missed an update, rely on the (compiler)
+         * barrier in atomic_dec_and_test() to re-read data->head.
+         */
+        if (unlikely(head != local_read(&data->head))) {
+                local_inc(&data->nest);
                 goto again;
         }
 
-        if (atomic_xchg(&data->wakeup, 0))
+        if (handle->wakeup != local_read(&data->wakeup))
                 perf_output_wakeup(handle);
-out:
-        put_cpu();
+
+ out:
+        preempt_enable();
 }
 
-void perf_output_copy(struct perf_output_handle *handle,
+__always_inline void perf_output_copy(struct perf_output_handle *handle,
                       const void *buf, unsigned int len)
 {
-        unsigned int pages_mask;
-        unsigned long offset;
-        unsigned int size;
-        void **pages;
-
-        offset          = handle->offset;
-        pages_mask      = handle->data->nr_pages - 1;
-        pages           = handle->data->data_pages;
-
         do {
-                unsigned long page_offset;
-                unsigned long page_size;
-                int nr;
+                unsigned long size = min_t(unsigned long, handle->size, len);
 
-                nr          = (offset >> PAGE_SHIFT) & pages_mask;
-                page_size   = 1UL << (handle->data->data_order + PAGE_SHIFT);
-                page_offset = offset & (page_size - 1);
-                size        = min_t(unsigned int, page_size - page_offset, len);
+                memcpy(handle->addr, buf, size);
 
-                memcpy(pages[nr] + page_offset, buf, size);
+                len -= size;
+                handle->addr += size;
+                handle->size -= size;
+                if (!handle->size) {
+                        struct perf_mmap_data *data = handle->data;
 
-                len         -= size;
-                buf         += size;
-                offset      += size;
+                        handle->page++;
+                        handle->page &= data->nr_pages - 1;
+                        handle->addr = data->data_pages[handle->page];
+                        handle->size = PAGE_SIZE << page_order(data);
+                }
         } while (len);
-
-        handle->offset = offset;
-
-        /*
-         * Check we didn't copy past our reservation window, taking the
-         * possible unsigned int wrap into account.
-         */
-        WARN_ON_ONCE(((long)(handle->head - handle->offset)) < 0);
 }
 
 int perf_output_begin(struct perf_output_handle *handle,
@@ -3036,13 +3024,13 @@ int perf_output_begin(struct perf_output_handle *handle,
         handle->sample  = sample;
 
         if (!data->nr_pages)
-                goto fail;
+                goto out;
 
-        have_lost = atomic_read(&data->lost);
+        have_lost = local_read(&data->lost);
         if (have_lost)
                 size += sizeof(lost_event);
 
-        perf_output_lock(handle);
+        perf_output_get_handle(handle);
 
         do {
                 /*
@@ -3052,24 +3040,28 @@ int perf_output_begin(struct perf_output_handle *handle,
                  */
                 tail = ACCESS_ONCE(data->user_page->data_tail);
                 smp_rmb();
-                offset = head = atomic_long_read(&data->head);
+                offset = head = local_read(&data->head);
                 head += size;
                 if (unlikely(!perf_output_space(data, tail, offset, head)))
                         goto fail;
-        } while (atomic_long_cmpxchg(&data->head, offset, head) != offset);
+        } while (local_cmpxchg(&data->head, offset, head) != offset);
 
-        handle->offset  = offset;
-        handle->head    = head;
+        if (head - local_read(&data->wakeup) > data->watermark)
+                local_add(data->watermark, &data->wakeup);
 
-        if (head - tail > data->watermark)
-                atomic_set(&data->wakeup, 1);
+        handle->page = offset >> (PAGE_SHIFT + page_order(data));
+        handle->page &= data->nr_pages - 1;
+        handle->size = offset & ((PAGE_SIZE << page_order(data)) - 1);
+        handle->addr = data->data_pages[handle->page];
+        handle->addr += handle->size;
+        handle->size = (PAGE_SIZE << page_order(data)) - handle->size;
 
         if (have_lost) {
                 lost_event.header.type = PERF_RECORD_LOST;
                 lost_event.header.misc = 0;
                 lost_event.header.size = sizeof(lost_event);
                 lost_event.id          = event->id;
-                lost_event.lost        = atomic_xchg(&data->lost, 0);
+                lost_event.lost        = local_xchg(&data->lost, 0);
 
                 perf_output_put(handle, lost_event);
         }
@@ -3077,8 +3069,8 @@ int perf_output_begin(struct perf_output_handle *handle,
         return 0;
 
 fail:
-        atomic_inc(&data->lost);
-        perf_output_unlock(handle);
+        local_inc(&data->lost);
+        perf_output_put_handle(handle);
 out:
         rcu_read_unlock();
 
@@ -3093,14 +3085,14 @@ void perf_output_end(struct perf_output_handle *handle)
         int wakeup_events = event->attr.wakeup_events;
 
         if (handle->sample && wakeup_events) {
-                int events = atomic_inc_return(&data->events);
+                int events = local_inc_return(&data->events);
                 if (events >= wakeup_events) {
-                        atomic_sub(wakeup_events, &data->events);
-                        atomic_set(&data->wakeup, 1);
+                        local_sub(wakeup_events, &data->events);
+                        local_inc(&data->wakeup);
                 }
         }
 
-        perf_output_unlock(handle);
+        perf_output_put_handle(handle);
         rcu_read_unlock();
 }
 
@@ -3436,22 +3428,13 @@ static void perf_event_task_output(struct perf_event *event,
 {
         struct perf_output_handle handle;
         struct task_struct *task = task_event->task;
-        unsigned long flags;
         int size, ret;
 
-        /*
-         * If this CPU attempts to acquire an rq lock held by a CPU spinning
-         * in perf_output_lock() from interrupt context, it's game over.
-         */
-        local_irq_save(flags);
-
         size  = task_event->event_id.header.size;
         ret = perf_output_begin(&handle, event, size, 0, 0);
 
-        if (ret) {
-                local_irq_restore(flags);
+        if (ret)
                 return;
-        }
 
         task_event->event_id.pid = perf_event_pid(event, task);
         task_event->event_id.ppid = perf_event_pid(event, current);
@@ -3462,7 +3445,6 @@ static void perf_event_task_output(struct perf_event *event,
         perf_output_put(&handle, task_event->event_id);
 
         perf_output_end(&handle);
-        local_irq_restore(flags);
 }
 
 static int perf_event_task_match(struct perf_event *event)
@@ -4020,9 +4002,6 @@ static void perf_swevent_add(struct perf_event *event, u64 nr,
         perf_swevent_overflow(event, 0, nmi, data, regs);
 }
 
-static int perf_tp_event_match(struct perf_event *event,
-                                struct perf_sample_data *data);
-
 static int perf_exclude_event(struct perf_event *event,
                               struct pt_regs *regs)
 {
@@ -4052,10 +4031,6 @@ static int perf_swevent_match(struct perf_event *event,
         if (perf_exclude_event(event, regs))
                 return 0;
 
-        if (event->attr.type == PERF_TYPE_TRACEPOINT &&
-            !perf_tp_event_match(event, data))
-                return 0;
-
         return 1;
 }
 
@@ -4066,19 +4041,46 @@ static inline u64 swevent_hash(u64 type, u32 event_id)
         return hash_64(val, SWEVENT_HLIST_BITS);
 }
 
-static struct hlist_head *
-find_swevent_head(struct perf_cpu_context *ctx, u64 type, u32 event_id)
+static inline struct hlist_head *
+__find_swevent_head(struct swevent_hlist *hlist, u64 type, u32 event_id)
 {
-        u64 hash;
-        struct swevent_hlist *hlist;
+        u64 hash = swevent_hash(type, event_id);
 
-        hash = swevent_hash(type, event_id);
+        return &hlist->heads[hash];
+}
+
+/* For the read side: events when they trigger */
+static inline struct hlist_head *
+find_swevent_head_rcu(struct perf_cpu_context *ctx, u64 type, u32 event_id)
+{
+        struct swevent_hlist *hlist;
 
         hlist = rcu_dereference(ctx->swevent_hlist);
         if (!hlist)
                 return NULL;
 
-        return &hlist->heads[hash];
+        return __find_swevent_head(hlist, type, event_id);
+}
+
+/* For the event head insertion and removal in the hlist */
+static inline struct hlist_head *
+find_swevent_head(struct perf_cpu_context *ctx, struct perf_event *event)
+{
+        struct swevent_hlist *hlist;
+        u32 event_id = event->attr.config;
+        u64 type = event->attr.type;
+
+        /*
+         * Event scheduling is always serialized against hlist allocation
+         * and release. Which makes the protected version suitable here.
+         * The context lock guarantees that.
+         */
+        hlist = rcu_dereference_protected(ctx->swevent_hlist,
+                                          lockdep_is_held(&event->ctx->lock));
+        if (!hlist)
+                return NULL;
+
+        return __find_swevent_head(hlist, type, event_id);
 }
 
 static void do_perf_sw_event(enum perf_type_id type, u32 event_id,
@@ -4095,7 +4097,7 @@ static void do_perf_sw_event(enum perf_type_id type, u32 event_id,
 
         rcu_read_lock();
 
-        head = find_swevent_head(cpuctx, type, event_id);
+        head = find_swevent_head_rcu(cpuctx, type, event_id);
 
         if (!head)
                 goto end;
@@ -4110,7 +4112,7 @@ end:
 
 int perf_swevent_get_recursion_context(void)
 {
-        struct perf_cpu_context *cpuctx = &get_cpu_var(perf_cpu_context);
+        struct perf_cpu_context *cpuctx = &__get_cpu_var(perf_cpu_context);
         int rctx;
 
         if (in_nmi())
@@ -4122,10 +4124,8 @@ int perf_swevent_get_recursion_context(void)
         else
                 rctx = 0;
 
-        if (cpuctx->recursion[rctx]) {
-                put_cpu_var(perf_cpu_context);
+        if (cpuctx->recursion[rctx])
                 return -1;
-        }
 
         cpuctx->recursion[rctx]++;
         barrier();
@@ -4139,7 +4139,6 @@ void perf_swevent_put_recursion_context(int rctx)
         struct perf_cpu_context *cpuctx = &__get_cpu_var(perf_cpu_context);
         barrier();
         cpuctx->recursion[rctx]--;
-        put_cpu_var(perf_cpu_context);
 }
 EXPORT_SYMBOL_GPL(perf_swevent_put_recursion_context);
 
@@ -4150,6 +4149,7 @@ void __perf_sw_event(u32 event_id, u64 nr, int nmi,
         struct perf_sample_data data;
         int rctx;
 
+        preempt_disable_notrace();
         rctx = perf_swevent_get_recursion_context();
         if (rctx < 0)
                 return;
@@ -4159,6 +4159,7 @@ void __perf_sw_event(u32 event_id, u64 nr, int nmi,
         do_perf_sw_event(PERF_TYPE_SOFTWARE, event_id, nr, nmi, &data, regs);
 
         perf_swevent_put_recursion_context(rctx);
+        preempt_enable_notrace();
 }
 
 static void perf_swevent_read(struct perf_event *event)
@@ -4178,7 +4179,7 @@ static int perf_swevent_enable(struct perf_event *event)
                 perf_swevent_set_period(event);
         }
 
-        head = find_swevent_head(cpuctx, event->attr.type, event->attr.config);
+        head = find_swevent_head(cpuctx, event);
         if (WARN_ON_ONCE(!head))
                 return -EINVAL;
 
@@ -4366,6 +4367,14 @@ static const struct pmu perf_ops_task_clock = {
         .read           = task_clock_perf_event_read,
 };
 
+/* Deref the hlist from the update side */
+static inline struct swevent_hlist *
+swevent_hlist_deref(struct perf_cpu_context *cpuctx)
+{
+        return rcu_dereference_protected(cpuctx->swevent_hlist,
+                                         lockdep_is_held(&cpuctx->hlist_mutex));
+}
+
 static void swevent_hlist_release_rcu(struct rcu_head *rcu_head)
 {
         struct swevent_hlist *hlist;
@@ -4376,12 +4385,11 @@ static void swevent_hlist_release_rcu(struct rcu_head *rcu_head)
 
 static void swevent_hlist_release(struct perf_cpu_context *cpuctx)
 {
-        struct swevent_hlist *hlist;
+        struct swevent_hlist *hlist = swevent_hlist_deref(cpuctx);
 
-        if (!cpuctx->swevent_hlist)
+        if (!hlist)
                 return;
 
-        hlist = cpuctx->swevent_hlist;
         rcu_assign_pointer(cpuctx->swevent_hlist, NULL);
         call_rcu(&hlist->rcu_head, swevent_hlist_release_rcu);
 }
@@ -4418,7 +4426,7 @@ static int swevent_hlist_get_cpu(struct perf_event *event, int cpu)
 
         mutex_lock(&cpuctx->hlist_mutex);
 
-        if (!cpuctx->swevent_hlist && cpu_online(cpu)) {
+        if (!swevent_hlist_deref(cpuctx) && cpu_online(cpu)) {
                 struct swevent_hlist *hlist;
 
                 hlist = kzalloc(sizeof(*hlist), GFP_KERNEL);
@@ -4467,10 +4475,46 @@ static int swevent_hlist_get(struct perf_event *event)
 
 #ifdef CONFIG_EVENT_TRACING
 
-void perf_tp_event(int event_id, u64 addr, u64 count, void *record,
-                   int entry_size, struct pt_regs *regs)
+static const struct pmu perf_ops_tracepoint = {
+        .enable         = perf_trace_enable,
+        .disable        = perf_trace_disable,
+        .read           = perf_swevent_read,
+        .unthrottle     = perf_swevent_unthrottle,
+};
+
+static int perf_tp_filter_match(struct perf_event *event,
+                                struct perf_sample_data *data)
+{
+        void *record = data->raw->data;
+
+        if (likely(!event->filter) || filter_match_preds(event->filter, record))
+                return 1;
+        return 0;
+}
+
+static int perf_tp_event_match(struct perf_event *event,
+                                struct perf_sample_data *data,
+                                struct pt_regs *regs)
+{
+        /*
+         * All tracepoints are from kernel-space.
+         */
+        if (event->attr.exclude_kernel)
+                return 0;
+
+        if (!perf_tp_filter_match(event, data))
+                return 0;
+
+        return 1;
+}
+
+void perf_tp_event(u64 addr, u64 count, void *record, int entry_size,
+                   struct pt_regs *regs, struct hlist_head *head)
 {
         struct perf_sample_data data;
+        struct perf_event *event;
+        struct hlist_node *node;
+
         struct perf_raw_record raw = {
                 .size = entry_size,
                 .data = record,
@@ -4479,26 +4523,18 @@ void perf_tp_event(int event_id, u64 addr, u64 count, void *record,
         perf_sample_data_init(&data, addr);
         data.raw = &raw;
 
-        /* Trace events already protected against recursion */
-        do_perf_sw_event(PERF_TYPE_TRACEPOINT, event_id, count, 1,
-                         &data, regs);
+        rcu_read_lock();
+        hlist_for_each_entry_rcu(event, node, head, hlist_entry) {
+                if (perf_tp_event_match(event, &data, regs))
+                        perf_swevent_add(event, count, 1, &data, regs);
+        }
+        rcu_read_unlock();
 }
 EXPORT_SYMBOL_GPL(perf_tp_event);
 
-static int perf_tp_event_match(struct perf_event *event,
-                                struct perf_sample_data *data)
-{
-        void *record = data->raw->data;
-
-        if (likely(!event->filter) || filter_match_preds(event->filter, record))
-                return 1;
-        return 0;
-}
-
 static void tp_perf_event_destroy(struct perf_event *event)
 {
-        perf_trace_disable(event->attr.config);
-        swevent_hlist_put(event);
+        perf_trace_destroy(event);
 }
 
 static const struct pmu *tp_perf_event_init(struct perf_event *event)
@@ -4514,17 +4550,13 @@ static const struct pmu *tp_perf_event_init(struct perf_event *event)
                         !capable(CAP_SYS_ADMIN))
                 return ERR_PTR(-EPERM);
 
-        if (perf_trace_enable(event->attr.config))
+        err = perf_trace_init(event);
+        if (err)
                 return NULL;
 
         event->destroy = tp_perf_event_destroy;
-        err = swevent_hlist_get(event);
-        if (err) {
-                perf_trace_disable(event->attr.config);
-                return ERR_PTR(err);
-        }
 
-        return &perf_ops_generic;
+        return &perf_ops_tracepoint;
 }
 
 static int perf_event_set_filter(struct perf_event *event, void __user *arg)
@@ -4552,12 +4584,6 @@ static void perf_event_free_filter(struct perf_event *event)
 
 #else
 
-static int perf_tp_event_match(struct perf_event *event,
-                                struct perf_sample_data *data)
-{
-        return 1;
-}
-
 static const struct pmu *tp_perf_event_init(struct perf_event *event)
 {
         return NULL;
@@ -4894,6 +4920,13 @@ static int perf_event_set_output(struct perf_event *event, int output_fd)
         int fput_needed = 0;
         int ret = -EINVAL;
 
+        /*
+         * Don't allow output of inherited per-task events. This would
+         * create performance issues due to cross cpu access.
+         */
+        if (event->cpu == -1 && event->attr.inherit)
+                return -EINVAL;
+
         if (!output_fd)
                 goto set;
 
@@ -4914,6 +4947,18 @@ static int perf_event_set_output(struct perf_event *event, int output_fd)
         if (event->data)
                 goto out;
 
+        /*
+         * Don't allow cross-cpu buffers
+         */
+        if (output_event->cpu != event->cpu)
+                goto out;
+
+        /*
+         * If its not a per-cpu buffer, it must be the same task.
+         */
+        if (output_event->cpu == -1 && output_event->ctx != event->ctx)
+                goto out;
+
         atomic_long_inc(&output_file->f_count);
 
 set:
@@ -4954,8 +4999,8 @@ SYSCALL_DEFINE5(perf_event_open,
         struct perf_event_context *ctx;
         struct file *event_file = NULL;
         struct file *group_file = NULL;
+        int event_fd;
         int fput_needed = 0;
-        int fput_needed2 = 0;
         int err;
 
         /* for future expandability... */
@@ -4976,12 +5021,18 @@ SYSCALL_DEFINE5(perf_event_open,
                         return -EINVAL;
         }
 
+        event_fd = get_unused_fd_flags(O_RDWR);
+        if (event_fd < 0)
+                return event_fd;
+
         /*
          * Get the target context (task or percpu):
          */
         ctx = find_get_context(pid, cpu);
-        if (IS_ERR(ctx))
-                return PTR_ERR(ctx);
+        if (IS_ERR(ctx)) {
+                err = PTR_ERR(ctx);
+                goto err_fd;
+        }
 
         /*
          * Look up the group leader (we will attach this event to it):
@@ -5021,13 +5072,11 @@ SYSCALL_DEFINE5(perf_event_open,
         if (IS_ERR(event))
                 goto err_put_context;
 
-        err = anon_inode_getfd("[perf_event]", &perf_fops, event, O_RDWR);
-        if (err < 0)
-                goto err_free_put_context;
-
-        event_file = fget_light(err, &fput_needed2);
-        if (!event_file)
+        event_file = anon_inode_getfile("[perf_event]", &perf_fops, event, O_RDWR);
+        if (IS_ERR(event_file)) {
+                err = PTR_ERR(event_file);
                 goto err_free_put_context;
+        }
 
         if (flags & PERF_FLAG_FD_OUTPUT) {
                 err = perf_event_set_output(event, group_fd);
@@ -5048,19 +5097,19 @@ SYSCALL_DEFINE5(perf_event_open,
         list_add_tail(&event->owner_entry, &current->perf_event_list);
         mutex_unlock(&current->perf_event_mutex);
 
-err_fput_free_put_context:
-        fput_light(event_file, fput_needed2);
+        fput_light(group_file, fput_needed);
+        fd_install(event_fd, event_file);
+        return event_fd;
 
+err_fput_free_put_context:
+        fput(event_file);
 err_free_put_context:
-        if (err < 0)
-                free_event(event);
-
+        free_event(event);
 err_put_context:
-        if (err < 0)
-                put_ctx(ctx);
-
         fput_light(group_file, fput_needed);
-
+        put_ctx(ctx);
+err_fd:
+        put_unused_fd(event_fd);
         return err;
 }
 
diff --git a/kernel/pid.c b/kernel/pid.c
index aebb30d9c233..e9fd8c132d26 100644
--- a/kernel/pid.c
+++ b/kernel/pid.c
@@ -513,6 +513,13 @@ void __init pidhash_init(void)
 
 void __init pidmap_init(void)
 {
+        /* bump default and minimum pid_max based on number of cpus */
+        pid_max = min(pid_max_max, max_t(int, pid_max,
+                                PIDS_PER_CPU_DEFAULT * num_possible_cpus()));
+        pid_max_min = max_t(int, pid_max_min,
+                                PIDS_PER_CPU_MIN * num_possible_cpus());
+        pr_info("pid_max: default: %u minimum: %u\n", pid_max, pid_max_min);
+
         init_pid_ns.pidmap[0].page = kzalloc(PAGE_SIZE, GFP_KERNEL);
         /* Reserve PID 0. We never call free_pidmap(0) */
         set_bit(0, init_pid_ns.pidmap[0].page);
diff --git a/kernel/posix-cpu-timers.c b/kernel/posix-cpu-timers.c
index 00bb252f29a2..9829646d399c 100644
--- a/kernel/posix-cpu-timers.c
+++ b/kernel/posix-cpu-timers.c
@@ -363,7 +363,7 @@ int posix_cpu_clock_get(const clockid_t which_clock, struct timespec *tp)
                                 }
                         } else {
                                 read_lock(&tasklist_lock);
-                                if (thread_group_leader(p) && p->signal) {
+                                if (thread_group_leader(p) && p->sighand) {
                                         error =
                                             cpu_clock_sample_group(which_clock,
                                                                    p, &rtn);
@@ -439,7 +439,7 @@ int posix_cpu_timer_del(struct k_itimer *timer)
 
         if (likely(p != NULL)) {
                 read_lock(&tasklist_lock);
-                if (unlikely(p->signal == NULL)) {
+                if (unlikely(p->sighand == NULL)) {
                         /*
                          * We raced with the reaping of the task.
                          * The deletion should have cleared us off the list.
@@ -691,10 +691,10 @@ int posix_cpu_timer_set(struct k_itimer *timer, int flags,
         read_lock(&tasklist_lock);
         /*
          * We need the tasklist_lock to protect against reaping that
-         * clears p->signal.  If p has just been reaped, we can no
+         * clears p->sighand.  If p has just been reaped, we can no
          * longer get any information about it at all.
          */
-        if (unlikely(p->signal == NULL)) {
+        if (unlikely(p->sighand == NULL)) {
                 read_unlock(&tasklist_lock);
                 put_task_struct(p);
                 timer->it.cpu.task = NULL;
@@ -863,7 +863,7 @@ void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec *itp)
                 clear_dead = p->exit_state;
         } else {
                 read_lock(&tasklist_lock);
-                if (unlikely(p->signal == NULL)) {
+                if (unlikely(p->sighand == NULL)) {
                         /*
                          * The process has been reaped.
                          * We can't even collect a sample any more.
@@ -1199,7 +1199,7 @@ void posix_cpu_timer_schedule(struct k_itimer *timer)
                 spin_lock(&p->sighand->siglock);
         } else {
                 read_lock(&tasklist_lock);
-                if (unlikely(p->signal == NULL)) {
+                if (unlikely(p->sighand == NULL)) {
                         /*
                          * The process has been reaped.
                          * We can't even collect a sample any more.
diff --git a/kernel/posix-timers.c b/kernel/posix-timers.c
index 00d1fda58ab6..ad723420acc3 100644
--- a/kernel/posix-timers.c
+++ b/kernel/posix-timers.c
@@ -559,14 +559,7 @@ SYSCALL_DEFINE3(timer_create, const clockid_t, which_clock,
         new_timer->it_id = (timer_t) new_timer_id;
         new_timer->it_clock = which_clock;
         new_timer->it_overrun = -1;
-        error = CLOCK_DISPATCH(which_clock, timer_create, (new_timer));
-        if (error)
-                goto out;
 
-        /*
-         * return the timer_id now.  The next step is hard to
-         * back out if there is an error.
-         */
         if (copy_to_user(created_timer_id,
                          &new_timer_id, sizeof (new_timer_id))) {
                 error = -EFAULT;
@@ -597,6 +590,10 @@ SYSCALL_DEFINE3(timer_create, const clockid_t, which_clock,
         new_timer->sigq->info.si_tid   = new_timer->it_id;
         new_timer->sigq->info.si_code  = SI_TIMER;
 
+        error = CLOCK_DISPATCH(which_clock, timer_create, (new_timer));
+        if (error)
+                goto out;
+
         spin_lock_irq(&current->sighand->siglock);
         new_timer->it_signal = current->signal;
         list_add(&new_timer->list, &current->signal->posix_timers);
diff --git a/kernel/printk.c b/kernel/printk.c
index 75077ad0b537..444b770c9595 100644
--- a/kernel/printk.c
+++ b/kernel/printk.c
@@ -33,6 +33,7 @@
 #include <linux/bootmem.h>
 #include <linux/syscalls.h>
 #include <linux/kexec.h>
+#include <linux/kdb.h>
 #include <linux/ratelimit.h>
 #include <linux/kmsg_dump.h>
 #include <linux/syslog.h>
@@ -413,6 +414,22 @@ SYSCALL_DEFINE3(syslog, int, type, char __user *, buf, int, len)
         return do_syslog(type, buf, len, SYSLOG_FROM_CALL);
 }
 
+#ifdef  CONFIG_KGDB_KDB
+/* kdb dmesg command needs access to the syslog buffer.  do_syslog()
+ * uses locks so it cannot be used during debugging.  Just tell kdb
+ * where the start and end of the physical and logical logs are.  This
+ * is equivalent to do_syslog(3).
+ */
+void kdb_syslog_data(char *syslog_data[4])
+{
+        syslog_data[0] = log_buf;
+        syslog_data[1] = log_buf + log_buf_len;
+        syslog_data[2] = log_buf + log_end -
+                (logged_chars < log_buf_len ? logged_chars : log_buf_len);
+        syslog_data[3] = log_buf + log_end;
+}
+#endif  /* CONFIG_KGDB_KDB */
+
 /*
  * Call the console drivers on a range of log_buf
  */
@@ -586,6 +603,14 @@ asmlinkage int printk(const char *fmt, ...)
         va_list args;
         int r;
 
+#ifdef CONFIG_KGDB_KDB
+        if (unlikely(kdb_trap_printk)) {
+                va_start(args, fmt);
+                r = vkdb_printf(fmt, args);
+                va_end(args);
+                return r;
+        }
+#endif
         va_start(args, fmt);
         r = vprintk(fmt, args);
         va_end(args);
diff --git a/kernel/profile.c b/kernel/profile.c
index dfadc5b729f1..b22a899934cc 100644
--- a/kernel/profile.c
+++ b/kernel/profile.c
@@ -365,14 +365,14 @@ static int __cpuinit profile_cpu_callback(struct notifier_block *info,
         switch (action) {
         case CPU_UP_PREPARE:
         case CPU_UP_PREPARE_FROZEN:
-                node = cpu_to_node(cpu);
+                node = cpu_to_mem(cpu);
                 per_cpu(cpu_profile_flip, cpu) = 0;
                 if (!per_cpu(cpu_profile_hits, cpu)[1]) {
                         page = alloc_pages_exact_node(node,
                                         GFP_KERNEL | __GFP_ZERO,
                                         0);
                         if (!page)
-                                return NOTIFY_BAD;
+                                return notifier_from_errno(-ENOMEM);
                         per_cpu(cpu_profile_hits, cpu)[1] = page_address(page);
                 }
                 if (!per_cpu(cpu_profile_hits, cpu)[0]) {
@@ -388,7 +388,7 @@ out_free:
                 page = virt_to_page(per_cpu(cpu_profile_hits, cpu)[1]);
                 per_cpu(cpu_profile_hits, cpu)[1] = NULL;
                 __free_page(page);
-                return NOTIFY_BAD;
+                return notifier_from_errno(-ENOMEM);
         case CPU_ONLINE:
         case CPU_ONLINE_FROZEN:
                 if (prof_cpu_mask != NULL)
@@ -567,7 +567,7 @@ static int create_hash_tables(void)
         int cpu;
 
         for_each_online_cpu(cpu) {
-                int node = cpu_to_node(cpu);
+                int node = cpu_to_mem(cpu);
                 struct page *page;
 
                 page = alloc_pages_exact_node(node,
diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index 6af9cdd558b7..74a3d693c196 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
@@ -594,6 +594,32 @@ int ptrace_request(struct task_struct *child, long request,
                 ret = ptrace_detach(child, data);
                 break;
 
+#ifdef CONFIG_BINFMT_ELF_FDPIC
+        case PTRACE_GETFDPIC: {
+                struct mm_struct *mm = get_task_mm(child);
+                unsigned long tmp = 0;
+
+                ret = -ESRCH;
+                if (!mm)
+                        break;
+
+                switch (addr) {
+                case PTRACE_GETFDPIC_EXEC:
+                        tmp = mm->context.exec_fdpic_loadmap;
+                        break;
+                case PTRACE_GETFDPIC_INTERP:
+                        tmp = mm->context.interp_fdpic_loadmap;
+                        break;
+                default:
+                        break;
+                }
+                mmput(mm);
+
+                ret = put_user(tmp, (unsigned long __user *) data);
+                break;
+        }
+#endif
+
 #ifdef PTRACE_SINGLESTEP
         case PTRACE_SINGLESTEP:
 #endif
diff --git a/kernel/relay.c b/kernel/relay.c
index 3d97f2821611..c7cf397fb929 100644
--- a/kernel/relay.c
+++ b/kernel/relay.c
@@ -539,7 +539,7 @@ static int __cpuinit relay_hotcpu_callback(struct notifier_block *nb,
                                         "relay_hotcpu_callback: cpu %d buffer "
                                         "creation failed\n", hotcpu);
                                 mutex_unlock(&relay_channels_mutex);
-                                return NOTIFY_BAD;
+                                return notifier_from_errno(-ENOMEM);
                         }
                 }
                 mutex_unlock(&relay_channels_mutex);
@@ -1231,8 +1231,8 @@ static ssize_t subbuf_splice_actor(struct file *in,
         size_t read_subbuf = read_start / subbuf_size;
         size_t padding = rbuf->padding[read_subbuf];
         size_t nonpad_end = read_subbuf * subbuf_size + subbuf_size - padding;
-        struct page *pages[PIPE_BUFFERS];
-        struct partial_page partial[PIPE_BUFFERS];
+        struct page *pages[PIPE_DEF_BUFFERS];
+        struct partial_page partial[PIPE_DEF_BUFFERS];
         struct splice_pipe_desc spd = {
                 .pages = pages,
                 .nr_pages = 0,
@@ -1245,6 +1245,8 @@ static ssize_t subbuf_splice_actor(struct file *in,
 
         if (rbuf->subbufs_produced == rbuf->subbufs_consumed)
                 return 0;
+        if (splice_grow_spd(pipe, &spd))
+                return -ENOMEM;
 
         /*
          * Adjust read len, if longer than what is available
@@ -1255,7 +1257,7 @@ static ssize_t subbuf_splice_actor(struct file *in,
         subbuf_pages = rbuf->chan->alloc_size >> PAGE_SHIFT;
         pidx = (read_start / PAGE_SIZE) % subbuf_pages;
         poff = read_start & ~PAGE_MASK;
-        nr_pages = min_t(unsigned int, subbuf_pages, PIPE_BUFFERS);
+        nr_pages = min_t(unsigned int, subbuf_pages, pipe->buffers);
 
         for (total_len = 0; spd.nr_pages < nr_pages; spd.nr_pages++) {
                 unsigned int this_len, this_end, private;
@@ -1289,16 +1291,19 @@ static ssize_t subbuf_splice_actor(struct file *in,
                 }
         }
 
+        ret = 0;
         if (!spd.nr_pages)
-                return 0;
+                goto out;
 
         ret = *nonpad_ret = splice_to_pipe(pipe, &spd);
         if (ret < 0 || ret < total_len)
-                return ret;
+                goto out;
 
         if (read_start + ret == nonpad_end)
                 ret += padding;
 
+out:
+        splice_shrink_spd(pipe, &spd);
         return ret;
 }
 
diff --git a/kernel/resource.c b/kernel/resource.c
index 9c358e263534..7b36976e5dea 100644
--- a/kernel/resource.c
+++ b/kernel/resource.c
@@ -15,6 +15,7 @@
 #include <linux/spinlock.h>
 #include <linux/fs.h>
 #include <linux/proc_fs.h>
+#include <linux/sched.h>
 #include <linux/seq_file.h>
 #include <linux/device.h>
 #include <linux/pfn.h>
@@ -681,6 +682,8 @@ resource_size_t resource_alignment(struct resource *res)
  * release_region releases a matching busy region.
  */
 
+static DECLARE_WAIT_QUEUE_HEAD(muxed_resource_wait);
+
 /**
  * __request_region - create a new busy resource region
  * @parent: parent resource descriptor
@@ -693,6 +696,7 @@ struct resource * __request_region(struct resource *parent,
                                    resource_size_t start, resource_size_t n,
                                    const char *name, int flags)
 {
+        DECLARE_WAITQUEUE(wait, current);
         struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
 
         if (!res)
@@ -717,7 +721,15 @@ struct resource * __request_region(struct resource *parent,
                         if (!(conflict->flags & IORESOURCE_BUSY))
                                 continue;
                 }
-
+                if (conflict->flags & flags & IORESOURCE_MUXED) {
+                        add_wait_queue(&muxed_resource_wait, &wait);
+                        write_unlock(&resource_lock);
+                        set_current_state(TASK_UNINTERRUPTIBLE);
+                        schedule();
+                        remove_wait_queue(&muxed_resource_wait, &wait);
+                        write_lock(&resource_lock);
+                        continue;
+                }
                 /* Uhhuh, that didn't work out.. */
                 kfree(res);
                 res = NULL;
@@ -791,6 +803,8 @@ void __release_region(struct resource *parent, resource_size_t start,
                                 break;
                         *p = res->sibling;
                         write_unlock(&resource_lock);
+                        if (res->flags & IORESOURCE_MUXED)
+                                wake_up(&muxed_resource_wait);
                         kfree(res);
                         return;
                 }
diff --git a/kernel/sched.c b/kernel/sched.c
index d9c0368eeb21..d48408142503 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -969,14 +969,6 @@ static struct rq *task_rq_lock(struct task_struct *p, unsigned long *flags)
         }
 }
 
-void task_rq_unlock_wait(struct task_struct *p)
-{
-        struct rq *rq = task_rq(p);
-
-        smp_mb(); /* spin-unlock-wait is not a full memory barrier */
-        raw_spin_unlock_wait(&rq->lock);
-}
-
 static void __task_rq_unlock(struct rq *rq)
         __releases(rq->lock)
 {
@@ -4062,6 +4054,23 @@ int __sched wait_for_completion_killable(struct completion *x)
 EXPORT_SYMBOL(wait_for_completion_killable);
 
 /**
+ * wait_for_completion_killable_timeout: - waits for completion of a task (w/(to,killable))
+ * @x:  holds the state of this particular completion
+ * @timeout:  timeout value in jiffies
+ *
+ * This waits for either a completion of a specific task to be
+ * signaled or for a specified timeout to expire. It can be
+ * interrupted by a kill signal. The timeout is in jiffies.
+ */
+unsigned long __sched
+wait_for_completion_killable_timeout(struct completion *x,
+                                     unsigned long timeout)
+{
+        return wait_for_common(x, timeout, TASK_KILLABLE);
+}
+EXPORT_SYMBOL(wait_for_completion_killable_timeout);
+
+/**
  *      try_wait_for_completion - try to decrement a completion without blocking
  *      @x:     completion structure
  *
@@ -7759,9 +7768,9 @@ void normalize_rt_tasks(void)
 
 #endif /* CONFIG_MAGIC_SYSRQ */
 
-#ifdef CONFIG_IA64
+#if defined(CONFIG_IA64) || defined(CONFIG_KGDB_KDB)
 /*
- * These functions are only useful for the IA64 MCA handling.
+ * These functions are only useful for the IA64 MCA handling, or kdb.
  *
  * They can only be called when the whole system has been
  * stopped - every CPU needs to be quiescent, and no scheduling
@@ -7781,6 +7790,9 @@ struct task_struct *curr_task(int cpu)
         return cpu_curr(cpu);
 }
 
+#endif /* defined(CONFIG_IA64) || defined(CONFIG_KGDB_KDB) */
+
+#ifdef CONFIG_IA64
 /**
  * set_curr_task - set the current task for a given cpu.
  * @cpu: the processor in question.
diff --git a/kernel/sched_clock.c b/kernel/sched_clock.c
index 5b496132c28a..906a0f718cb3 100644
--- a/kernel/sched_clock.c
+++ b/kernel/sched_clock.c
@@ -41,6 +41,7 @@ unsigned long long __attribute__((weak)) sched_clock(void)
         return (unsigned long long)(jiffies - INITIAL_JIFFIES)
                                         * (NSEC_PER_SEC / HZ);
 }
+EXPORT_SYMBOL_GPL(sched_clock);
 
 static __read_mostly int sched_clock_running;
 
diff --git a/kernel/sched_debug.c b/kernel/sched_debug.c
index 87a330a7185f..35565395d00d 100644
--- a/kernel/sched_debug.c
+++ b/kernel/sched_debug.c
@@ -381,15 +381,9 @@ __initcall(init_sched_debug_procfs);
 void proc_sched_show_task(struct task_struct *p, struct seq_file *m)
 {
         unsigned long nr_switches;
-        unsigned long flags;
-        int num_threads = 1;
-
-        if (lock_task_sighand(p, &flags)) {
-                num_threads = atomic_read(&p->signal->count);
-                unlock_task_sighand(p, &flags);
-        }
 
-        SEQ_printf(m, "%s (%d, #threads: %d)\n", p->comm, p->pid, num_threads);
+        SEQ_printf(m, "%s (%d, #threads: %d)\n", p->comm, p->pid,
+                                                get_nr_threads(p));
         SEQ_printf(m,
                 "---------------------------------------------------------\n");
 #define __P(F) \
diff --git a/kernel/signal.c b/kernel/signal.c
index dbd7fe073c55..906ae5a1779c 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -642,7 +642,7 @@ static inline bool si_fromuser(const struct siginfo *info)
 static int check_kill_permission(int sig, struct siginfo *info,
                                  struct task_struct *t)
 {
-        const struct cred *cred = current_cred(), *tcred;
+        const struct cred *cred, *tcred;
         struct pid *sid;
         int error;
 
@@ -656,8 +656,10 @@ static int check_kill_permission(int sig, struct siginfo *info,
         if (error)
                 return error;
 
+        cred = current_cred();
         tcred = __task_cred(t);
-        if ((cred->euid ^ tcred->suid) &&
+        if (!same_thread_group(current, t) &&
+            (cred->euid ^ tcred->suid) &&
             (cred->euid ^ tcred->uid) &&
             (cred->uid  ^ tcred->suid) &&
             (cred->uid  ^ tcred->uid) &&
@@ -1083,23 +1085,24 @@ force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
 /*
  * Nuke all other threads in the group.
  */
-void zap_other_threads(struct task_struct *p)
+int zap_other_threads(struct task_struct *p)
 {
-        struct task_struct *t;
+        struct task_struct *t = p;
+        int count = 0;
 
         p->signal->group_stop_count = 0;
 
-        for (t = next_thread(p); t != p; t = next_thread(t)) {
-                /*
-                 * Don't bother with already dead threads
-                 */
+        while_each_thread(p, t) {
+                count++;
+
+                /* Don't bother with already dead threads */
                 if (t->exit_state)
                         continue;
-
-                /* SIGKILL will be handled before any pending SIGSTOP */
                 sigaddset(&t->pending.signal, SIGKILL);
                 signal_wake_up(t, 1);
         }
+
+        return count;
 }
 
 struct sighand_struct *lock_task_sighand(struct task_struct *tsk, unsigned long *flags)
@@ -2735,3 +2738,43 @@ void __init signals_init(void)
 {
         sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
 }
+
+#ifdef CONFIG_KGDB_KDB
+#include <linux/kdb.h>
+/*
+ * kdb_send_sig_info - Allows kdb to send signals without exposing
+ * signal internals.  This function checks if the required locks are
+ * available before calling the main signal code, to avoid kdb
+ * deadlocks.
+ */
+void
+kdb_send_sig_info(struct task_struct *t, struct siginfo *info)
+{
+        static struct task_struct *kdb_prev_t;
+        int sig, new_t;
+        if (!spin_trylock(&t->sighand->siglock)) {
+                kdb_printf("Can't do kill command now.\n"
+                           "The sigmask lock is held somewhere else in "
+                           "kernel, try again later\n");
+                return;
+        }
+        spin_unlock(&t->sighand->siglock);
+        new_t = kdb_prev_t != t;
+        kdb_prev_t = t;
+        if (t->state != TASK_RUNNING && new_t) {
+                kdb_printf("Process is not RUNNING, sending a signal from "
+                           "kdb risks deadlock\n"
+                           "on the run queue locks. "
+                           "The signal has _not_ been sent.\n"
+                           "Reissue the kill command if you want to risk "
+                           "the deadlock.\n");
+                return;
+        }
+        sig = info->si_signo;
+        if (send_sig_info(sig, info, t))
+                kdb_printf("Fail to deliver Signal %d to process %d.\n",
+                           sig, t->pid);
+        else
+                kdb_printf("Signal %d is sent to process %d.\n", sig, t->pid);
+}
+#endif  /* CONFIG_KGDB_KDB */
diff --git a/kernel/smp.c b/kernel/smp.c
index 3fc697336183..75c970c715d3 100644
--- a/kernel/smp.c
+++ b/kernel/smp.c
@@ -52,7 +52,7 @@ hotplug_cfd(struct notifier_block *nfb, unsigned long action, void *hcpu)
         case CPU_UP_PREPARE_FROZEN:
                 if (!zalloc_cpumask_var_node(&cfd->cpumask, GFP_KERNEL,
                                 cpu_to_node(cpu)))
-                        return NOTIFY_BAD;
+                        return notifier_from_errno(-ENOMEM);
                 break;
 
 #ifdef CONFIG_HOTPLUG_CPU
diff --git a/kernel/softirq.c b/kernel/softirq.c
index 0db913a5c60f..825e1126008f 100644
--- a/kernel/softirq.c
+++ b/kernel/softirq.c
@@ -808,7 +808,7 @@ static int __cpuinit cpu_callback(struct notifier_block *nfb,
                 p = kthread_create(run_ksoftirqd, hcpu, "ksoftirqd/%d", hotcpu);
                 if (IS_ERR(p)) {
                         printk("ksoftirqd for %i failed\n", hotcpu);
-                        return NOTIFY_BAD;
+                        return notifier_from_errno(PTR_ERR(p));
                 }
                 kthread_bind(p, hotcpu);
                 per_cpu(ksoftirqd, hotcpu) = p;
diff --git a/kernel/sys.c b/kernel/sys.c
index 0d36d889c74d..e83ddbbaf89d 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -1632,9 +1632,9 @@ SYSCALL_DEFINE3(getcpu, unsigned __user *, cpup, unsigned __user *, nodep,
 
 char poweroff_cmd[POWEROFF_CMD_PATH_LEN] = "/sbin/poweroff";
 
-static void argv_cleanup(char **argv, char **envp)
+static void argv_cleanup(struct subprocess_info *info)
 {
-        argv_free(argv);
+        argv_free(info->argv);
 }
 
 /**
@@ -1668,7 +1668,7 @@ int orderly_poweroff(bool force)
                 goto out;
         }
 
-        call_usermodehelper_setcleanup(info, argv_cleanup);
+        call_usermodehelper_setfns(info, NULL, argv_cleanup, NULL);
 
         ret = call_usermodehelper_exec(info, UMH_NO_WAIT);
 
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index f948f20f09cb..997080f00e0b 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -37,6 +37,7 @@
 #include <linux/highuid.h>
 #include <linux/writeback.h>
 #include <linux/ratelimit.h>
+#include <linux/compaction.h>
 #include <linux/hugetlb.h>
 #include <linux/initrd.h>
 #include <linux/key.h>
@@ -52,6 +53,7 @@
 #include <linux/slow-work.h>
 #include <linux/perf_event.h>
 #include <linux/kprobes.h>
+#include <linux/pipe_fs_i.h>
 
 #include <asm/uaccess.h>
 #include <asm/processor.h>
@@ -261,6 +263,11 @@ static int min_sched_shares_ratelimit = 100000; /* 100 usec */
 static int max_sched_shares_ratelimit = NSEC_PER_SEC; /* 1 second */
 #endif
 
+#ifdef CONFIG_COMPACTION
+static int min_extfrag_threshold;
+static int max_extfrag_threshold = 1000;
+#endif
+
 static struct ctl_table kern_table[] = {
         {
                 .procname       = "sched_child_runs_first",
@@ -1120,6 +1127,25 @@ static struct ctl_table vm_table[] = {
                 .mode           = 0644,
                 .proc_handler   = drop_caches_sysctl_handler,
         },
+#ifdef CONFIG_COMPACTION
+        {
+                .procname       = "compact_memory",
+                .data           = &sysctl_compact_memory,
+                .maxlen         = sizeof(int),
+                .mode           = 0200,
+                .proc_handler   = sysctl_compaction_handler,
+        },
+        {
+                .procname       = "extfrag_threshold",
+                .data           = &sysctl_extfrag_threshold,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = sysctl_extfrag_handler,
+                .extra1         = &min_extfrag_threshold,
+                .extra2         = &max_extfrag_threshold,
+        },
+
+#endif /* CONFIG_COMPACTION */
         {
                 .procname       = "min_free_kbytes",
                 .data           = &min_free_kbytes,
@@ -1444,6 +1470,14 @@ static struct ctl_table fs_table[] = {
                 .child          = binfmt_misc_table,
         },
 #endif
+        {
+                .procname       = "pipe-max-pages",
+                .data           = &pipe_max_pages,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec_minmax,
+                .extra1         = &two,
+        },
 /*
  * NOTE: do not add new entries to this table unless you have read
  * Documentation/sysctl/ctl_unnumbered.txt
@@ -2083,20 +2117,20 @@ static void proc_skip_char(char **buf, size_t *size, const char v)
 
 #define TMPBUFLEN 22
 /**
- * proc_get_long - reads an ASCII formated integer from a user buffer
+ * proc_get_long - reads an ASCII formatted integer from a user buffer
  *
- * @buf - a kernel buffer
- * @size - size of the kernel buffer
- * @val - this is where the number will be stored
- * @neg - set to %TRUE if number is negative
- * @perm_tr - a vector which contains the allowed trailers
- * @perm_tr_len - size of the perm_tr vector
- * @tr - pointer to store the trailer character
+ * @buf: a kernel buffer
+ * @size: size of the kernel buffer
+ * @val: this is where the number will be stored
+ * @neg: set to %TRUE if number is negative
+ * @perm_tr: a vector which contains the allowed trailers
+ * @perm_tr_len: size of the perm_tr vector
+ * @tr: pointer to store the trailer character
  *
- * In case of success 0 is returned and buf and size are updated with
- * the amount of bytes read. If tr is non NULL and a trailing
- * character exist (size is non zero after returning from this
- * function) tr is updated with the trailing character.
+ * In case of success %0 is returned and @buf and @size are updated with
+ * the amount of bytes read. If @tr is non-NULL and a trailing
+ * character exists (size is non-zero after returning from this
+ * function), @tr is updated with the trailing character.
  */
 static int proc_get_long(char **buf, size_t *size,
                           unsigned long *val, bool *neg,
@@ -2147,15 +2181,15 @@ static int proc_get_long(char **buf, size_t *size,
 }
 
 /**
- * proc_put_long - coverts an integer to a decimal ASCII formated string
+ * proc_put_long - converts an integer to a decimal ASCII formatted string
  *
- * @buf - the user buffer
- * @size - the size of the user buffer
- * @val - the integer to be converted
- * @neg - sign of the number, %TRUE for negative
+ * @buf: the user buffer
+ * @size: the size of the user buffer
+ * @val: the integer to be converted
+ * @neg: sign of the number, %TRUE for negative
  *
- * In case of success 0 is returned and buf and size are updated with
- * the amount of bytes read.
+ * In case of success %0 is returned and @buf and @size are updated with
+ * the amount of bytes written.
  */
 static int proc_put_long(void __user **buf, size_t *size, unsigned long val,
                           bool neg)
diff --git a/kernel/sysctl_binary.c b/kernel/sysctl_binary.c
index 937d31dc8566..1357c5786064 100644
--- a/kernel/sysctl_binary.c
+++ b/kernel/sysctl_binary.c
@@ -13,6 +13,7 @@
 #include <linux/file.h>
 #include <linux/ctype.h>
 #include <linux/netdevice.h>
+#include <linux/kernel.h>
 #include <linux/slab.h>
 
 #ifdef CONFIG_SYSCTL_SYSCALL
@@ -1124,11 +1125,6 @@ out:
         return result;
 }
 
-static unsigned hex_value(int ch)
-{
-        return isdigit(ch) ? ch - '0' : ((ch | 0x20) - 'a') + 10;
-}
-
 static ssize_t bin_uuid(struct file *file,
         void __user *oldval, size_t oldlen, void __user *newval, size_t newlen)
 {
@@ -1156,7 +1152,8 @@ static ssize_t bin_uuid(struct file *file,
                         if (!isxdigit(str[0]) || !isxdigit(str[1]))
                                 goto out;
 
-                        uuid[i] = (hex_value(str[0]) << 4) | hex_value(str[1]);
+                        uuid[i] = (hex_to_bin(str[0]) << 4) |
+                                        hex_to_bin(str[1]);
                         str += 2;
                         if (*str == '-')
                                 str++;
diff --git a/kernel/time.c b/kernel/time.c
index 50612faa9baf..848b1c2ab09a 100644
--- a/kernel/time.c
+++ b/kernel/time.c
@@ -132,10 +132,10 @@ SYSCALL_DEFINE2(gettimeofday, struct timeval __user *, tv,
  */
 static inline void warp_clock(void)
 {
-        struct timespec delta, adjust;
-        delta.tv_sec = sys_tz.tz_minuteswest * 60;
-        delta.tv_nsec = 0;
-        adjust = timespec_add_safe(current_kernel_time(), delta);
+        struct timespec adjust;
+
+        adjust = current_kernel_time();
+        adjust.tv_sec += sys_tz.tz_minuteswest * 60;
         do_settimeofday(&adjust);
 }
 
diff --git a/kernel/timer.c b/kernel/timer.c
index 9199f3c52215..2454172a80d3 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -750,13 +750,18 @@ unsigned long apply_slack(struct timer_list *timer, unsigned long expires)
         unsigned long expires_limit, mask;
         int bit;
 
-        expires_limit = expires + timer->slack;
+        expires_limit = expires;
 
-        if (timer->slack < 0) /* auto slack: use 0.4% */
-                expires_limit = expires + (expires - jiffies)/256;
+        if (timer->slack >= 0) {
+                expires_limit = expires + timer->slack;
+        } else {
+                unsigned long now = jiffies;
 
+                /* No slack, if already expired else auto slack 0.4% */
+                if (time_after(expires, now))
+                        expires_limit = expires + (expires - now)/256;
+        }
         mask = expires ^ expires_limit;
-
         if (mask == 0)
                 return expires;
 
@@ -1679,11 +1684,14 @@ static int __cpuinit timer_cpu_notify(struct notifier_block *self,
                                 unsigned long action, void *hcpu)
 {
         long cpu = (long)hcpu;
+        int err;
+
         switch(action) {
         case CPU_UP_PREPARE:
         case CPU_UP_PREPARE_FROZEN:
-                if (init_timers_cpu(cpu) < 0)
-                        return NOTIFY_BAD;
+                err = init_timers_cpu(cpu);
+                if (err < 0)
+                        return notifier_from_errno(err);
                 break;
 #ifdef CONFIG_HOTPLUG_CPU
         case CPU_DEAD:
diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index b3bc91a3f510..36ea2b65dcdc 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -675,28 +675,33 @@ static void blk_add_trace_rq(struct request_queue *q, struct request *rq,
         }
 }
 
-static void blk_add_trace_rq_abort(struct request_queue *q, struct request *rq)
+static void blk_add_trace_rq_abort(void *ignore,
+                                   struct request_queue *q, struct request *rq)
 {
         blk_add_trace_rq(q, rq, BLK_TA_ABORT);
 }
 
-static void blk_add_trace_rq_insert(struct request_queue *q, struct request *rq)
+static void blk_add_trace_rq_insert(void *ignore,
+                                    struct request_queue *q, struct request *rq)
 {
         blk_add_trace_rq(q, rq, BLK_TA_INSERT);
 }
 
-static void blk_add_trace_rq_issue(struct request_queue *q, struct request *rq)
+static void blk_add_trace_rq_issue(void *ignore,
+                                   struct request_queue *q, struct request *rq)
 {
         blk_add_trace_rq(q, rq, BLK_TA_ISSUE);
 }
 
-static void blk_add_trace_rq_requeue(struct request_queue *q,
+static void blk_add_trace_rq_requeue(void *ignore,
+                                     struct request_queue *q,
                                      struct request *rq)
 {
         blk_add_trace_rq(q, rq, BLK_TA_REQUEUE);
 }
 
-static void blk_add_trace_rq_complete(struct request_queue *q,
+static void blk_add_trace_rq_complete(void *ignore,
+                                      struct request_queue *q,
                                       struct request *rq)
 {
         blk_add_trace_rq(q, rq, BLK_TA_COMPLETE);
@@ -724,34 +729,40 @@ static void blk_add_trace_bio(struct request_queue *q, struct bio *bio,
                         !bio_flagged(bio, BIO_UPTODATE), 0, NULL);
 }
 
-static void blk_add_trace_bio_bounce(struct request_queue *q, struct bio *bio)
+static void blk_add_trace_bio_bounce(void *ignore,
+                                     struct request_queue *q, struct bio *bio)
 {
         blk_add_trace_bio(q, bio, BLK_TA_BOUNCE);
 }
 
-static void blk_add_trace_bio_complete(struct request_queue *q, struct bio *bio)
+static void blk_add_trace_bio_complete(void *ignore,
+                                       struct request_queue *q, struct bio *bio)
 {
         blk_add_trace_bio(q, bio, BLK_TA_COMPLETE);
 }
 
-static void blk_add_trace_bio_backmerge(struct request_queue *q,
+static void blk_add_trace_bio_backmerge(void *ignore,
+                                        struct request_queue *q,
                                         struct bio *bio)
 {
         blk_add_trace_bio(q, bio, BLK_TA_BACKMERGE);
 }
 
-static void blk_add_trace_bio_frontmerge(struct request_queue *q,
+static void blk_add_trace_bio_frontmerge(void *ignore,
+                                         struct request_queue *q,
                                          struct bio *bio)
 {
         blk_add_trace_bio(q, bio, BLK_TA_FRONTMERGE);
 }
 
-static void blk_add_trace_bio_queue(struct request_queue *q, struct bio *bio)
+static void blk_add_trace_bio_queue(void *ignore,
+                                    struct request_queue *q, struct bio *bio)
 {
         blk_add_trace_bio(q, bio, BLK_TA_QUEUE);
 }
 
-static void blk_add_trace_getrq(struct request_queue *q,
+static void blk_add_trace_getrq(void *ignore,
+                                struct request_queue *q,
                                 struct bio *bio, int rw)
 {
         if (bio)
@@ -765,7 +776,8 @@ static void blk_add_trace_getrq(struct request_queue *q,
 }
 
 
-static void blk_add_trace_sleeprq(struct request_queue *q,
+static void blk_add_trace_sleeprq(void *ignore,
+                                  struct request_queue *q,
                                   struct bio *bio, int rw)
 {
         if (bio)
@@ -779,7 +791,7 @@ static void blk_add_trace_sleeprq(struct request_queue *q,
         }
 }
 
-static void blk_add_trace_plug(struct request_queue *q)
+static void blk_add_trace_plug(void *ignore, struct request_queue *q)
 {
         struct blk_trace *bt = q->blk_trace;
 
@@ -787,7 +799,7 @@ static void blk_add_trace_plug(struct request_queue *q)
                 __blk_add_trace(bt, 0, 0, 0, BLK_TA_PLUG, 0, 0, NULL);
 }
 
-static void blk_add_trace_unplug_io(struct request_queue *q)
+static void blk_add_trace_unplug_io(void *ignore, struct request_queue *q)
 {
         struct blk_trace *bt = q->blk_trace;
 
@@ -800,7 +812,7 @@ static void blk_add_trace_unplug_io(struct request_queue *q)
         }
 }
 
-static void blk_add_trace_unplug_timer(struct request_queue *q)
+static void blk_add_trace_unplug_timer(void *ignore, struct request_queue *q)
 {
         struct blk_trace *bt = q->blk_trace;
 
@@ -813,7 +825,8 @@ static void blk_add_trace_unplug_timer(struct request_queue *q)
         }
 }
 
-static void blk_add_trace_split(struct request_queue *q, struct bio *bio,
+static void blk_add_trace_split(void *ignore,
+                                struct request_queue *q, struct bio *bio,
                                 unsigned int pdu)
 {
         struct blk_trace *bt = q->blk_trace;
@@ -839,8 +852,9 @@ static void blk_add_trace_split(struct request_queue *q, struct bio *bio,
  *     it spans a stripe (or similar). Add a trace for that action.
  *
  **/
-static void blk_add_trace_remap(struct request_queue *q, struct bio *bio,
-                                       dev_t dev, sector_t from)
+static void blk_add_trace_remap(void *ignore,
+                                struct request_queue *q, struct bio *bio,
+                                dev_t dev, sector_t from)
 {
         struct blk_trace *bt = q->blk_trace;
         struct blk_io_trace_remap r;
@@ -869,7 +883,8 @@ static void blk_add_trace_remap(struct request_queue *q, struct bio *bio,
  *     Add a trace for that action.
  *
  **/
-static void blk_add_trace_rq_remap(struct request_queue *q,
+static void blk_add_trace_rq_remap(void *ignore,
+                                   struct request_queue *q,
                                    struct request *rq, dev_t dev,
                                    sector_t from)
 {
@@ -921,64 +936,64 @@ static void blk_register_tracepoints(void)
 {
         int ret;
 
-        ret = register_trace_block_rq_abort(blk_add_trace_rq_abort);
+        ret = register_trace_block_rq_abort(blk_add_trace_rq_abort, NULL);
         WARN_ON(ret);
-        ret = register_trace_block_rq_insert(blk_add_trace_rq_insert);
+        ret = register_trace_block_rq_insert(blk_add_trace_rq_insert, NULL);
         WARN_ON(ret);
-        ret = register_trace_block_rq_issue(blk_add_trace_rq_issue);
+        ret = register_trace_block_rq_issue(blk_add_trace_rq_issue, NULL);
         WARN_ON(ret);
-        ret = register_trace_block_rq_requeue(blk_add_trace_rq_requeue);
+        ret = register_trace_block_rq_requeue(blk_add_trace_rq_requeue, NULL);
         WARN_ON(ret);
-        ret = register_trace_block_rq_complete(blk_add_trace_rq_complete);
+        ret = register_trace_block_rq_complete(blk_add_trace_rq_complete, NULL);
         WARN_ON(ret);
-        ret = register_trace_block_bio_bounce(blk_add_trace_bio_bounce);
+        ret = register_trace_block_bio_bounce(blk_add_trace_bio_bounce, NULL);
         WARN_ON(ret);
-        ret = register_trace_block_bio_complete(blk_add_trace_bio_complete);
+        ret = register_trace_block_bio_complete(blk_add_trace_bio_complete, NULL);
         WARN_ON(ret);
-        ret = register_trace_block_bio_backmerge(blk_add_trace_bio_backmerge);
+        ret = register_trace_block_bio_backmerge(blk_add_trace_bio_backmerge, NULL);
         WARN_ON(ret);
-        ret = register_trace_block_bio_frontmerge(blk_add_trace_bio_frontmerge);
+        ret = register_trace_block_bio_frontmerge(blk_add_trace_bio_frontmerge, NULL);
         WARN_ON(ret);
-        ret = register_trace_block_bio_queue(blk_add_trace_bio_queue);
+        ret = register_trace_block_bio_queue(blk_add_trace_bio_queue, NULL);
         WARN_ON(ret);
-        ret = register_trace_block_getrq(blk_add_trace_getrq);
+        ret = register_trace_block_getrq(blk_add_trace_getrq, NULL);
         WARN_ON(ret);
-        ret = register_trace_block_sleeprq(blk_add_trace_sleeprq);
+        ret = register_trace_block_sleeprq(blk_add_trace_sleeprq, NULL);
         WARN_ON(ret);
-        ret = register_trace_block_plug(blk_add_trace_plug);
+        ret = register_trace_block_plug(blk_add_trace_plug, NULL);
         WARN_ON(ret);
-        ret = register_trace_block_unplug_timer(blk_add_trace_unplug_timer);
+        ret = register_trace_block_unplug_timer(blk_add_trace_unplug_timer, NULL);
         WARN_ON(ret);
-        ret = register_trace_block_unplug_io(blk_add_trace_unplug_io);
+        ret = register_trace_block_unplug_io(blk_add_trace_unplug_io, NULL);
         WARN_ON(ret);
-        ret = register_trace_block_split(blk_add_trace_split);
+        ret = register_trace_block_split(blk_add_trace_split, NULL);
         WARN_ON(ret);
-        ret = register_trace_block_remap(blk_add_trace_remap);
+        ret = register_trace_block_remap(blk_add_trace_remap, NULL);
         WARN_ON(ret);
-        ret = register_trace_block_rq_remap(blk_add_trace_rq_remap);
+        ret = register_trace_block_rq_remap(blk_add_trace_rq_remap, NULL);
         WARN_ON(ret);
 }
 
 static void blk_unregister_tracepoints(void)
 {
-        unregister_trace_block_rq_remap(blk_add_trace_rq_remap);
-        unregister_trace_block_remap(blk_add_trace_remap);
-        unregister_trace_block_split(blk_add_trace_split);
-        unregister_trace_block_unplug_io(blk_add_trace_unplug_io);
-        unregister_trace_block_unplug_timer(blk_add_trace_unplug_timer);
-        unregister_trace_block_plug(blk_add_trace_plug);
-        unregister_trace_block_sleeprq(blk_add_trace_sleeprq);
-        unregister_trace_block_getrq(blk_add_trace_getrq);
-        unregister_trace_block_bio_queue(blk_add_trace_bio_queue);
-        unregister_trace_block_bio_frontmerge(blk_add_trace_bio_frontmerge);
-        unregister_trace_block_bio_backmerge(blk_add_trace_bio_backmerge);
-        unregister_trace_block_bio_complete(blk_add_trace_bio_complete);
-        unregister_trace_block_bio_bounce(blk_add_trace_bio_bounce);
-        unregister_trace_block_rq_complete(blk_add_trace_rq_complete);
-        unregister_trace_block_rq_requeue(blk_add_trace_rq_requeue);
-        unregister_trace_block_rq_issue(blk_add_trace_rq_issue);
-        unregister_trace_block_rq_insert(blk_add_trace_rq_insert);
-        unregister_trace_block_rq_abort(blk_add_trace_rq_abort);
+        unregister_trace_block_rq_remap(blk_add_trace_rq_remap, NULL);
+        unregister_trace_block_remap(blk_add_trace_remap, NULL);
+        unregister_trace_block_split(blk_add_trace_split, NULL);
+        unregister_trace_block_unplug_io(blk_add_trace_unplug_io, NULL);
+        unregister_trace_block_unplug_timer(blk_add_trace_unplug_timer, NULL);
+        unregister_trace_block_plug(blk_add_trace_plug, NULL);
+        unregister_trace_block_sleeprq(blk_add_trace_sleeprq, NULL);
+        unregister_trace_block_getrq(blk_add_trace_getrq, NULL);
+        unregister_trace_block_bio_queue(blk_add_trace_bio_queue, NULL);
+        unregister_trace_block_bio_frontmerge(blk_add_trace_bio_frontmerge, NULL);
+        unregister_trace_block_bio_backmerge(blk_add_trace_bio_backmerge, NULL);
+        unregister_trace_block_bio_complete(blk_add_trace_bio_complete, NULL);
+        unregister_trace_block_bio_bounce(blk_add_trace_bio_bounce, NULL);
+        unregister_trace_block_rq_complete(blk_add_trace_rq_complete, NULL);
+        unregister_trace_block_rq_requeue(blk_add_trace_rq_requeue, NULL);
+        unregister_trace_block_rq_issue(blk_add_trace_rq_issue, NULL);
+        unregister_trace_block_rq_insert(blk_add_trace_rq_insert, NULL);
+        unregister_trace_block_rq_abort(blk_add_trace_rq_abort, NULL);
 
         tracepoint_synchronize_unregister();
 }
@@ -1321,7 +1336,7 @@ out:
 }
 
 static enum print_line_t blk_trace_event_print(struct trace_iterator *iter,
-                                               int flags)
+                                               int flags, struct trace_event *event)
 {
         return print_one_line(iter, false);
 }
@@ -1343,7 +1358,8 @@ static int blk_trace_synthesize_old_trace(struct trace_iterator *iter)
 }
 
 static enum print_line_t
-blk_trace_event_print_binary(struct trace_iterator *iter, int flags)
+blk_trace_event_print_binary(struct trace_iterator *iter, int flags,
+                             struct trace_event *event)
 {
         return blk_trace_synthesize_old_trace(iter) ?
                         TRACE_TYPE_HANDLED : TRACE_TYPE_PARTIAL_LINE;
@@ -1381,12 +1397,16 @@ static struct tracer blk_tracer __read_mostly = {
         .set_flag       = blk_tracer_set_flag,
 };
 
-static struct trace_event trace_blk_event = {
-        .type           = TRACE_BLK,
+static struct trace_event_functions trace_blk_event_funcs = {
         .trace          = blk_trace_event_print,
         .binary         = blk_trace_event_print_binary,
 };
 
+static struct trace_event trace_blk_event = {
+        .type           = TRACE_BLK,
+        .funcs          = &trace_blk_event_funcs,
+};
+
 static int __init init_blk_tracer(void)
 {
         if (!register_ftrace_event(&trace_blk_event)) {
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 32837e19e3bd..6d2cb14f9449 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -3234,7 +3234,8 @@ free:
 }
 
 static void
-ftrace_graph_probe_sched_switch(struct task_struct *prev, struct task_struct *next)
+ftrace_graph_probe_sched_switch(void *ignore,
+                        struct task_struct *prev, struct task_struct *next)
 {
         unsigned long long timestamp;
         int index;
@@ -3288,7 +3289,7 @@ static int start_graph_tracing(void)
         } while (ret == -EAGAIN);
 
         if (!ret) {
-                ret = register_trace_sched_switch(ftrace_graph_probe_sched_switch);
+                ret = register_trace_sched_switch(ftrace_graph_probe_sched_switch, NULL);
                 if (ret)
                         pr_info("ftrace_graph: Couldn't activate tracepoint"
                                 " probe to kernel_sched_switch\n");
@@ -3364,7 +3365,7 @@ void unregister_ftrace_graph(void)
         ftrace_graph_entry = ftrace_graph_entry_stub;
         ftrace_shutdown(FTRACE_STOP_FUNC_RET);
         unregister_pm_notifier(&ftrace_suspend_notifier);
-        unregister_trace_sched_switch(ftrace_graph_probe_sched_switch);
+        unregister_trace_sched_switch(ftrace_graph_probe_sched_switch, NULL);
 
  out:
         mutex_unlock(&ftrace_lock);
diff --git a/kernel/trace/kmemtrace.c b/kernel/trace/kmemtrace.c
index a91da69f153a..bbfc1bb1660b 100644
--- a/kernel/trace/kmemtrace.c
+++ b/kernel/trace/kmemtrace.c
@@ -95,7 +95,8 @@ static inline void kmemtrace_free(enum kmemtrace_type_id type_id,
         trace_wake_up();
 }
 
-static void kmemtrace_kmalloc(unsigned long call_site,
+static void kmemtrace_kmalloc(void *ignore,
+                              unsigned long call_site,
                               const void *ptr,
                               size_t bytes_req,
                               size_t bytes_alloc,
@@ -105,7 +106,8 @@ static void kmemtrace_kmalloc(unsigned long call_site,
                         bytes_req, bytes_alloc, gfp_flags, -1);
 }
 
-static void kmemtrace_kmem_cache_alloc(unsigned long call_site,
+static void kmemtrace_kmem_cache_alloc(void *ignore,
+                                       unsigned long call_site,
                                        const void *ptr,
                                        size_t bytes_req,
                                        size_t bytes_alloc,
@@ -115,7 +117,8 @@ static void kmemtrace_kmem_cache_alloc(unsigned long call_site,
                         bytes_req, bytes_alloc, gfp_flags, -1);
 }
 
-static void kmemtrace_kmalloc_node(unsigned long call_site,
+static void kmemtrace_kmalloc_node(void *ignore,
+                                   unsigned long call_site,
                                    const void *ptr,
                                    size_t bytes_req,
                                    size_t bytes_alloc,
@@ -126,7 +129,8 @@ static void kmemtrace_kmalloc_node(unsigned long call_site,
                         bytes_req, bytes_alloc, gfp_flags, node);
 }
 
-static void kmemtrace_kmem_cache_alloc_node(unsigned long call_site,
+static void kmemtrace_kmem_cache_alloc_node(void *ignore,
+                                            unsigned long call_site,
                                             const void *ptr,
                                             size_t bytes_req,
                                             size_t bytes_alloc,
@@ -137,12 +141,14 @@ static void kmemtrace_kmem_cache_alloc_node(unsigned long call_site,
                         bytes_req, bytes_alloc, gfp_flags, node);
 }
 
-static void kmemtrace_kfree(unsigned long call_site, const void *ptr)
+static void
+kmemtrace_kfree(void *ignore, unsigned long call_site, const void *ptr)
 {
         kmemtrace_free(KMEMTRACE_TYPE_KMALLOC, call_site, ptr);
 }
 
-static void kmemtrace_kmem_cache_free(unsigned long call_site, const void *ptr)
+static void kmemtrace_kmem_cache_free(void *ignore,
+                                      unsigned long call_site, const void *ptr)
 {
         kmemtrace_free(KMEMTRACE_TYPE_CACHE, call_site, ptr);
 }
@@ -151,34 +157,34 @@ static int kmemtrace_start_probes(void)
 {
         int err;
 
-        err = register_trace_kmalloc(kmemtrace_kmalloc);
+        err = register_trace_kmalloc(kmemtrace_kmalloc, NULL);
         if (err)
                 return err;
-        err = register_trace_kmem_cache_alloc(kmemtrace_kmem_cache_alloc);
+        err = register_trace_kmem_cache_alloc(kmemtrace_kmem_cache_alloc, NULL);
         if (err)
                 return err;
-        err = register_trace_kmalloc_node(kmemtrace_kmalloc_node);
+        err = register_trace_kmalloc_node(kmemtrace_kmalloc_node, NULL);
         if (err)
                 return err;
-        err = register_trace_kmem_cache_alloc_node(kmemtrace_kmem_cache_alloc_node);
+        err = register_trace_kmem_cache_alloc_node(kmemtrace_kmem_cache_alloc_node, NULL);
         if (err)
                 return err;
-        err = register_trace_kfree(kmemtrace_kfree);
+        err = register_trace_kfree(kmemtrace_kfree, NULL);
         if (err)
                 return err;
-        err = register_trace_kmem_cache_free(kmemtrace_kmem_cache_free);
+        err = register_trace_kmem_cache_free(kmemtrace_kmem_cache_free, NULL);
 
         return err;
 }
 
 static void kmemtrace_stop_probes(void)
 {
-        unregister_trace_kmalloc(kmemtrace_kmalloc);
-        unregister_trace_kmem_cache_alloc(kmemtrace_kmem_cache_alloc);
-        unregister_trace_kmalloc_node(kmemtrace_kmalloc_node);
-        unregister_trace_kmem_cache_alloc_node(kmemtrace_kmem_cache_alloc_node);
-        unregister_trace_kfree(kmemtrace_kfree);
-        unregister_trace_kmem_cache_free(kmemtrace_kmem_cache_free);
+        unregister_trace_kmalloc(kmemtrace_kmalloc, NULL);
+        unregister_trace_kmem_cache_alloc(kmemtrace_kmem_cache_alloc, NULL);
+        unregister_trace_kmalloc_node(kmemtrace_kmalloc_node, NULL);
+        unregister_trace_kmem_cache_alloc_node(kmemtrace_kmem_cache_alloc_node, NULL);
+        unregister_trace_kfree(kmemtrace_kfree, NULL);
+        unregister_trace_kmem_cache_free(kmemtrace_kmem_cache_free, NULL);
 }
 
 static int kmem_trace_init(struct trace_array *tr)
@@ -237,7 +243,8 @@ struct kmemtrace_user_event_alloc {
 };
 
 static enum print_line_t
-kmemtrace_print_alloc(struct trace_iterator *iter, int flags)
+kmemtrace_print_alloc(struct trace_iterator *iter, int flags,
+                      struct trace_event *event)
 {
         struct trace_seq *s = &iter->seq;
         struct kmemtrace_alloc_entry *entry;
@@ -257,7 +264,8 @@ kmemtrace_print_alloc(struct trace_iterator *iter, int flags)
 }
 
 static enum print_line_t
-kmemtrace_print_free(struct trace_iterator *iter, int flags)
+kmemtrace_print_free(struct trace_iterator *iter, int flags,
+                     struct trace_event *event)
 {
         struct trace_seq *s = &iter->seq;
         struct kmemtrace_free_entry *entry;
@@ -275,7 +283,8 @@ kmemtrace_print_free(struct trace_iterator *iter, int flags)
 }
 
 static enum print_line_t
-kmemtrace_print_alloc_user(struct trace_iterator *iter, int flags)
+kmemtrace_print_alloc_user(struct trace_iterator *iter, int flags,
+                           struct trace_event *event)
 {
         struct trace_seq *s = &iter->seq;
         struct kmemtrace_alloc_entry *entry;
@@ -309,7 +318,8 @@ kmemtrace_print_alloc_user(struct trace_iterator *iter, int flags)
 }
 
 static enum print_line_t
-kmemtrace_print_free_user(struct trace_iterator *iter, int flags)
+kmemtrace_print_free_user(struct trace_iterator *iter, int flags,
+                          struct trace_event *event)
 {
         struct trace_seq *s = &iter->seq;
         struct kmemtrace_free_entry *entry;
@@ -463,18 +473,26 @@ static enum print_line_t kmemtrace_print_line(struct trace_iterator *iter)
         }
 }
 
-static struct trace_event kmem_trace_alloc = {
-        .type                   = TRACE_KMEM_ALLOC,
+static struct trace_event_functions kmem_trace_alloc_funcs = {
         .trace                  = kmemtrace_print_alloc,
         .binary                 = kmemtrace_print_alloc_user,
 };
 
-static struct trace_event kmem_trace_free = {
-        .type                   = TRACE_KMEM_FREE,
+static struct trace_event kmem_trace_alloc = {
+        .type                   = TRACE_KMEM_ALLOC,
+        .funcs                  = &kmem_trace_alloc_funcs,
+};
+
+static struct trace_event_functions kmem_trace_free_funcs = {
         .trace                  = kmemtrace_print_free,
         .binary                 = kmemtrace_print_free_user,
 };
 
+static struct trace_event kmem_trace_free = {
+        .type                   = TRACE_KMEM_FREE,
+        .funcs                  = &kmem_trace_free_funcs,
+};
+
 static struct tracer kmem_tracer __read_mostly = {
         .name                   = "kmemtrace",
         .init                   = kmem_trace_init,
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index 7f6059c5aa94..1da7b6ea8b85 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -1768,6 +1768,14 @@ rb_reset_tail(struct ring_buffer_per_cpu *cpu_buffer,
          * must fill the old tail_page with padding.
          */
         if (tail >= BUF_PAGE_SIZE) {
+                /*
+                 * If the page was filled, then we still need
+                 * to update the real_end. Reset it to zero
+                 * and the reader will ignore it.
+                 */
+                if (tail == BUF_PAGE_SIZE)
+                        tail_page->real_end = 0;
+
                 local_sub(length, &tail_page->write);
                 return;
         }
@@ -3894,12 +3902,12 @@ int ring_buffer_read_page(struct ring_buffer *buffer,
         ret = read;
 
         cpu_buffer->lost_events = 0;
+
+        commit = local_read(&bpage->commit);
         /*
          * Set a flag in the commit field if we lost events
          */
         if (missed_events) {
-                commit = local_read(&bpage->commit);
-
                 /* If there is room at the end of the page to save the
                  * missed events, then record it there.
                  */
@@ -3907,10 +3915,17 @@ int ring_buffer_read_page(struct ring_buffer *buffer,
                         memcpy(&bpage->data[commit], &missed_events,
                                sizeof(missed_events));
                         local_add(RB_MISSED_STORED, &bpage->commit);
+                        commit += sizeof(missed_events);
                 }
                 local_add(RB_MISSED_EVENTS, &bpage->commit);
         }
 
+        /*
+         * This page may be off to user land. Zero it out here.
+         */
+        if (commit < BUF_PAGE_SIZE)
+                memset(&bpage->data[commit], 0, BUF_PAGE_SIZE - commit);
+
  out_unlock:
         spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 756d7283318b..086d36316805 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -1936,7 +1936,7 @@ static enum print_line_t print_trace_fmt(struct trace_iterator *iter)
         }
 
         if (event)
-                return event->trace(iter, sym_flags);
+                return event->funcs->trace(iter, sym_flags, event);
 
         if (!trace_seq_printf(s, "Unknown type %d\n", entry->type))
                 goto partial;
@@ -1962,7 +1962,7 @@ static enum print_line_t print_raw_fmt(struct trace_iterator *iter)
 
         event = ftrace_find_event(entry->type);
         if (event)
-                return event->raw(iter, 0);
+                return event->funcs->raw(iter, 0, event);
 
         if (!trace_seq_printf(s, "%d ?\n", entry->type))
                 goto partial;
@@ -1989,7 +1989,7 @@ static enum print_line_t print_hex_fmt(struct trace_iterator *iter)
 
         event = ftrace_find_event(entry->type);
         if (event) {
-                enum print_line_t ret = event->hex(iter, 0);
+                enum print_line_t ret = event->funcs->hex(iter, 0, event);
                 if (ret != TRACE_TYPE_HANDLED)
                         return ret;
         }
@@ -2014,7 +2014,8 @@ static enum print_line_t print_bin_fmt(struct trace_iterator *iter)
         }
 
         event = ftrace_find_event(entry->type);
-        return event ? event->binary(iter, 0) : TRACE_TYPE_HANDLED;
+        return event ? event->funcs->binary(iter, 0, event) :
+                TRACE_TYPE_HANDLED;
 }
 
 int trace_empty(struct trace_iterator *iter)
@@ -3309,12 +3310,12 @@ static ssize_t tracing_splice_read_pipe(struct file *filp,
                                         size_t len,
                                         unsigned int flags)
 {
-        struct page *pages[PIPE_BUFFERS];
-        struct partial_page partial[PIPE_BUFFERS];
+        struct page *pages_def[PIPE_DEF_BUFFERS];
+        struct partial_page partial_def[PIPE_DEF_BUFFERS];
         struct trace_iterator *iter = filp->private_data;
         struct splice_pipe_desc spd = {
-                .pages          = pages,
-                .partial        = partial,
+                .pages          = pages_def,
+                .partial        = partial_def,
                 .nr_pages       = 0, /* This gets updated below. */
                 .flags          = flags,
                 .ops            = &tracing_pipe_buf_ops,
@@ -3325,6 +3326,9 @@ static ssize_t tracing_splice_read_pipe(struct file *filp,
         size_t rem;
         unsigned int i;
 
+        if (splice_grow_spd(pipe, &spd))
+                return -ENOMEM;
+
         /* copy the tracer to avoid using a global lock all around */
         mutex_lock(&trace_types_lock);
         if (unlikely(old_tracer != current_trace && current_trace)) {
@@ -3355,23 +3359,23 @@ static ssize_t tracing_splice_read_pipe(struct file *filp,
         trace_access_lock(iter->cpu_file);
 
         /* Fill as many pages as possible. */
-        for (i = 0, rem = len; i < PIPE_BUFFERS && rem; i++) {
-                pages[i] = alloc_page(GFP_KERNEL);
-                if (!pages[i])
+        for (i = 0, rem = len; i < pipe->buffers && rem; i++) {
+                spd.pages[i] = alloc_page(GFP_KERNEL);
+                if (!spd.pages[i])
                         break;
 
                 rem = tracing_fill_pipe_page(rem, iter);
 
                 /* Copy the data into the page, so we can start over. */
                 ret = trace_seq_to_buffer(&iter->seq,
-                                          page_address(pages[i]),
+                                          page_address(spd.pages[i]),
                                           iter->seq.len);
                 if (ret < 0) {
-                        __free_page(pages[i]);
+                        __free_page(spd.pages[i]);
                         break;
                 }
-                partial[i].offset = 0;
-                partial[i].len = iter->seq.len;
+                spd.partial[i].offset = 0;
+                spd.partial[i].len = iter->seq.len;
 
                 trace_seq_init(&iter->seq);
         }
@@ -3382,12 +3386,14 @@ static ssize_t tracing_splice_read_pipe(struct file *filp,
 
         spd.nr_pages = i;
 
-        return splice_to_pipe(pipe, &spd);
+        ret = splice_to_pipe(pipe, &spd);
+out:
+        splice_shrink_spd(pipe, &spd);
+        return ret;
 
 out_err:
         mutex_unlock(&iter->mutex);
-
-        return ret;
+        goto out;
 }
 
 static ssize_t
@@ -3660,7 +3666,6 @@ tracing_buffers_read(struct file *filp, char __user *ubuf,
                      size_t count, loff_t *ppos)
 {
         struct ftrace_buffer_info *info = filp->private_data;
-        unsigned int pos;
         ssize_t ret;
         size_t size;
 
@@ -3687,11 +3692,6 @@ tracing_buffers_read(struct file *filp, char __user *ubuf,
         if (ret < 0)
                 return 0;
 
-        pos = ring_buffer_page_len(info->spare);
-
-        if (pos < PAGE_SIZE)
-                memset(info->spare + pos, 0, PAGE_SIZE - pos);
-
 read:
         size = PAGE_SIZE - info->read;
         if (size > count)
@@ -3786,11 +3786,11 @@ tracing_buffers_splice_read(struct file *file, loff_t *ppos,
                             unsigned int flags)
 {
         struct ftrace_buffer_info *info = file->private_data;
-        struct partial_page partial[PIPE_BUFFERS];
-        struct page *pages[PIPE_BUFFERS];
+        struct partial_page partial_def[PIPE_DEF_BUFFERS];
+        struct page *pages_def[PIPE_DEF_BUFFERS];
         struct splice_pipe_desc spd = {
-                .pages          = pages,
-                .partial        = partial,
+                .pages          = pages_def,
+                .partial        = partial_def,
                 .flags          = flags,
                 .ops            = &buffer_pipe_buf_ops,
                 .spd_release    = buffer_spd_release,
@@ -3799,22 +3799,28 @@ tracing_buffers_splice_read(struct file *file, loff_t *ppos,
         int entries, size, i;
         size_t ret;
 
+        if (splice_grow_spd(pipe, &spd))
+                return -ENOMEM;
+
         if (*ppos & (PAGE_SIZE - 1)) {
                 WARN_ONCE(1, "Ftrace: previous read must page-align\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto out;
         }
 
         if (len & (PAGE_SIZE - 1)) {
                 WARN_ONCE(1, "Ftrace: splice_read should page-align\n");
-                if (len < PAGE_SIZE)
-                        return -EINVAL;
+                if (len < PAGE_SIZE) {
+                        ret = -EINVAL;
+                        goto out;
+                }
                 len &= PAGE_MASK;
         }
 
         trace_access_lock(info->cpu);
         entries = ring_buffer_entries_cpu(info->tr->buffer, info->cpu);
 
-        for (i = 0; i < PIPE_BUFFERS && len && entries; i++, len -= PAGE_SIZE) {
+        for (i = 0; i < pipe->buffers && len && entries; i++, len -= PAGE_SIZE) {
                 struct page *page;
                 int r;
 
@@ -3869,11 +3875,12 @@ tracing_buffers_splice_read(struct file *file, loff_t *ppos,
                 else
                         ret = 0;
                 /* TODO: block */
-                return ret;
+                goto out;
         }
 
         ret = splice_to_pipe(pipe, &spd);
-
+        splice_shrink_spd(pipe, &spd);
+out:
         return ret;
 }
 
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index d1ce0bec1b3f..2cd96399463f 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -405,12 +405,12 @@ void ftrace_trace_userstack(struct ring_buffer *buffer, unsigned long flags,
 void __trace_stack(struct trace_array *tr, unsigned long flags, int skip,
                    int pc);
 #else
-static inline void ftrace_trace_stack(struct trace_array *tr,
+static inline void ftrace_trace_stack(struct ring_buffer *buffer,
                                       unsigned long flags, int skip, int pc)
 {
 }
 
-static inline void ftrace_trace_userstack(struct trace_array *tr,
+static inline void ftrace_trace_userstack(struct ring_buffer *buffer,
                                           unsigned long flags, int pc)
 {
 }
@@ -778,12 +778,15 @@ extern void print_subsystem_event_filter(struct event_subsystem *system,
                                          struct trace_seq *s);
 extern int filter_assign_type(const char *type);
 
+struct list_head *
+trace_get_fields(struct ftrace_event_call *event_call);
+
 static inline int
 filter_check_discard(struct ftrace_event_call *call, void *rec,
                      struct ring_buffer *buffer,
                      struct ring_buffer_event *event)
 {
-        if (unlikely(call->filter_active) &&
+        if (unlikely(call->flags & TRACE_EVENT_FL_FILTERED) &&
             !filter_match_preds(call->filter, rec)) {
                 ring_buffer_discard_commit(buffer, event);
                 return 1;
diff --git a/kernel/trace/trace_branch.c b/kernel/trace/trace_branch.c
index b9bc4d470177..8d3538b4ea5f 100644
--- a/kernel/trace/trace_branch.c
+++ b/kernel/trace/trace_branch.c
@@ -143,7 +143,7 @@ static void branch_trace_reset(struct trace_array *tr)
 }
 
 static enum print_line_t trace_branch_print(struct trace_iterator *iter,
-                                            int flags)
+                                            int flags, struct trace_event *event)
 {
         struct trace_branch *field;
 
@@ -167,9 +167,13 @@ static void branch_print_header(struct seq_file *s)
                 "    |\n");
 }
 
+static struct trace_event_functions trace_branch_funcs = {
+        .trace          = trace_branch_print,
+};
+
 static struct trace_event trace_branch_event = {
         .type           = TRACE_BRANCH,
-        .trace          = trace_branch_print,
+        .funcs          = &trace_branch_funcs,
 };
 
 static struct tracer branch_trace __read_mostly =
diff --git a/kernel/trace/trace_event_perf.c b/kernel/trace/trace_event_perf.c
index 0565bb42566f..cb6f365016e4 100644
--- a/kernel/trace/trace_event_perf.c
+++ b/kernel/trace/trace_event_perf.c
@@ -9,13 +9,9 @@
 #include <linux/kprobes.h>
 #include "trace.h"
 
-DEFINE_PER_CPU(struct pt_regs, perf_trace_regs);
-EXPORT_PER_CPU_SYMBOL_GPL(perf_trace_regs);
-
 EXPORT_SYMBOL_GPL(perf_arch_fetch_caller_regs);
 
-static char *perf_trace_buf;
-static char *perf_trace_buf_nmi;
+static char *perf_trace_buf[4];
 
 /*
  * Force it to be aligned to unsigned long to avoid misaligned accesses
@@ -27,57 +23,82 @@ typedef typeof(unsigned long [PERF_MAX_TRACE_SIZE / sizeof(unsigned long)])
 /* Count the events in use (per event id, not per instance) */
 static int      total_ref_count;
 
-static int perf_trace_event_enable(struct ftrace_event_call *event)
+static int perf_trace_event_init(struct ftrace_event_call *tp_event,
+                                 struct perf_event *p_event)
 {
-        char *buf;
+        struct hlist_head *list;
         int ret = -ENOMEM;
+        int cpu;
 
-        if (event->perf_refcount++ > 0)
+        p_event->tp_event = tp_event;
+        if (tp_event->perf_refcount++ > 0)
                 return 0;
 
-        if (!total_ref_count) {
-                buf = (char *)alloc_percpu(perf_trace_t);
-                if (!buf)
-                        goto fail_buf;
+        list = alloc_percpu(struct hlist_head);
+        if (!list)
+                goto fail;
 
-                rcu_assign_pointer(perf_trace_buf, buf);
+        for_each_possible_cpu(cpu)
+                INIT_HLIST_HEAD(per_cpu_ptr(list, cpu));
 
-                buf = (char *)alloc_percpu(perf_trace_t);
-                if (!buf)
-                        goto fail_buf_nmi;
+        tp_event->perf_events = list;
 
-                rcu_assign_pointer(perf_trace_buf_nmi, buf);
-        }
+        if (!total_ref_count) {
+                char *buf;
+                int i;
 
-        ret = event->perf_event_enable(event);
-        if (!ret) {
-                total_ref_count++;
-                return 0;
+                for (i = 0; i < 4; i++) {
+                        buf = (char *)alloc_percpu(perf_trace_t);
+                        if (!buf)
+                                goto fail;
+
+                        perf_trace_buf[i] = buf;
+                }
         }
 
-fail_buf_nmi:
+        if (tp_event->class->reg)
+                ret = tp_event->class->reg(tp_event, TRACE_REG_PERF_REGISTER);
+        else
+                ret = tracepoint_probe_register(tp_event->name,
+                                                tp_event->class->perf_probe,
+                                                tp_event);
+
+        if (ret)
+                goto fail;
+
+        total_ref_count++;
+        return 0;
+
+fail:
         if (!total_ref_count) {
-                free_percpu(perf_trace_buf_nmi);
-                free_percpu(perf_trace_buf);
-                perf_trace_buf_nmi = NULL;
-                perf_trace_buf = NULL;
+                int i;
+
+                for (i = 0; i < 4; i++) {
+                        free_percpu(perf_trace_buf[i]);
+                        perf_trace_buf[i] = NULL;
+                }
+        }
+
+        if (!--tp_event->perf_refcount) {
+                free_percpu(tp_event->perf_events);
+                tp_event->perf_events = NULL;
         }
-fail_buf:
-        event->perf_refcount--;
 
         return ret;
 }
 
-int perf_trace_enable(int event_id)
+int perf_trace_init(struct perf_event *p_event)
 {
-        struct ftrace_event_call *event;
+        struct ftrace_event_call *tp_event;
+        int event_id = p_event->attr.config;
         int ret = -EINVAL;
 
         mutex_lock(&event_mutex);
-        list_for_each_entry(event, &ftrace_events, list) {
-                if (event->id == event_id && event->perf_event_enable &&
-                    try_module_get(event->mod)) {
-                        ret = perf_trace_event_enable(event);
+        list_for_each_entry(tp_event, &ftrace_events, list) {
+                if (tp_event->event.type == event_id &&
+                    tp_event->class && tp_event->class->perf_probe &&
+                    try_module_get(tp_event->mod)) {
+                        ret = perf_trace_event_init(tp_event, p_event);
                         break;
                 }
         }
@@ -86,90 +107,78 @@ int perf_trace_enable(int event_id)
         return ret;
 }
 
-static void perf_trace_event_disable(struct ftrace_event_call *event)
+int perf_trace_enable(struct perf_event *p_event)
 {
-        char *buf, *nmi_buf;
-
-        if (--event->perf_refcount > 0)
-                return;
-
-        event->perf_event_disable(event);
+        struct ftrace_event_call *tp_event = p_event->tp_event;
+        struct hlist_head *list;
 
-        if (!--total_ref_count) {
-                buf = perf_trace_buf;
-                rcu_assign_pointer(perf_trace_buf, NULL);
+        list = tp_event->perf_events;
+        if (WARN_ON_ONCE(!list))
+                return -EINVAL;
 
-                nmi_buf = perf_trace_buf_nmi;
-                rcu_assign_pointer(perf_trace_buf_nmi, NULL);
+        list = per_cpu_ptr(list, smp_processor_id());
+        hlist_add_head_rcu(&p_event->hlist_entry, list);
 
-                /*
-                 * Ensure every events in profiling have finished before
-                 * releasing the buffers
-                 */
-                synchronize_sched();
+        return 0;
+}
 
-                free_percpu(buf);
-                free_percpu(nmi_buf);
-        }
+void perf_trace_disable(struct perf_event *p_event)
+{
+        hlist_del_rcu(&p_event->hlist_entry);
 }
 
-void perf_trace_disable(int event_id)
+void perf_trace_destroy(struct perf_event *p_event)
 {
-        struct ftrace_event_call *event;
+        struct ftrace_event_call *tp_event = p_event->tp_event;
+        int i;
 
-        mutex_lock(&event_mutex);
-        list_for_each_entry(event, &ftrace_events, list) {
-                if (event->id == event_id) {
-                        perf_trace_event_disable(event);
-                        module_put(event->mod);
-                        break;
+        if (--tp_event->perf_refcount > 0)
+                return;
+
+        if (tp_event->class->reg)
+                tp_event->class->reg(tp_event, TRACE_REG_PERF_UNREGISTER);
+        else
+                tracepoint_probe_unregister(tp_event->name,
+                                            tp_event->class->perf_probe,
+                                            tp_event);
+
+        free_percpu(tp_event->perf_events);
+        tp_event->perf_events = NULL;
+
+        if (!--total_ref_count) {
+                for (i = 0; i < 4; i++) {
+                        free_percpu(perf_trace_buf[i]);
+                        perf_trace_buf[i] = NULL;
                 }
         }
-        mutex_unlock(&event_mutex);
 }
 
 __kprobes void *perf_trace_buf_prepare(int size, unsigned short type,
-                                       int *rctxp, unsigned long *irq_flags)
+                                       struct pt_regs *regs, int *rctxp)
 {
         struct trace_entry *entry;
-        char *trace_buf, *raw_data;
-        int pc, cpu;
+        unsigned long flags;
+        char *raw_data;
+        int pc;
 
         BUILD_BUG_ON(PERF_MAX_TRACE_SIZE % sizeof(unsigned long));
 
         pc = preempt_count();
 
-        /* Protect the per cpu buffer, begin the rcu read side */
-        local_irq_save(*irq_flags);
-
         *rctxp = perf_swevent_get_recursion_context();
         if (*rctxp < 0)
-                goto err_recursion;
-
-        cpu = smp_processor_id();
-
-        if (in_nmi())
-                trace_buf = rcu_dereference_sched(perf_trace_buf_nmi);
-        else
-                trace_buf = rcu_dereference_sched(perf_trace_buf);
-
-        if (!trace_buf)
-                goto err;
+                return NULL;
 
-        raw_data = per_cpu_ptr(trace_buf, cpu);
+        raw_data = per_cpu_ptr(perf_trace_buf[*rctxp], smp_processor_id());
 
         /* zero the dead bytes from align to not leak stack to user */
         memset(&raw_data[size - sizeof(u64)], 0, sizeof(u64));
 
         entry = (struct trace_entry *)raw_data;
-        tracing_generic_entry_update(entry, *irq_flags, pc);
+        local_save_flags(flags);
+        tracing_generic_entry_update(entry, flags, pc);
         entry->type = type;
 
         return raw_data;
-err:
-        perf_swevent_put_recursion_context(*rctxp);
-err_recursion:
-        local_irq_restore(*irq_flags);
-        return NULL;
 }
 EXPORT_SYMBOL_GPL(perf_trace_buf_prepare);
diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
index c697c7043349..53cffc0b0801 100644
--- a/kernel/trace/trace_events.c
+++ b/kernel/trace/trace_events.c
@@ -29,11 +29,23 @@ DEFINE_MUTEX(event_mutex);
 
 LIST_HEAD(ftrace_events);
 
+struct list_head *
+trace_get_fields(struct ftrace_event_call *event_call)
+{
+        if (!event_call->class->get_fields)
+                return &event_call->class->fields;
+        return event_call->class->get_fields(event_call);
+}
+
 int trace_define_field(struct ftrace_event_call *call, const char *type,
                        const char *name, int offset, int size, int is_signed,
                        int filter_type)
 {
         struct ftrace_event_field *field;
+        struct list_head *head;
+
+        if (WARN_ON(!call->class))
+                return 0;
 
         field = kzalloc(sizeof(*field), GFP_KERNEL);
         if (!field)
@@ -56,7 +68,8 @@ int trace_define_field(struct ftrace_event_call *call, const char *type,
         field->size = size;
         field->is_signed = is_signed;
 
-        list_add(&field->link, &call->fields);
+        head = trace_get_fields(call);
+        list_add(&field->link, head);
 
         return 0;
 
@@ -94,8 +107,10 @@ static int trace_define_common_fields(struct ftrace_event_call *call)
 void trace_destroy_fields(struct ftrace_event_call *call)
 {
         struct ftrace_event_field *field, *next;
+        struct list_head *head;
 
-        list_for_each_entry_safe(field, next, &call->fields, link) {
+        head = trace_get_fields(call);
+        list_for_each_entry_safe(field, next, head, link) {
                 list_del(&field->link);
                 kfree(field->type);
                 kfree(field->name);
@@ -107,11 +122,9 @@ int trace_event_raw_init(struct ftrace_event_call *call)
 {
         int id;
 
-        id = register_ftrace_event(call->event);
+        id = register_ftrace_event(&call->event);
         if (!id)
                 return -ENODEV;
-        call->id = id;
-        INIT_LIST_HEAD(&call->fields);
 
         return 0;
 }
@@ -124,23 +137,33 @@ static int ftrace_event_enable_disable(struct ftrace_event_call *call,
 
         switch (enable) {
         case 0:
-                if (call->enabled) {
-                        call->enabled = 0;
+                if (call->flags & TRACE_EVENT_FL_ENABLED) {
+                        call->flags &= ~TRACE_EVENT_FL_ENABLED;
                         tracing_stop_cmdline_record();
-                        call->unregfunc(call);
+                        if (call->class->reg)
+                                call->class->reg(call, TRACE_REG_UNREGISTER);
+                        else
+                                tracepoint_probe_unregister(call->name,
+                                                            call->class->probe,
+                                                            call);
                 }
                 break;
         case 1:
-                if (!call->enabled) {
+                if (!(call->flags & TRACE_EVENT_FL_ENABLED)) {
                         tracing_start_cmdline_record();
-                        ret = call->regfunc(call);
+                        if (call->class->reg)
+                                ret = call->class->reg(call, TRACE_REG_REGISTER);
+                        else
+                                ret = tracepoint_probe_register(call->name,
+                                                                call->class->probe,
+                                                                call);
                         if (ret) {
                                 tracing_stop_cmdline_record();
                                 pr_info("event trace: Could not enable event "
                                         "%s\n", call->name);
                                 break;
                         }
-                        call->enabled = 1;
+                        call->flags |= TRACE_EVENT_FL_ENABLED;
                 }
                 break;
         }
@@ -171,15 +194,16 @@ static int __ftrace_set_clr_event(const char *match, const char *sub,
         mutex_lock(&event_mutex);
         list_for_each_entry(call, &ftrace_events, list) {
 
-                if (!call->name || !call->regfunc)
+                if (!call->name || !call->class ||
+                    (!call->class->probe && !call->class->reg))
                         continue;
 
                 if (match &&
                     strcmp(match, call->name) != 0 &&
-                    strcmp(match, call->system) != 0)
+                    strcmp(match, call->class->system) != 0)
                         continue;
 
-                if (sub && strcmp(sub, call->system) != 0)
+                if (sub && strcmp(sub, call->class->system) != 0)
                         continue;
 
                 if (event && strcmp(event, call->name) != 0)
@@ -297,7 +321,7 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
                  * The ftrace subsystem is for showing formats only.
                  * They can not be enabled or disabled via the event files.
                  */
-                if (call->regfunc)
+                if (call->class && (call->class->probe || call->class->reg))
                         return call;
         }
 
@@ -328,7 +352,7 @@ s_next(struct seq_file *m, void *v, loff_t *pos)
         (*pos)++;
 
         list_for_each_entry_continue(call, &ftrace_events, list) {
-                if (call->enabled)
+                if (call->flags & TRACE_EVENT_FL_ENABLED)
                         return call;
         }
 
@@ -355,8 +379,8 @@ static int t_show(struct seq_file *m, void *v)
 {
         struct ftrace_event_call *call = v;
 
-        if (strcmp(call->system, TRACE_SYSTEM) != 0)
-                seq_printf(m, "%s:", call->system);
+        if (strcmp(call->class->system, TRACE_SYSTEM) != 0)
+                seq_printf(m, "%s:", call->class->system);
         seq_printf(m, "%s\n", call->name);
 
         return 0;
@@ -387,7 +411,7 @@ event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
         struct ftrace_event_call *call = filp->private_data;
         char *buf;
 
-        if (call->enabled)
+        if (call->flags & TRACE_EVENT_FL_ENABLED)
                 buf = "1\n";
         else
                 buf = "0\n";
@@ -450,10 +474,11 @@ system_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
 
         mutex_lock(&event_mutex);
         list_for_each_entry(call, &ftrace_events, list) {
-                if (!call->name || !call->regfunc)
+                if (!call->name || !call->class ||
+                    (!call->class->probe && !call->class->reg))
                         continue;
 
-                if (system && strcmp(call->system, system) != 0)
+                if (system && strcmp(call->class->system, system) != 0)
                         continue;
 
                 /*
@@ -461,7 +486,7 @@ system_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
                  * or if all events or cleared, or if we have
                  * a mixture.
                  */
-                set |= (1 << !!call->enabled);
+                set |= (1 << !!(call->flags & TRACE_EVENT_FL_ENABLED));
 
                 /*
                  * If we have a mixture, no need to look further.
@@ -525,6 +550,7 @@ event_format_read(struct file *filp, char __user *ubuf, size_t cnt,
 {
         struct ftrace_event_call *call = filp->private_data;
         struct ftrace_event_field *field;
+        struct list_head *head;
         struct trace_seq *s;
         int common_field_count = 5;
         char *buf;
@@ -540,10 +566,11 @@ event_format_read(struct file *filp, char __user *ubuf, size_t cnt,
         trace_seq_init(s);
 
         trace_seq_printf(s, "name: %s\n", call->name);
-        trace_seq_printf(s, "ID: %d\n", call->id);
+        trace_seq_printf(s, "ID: %d\n", call->event.type);
         trace_seq_printf(s, "format:\n");
 
-        list_for_each_entry_reverse(field, &call->fields, link) {
+        head = trace_get_fields(call);
+        list_for_each_entry_reverse(field, head, link) {
                 /*
                  * Smartly shows the array type(except dynamic array).
                  * Normal:
@@ -613,7 +640,7 @@ event_id_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
                 return -ENOMEM;
 
         trace_seq_init(s);
-        trace_seq_printf(s, "%d\n", call->id);
+        trace_seq_printf(s, "%d\n", call->event.type);
 
         r = simple_read_from_buffer(ubuf, cnt, ppos,
                                     s->buffer, s->len);
@@ -919,14 +946,15 @@ event_create_dir(struct ftrace_event_call *call, struct dentry *d_events,
                  const struct file_operations *filter,
                  const struct file_operations *format)
 {
+        struct list_head *head;
         int ret;
 
         /*
          * If the trace point header did not define TRACE_SYSTEM
          * then the system would be called "TRACE_SYSTEM".
          */
-        if (strcmp(call->system, TRACE_SYSTEM) != 0)
-                d_events = event_subsystem_dir(call->system, d_events);
+        if (strcmp(call->class->system, TRACE_SYSTEM) != 0)
+                d_events = event_subsystem_dir(call->class->system, d_events);
 
         call->dir = debugfs_create_dir(call->name, d_events);
         if (!call->dir) {
@@ -935,22 +963,31 @@ event_create_dir(struct ftrace_event_call *call, struct dentry *d_events,
                 return -1;
         }
 
-        if (call->regfunc)
+        if (call->class->probe || call->class->reg)
                 trace_create_file("enable", 0644, call->dir, call,
                                   enable);
 
-        if (call->id && call->perf_event_enable)
+#ifdef CONFIG_PERF_EVENTS
+        if (call->event.type && (call->class->perf_probe || call->class->reg))
                 trace_create_file("id", 0444, call->dir, call,
                                   id);
+#endif
 
-        if (call->define_fields) {
-                ret = trace_define_common_fields(call);
-                if (!ret)
-                        ret = call->define_fields(call);
-                if (ret < 0) {
-                        pr_warning("Could not initialize trace point"
-                                   " events/%s\n", call->name);
-                        return ret;
+        if (call->class->define_fields) {
+                /*
+                 * Other events may have the same class. Only update
+                 * the fields if they are not already defined.
+                 */
+                head = trace_get_fields(call);
+                if (list_empty(head)) {
+                        ret = trace_define_common_fields(call);
+                        if (!ret)
+                                ret = call->class->define_fields(call);
+                        if (ret < 0) {
+                                pr_warning("Could not initialize trace point"
+                                           " events/%s\n", call->name);
+                                return ret;
+                        }
                 }
                 trace_create_file("filter", 0644, call->dir, call,
                                   filter);
@@ -970,8 +1007,8 @@ static int __trace_add_event_call(struct ftrace_event_call *call)
         if (!call->name)
                 return -EINVAL;
 
-        if (call->raw_init) {
-                ret = call->raw_init(call);
+        if (call->class->raw_init) {
+                ret = call->class->raw_init(call);
                 if (ret < 0) {
                         if (ret != -ENOSYS)
                                 pr_warning("Could not initialize trace "
@@ -1035,13 +1072,13 @@ static void remove_subsystem_dir(const char *name)
 static void __trace_remove_event_call(struct ftrace_event_call *call)
 {
         ftrace_event_enable_disable(call, 0);
-        if (call->event)
-                __unregister_ftrace_event(call->event);
+        if (call->event.funcs)
+                __unregister_ftrace_event(&call->event);
         debugfs_remove_recursive(call->dir);
         list_del(&call->list);
         trace_destroy_fields(call);
         destroy_preds(call);
-        remove_subsystem_dir(call->system);
+        remove_subsystem_dir(call->class->system);
 }
 
 /* Remove an event_call */
@@ -1132,8 +1169,8 @@ static void trace_module_add_events(struct module *mod)
                 /* The linker may leave blanks */
                 if (!call->name)
                         continue;
-                if (call->raw_init) {
-                        ret = call->raw_init(call);
+                if (call->class->raw_init) {
+                        ret = call->class->raw_init(call);
                         if (ret < 0) {
                                 if (ret != -ENOSYS)
                                         pr_warning("Could not initialize trace "
@@ -1286,8 +1323,8 @@ static __init int event_trace_init(void)
                 /* The linker may leave blanks */
                 if (!call->name)
                         continue;
-                if (call->raw_init) {
-                        ret = call->raw_init(call);
+                if (call->class->raw_init) {
+                        ret = call->class->raw_init(call);
                         if (ret < 0) {
                                 if (ret != -ENOSYS)
                                         pr_warning("Could not initialize trace "
@@ -1388,8 +1425,8 @@ static __init void event_trace_self_tests(void)
 
         list_for_each_entry(call, &ftrace_events, list) {
 
-                /* Only test those that have a regfunc */
-                if (!call->regfunc)
+                /* Only test those that have a probe */
+                if (!call->class || !call->class->probe)
                         continue;
 
 /*
@@ -1399,8 +1436,8 @@ static __init void event_trace_self_tests(void)
  * syscalls as we test.
  */
 #ifndef CONFIG_EVENT_TRACE_TEST_SYSCALLS
-                if (call->system &&
-                    strcmp(call->system, "syscalls") == 0)
+                if (call->class->system &&
+                    strcmp(call->class->system, "syscalls") == 0)
                         continue;
 #endif
 
@@ -1410,7 +1447,7 @@ static __init void event_trace_self_tests(void)
                  * If an event is already enabled, someone is using
                  * it and the self test should not be on.
                  */
-                if (call->enabled) {
+                if (call->flags & TRACE_EVENT_FL_ENABLED) {
                         pr_warning("Enabled event during self test!\n");
                         WARN_ON_ONCE(1);
                         continue;
diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c
index 58092d844a1f..57bb1bb32999 100644
--- a/kernel/trace/trace_events_filter.c
+++ b/kernel/trace/trace_events_filter.c
@@ -500,8 +500,10 @@ static struct ftrace_event_field *
 find_event_field(struct ftrace_event_call *call, char *name)
 {
         struct ftrace_event_field *field;
+        struct list_head *head;
 
-        list_for_each_entry(field, &call->fields, link) {
+        head = trace_get_fields(call);
+        list_for_each_entry(field, head, link) {
                 if (!strcmp(field->name, name))
                         return field;
         }
@@ -545,7 +547,7 @@ static void filter_disable_preds(struct ftrace_event_call *call)
         struct event_filter *filter = call->filter;
         int i;
 
-        call->filter_active = 0;
+        call->flags &= ~TRACE_EVENT_FL_FILTERED;
         filter->n_preds = 0;
 
         for (i = 0; i < MAX_FILTER_PRED; i++)
@@ -572,7 +574,7 @@ void destroy_preds(struct ftrace_event_call *call)
 {
         __free_preds(call->filter);
         call->filter = NULL;
-        call->filter_active = 0;
+        call->flags &= ~TRACE_EVENT_FL_FILTERED;
 }
 
 static struct event_filter *__alloc_preds(void)
@@ -611,7 +613,7 @@ static int init_preds(struct ftrace_event_call *call)
         if (call->filter)
                 return 0;
 
-        call->filter_active = 0;
+        call->flags &= ~TRACE_EVENT_FL_FILTERED;
         call->filter = __alloc_preds();
         if (IS_ERR(call->filter))
                 return PTR_ERR(call->filter);
@@ -625,10 +627,10 @@ static int init_subsystem_preds(struct event_subsystem *system)
         int err;
 
         list_for_each_entry(call, &ftrace_events, list) {
-                if (!call->define_fields)
+                if (!call->class || !call->class->define_fields)
                         continue;
 
-                if (strcmp(call->system, system->name) != 0)
+                if (strcmp(call->class->system, system->name) != 0)
                         continue;
 
                 err = init_preds(call);
@@ -644,10 +646,10 @@ static void filter_free_subsystem_preds(struct event_subsystem *system)
         struct ftrace_event_call *call;
 
         list_for_each_entry(call, &ftrace_events, list) {
-                if (!call->define_fields)
+                if (!call->class || !call->class->define_fields)
                         continue;
 
-                if (strcmp(call->system, system->name) != 0)
+                if (strcmp(call->class->system, system->name) != 0)
                         continue;
 
                 filter_disable_preds(call);
@@ -1249,10 +1251,10 @@ static int replace_system_preds(struct event_subsystem *system,
         list_for_each_entry(call, &ftrace_events, list) {
                 struct event_filter *filter = call->filter;
 
-                if (!call->define_fields)
+                if (!call->class || !call->class->define_fields)
                         continue;
 
-                if (strcmp(call->system, system->name) != 0)
+                if (strcmp(call->class->system, system->name) != 0)
                         continue;
 
                 /* try to see if the filter can be applied */
@@ -1266,7 +1268,7 @@ static int replace_system_preds(struct event_subsystem *system,
                 if (err)
                         filter_disable_preds(call);
                 else {
-                        call->filter_active = 1;
+                        call->flags |= TRACE_EVENT_FL_FILTERED;
                         replace_filter_string(filter, filter_string);
                 }
                 fail = false;
@@ -1315,7 +1317,7 @@ int apply_event_filter(struct ftrace_event_call *call, char *filter_string)
         if (err)
                 append_filter_err(ps, call->filter);
         else
-                call->filter_active = 1;
+                call->flags |= TRACE_EVENT_FL_FILTERED;
 out:
         filter_opstack_clear(ps);
         postfix_clear(ps);
@@ -1393,7 +1395,7 @@ int ftrace_profile_set_filter(struct perf_event *event, int event_id,
         mutex_lock(&event_mutex);
 
         list_for_each_entry(call, &ftrace_events, list) {
-                if (call->id == event_id)
+                if (call->event.type == event_id)
                         break;
         }
 
diff --git a/kernel/trace/trace_export.c b/kernel/trace/trace_export.c
index e091f64ba6ce..8536e2a65969 100644
--- a/kernel/trace/trace_export.c
+++ b/kernel/trace/trace_export.c
@@ -127,7 +127,7 @@ ftrace_define_fields_##name(struct ftrace_event_call *event_call)	\
 
 static int ftrace_raw_init_event(struct ftrace_event_call *call)
 {
-        INIT_LIST_HEAD(&call->fields);
+        INIT_LIST_HEAD(&call->class->fields);
         return 0;
 }
 
@@ -153,17 +153,21 @@ static int ftrace_raw_init_event(struct ftrace_event_call *call)
 #define F_printk(fmt, args...) #fmt ", "  __stringify(args)
 
 #undef FTRACE_ENTRY
-#define FTRACE_ENTRY(call, struct_name, type, tstruct, print)           \
+#define FTRACE_ENTRY(call, struct_name, etype, tstruct, print)          \
+                                                                        \
+struct ftrace_event_class event_class_ftrace_##call = {                 \
+        .system                 = __stringify(TRACE_SYSTEM),            \
+        .define_fields          = ftrace_define_fields_##call,          \
+        .raw_init               = ftrace_raw_init_event,                \
+};                                                                      \
                                                                         \
 struct ftrace_event_call __used                                         \
 __attribute__((__aligned__(4)))                                         \
 __attribute__((section("_ftrace_events"))) event_##call = {             \
         .name                   = #call,                                \
-        .id                     = type,                                 \
-        .system                 = __stringify(TRACE_SYSTEM),            \
-        .raw_init               = ftrace_raw_init_event,                \
+        .event.type             = etype,                                \
+        .class                  = &event_class_ftrace_##call,           \
         .print_fmt              = print,                                \
-        .define_fields          = ftrace_define_fields_##call,          \
 };                                                                      \
 
 #include "trace_entries.h"
diff --git a/kernel/trace/trace_functions_graph.c b/kernel/trace/trace_functions_graph.c
index dd11c830eb84..79f4bac99a94 100644
--- a/kernel/trace/trace_functions_graph.c
+++ b/kernel/trace/trace_functions_graph.c
@@ -1025,7 +1025,7 @@ print_graph_comment(struct trace_seq *s, struct trace_entry *ent,
                 if (!event)
                         return TRACE_TYPE_UNHANDLED;
 
-                ret = event->trace(iter, sym_flags);
+                ret = event->funcs->trace(iter, sym_flags, event);
                 if (ret != TRACE_TYPE_HANDLED)
                         return ret;
         }
@@ -1112,7 +1112,8 @@ print_graph_function(struct trace_iterator *iter)
 }
 
 static enum print_line_t
-print_graph_function_event(struct trace_iterator *iter, int flags)
+print_graph_function_event(struct trace_iterator *iter, int flags,
+                           struct trace_event *event)
 {
         return print_graph_function(iter);
 }
@@ -1225,14 +1226,18 @@ void graph_trace_close(struct trace_iterator *iter)
         }
 }
 
+static struct trace_event_functions graph_functions = {
+        .trace          = print_graph_function_event,
+};
+
 static struct trace_event graph_trace_entry_event = {
         .type           = TRACE_GRAPH_ENT,
-        .trace          = print_graph_function_event,
+        .funcs          = &graph_functions,
 };
 
 static struct trace_event graph_trace_ret_event = {
         .type           = TRACE_GRAPH_RET,
-        .trace          = print_graph_function_event,
+        .funcs          = &graph_functions
 };
 
 static struct tracer graph_trace __read_mostly = {
diff --git a/kernel/trace/trace_kprobe.c b/kernel/trace/trace_kprobe.c
index a7514326052b..faf7cefd15da 100644
--- a/kernel/trace/trace_kprobe.c
+++ b/kernel/trace/trace_kprobe.c
@@ -324,8 +324,8 @@ struct trace_probe {
         unsigned long           nhit;
         unsigned int            flags;  /* For TP_FLAG_* */
         const char              *symbol;        /* symbol name */
+        struct ftrace_event_class       class;
         struct ftrace_event_call        call;
-        struct trace_event              event;
         ssize_t                 size;           /* trace entry size */
         unsigned int            nr_args;
         struct probe_arg        args[];
@@ -404,6 +404,7 @@ static struct trace_probe *alloc_trace_probe(const char *group,
                 goto error;
         }
 
+        tp->call.class = &tp->class;
         tp->call.name = kstrdup(event, GFP_KERNEL);
         if (!tp->call.name)
                 goto error;
@@ -413,8 +414,8 @@ static struct trace_probe *alloc_trace_probe(const char *group,
                 goto error;
         }
 
-        tp->call.system = kstrdup(group, GFP_KERNEL);
-        if (!tp->call.system)
+        tp->class.system = kstrdup(group, GFP_KERNEL);
+        if (!tp->class.system)
                 goto error;
 
         INIT_LIST_HEAD(&tp->list);
@@ -443,7 +444,7 @@ static void free_trace_probe(struct trace_probe *tp)
         for (i = 0; i < tp->nr_args; i++)
                 free_probe_arg(&tp->args[i]);
 
-        kfree(tp->call.system);
+        kfree(tp->call.class->system);
         kfree(tp->call.name);
         kfree(tp->symbol);
         kfree(tp);
@@ -456,7 +457,7 @@ static struct trace_probe *find_probe_event(const char *event,
 
         list_for_each_entry(tp, &probe_list, list)
                 if (strcmp(tp->call.name, event) == 0 &&
-                    strcmp(tp->call.system, group) == 0)
+                    strcmp(tp->call.class->system, group) == 0)
                         return tp;
         return NULL;
 }
@@ -481,7 +482,7 @@ static int register_trace_probe(struct trace_probe *tp)
         mutex_lock(&probe_lock);
 
         /* register as an event */
-        old_tp = find_probe_event(tp->call.name, tp->call.system);
+        old_tp = find_probe_event(tp->call.name, tp->call.class->system);
         if (old_tp) {
                 /* delete old event */
                 unregister_trace_probe(old_tp);
@@ -904,7 +905,7 @@ static int probes_seq_show(struct seq_file *m, void *v)
         int i;
 
         seq_printf(m, "%c", probe_is_return(tp) ? 'r' : 'p');
-        seq_printf(m, ":%s/%s", tp->call.system, tp->call.name);
+        seq_printf(m, ":%s/%s", tp->call.class->system, tp->call.name);
 
         if (!tp->symbol)
                 seq_printf(m, " 0x%p", tp->rp.kp.addr);
@@ -1061,8 +1062,8 @@ static __kprobes void kprobe_trace_func(struct kprobe *kp, struct pt_regs *regs)
 
         size = sizeof(*entry) + tp->size;
 
-        event = trace_current_buffer_lock_reserve(&buffer, call->id, size,
-                                                  irq_flags, pc);
+        event = trace_current_buffer_lock_reserve(&buffer, call->event.type,
+                                                  size, irq_flags, pc);
         if (!event)
                 return;
 
@@ -1094,8 +1095,8 @@ static __kprobes void kretprobe_trace_func(struct kretprobe_instance *ri,
 
         size = sizeof(*entry) + tp->size;
 
-        event = trace_current_buffer_lock_reserve(&buffer, call->id, size,
-                                                  irq_flags, pc);
+        event = trace_current_buffer_lock_reserve(&buffer, call->event.type,
+                                                  size, irq_flags, pc);
         if (!event)
                 return;
 
@@ -1112,18 +1113,17 @@ static __kprobes void kretprobe_trace_func(struct kretprobe_instance *ri,
 
 /* Event entry printers */
 enum print_line_t
-print_kprobe_event(struct trace_iterator *iter, int flags)
+print_kprobe_event(struct trace_iterator *iter, int flags,
+                   struct trace_event *event)
 {
         struct kprobe_trace_entry_head *field;
         struct trace_seq *s = &iter->seq;
-        struct trace_event *event;
         struct trace_probe *tp;
         u8 *data;
         int i;
 
         field = (struct kprobe_trace_entry_head *)iter->ent;
-        event = ftrace_find_event(field->ent.type);
-        tp = container_of(event, struct trace_probe, event);
+        tp = container_of(event, struct trace_probe, call.event);
 
         if (!trace_seq_printf(s, "%s: (", tp->call.name))
                 goto partial;
@@ -1149,18 +1149,17 @@ partial:
 }
 
 enum print_line_t
-print_kretprobe_event(struct trace_iterator *iter, int flags)
+print_kretprobe_event(struct trace_iterator *iter, int flags,
+                      struct trace_event *event)
 {
         struct kretprobe_trace_entry_head *field;
         struct trace_seq *s = &iter->seq;
-        struct trace_event *event;
         struct trace_probe *tp;
         u8 *data;
         int i;
 
         field = (struct kretprobe_trace_entry_head *)iter->ent;
-        event = ftrace_find_event(field->ent.type);
-        tp = container_of(event, struct trace_probe, event);
+        tp = container_of(event, struct trace_probe, call.event);
 
         if (!trace_seq_printf(s, "%s: (", tp->call.name))
                 goto partial;
@@ -1217,8 +1216,6 @@ static void probe_event_disable(struct ftrace_event_call *call)
 
 static int probe_event_raw_init(struct ftrace_event_call *event_call)
 {
-        INIT_LIST_HEAD(&event_call->fields);
-
         return 0;
 }
 
@@ -1341,9 +1338,9 @@ static __kprobes void kprobe_perf_func(struct kprobe *kp,
         struct trace_probe *tp = container_of(kp, struct trace_probe, rp.kp);
         struct ftrace_event_call *call = &tp->call;
         struct kprobe_trace_entry_head *entry;
+        struct hlist_head *head;
         u8 *data;
         int size, __size, i;
-        unsigned long irq_flags;
         int rctx;
 
         __size = sizeof(*entry) + tp->size;
@@ -1353,7 +1350,7 @@ static __kprobes void kprobe_perf_func(struct kprobe *kp,
                      "profile buffer not large enough"))
                 return;
 
-        entry = perf_trace_buf_prepare(size, call->id, &rctx, &irq_flags);
+        entry = perf_trace_buf_prepare(size, call->event.type, regs, &rctx);
         if (!entry)
                 return;
 
@@ -1362,7 +1359,8 @@ static __kprobes void kprobe_perf_func(struct kprobe *kp,
         for (i = 0; i < tp->nr_args; i++)
                 call_fetch(&tp->args[i].fetch, regs, data + tp->args[i].offset);
 
-        perf_trace_buf_submit(entry, size, rctx, entry->ip, 1, irq_flags, regs);
+        head = per_cpu_ptr(call->perf_events, smp_processor_id());
+        perf_trace_buf_submit(entry, size, rctx, entry->ip, 1, regs, head);
 }
 
 /* Kretprobe profile handler */
@@ -1372,9 +1370,9 @@ static __kprobes void kretprobe_perf_func(struct kretprobe_instance *ri,
         struct trace_probe *tp = container_of(ri->rp, struct trace_probe, rp);
         struct ftrace_event_call *call = &tp->call;
         struct kretprobe_trace_entry_head *entry;
+        struct hlist_head *head;
         u8 *data;
         int size, __size, i;
-        unsigned long irq_flags;
         int rctx;
 
         __size = sizeof(*entry) + tp->size;
@@ -1384,7 +1382,7 @@ static __kprobes void kretprobe_perf_func(struct kretprobe_instance *ri,
                      "profile buffer not large enough"))
                 return;
 
-        entry = perf_trace_buf_prepare(size, call->id, &rctx, &irq_flags);
+        entry = perf_trace_buf_prepare(size, call->event.type, regs, &rctx);
         if (!entry)
                 return;
 
@@ -1394,8 +1392,8 @@ static __kprobes void kretprobe_perf_func(struct kretprobe_instance *ri,
         for (i = 0; i < tp->nr_args; i++)
                 call_fetch(&tp->args[i].fetch, regs, data + tp->args[i].offset);
 
-        perf_trace_buf_submit(entry, size, rctx, entry->ret_ip, 1,
-                               irq_flags, regs);
+        head = per_cpu_ptr(call->perf_events, smp_processor_id());
+        perf_trace_buf_submit(entry, size, rctx, entry->ret_ip, 1, regs, head);
 }
 
 static int probe_perf_enable(struct ftrace_event_call *call)
@@ -1425,6 +1423,26 @@ static void probe_perf_disable(struct ftrace_event_call *call)
 }
 #endif  /* CONFIG_PERF_EVENTS */
 
+static __kprobes
+int kprobe_register(struct ftrace_event_call *event, enum trace_reg type)
+{
+        switch (type) {
+        case TRACE_REG_REGISTER:
+                return probe_event_enable(event);
+        case TRACE_REG_UNREGISTER:
+                probe_event_disable(event);
+                return 0;
+
+#ifdef CONFIG_PERF_EVENTS
+        case TRACE_REG_PERF_REGISTER:
+                return probe_perf_enable(event);
+        case TRACE_REG_PERF_UNREGISTER:
+                probe_perf_disable(event);
+                return 0;
+#endif
+        }
+        return 0;
+}
 
 static __kprobes
 int kprobe_dispatcher(struct kprobe *kp, struct pt_regs *regs)
@@ -1454,6 +1472,14 @@ int kretprobe_dispatcher(struct kretprobe_instance *ri, struct pt_regs *regs)
         return 0;       /* We don't tweek kernel, so just return 0 */
 }
 
+static struct trace_event_functions kretprobe_funcs = {
+        .trace          = print_kretprobe_event
+};
+
+static struct trace_event_functions kprobe_funcs = {
+        .trace          = print_kprobe_event
+};
+
 static int register_probe_event(struct trace_probe *tp)
 {
         struct ftrace_event_call *call = &tp->call;
@@ -1461,36 +1487,31 @@ static int register_probe_event(struct trace_probe *tp)
 
         /* Initialize ftrace_event_call */
         if (probe_is_return(tp)) {
-                tp->event.trace = print_kretprobe_event;
-                call->raw_init = probe_event_raw_init;
-                call->define_fields = kretprobe_event_define_fields;
+                INIT_LIST_HEAD(&call->class->fields);
+                call->event.funcs = &kretprobe_funcs;
+                call->class->raw_init = probe_event_raw_init;
+                call->class->define_fields = kretprobe_event_define_fields;
         } else {
-                tp->event.trace = print_kprobe_event;
-                call->raw_init = probe_event_raw_init;
-                call->define_fields = kprobe_event_define_fields;
+                INIT_LIST_HEAD(&call->class->fields);
+                call->event.funcs = &kprobe_funcs;
+                call->class->raw_init = probe_event_raw_init;
+                call->class->define_fields = kprobe_event_define_fields;
         }
         if (set_print_fmt(tp) < 0)
                 return -ENOMEM;
-        call->event = &tp->event;
-        call->id = register_ftrace_event(&tp->event);
-        if (!call->id) {
+        ret = register_ftrace_event(&call->event);
+        if (!ret) {
                 kfree(call->print_fmt);
                 return -ENODEV;
         }
-        call->enabled = 0;
-        call->regfunc = probe_event_enable;
-        call->unregfunc = probe_event_disable;
-
-#ifdef CONFIG_PERF_EVENTS
-        call->perf_event_enable = probe_perf_enable;
-        call->perf_event_disable = probe_perf_disable;
-#endif
+        call->flags = 0;
+        call->class->reg = kprobe_register;
         call->data = tp;
         ret = trace_add_event_call(call);
         if (ret) {
                 pr_info("Failed to register kprobe event: %s\n", call->name);
                 kfree(call->print_fmt);
-                unregister_ftrace_event(&tp->event);
+                unregister_ftrace_event(&call->event);
         }
         return ret;
 }
diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c
index 2404c129a8c9..57c1b4596470 100644
--- a/kernel/trace/trace_output.c
+++ b/kernel/trace/trace_output.c
@@ -209,6 +209,7 @@ int trace_seq_putc(struct trace_seq *s, unsigned char c)
 
         return 1;
 }
+EXPORT_SYMBOL(trace_seq_putc);
 
 int trace_seq_putmem(struct trace_seq *s, const void *mem, size_t len)
 {
@@ -355,6 +356,21 @@ ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
 }
 EXPORT_SYMBOL(ftrace_print_symbols_seq);
 
+const char *
+ftrace_print_hex_seq(struct trace_seq *p, const unsigned char *buf, int buf_len)
+{
+        int i;
+        const char *ret = p->buffer + p->len;
+
+        for (i = 0; i < buf_len; i++)
+                trace_seq_printf(p, "%s%2.2x", i == 0 ? "" : " ", buf[i]);
+
+        trace_seq_putc(p, 0);
+
+        return ret;
+}
+EXPORT_SYMBOL(ftrace_print_hex_seq);
+
 #ifdef CONFIG_KRETPROBES
 static inline const char *kretprobed(const char *name)
 {
@@ -726,6 +742,9 @@ int register_ftrace_event(struct trace_event *event)
         if (WARN_ON(!event))
                 goto out;
 
+        if (WARN_ON(!event->funcs))
+                goto out;
+
         INIT_LIST_HEAD(&event->list);
 
         if (!event->type) {
@@ -758,14 +777,14 @@ int register_ftrace_event(struct trace_event *event)
                         goto out;
         }
 
-        if (event->trace == NULL)
-                event->trace = trace_nop_print;
-        if (event->raw == NULL)
-                event->raw = trace_nop_print;
-        if (event->hex == NULL)
-                event->hex = trace_nop_print;
-        if (event->binary == NULL)
-                event->binary = trace_nop_print;
+        if (event->funcs->trace == NULL)
+                event->funcs->trace = trace_nop_print;
+        if (event->funcs->raw == NULL)
+                event->funcs->raw = trace_nop_print;
+        if (event->funcs->hex == NULL)
+                event->funcs->hex = trace_nop_print;
+        if (event->funcs->binary == NULL)
+                event->funcs->binary = trace_nop_print;
 
         key = event->type & (EVENT_HASHSIZE - 1);
 
@@ -807,13 +826,15 @@ EXPORT_SYMBOL_GPL(unregister_ftrace_event);
  * Standard events
  */
 
-enum print_line_t trace_nop_print(struct trace_iterator *iter, int flags)
+enum print_line_t trace_nop_print(struct trace_iterator *iter, int flags,
+                                  struct trace_event *event)
 {
         return TRACE_TYPE_HANDLED;
 }
 
 /* TRACE_FN */
-static enum print_line_t trace_fn_trace(struct trace_iterator *iter, int flags)
+static enum print_line_t trace_fn_trace(struct trace_iterator *iter, int flags,
+                                        struct trace_event *event)
 {
         struct ftrace_entry *field;
         struct trace_seq *s = &iter->seq;
@@ -840,7 +861,8 @@ static enum print_line_t trace_fn_trace(struct trace_iterator *iter, int flags)
         return TRACE_TYPE_PARTIAL_LINE;
 }
 
-static enum print_line_t trace_fn_raw(struct trace_iterator *iter, int flags)
+static enum print_line_t trace_fn_raw(struct trace_iterator *iter, int flags,
+                                      struct trace_event *event)
 {
         struct ftrace_entry *field;
 
@@ -854,7 +876,8 @@ static enum print_line_t trace_fn_raw(struct trace_iterator *iter, int flags)
         return TRACE_TYPE_HANDLED;
 }
 
-static enum print_line_t trace_fn_hex(struct trace_iterator *iter, int flags)
+static enum print_line_t trace_fn_hex(struct trace_iterator *iter, int flags,
+                                      struct trace_event *event)
 {
         struct ftrace_entry *field;
         struct trace_seq *s = &iter->seq;
@@ -867,7 +890,8 @@ static enum print_line_t trace_fn_hex(struct trace_iterator *iter, int flags)
         return TRACE_TYPE_HANDLED;
 }
 
-static enum print_line_t trace_fn_bin(struct trace_iterator *iter, int flags)
+static enum print_line_t trace_fn_bin(struct trace_iterator *iter, int flags,
+                                      struct trace_event *event)
 {
         struct ftrace_entry *field;
         struct trace_seq *s = &iter->seq;
@@ -880,14 +904,18 @@ static enum print_line_t trace_fn_bin(struct trace_iterator *iter, int flags)
         return TRACE_TYPE_HANDLED;
 }
 
-static struct trace_event trace_fn_event = {
-        .type           = TRACE_FN,
+static struct trace_event_functions trace_fn_funcs = {
         .trace          = trace_fn_trace,
         .raw            = trace_fn_raw,
         .hex            = trace_fn_hex,
         .binary         = trace_fn_bin,
 };
 
+static struct trace_event trace_fn_event = {
+        .type           = TRACE_FN,
+        .funcs          = &trace_fn_funcs,
+};
+
 /* TRACE_CTX an TRACE_WAKE */
 static enum print_line_t trace_ctxwake_print(struct trace_iterator *iter,
                                              char *delim)
@@ -916,13 +944,14 @@ static enum print_line_t trace_ctxwake_print(struct trace_iterator *iter,
         return TRACE_TYPE_HANDLED;
 }
 
-static enum print_line_t trace_ctx_print(struct trace_iterator *iter, int flags)
+static enum print_line_t trace_ctx_print(struct trace_iterator *iter, int flags,
+                                         struct trace_event *event)
 {
         return trace_ctxwake_print(iter, "==>");
 }
 
 static enum print_line_t trace_wake_print(struct trace_iterator *iter,
-                                          int flags)
+                                          int flags, struct trace_event *event)
 {
         return trace_ctxwake_print(iter, "  +");
 }
@@ -950,12 +979,14 @@ static int trace_ctxwake_raw(struct trace_iterator *iter, char S)
         return TRACE_TYPE_HANDLED;
 }
 
-static enum print_line_t trace_ctx_raw(struct trace_iterator *iter, int flags)
+static enum print_line_t trace_ctx_raw(struct trace_iterator *iter, int flags,
+                                       struct trace_event *event)
 {
         return trace_ctxwake_raw(iter, 0);
 }
 
-static enum print_line_t trace_wake_raw(struct trace_iterator *iter, int flags)
+static enum print_line_t trace_wake_raw(struct trace_iterator *iter, int flags,
+                                        struct trace_event *event)
 {
         return trace_ctxwake_raw(iter, '+');
 }
@@ -984,18 +1015,20 @@ static int trace_ctxwake_hex(struct trace_iterator *iter, char S)
         return TRACE_TYPE_HANDLED;
 }
 
-static enum print_line_t trace_ctx_hex(struct trace_iterator *iter, int flags)
+static enum print_line_t trace_ctx_hex(struct trace_iterator *iter, int flags,
+                                       struct trace_event *event)
 {
         return trace_ctxwake_hex(iter, 0);
 }
 
-static enum print_line_t trace_wake_hex(struct trace_iterator *iter, int flags)
+static enum print_line_t trace_wake_hex(struct trace_iterator *iter, int flags,
+                                        struct trace_event *event)
 {
         return trace_ctxwake_hex(iter, '+');
 }
 
 static enum print_line_t trace_ctxwake_bin(struct trace_iterator *iter,
-                                           int flags)
+                                           int flags, struct trace_event *event)
 {
         struct ctx_switch_entry *field;
         struct trace_seq *s = &iter->seq;
@@ -1012,25 +1045,33 @@ static enum print_line_t trace_ctxwake_bin(struct trace_iterator *iter,
         return TRACE_TYPE_HANDLED;
 }
 
-static struct trace_event trace_ctx_event = {
-        .type           = TRACE_CTX,
+static struct trace_event_functions trace_ctx_funcs = {
         .trace          = trace_ctx_print,
         .raw            = trace_ctx_raw,
         .hex            = trace_ctx_hex,
         .binary         = trace_ctxwake_bin,
 };
 
-static struct trace_event trace_wake_event = {
-        .type           = TRACE_WAKE,
+static struct trace_event trace_ctx_event = {
+        .type           = TRACE_CTX,
+        .funcs          = &trace_ctx_funcs,
+};
+
+static struct trace_event_functions trace_wake_funcs = {
         .trace          = trace_wake_print,
         .raw            = trace_wake_raw,
         .hex            = trace_wake_hex,
         .binary         = trace_ctxwake_bin,
 };
 
+static struct trace_event trace_wake_event = {
+        .type           = TRACE_WAKE,
+        .funcs          = &trace_wake_funcs,
+};
+
 /* TRACE_SPECIAL */
 static enum print_line_t trace_special_print(struct trace_iterator *iter,
-                                             int flags)
+                                             int flags, struct trace_event *event)
 {
         struct special_entry *field;
 
@@ -1046,7 +1087,7 @@ static enum print_line_t trace_special_print(struct trace_iterator *iter,
 }
 
 static enum print_line_t trace_special_hex(struct trace_iterator *iter,
-                                           int flags)
+                                           int flags, struct trace_event *event)
 {
         struct special_entry *field;
         struct trace_seq *s = &iter->seq;
@@ -1061,7 +1102,7 @@ static enum print_line_t trace_special_hex(struct trace_iterator *iter,
 }
 
 static enum print_line_t trace_special_bin(struct trace_iterator *iter,
-                                           int flags)
+                                           int flags, struct trace_event *event)
 {
         struct special_entry *field;
         struct trace_seq *s = &iter->seq;
@@ -1075,18 +1116,22 @@ static enum print_line_t trace_special_bin(struct trace_iterator *iter,
         return TRACE_TYPE_HANDLED;
 }
 
-static struct trace_event trace_special_event = {
-        .type           = TRACE_SPECIAL,
+static struct trace_event_functions trace_special_funcs = {
         .trace          = trace_special_print,
         .raw            = trace_special_print,
         .hex            = trace_special_hex,
         .binary         = trace_special_bin,
 };
 
+static struct trace_event trace_special_event = {
+        .type           = TRACE_SPECIAL,
+        .funcs          = &trace_special_funcs,
+};
+
 /* TRACE_STACK */
 
 static enum print_line_t trace_stack_print(struct trace_iterator *iter,
-                                           int flags)
+                                           int flags, struct trace_event *event)
 {
         struct stack_entry *field;
         struct trace_seq *s = &iter->seq;
@@ -1114,17 +1159,21 @@ static enum print_line_t trace_stack_print(struct trace_iterator *iter,
         return TRACE_TYPE_PARTIAL_LINE;
 }
 
-static struct trace_event trace_stack_event = {
-        .type           = TRACE_STACK,
+static struct trace_event_functions trace_stack_funcs = {
         .trace          = trace_stack_print,
         .raw            = trace_special_print,
         .hex            = trace_special_hex,
         .binary         = trace_special_bin,
 };
 
+static struct trace_event trace_stack_event = {
+        .type           = TRACE_STACK,
+        .funcs          = &trace_stack_funcs,
+};
+
 /* TRACE_USER_STACK */
 static enum print_line_t trace_user_stack_print(struct trace_iterator *iter,
-                                                int flags)
+                                                int flags, struct trace_event *event)
 {
         struct userstack_entry *field;
         struct trace_seq *s = &iter->seq;
@@ -1143,17 +1192,22 @@ static enum print_line_t trace_user_stack_print(struct trace_iterator *iter,
         return TRACE_TYPE_PARTIAL_LINE;
 }
 
-static struct trace_event trace_user_stack_event = {
-        .type           = TRACE_USER_STACK,
+static struct trace_event_functions trace_user_stack_funcs = {
         .trace          = trace_user_stack_print,
         .raw            = trace_special_print,
         .hex            = trace_special_hex,
         .binary         = trace_special_bin,
 };
 
+static struct trace_event trace_user_stack_event = {
+        .type           = TRACE_USER_STACK,
+        .funcs          = &trace_user_stack_funcs,
+};
+
 /* TRACE_BPRINT */
 static enum print_line_t
-trace_bprint_print(struct trace_iterator *iter, int flags)
+trace_bprint_print(struct trace_iterator *iter, int flags,
+                   struct trace_event *event)
 {
         struct trace_entry *entry = iter->ent;
         struct trace_seq *s = &iter->seq;
@@ -1178,7 +1232,8 @@ trace_bprint_print(struct trace_iterator *iter, int flags)
 
 
 static enum print_line_t
-trace_bprint_raw(struct trace_iterator *iter, int flags)
+trace_bprint_raw(struct trace_iterator *iter, int flags,
+                 struct trace_event *event)
 {
         struct bprint_entry *field;
         struct trace_seq *s = &iter->seq;
@@ -1197,16 +1252,19 @@ trace_bprint_raw(struct trace_iterator *iter, int flags)
         return TRACE_TYPE_PARTIAL_LINE;
 }
 
+static struct trace_event_functions trace_bprint_funcs = {
+        .trace          = trace_bprint_print,
+        .raw            = trace_bprint_raw,
+};
 
 static struct trace_event trace_bprint_event = {
         .type           = TRACE_BPRINT,
-        .trace          = trace_bprint_print,
-        .raw            = trace_bprint_raw,
+        .funcs          = &trace_bprint_funcs,
 };
 
 /* TRACE_PRINT */
 static enum print_line_t trace_print_print(struct trace_iterator *iter,
-                                           int flags)
+                                           int flags, struct trace_event *event)
 {
         struct print_entry *field;
         struct trace_seq *s = &iter->seq;
@@ -1225,7 +1283,8 @@ static enum print_line_t trace_print_print(struct trace_iterator *iter,
         return TRACE_TYPE_PARTIAL_LINE;
 }
 
-static enum print_line_t trace_print_raw(struct trace_iterator *iter, int flags)
+static enum print_line_t trace_print_raw(struct trace_iterator *iter, int flags,
+                                         struct trace_event *event)
 {
         struct print_entry *field;
 
@@ -1240,12 +1299,16 @@ static enum print_line_t trace_print_raw(struct trace_iterator *iter, int flags)
         return TRACE_TYPE_PARTIAL_LINE;
 }
 
-static struct trace_event trace_print_event = {
-        .type           = TRACE_PRINT,
+static struct trace_event_functions trace_print_funcs = {
         .trace          = trace_print_print,
         .raw            = trace_print_raw,
 };
 
+static struct trace_event trace_print_event = {
+        .type           = TRACE_PRINT,
+        .funcs          = &trace_print_funcs,
+};
+
 
 static struct trace_event *events[] __initdata = {
         &trace_fn_event,
diff --git a/kernel/trace/trace_output.h b/kernel/trace/trace_output.h
index 9d91c72ba38b..c038eba0492b 100644
--- a/kernel/trace/trace_output.h
+++ b/kernel/trace/trace_output.h
@@ -25,7 +25,7 @@ extern void trace_event_read_unlock(void);
 extern struct trace_event *ftrace_find_event(int type);
 
 extern enum print_line_t trace_nop_print(struct trace_iterator *iter,
-                                         int flags);
+                                         int flags, struct trace_event *event);
 extern int
 trace_print_lat_fmt(struct trace_seq *s, struct trace_entry *entry);
 
diff --git a/kernel/trace/trace_sched_switch.c b/kernel/trace/trace_sched_switch.c
index a55fccfede5d..8f758d070c43 100644
--- a/kernel/trace/trace_sched_switch.c
+++ b/kernel/trace/trace_sched_switch.c
@@ -50,7 +50,7 @@ tracing_sched_switch_trace(struct trace_array *tr,
 }
 
 static void
-probe_sched_switch(struct task_struct *prev, struct task_struct *next)
+probe_sched_switch(void *ignore, struct task_struct *prev, struct task_struct *next)
 {
         struct trace_array_cpu *data;
         unsigned long flags;
@@ -108,7 +108,7 @@ tracing_sched_wakeup_trace(struct trace_array *tr,
 }
 
 static void
-probe_sched_wakeup(struct task_struct *wakee, int success)
+probe_sched_wakeup(void *ignore, struct task_struct *wakee, int success)
 {
         struct trace_array_cpu *data;
         unsigned long flags;
@@ -138,21 +138,21 @@ static int tracing_sched_register(void)
 {
         int ret;
 
-        ret = register_trace_sched_wakeup(probe_sched_wakeup);
+        ret = register_trace_sched_wakeup(probe_sched_wakeup, NULL);
         if (ret) {
                 pr_info("wakeup trace: Couldn't activate tracepoint"
                         " probe to kernel_sched_wakeup\n");
                 return ret;
         }
 
-        ret = register_trace_sched_wakeup_new(probe_sched_wakeup);
+        ret = register_trace_sched_wakeup_new(probe_sched_wakeup, NULL);
         if (ret) {
                 pr_info("wakeup trace: Couldn't activate tracepoint"
                         " probe to kernel_sched_wakeup_new\n");
                 goto fail_deprobe;
         }
 
-        ret = register_trace_sched_switch(probe_sched_switch);
+        ret = register_trace_sched_switch(probe_sched_switch, NULL);
         if (ret) {
                 pr_info("sched trace: Couldn't activate tracepoint"
                         " probe to kernel_sched_switch\n");
@@ -161,17 +161,17 @@ static int tracing_sched_register(void)
 
         return ret;
 fail_deprobe_wake_new:
-        unregister_trace_sched_wakeup_new(probe_sched_wakeup);
+        unregister_trace_sched_wakeup_new(probe_sched_wakeup, NULL);
 fail_deprobe:
-        unregister_trace_sched_wakeup(probe_sched_wakeup);
+        unregister_trace_sched_wakeup(probe_sched_wakeup, NULL);
         return ret;
 }
 
 static void tracing_sched_unregister(void)
 {
-        unregister_trace_sched_switch(probe_sched_switch);
-        unregister_trace_sched_wakeup_new(probe_sched_wakeup);
-        unregister_trace_sched_wakeup(probe_sched_wakeup);
+        unregister_trace_sched_switch(probe_sched_switch, NULL);
+        unregister_trace_sched_wakeup_new(probe_sched_wakeup, NULL);
+        unregister_trace_sched_wakeup(probe_sched_wakeup, NULL);
 }
 
 static void tracing_start_sched_switch(void)
diff --git a/kernel/trace/trace_sched_wakeup.c b/kernel/trace/trace_sched_wakeup.c
index 8052446ceeaa..0e73bc2ef8c5 100644
--- a/kernel/trace/trace_sched_wakeup.c
+++ b/kernel/trace/trace_sched_wakeup.c
@@ -98,7 +98,8 @@ static int report_latency(cycle_t delta)
         return 1;
 }
 
-static void probe_wakeup_migrate_task(struct task_struct *task, int cpu)
+static void
+probe_wakeup_migrate_task(void *ignore, struct task_struct *task, int cpu)
 {
         if (task != wakeup_task)
                 return;
@@ -107,7 +108,8 @@ static void probe_wakeup_migrate_task(struct task_struct *task, int cpu)
 }
 
 static void notrace
-probe_wakeup_sched_switch(struct task_struct *prev, struct task_struct *next)
+probe_wakeup_sched_switch(void *ignore,
+                          struct task_struct *prev, struct task_struct *next)
 {
         struct trace_array_cpu *data;
         cycle_t T0, T1, delta;
@@ -199,7 +201,7 @@ static void wakeup_reset(struct trace_array *tr)
 }
 
 static void
-probe_wakeup(struct task_struct *p, int success)
+probe_wakeup(void *ignore, struct task_struct *p, int success)
 {
         struct trace_array_cpu *data;
         int cpu = smp_processor_id();
@@ -263,28 +265,28 @@ static void start_wakeup_tracer(struct trace_array *tr)
 {
         int ret;
 
-        ret = register_trace_sched_wakeup(probe_wakeup);
+        ret = register_trace_sched_wakeup(probe_wakeup, NULL);
         if (ret) {
                 pr_info("wakeup trace: Couldn't activate tracepoint"
                         " probe to kernel_sched_wakeup\n");
                 return;
         }
 
-        ret = register_trace_sched_wakeup_new(probe_wakeup);
+        ret = register_trace_sched_wakeup_new(probe_wakeup, NULL);
         if (ret) {
                 pr_info("wakeup trace: Couldn't activate tracepoint"
                         " probe to kernel_sched_wakeup_new\n");
                 goto fail_deprobe;
         }
 
-        ret = register_trace_sched_switch(probe_wakeup_sched_switch);
+        ret = register_trace_sched_switch(probe_wakeup_sched_switch, NULL);
         if (ret) {
                 pr_info("sched trace: Couldn't activate tracepoint"
                         " probe to kernel_sched_switch\n");
                 goto fail_deprobe_wake_new;
         }
 
-        ret = register_trace_sched_migrate_task(probe_wakeup_migrate_task);
+        ret = register_trace_sched_migrate_task(probe_wakeup_migrate_task, NULL);
         if (ret) {
                 pr_info("wakeup trace: Couldn't activate tracepoint"
                         " probe to kernel_sched_migrate_task\n");
@@ -311,19 +313,19 @@ static void start_wakeup_tracer(struct trace_array *tr)
 
         return;
 fail_deprobe_wake_new:
-        unregister_trace_sched_wakeup_new(probe_wakeup);
+        unregister_trace_sched_wakeup_new(probe_wakeup, NULL);
 fail_deprobe:
-        unregister_trace_sched_wakeup(probe_wakeup);
+        unregister_trace_sched_wakeup(probe_wakeup, NULL);
 }
 
 static void stop_wakeup_tracer(struct trace_array *tr)
 {
         tracer_enabled = 0;
         unregister_ftrace_function(&trace_ops);
-        unregister_trace_sched_switch(probe_wakeup_sched_switch);
-        unregister_trace_sched_wakeup_new(probe_wakeup);
-        unregister_trace_sched_wakeup(probe_wakeup);
-        unregister_trace_sched_migrate_task(probe_wakeup_migrate_task);
+        unregister_trace_sched_switch(probe_wakeup_sched_switch, NULL);
+        unregister_trace_sched_wakeup_new(probe_wakeup, NULL);
+        unregister_trace_sched_wakeup(probe_wakeup, NULL);
+        unregister_trace_sched_migrate_task(probe_wakeup_migrate_task, NULL);
 }
 
 static int __wakeup_tracer_init(struct trace_array *tr)
diff --git a/kernel/trace/trace_syscalls.c b/kernel/trace/trace_syscalls.c
index 4d6d711717f2..d2c859cec9ea 100644
--- a/kernel/trace/trace_syscalls.c
+++ b/kernel/trace/trace_syscalls.c
@@ -15,6 +15,54 @@ static int sys_refcount_exit;
 static DECLARE_BITMAP(enabled_enter_syscalls, NR_syscalls);
 static DECLARE_BITMAP(enabled_exit_syscalls, NR_syscalls);
 
+static int syscall_enter_register(struct ftrace_event_call *event,
+                                 enum trace_reg type);
+static int syscall_exit_register(struct ftrace_event_call *event,
+                                 enum trace_reg type);
+
+static int syscall_enter_define_fields(struct ftrace_event_call *call);
+static int syscall_exit_define_fields(struct ftrace_event_call *call);
+
+static struct list_head *
+syscall_get_enter_fields(struct ftrace_event_call *call)
+{
+        struct syscall_metadata *entry = call->data;
+
+        return &entry->enter_fields;
+}
+
+static struct list_head *
+syscall_get_exit_fields(struct ftrace_event_call *call)
+{
+        struct syscall_metadata *entry = call->data;
+
+        return &entry->exit_fields;
+}
+
+struct trace_event_functions enter_syscall_print_funcs = {
+        .trace                  = print_syscall_enter,
+};
+
+struct trace_event_functions exit_syscall_print_funcs = {
+        .trace                  = print_syscall_exit,
+};
+
+struct ftrace_event_class event_class_syscall_enter = {
+        .system                 = "syscalls",
+        .reg                    = syscall_enter_register,
+        .define_fields          = syscall_enter_define_fields,
+        .get_fields             = syscall_get_enter_fields,
+        .raw_init               = init_syscall_trace,
+};
+
+struct ftrace_event_class event_class_syscall_exit = {
+        .system                 = "syscalls",
+        .reg                    = syscall_exit_register,
+        .define_fields          = syscall_exit_define_fields,
+        .get_fields             = syscall_get_exit_fields,
+        .raw_init               = init_syscall_trace,
+};
+
 extern unsigned long __start_syscalls_metadata[];
 extern unsigned long __stop_syscalls_metadata[];
 
@@ -53,7 +101,8 @@ static struct syscall_metadata *syscall_nr_to_meta(int nr)
 }
 
 enum print_line_t
-print_syscall_enter(struct trace_iterator *iter, int flags)
+print_syscall_enter(struct trace_iterator *iter, int flags,
+                    struct trace_event *event)
 {
         struct trace_seq *s = &iter->seq;
         struct trace_entry *ent = iter->ent;
@@ -68,7 +117,7 @@ print_syscall_enter(struct trace_iterator *iter, int flags)
         if (!entry)
                 goto end;
 
-        if (entry->enter_event->id != ent->type) {
+        if (entry->enter_event->event.type != ent->type) {
                 WARN_ON_ONCE(1);
                 goto end;
         }
@@ -105,7 +154,8 @@ end:
 }
 
 enum print_line_t
-print_syscall_exit(struct trace_iterator *iter, int flags)
+print_syscall_exit(struct trace_iterator *iter, int flags,
+                   struct trace_event *event)
 {
         struct trace_seq *s = &iter->seq;
         struct trace_entry *ent = iter->ent;
@@ -123,7 +173,7 @@ print_syscall_exit(struct trace_iterator *iter, int flags)
                 return TRACE_TYPE_HANDLED;
         }
 
-        if (entry->exit_event->id != ent->type) {
+        if (entry->exit_event->event.type != ent->type) {
                 WARN_ON_ONCE(1);
                 return TRACE_TYPE_UNHANDLED;
         }
@@ -205,7 +255,7 @@ static void free_syscall_print_fmt(struct ftrace_event_call *call)
                 kfree(call->print_fmt);
 }
 
-int syscall_enter_define_fields(struct ftrace_event_call *call)
+static int syscall_enter_define_fields(struct ftrace_event_call *call)
 {
         struct syscall_trace_enter trace;
         struct syscall_metadata *meta = call->data;
@@ -228,7 +278,7 @@ int syscall_enter_define_fields(struct ftrace_event_call *call)
         return ret;
 }
 
-int syscall_exit_define_fields(struct ftrace_event_call *call)
+static int syscall_exit_define_fields(struct ftrace_event_call *call)
 {
         struct syscall_trace_exit trace;
         int ret;
@@ -243,7 +293,7 @@ int syscall_exit_define_fields(struct ftrace_event_call *call)
         return ret;
 }
 
-void ftrace_syscall_enter(struct pt_regs *regs, long id)
+void ftrace_syscall_enter(void *ignore, struct pt_regs *regs, long id)
 {
         struct syscall_trace_enter *entry;
         struct syscall_metadata *sys_data;
@@ -265,7 +315,7 @@ void ftrace_syscall_enter(struct pt_regs *regs, long id)
         size = sizeof(*entry) + sizeof(unsigned long) * sys_data->nb_args;
 
         event = trace_current_buffer_lock_reserve(&buffer,
-                        sys_data->enter_event->id, size, 0, 0);
+                        sys_data->enter_event->event.type, size, 0, 0);
         if (!event)
                 return;
 
@@ -278,7 +328,7 @@ void ftrace_syscall_enter(struct pt_regs *regs, long id)
                 trace_current_buffer_unlock_commit(buffer, event, 0, 0);
 }
 
-void ftrace_syscall_exit(struct pt_regs *regs, long ret)
+void ftrace_syscall_exit(void *ignore, struct pt_regs *regs, long ret)
 {
         struct syscall_trace_exit *entry;
         struct syscall_metadata *sys_data;
@@ -297,7 +347,7 @@ void ftrace_syscall_exit(struct pt_regs *regs, long ret)
                 return;
 
         event = trace_current_buffer_lock_reserve(&buffer,
-                        sys_data->exit_event->id, sizeof(*entry), 0, 0);
+                        sys_data->exit_event->event.type, sizeof(*entry), 0, 0);
         if (!event)
                 return;
 
@@ -320,7 +370,7 @@ int reg_event_syscall_enter(struct ftrace_event_call *call)
                 return -ENOSYS;
         mutex_lock(&syscall_trace_lock);
         if (!sys_refcount_enter)
-                ret = register_trace_sys_enter(ftrace_syscall_enter);
+                ret = register_trace_sys_enter(ftrace_syscall_enter, NULL);
         if (!ret) {
                 set_bit(num, enabled_enter_syscalls);
                 sys_refcount_enter++;
@@ -340,7 +390,7 @@ void unreg_event_syscall_enter(struct ftrace_event_call *call)
         sys_refcount_enter--;
         clear_bit(num, enabled_enter_syscalls);
         if (!sys_refcount_enter)
-                unregister_trace_sys_enter(ftrace_syscall_enter);
+                unregister_trace_sys_enter(ftrace_syscall_enter, NULL);
         mutex_unlock(&syscall_trace_lock);
 }
 
@@ -354,7 +404,7 @@ int reg_event_syscall_exit(struct ftrace_event_call *call)
                 return -ENOSYS;
         mutex_lock(&syscall_trace_lock);
         if (!sys_refcount_exit)
-                ret = register_trace_sys_exit(ftrace_syscall_exit);
+                ret = register_trace_sys_exit(ftrace_syscall_exit, NULL);
         if (!ret) {
                 set_bit(num, enabled_exit_syscalls);
                 sys_refcount_exit++;
@@ -374,7 +424,7 @@ void unreg_event_syscall_exit(struct ftrace_event_call *call)
         sys_refcount_exit--;
         clear_bit(num, enabled_exit_syscalls);
         if (!sys_refcount_exit)
-                unregister_trace_sys_exit(ftrace_syscall_exit);
+                unregister_trace_sys_exit(ftrace_syscall_exit, NULL);
         mutex_unlock(&syscall_trace_lock);
 }
 
@@ -434,11 +484,11 @@ static DECLARE_BITMAP(enabled_perf_exit_syscalls, NR_syscalls);
 static int sys_perf_refcount_enter;
 static int sys_perf_refcount_exit;
 
-static void perf_syscall_enter(struct pt_regs *regs, long id)
+static void perf_syscall_enter(void *ignore, struct pt_regs *regs, long id)
 {
         struct syscall_metadata *sys_data;
         struct syscall_trace_enter *rec;
-        unsigned long flags;
+        struct hlist_head *head;
         int syscall_nr;
         int rctx;
         int size;
@@ -461,14 +511,16 @@ static void perf_syscall_enter(struct pt_regs *regs, long id)
                 return;
 
         rec = (struct syscall_trace_enter *)perf_trace_buf_prepare(size,
-                                sys_data->enter_event->id, &rctx, &flags);
+                                sys_data->enter_event->event.type, regs, &rctx);
         if (!rec)
                 return;
 
         rec->nr = syscall_nr;
         syscall_get_arguments(current, regs, 0, sys_data->nb_args,
                                (unsigned long *)&rec->args);
-        perf_trace_buf_submit(rec, size, rctx, 0, 1, flags, regs);
+
+        head = per_cpu_ptr(sys_data->enter_event->perf_events, smp_processor_id());
+        perf_trace_buf_submit(rec, size, rctx, 0, 1, regs, head);
 }
 
 int perf_sysenter_enable(struct ftrace_event_call *call)
@@ -480,7 +532,7 @@ int perf_sysenter_enable(struct ftrace_event_call *call)
 
         mutex_lock(&syscall_trace_lock);
         if (!sys_perf_refcount_enter)
-                ret = register_trace_sys_enter(perf_syscall_enter);
+                ret = register_trace_sys_enter(perf_syscall_enter, NULL);
         if (ret) {
                 pr_info("event trace: Could not activate"
                                 "syscall entry trace point");
@@ -502,15 +554,15 @@ void perf_sysenter_disable(struct ftrace_event_call *call)
         sys_perf_refcount_enter--;
         clear_bit(num, enabled_perf_enter_syscalls);
         if (!sys_perf_refcount_enter)
-                unregister_trace_sys_enter(perf_syscall_enter);
+                unregister_trace_sys_enter(perf_syscall_enter, NULL);
         mutex_unlock(&syscall_trace_lock);
 }
 
-static void perf_syscall_exit(struct pt_regs *regs, long ret)
+static void perf_syscall_exit(void *ignore, struct pt_regs *regs, long ret)
 {
         struct syscall_metadata *sys_data;
         struct syscall_trace_exit *rec;
-        unsigned long flags;
+        struct hlist_head *head;
         int syscall_nr;
         int rctx;
         int size;
@@ -536,14 +588,15 @@ static void perf_syscall_exit(struct pt_regs *regs, long ret)
                 return;
 
         rec = (struct syscall_trace_exit *)perf_trace_buf_prepare(size,
-                                sys_data->exit_event->id, &rctx, &flags);
+                                sys_data->exit_event->event.type, regs, &rctx);
         if (!rec)
                 return;
 
         rec->nr = syscall_nr;
         rec->ret = syscall_get_return_value(current, regs);
 
-        perf_trace_buf_submit(rec, size, rctx, 0, 1, flags, regs);
+        head = per_cpu_ptr(sys_data->exit_event->perf_events, smp_processor_id());
+        perf_trace_buf_submit(rec, size, rctx, 0, 1, regs, head);
 }
 
 int perf_sysexit_enable(struct ftrace_event_call *call)
@@ -555,7 +608,7 @@ int perf_sysexit_enable(struct ftrace_event_call *call)
 
         mutex_lock(&syscall_trace_lock);
         if (!sys_perf_refcount_exit)
-                ret = register_trace_sys_exit(perf_syscall_exit);
+                ret = register_trace_sys_exit(perf_syscall_exit, NULL);
         if (ret) {
                 pr_info("event trace: Could not activate"
                                 "syscall exit trace point");
@@ -577,9 +630,50 @@ void perf_sysexit_disable(struct ftrace_event_call *call)
         sys_perf_refcount_exit--;
         clear_bit(num, enabled_perf_exit_syscalls);
         if (!sys_perf_refcount_exit)
-                unregister_trace_sys_exit(perf_syscall_exit);
+                unregister_trace_sys_exit(perf_syscall_exit, NULL);
         mutex_unlock(&syscall_trace_lock);
 }
 
 #endif /* CONFIG_PERF_EVENTS */
 
+static int syscall_enter_register(struct ftrace_event_call *event,
+                                 enum trace_reg type)
+{
+        switch (type) {
+        case TRACE_REG_REGISTER:
+                return reg_event_syscall_enter(event);
+        case TRACE_REG_UNREGISTER:
+                unreg_event_syscall_enter(event);
+                return 0;
+
+#ifdef CONFIG_PERF_EVENTS
+        case TRACE_REG_PERF_REGISTER:
+                return perf_sysenter_enable(event);
+        case TRACE_REG_PERF_UNREGISTER:
+                perf_sysenter_disable(event);
+                return 0;
+#endif
+        }
+        return 0;
+}
+
+static int syscall_exit_register(struct ftrace_event_call *event,
+                                 enum trace_reg type)
+{
+        switch (type) {
+        case TRACE_REG_REGISTER:
+                return reg_event_syscall_exit(event);
+        case TRACE_REG_UNREGISTER:
+                unreg_event_syscall_exit(event);
+                return 0;
+
+#ifdef CONFIG_PERF_EVENTS
+        case TRACE_REG_PERF_REGISTER:
+                return perf_sysexit_enable(event);
+        case TRACE_REG_PERF_UNREGISTER:
+                perf_sysexit_disable(event);
+                return 0;
+#endif
+        }
+        return 0;
+}
diff --git a/kernel/trace/trace_workqueue.c b/kernel/trace/trace_workqueue.c
index cc2d2faa7d9e..a7cc3793baf6 100644
--- a/kernel/trace/trace_workqueue.c
+++ b/kernel/trace/trace_workqueue.c
@@ -49,7 +49,8 @@ static void cpu_workqueue_stat_free(struct kref *kref)
 
 /* Insertion of a work */
 static void
-probe_workqueue_insertion(struct task_struct *wq_thread,
+probe_workqueue_insertion(void *ignore,
+                          struct task_struct *wq_thread,
                           struct work_struct *work)
 {
         int cpu = cpumask_first(&wq_thread->cpus_allowed);
@@ -70,7 +71,8 @@ found:
 
 /* Execution of a work */
 static void
-probe_workqueue_execution(struct task_struct *wq_thread,
+probe_workqueue_execution(void *ignore,
+                          struct task_struct *wq_thread,
                           struct work_struct *work)
 {
         int cpu = cpumask_first(&wq_thread->cpus_allowed);
@@ -90,7 +92,8 @@ found:
 }
 
 /* Creation of a cpu workqueue thread */
-static void probe_workqueue_creation(struct task_struct *wq_thread, int cpu)
+static void probe_workqueue_creation(void *ignore,
+                                     struct task_struct *wq_thread, int cpu)
 {
         struct cpu_workqueue_stats *cws;
         unsigned long flags;
@@ -114,7 +117,8 @@ static void probe_workqueue_creation(struct task_struct *wq_thread, int cpu)
 }
 
 /* Destruction of a cpu workqueue thread */
-static void probe_workqueue_destruction(struct task_struct *wq_thread)
+static void
+probe_workqueue_destruction(void *ignore, struct task_struct *wq_thread)
 {
         /* Workqueue only execute on one cpu */
         int cpu = cpumask_first(&wq_thread->cpus_allowed);
@@ -259,19 +263,19 @@ int __init trace_workqueue_early_init(void)
 {
         int ret, cpu;
 
-        ret = register_trace_workqueue_insertion(probe_workqueue_insertion);
+        ret = register_trace_workqueue_insertion(probe_workqueue_insertion, NULL);
         if (ret)
                 goto out;
 
-        ret = register_trace_workqueue_execution(probe_workqueue_execution);
+        ret = register_trace_workqueue_execution(probe_workqueue_execution, NULL);
         if (ret)
                 goto no_insertion;
 
-        ret = register_trace_workqueue_creation(probe_workqueue_creation);
+        ret = register_trace_workqueue_creation(probe_workqueue_creation, NULL);
         if (ret)
                 goto no_execution;
 
-        ret = register_trace_workqueue_destruction(probe_workqueue_destruction);
+        ret = register_trace_workqueue_destruction(probe_workqueue_destruction, NULL);
         if (ret)
                 goto no_creation;
 
@@ -283,11 +287,11 @@ int __init trace_workqueue_early_init(void)
         return 0;
 
 no_creation:
-        unregister_trace_workqueue_creation(probe_workqueue_creation);
+        unregister_trace_workqueue_creation(probe_workqueue_creation, NULL);
 no_execution:
-        unregister_trace_workqueue_execution(probe_workqueue_execution);
+        unregister_trace_workqueue_execution(probe_workqueue_execution, NULL);
 no_insertion:
-        unregister_trace_workqueue_insertion(probe_workqueue_insertion);
+        unregister_trace_workqueue_insertion(probe_workqueue_insertion, NULL);
 out:
         pr_warning("trace_workqueue: unable to trace workqueues\n");
 
diff --git a/kernel/tracepoint.c b/kernel/tracepoint.c
index cc89be5bc0f8..c77f3eceea25 100644
--- a/kernel/tracepoint.c
+++ b/kernel/tracepoint.c
@@ -54,7 +54,7 @@ static struct hlist_head tracepoint_table[TRACEPOINT_TABLE_SIZE];
  */
 struct tracepoint_entry {
         struct hlist_node hlist;
-        void **funcs;
+        struct tracepoint_func *funcs;
         int refcount;   /* Number of times armed. 0 if disarmed. */
         char name[0];
 };
@@ -64,12 +64,12 @@ struct tp_probes {
                 struct rcu_head rcu;
                 struct list_head list;
         } u;
-        void *probes[0];
+        struct tracepoint_func probes[0];
 };
 
 static inline void *allocate_probes(int count)
 {
-        struct tp_probes *p  = kmalloc(count * sizeof(void *)
+        struct tp_probes *p  = kmalloc(count * sizeof(struct tracepoint_func)
                         + sizeof(struct tp_probes), GFP_KERNEL);
         return p == NULL ? NULL : p->probes;
 }
@@ -79,7 +79,7 @@ static void rcu_free_old_probes(struct rcu_head *head)
         kfree(container_of(head, struct tp_probes, u.rcu));
 }
 
-static inline void release_probes(void *old)
+static inline void release_probes(struct tracepoint_func *old)
 {
         if (old) {
                 struct tp_probes *tp_probes = container_of(old,
@@ -95,15 +95,16 @@ static void debug_print_probes(struct tracepoint_entry *entry)
         if (!tracepoint_debug || !entry->funcs)
                 return;
 
-        for (i = 0; entry->funcs[i]; i++)
-                printk(KERN_DEBUG "Probe %d : %p\n", i, entry->funcs[i]);
+        for (i = 0; entry->funcs[i].func; i++)
+                printk(KERN_DEBUG "Probe %d : %p\n", i, entry->funcs[i].func);
 }
 
-static void *
-tracepoint_entry_add_probe(struct tracepoint_entry *entry, void *probe)
+static struct tracepoint_func *
+tracepoint_entry_add_probe(struct tracepoint_entry *entry,
+                           void *probe, void *data)
 {
         int nr_probes = 0;
-        void **old, **new;
+        struct tracepoint_func *old, *new;
 
         WARN_ON(!probe);
 
@@ -111,8 +112,9 @@ tracepoint_entry_add_probe(struct tracepoint_entry *entry, void *probe)
         old = entry->funcs;
         if (old) {
                 /* (N -> N+1), (N != 0, 1) probes */
-                for (nr_probes = 0; old[nr_probes]; nr_probes++)
-                        if (old[nr_probes] == probe)
+                for (nr_probes = 0; old[nr_probes].func; nr_probes++)
+                        if (old[nr_probes].func == probe &&
+                            old[nr_probes].data == data)
                                 return ERR_PTR(-EEXIST);
         }
         /* + 2 : one for new probe, one for NULL func */
@@ -120,9 +122,10 @@ tracepoint_entry_add_probe(struct tracepoint_entry *entry, void *probe)
         if (new == NULL)
                 return ERR_PTR(-ENOMEM);
         if (old)
-                memcpy(new, old, nr_probes * sizeof(void *));
-        new[nr_probes] = probe;
-        new[nr_probes + 1] = NULL;
+                memcpy(new, old, nr_probes * sizeof(struct tracepoint_func));
+        new[nr_probes].func = probe;
+        new[nr_probes].data = data;
+        new[nr_probes + 1].func = NULL;
         entry->refcount = nr_probes + 1;
         entry->funcs = new;
         debug_print_probes(entry);
@@ -130,10 +133,11 @@ tracepoint_entry_add_probe(struct tracepoint_entry *entry, void *probe)
 }
 
 static void *
-tracepoint_entry_remove_probe(struct tracepoint_entry *entry, void *probe)
+tracepoint_entry_remove_probe(struct tracepoint_entry *entry,
+                              void *probe, void *data)
 {
         int nr_probes = 0, nr_del = 0, i;
-        void **old, **new;
+        struct tracepoint_func *old, *new;
 
         old = entry->funcs;
 
@@ -142,8 +146,10 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *entry, void *probe)
 
         debug_print_probes(entry);
         /* (N -> M), (N > 1, M >= 0) probes */
-        for (nr_probes = 0; old[nr_probes]; nr_probes++) {
-                if ((!probe || old[nr_probes] == probe))
+        for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
+                if (!probe ||
+                    (old[nr_probes].func == probe &&
+                     old[nr_probes].data == data))
                         nr_del++;
         }
 
@@ -160,10 +166,11 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *entry, void *probe)
                 new = allocate_probes(nr_probes - nr_del + 1);
                 if (new == NULL)
                         return ERR_PTR(-ENOMEM);
-                for (i = 0; old[i]; i++)
-                        if ((probe && old[i] != probe))
+                for (i = 0; old[i].func; i++)
+                        if (probe &&
+                            (old[i].func != probe || old[i].data != data))
                                 new[j++] = old[i];
-                new[nr_probes - nr_del] = NULL;
+                new[nr_probes - nr_del].func = NULL;
                 entry->refcount = nr_probes - nr_del;
                 entry->funcs = new;
         }
@@ -315,18 +322,19 @@ static void tracepoint_update_probes(void)
         module_update_tracepoints();
 }
 
-static void *tracepoint_add_probe(const char *name, void *probe)
+static struct tracepoint_func *
+tracepoint_add_probe(const char *name, void *probe, void *data)
 {
         struct tracepoint_entry *entry;
-        void *old;
+        struct tracepoint_func *old;
 
         entry = get_tracepoint(name);
         if (!entry) {
                 entry = add_tracepoint(name);
                 if (IS_ERR(entry))
-                        return entry;
+                        return (struct tracepoint_func *)entry;
         }
-        old = tracepoint_entry_add_probe(entry, probe);
+        old = tracepoint_entry_add_probe(entry, probe, data);
         if (IS_ERR(old) && !entry->refcount)
                 remove_tracepoint(entry);
         return old;
@@ -340,12 +348,12 @@ static void *tracepoint_add_probe(const char *name, void *probe)
  * Returns 0 if ok, error value on error.
  * The probe address must at least be aligned on the architecture pointer size.
  */
-int tracepoint_probe_register(const char *name, void *probe)
+int tracepoint_probe_register(const char *name, void *probe, void *data)
 {
-        void *old;
+        struct tracepoint_func *old;
 
         mutex_lock(&tracepoints_mutex);
-        old = tracepoint_add_probe(name, probe);
+        old = tracepoint_add_probe(name, probe, data);
         mutex_unlock(&tracepoints_mutex);
         if (IS_ERR(old))
                 return PTR_ERR(old);
@@ -356,15 +364,16 @@ int tracepoint_probe_register(const char *name, void *probe)
 }
 EXPORT_SYMBOL_GPL(tracepoint_probe_register);
 
-static void *tracepoint_remove_probe(const char *name, void *probe)
+static struct tracepoint_func *
+tracepoint_remove_probe(const char *name, void *probe, void *data)
 {
         struct tracepoint_entry *entry;
-        void *old;
+        struct tracepoint_func *old;
 
         entry = get_tracepoint(name);
         if (!entry)
                 return ERR_PTR(-ENOENT);
-        old = tracepoint_entry_remove_probe(entry, probe);
+        old = tracepoint_entry_remove_probe(entry, probe, data);
         if (IS_ERR(old))
                 return old;
         if (!entry->refcount)
@@ -382,12 +391,12 @@ static void *tracepoint_remove_probe(const char *name, void *probe)
  * itself uses stop_machine(), which insures that every preempt disabled section
  * have finished.
  */
-int tracepoint_probe_unregister(const char *name, void *probe)
+int tracepoint_probe_unregister(const char *name, void *probe, void *data)
 {
-        void *old;
+        struct tracepoint_func *old;
 
         mutex_lock(&tracepoints_mutex);
-        old = tracepoint_remove_probe(name, probe);
+        old = tracepoint_remove_probe(name, probe, data);
         mutex_unlock(&tracepoints_mutex);
         if (IS_ERR(old))
                 return PTR_ERR(old);
@@ -418,12 +427,13 @@ static void tracepoint_add_old_probes(void *old)
  *
  * caller must call tracepoint_probe_update_all()
  */
-int tracepoint_probe_register_noupdate(const char *name, void *probe)
+int tracepoint_probe_register_noupdate(const char *name, void *probe,
+                                       void *data)
 {
-        void *old;
+        struct tracepoint_func *old;
 
         mutex_lock(&tracepoints_mutex);
-        old = tracepoint_add_probe(name, probe);
+        old = tracepoint_add_probe(name, probe, data);
         if (IS_ERR(old)) {
                 mutex_unlock(&tracepoints_mutex);
                 return PTR_ERR(old);
@@ -441,12 +451,13 @@ EXPORT_SYMBOL_GPL(tracepoint_probe_register_noupdate);
  *
  * caller must call tracepoint_probe_update_all()
  */
-int tracepoint_probe_unregister_noupdate(const char *name, void *probe)
+int tracepoint_probe_unregister_noupdate(const char *name, void *probe,
+                                         void *data)
 {
-        void *old;
+        struct tracepoint_func *old;
 
         mutex_lock(&tracepoints_mutex);
-        old = tracepoint_remove_probe(name, probe);
+        old = tracepoint_remove_probe(name, probe, data);
         if (IS_ERR(old)) {
                 mutex_unlock(&tracepoints_mutex);
                 return PTR_ERR(old);
diff --git a/kernel/user_namespace.c b/kernel/user_namespace.c
index 076c7c8215b0..b2d70d38dff4 100644
--- a/kernel/user_namespace.c
+++ b/kernel/user_namespace.c
@@ -54,8 +54,8 @@ int create_user_ns(struct cred *new)
 #endif
         /* tgcred will be cleared in our caller bc CLONE_THREAD won't be set */
 
-        /* alloc_uid() incremented the userns refcount.  Just set it to 1 */
-        kref_set(&ns->kref, 1);
+        /* root_user holds a reference to ns, our reference can be dropped */
+        put_user_ns(ns);
 
         return 0;
 }
diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index 77dabbf64b8f..327d2deb4451 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -1110,7 +1110,7 @@ static int __devinit workqueue_cpu_callback(struct notifier_block *nfb,
         unsigned int cpu = (unsigned long)hcpu;
         struct cpu_workqueue_struct *cwq;
         struct workqueue_struct *wq;
-        int ret = NOTIFY_OK;
+        int err = 0;
 
         action &= ~CPU_TASKS_FROZEN;
 
@@ -1124,12 +1124,13 @@ undo:
 
                 switch (action) {
                 case CPU_UP_PREPARE:
-                        if (!create_workqueue_thread(cwq, cpu))
+                        err = create_workqueue_thread(cwq, cpu);
+                        if (!err)
                                 break;
                         printk(KERN_ERR "workqueue [%s] for %i failed\n",
                                 wq->name, cpu);
                         action = CPU_UP_CANCELED;
-                        ret = NOTIFY_BAD;
+                        err = -ENOMEM;
                         goto undo;
 
                 case CPU_ONLINE:
@@ -1150,7 +1151,7 @@ undo:
                 cpumask_clear_cpu(cpu, cpu_populated_map);
         }
 
-        return ret;
+        return notifier_from_errno(err);
 }
 
 #ifdef CONFIG_SMP