Patched in Tegra support.

10 files changed, 157 insertions, 298 deletions

diff --git a/kernel/debug/debug_core.c b/kernel/debug/debug_core.c
index 9a61738cefc..0d7c08784ef 100644
--- a/kernel/debug/debug_core.c
+++ b/kernel/debug/debug_core.c
@@ -41,7 +41,6 @@
 #include <linux/delay.h>
 #include <linux/sched.h>
 #include <linux/sysrq.h>
-#include <linux/reboot.h>
 #include <linux/init.h>
 #include <linux/kgdb.h>
 #include <linux/kdb.h>
@@ -53,6 +52,7 @@
 #include <asm/cacheflush.h>
 #include <asm/byteorder.h>
 #include <linux/atomic.h>
+#include <asm/system.h>
 
 #include "debug_core.h"
 
@@ -75,8 +75,6 @@ static int			exception_level;
 struct kgdb_io          *dbg_io_ops;
 static DEFINE_SPINLOCK(kgdb_registration_lock);
 
-/* Action for the reboot notifiter, a global allow kdb to change it */
-static int kgdbreboot;
 /* kgdb console driver is loaded */
 static int kgdb_con_registered;
 /* determine if kgdb console output should be used */
@@ -98,7 +96,6 @@ static int __init opt_kgdb_con(char *str)
 early_param("kgdbcon", opt_kgdb_con);
 
 module_param(kgdb_use_con, int, 0644);
-module_param(kgdbreboot, int, 0644);
 
 /*
  * Holds information about breakpoints in a kernel. These breakpoints are
@@ -160,39 +157,37 @@ early_param("nokgdbroundup", opt_nokgdbroundup);
  * Weak aliases for breakpoint management,
  * can be overriden by architectures when needed:
  */
-int __weak kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt)
+int __weak kgdb_arch_set_breakpoint(unsigned long addr, char *saved_instr)
 {
         int err;
 
-        err = probe_kernel_read(bpt->saved_instr, (char *)bpt->bpt_addr,
-                                BREAK_INSTR_SIZE);
+        err = probe_kernel_read(saved_instr, (char *)addr, BREAK_INSTR_SIZE);
         if (err)
                 return err;
-        err = probe_kernel_write((char *)bpt->bpt_addr,
-                                 arch_kgdb_ops.gdb_bpt_instr, BREAK_INSTR_SIZE);
-        return err;
+
+        return probe_kernel_write((char *)addr, arch_kgdb_ops.gdb_bpt_instr,
+                                  BREAK_INSTR_SIZE);
 }
 
-int __weak kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt)
+int __weak kgdb_arch_remove_breakpoint(unsigned long addr, char *bundle)
 {
-        return probe_kernel_write((char *)bpt->bpt_addr,
-                                  (char *)bpt->saved_instr, BREAK_INSTR_SIZE);
+        return probe_kernel_write((char *)addr,
+                                  (char *)bundle, BREAK_INSTR_SIZE);
 }
 
 int __weak kgdb_validate_break_address(unsigned long addr)
 {
-        struct kgdb_bkpt tmp;
+        char tmp_variable[BREAK_INSTR_SIZE];
         int err;
-        /* Validate setting the breakpoint and then removing it.  If the
+        /* 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.
          */
-        tmp.bpt_addr = addr;
-        err = kgdb_arch_set_breakpoint(&tmp);
+        err = kgdb_arch_set_breakpoint(addr, tmp_variable);
         if (err)
                 return err;
-        err = kgdb_arch_remove_breakpoint(&tmp);
+        err = kgdb_arch_remove_breakpoint(addr, tmp_variable);
         if (err)
                 printk(KERN_ERR "KGDB: Critical breakpoint error, kernel "
                    "memory destroyed at: %lx", addr);
@@ -236,6 +231,7 @@ static void kgdb_flush_swbreak_addr(unsigned long addr)
  */
 int dbg_activate_sw_breakpoints(void)
 {
+        unsigned long addr;
         int error;
         int ret = 0;
         int i;
@@ -244,15 +240,16 @@ int dbg_activate_sw_breakpoints(void)
                 if (kgdb_break[i].state != BP_SET)
                         continue;
 
-                error = kgdb_arch_set_breakpoint(&kgdb_break[i]);
+                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",
-                               kgdb_break[i].bpt_addr);
+                        printk(KERN_INFO "KGDB: BP install failed: %lx", addr);
                         continue;
                 }
 
-                kgdb_flush_swbreak_addr(kgdb_break[i].bpt_addr);
+                kgdb_flush_swbreak_addr(addr);
                 kgdb_break[i].state = BP_ACTIVE;
         }
         return ret;
@@ -301,6 +298,7 @@ int dbg_set_sw_break(unsigned long addr)
 
 int dbg_deactivate_sw_breakpoints(void)
 {
+        unsigned long addr;
         int error;
         int ret = 0;
         int i;
@@ -308,14 +306,15 @@ int dbg_deactivate_sw_breakpoints(void)
         for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
                 if (kgdb_break[i].state != BP_ACTIVE)
                         continue;
-                error = kgdb_arch_remove_breakpoint(&kgdb_break[i]);
+                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",
-                               kgdb_break[i].bpt_addr);
+                        printk(KERN_INFO "KGDB: BP remove failed: %lx\n", addr);
                         ret = error;
                 }
 
-                kgdb_flush_swbreak_addr(kgdb_break[i].bpt_addr);
+                kgdb_flush_swbreak_addr(addr);
                 kgdb_break[i].state = BP_SET;
         }
         return ret;
@@ -349,6 +348,7 @@ int kgdb_isremovedbreak(unsigned long addr)
 
 int dbg_remove_all_break(void)
 {
+        unsigned long addr;
         int error;
         int i;
 
@@ -356,10 +356,12 @@ int dbg_remove_all_break(void)
         for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
                 if (kgdb_break[i].state != BP_ACTIVE)
                         goto setundefined;
-                error = kgdb_arch_remove_breakpoint(&kgdb_break[i]);
+                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",
-                               kgdb_break[i].bpt_addr);
+                           addr);
 setundefined:
                 kgdb_break[i].state = BP_UNDEFINED;
         }
@@ -672,10 +674,6 @@ 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 = 0;
-
-        if (arch_kgdb_ops.enable_nmi)
-                arch_kgdb_ops.enable_nmi(0);
 
         ks->cpu                 = raw_smp_processor_id();
         ks->ex_vector           = evector;
@@ -685,33 +683,13 @@ kgdb_handle_exception(int evector, int signo, int ecode, struct pt_regs *regs)
         ks->linux_regs          = regs;
 
         if (kgdb_reenter_check(ks))
-                goto out; /* Ouch, double exception ! */
+                return 0; /* Ouch, double exception ! */
         if (kgdb_info[ks->cpu].enter_kgdb != 0)
-                goto out;
-
-        ret = kgdb_cpu_enter(ks, regs, DCPU_WANT_MASTER);
-out:
-        if (arch_kgdb_ops.enable_nmi)
-                arch_kgdb_ops.enable_nmi(1);
-        return ret;
-}
-
-/*
- * GDB places a breakpoint at this function to know dynamically
- * loaded objects. It's not defined static so that only one instance with this
- * name exists in the kernel.
- */
+                return 0;
 
-static int module_event(struct notifier_block *self, unsigned long val,
-        void *data)
-{
-        return 0;
+        return kgdb_cpu_enter(ks, regs, DCPU_WANT_MASTER);
 }
 
-static struct notifier_block dbg_module_load_nb = {
-        .notifier_call  = module_event,
-};
-
 int kgdb_nmicallback(int cpu, void *regs)
 {
 #ifdef CONFIG_SMP
@@ -806,33 +784,6 @@ void __init dbg_late_init(void)
         kdb_init(KDB_INIT_FULL);
 }
 
-static int
-dbg_notify_reboot(struct notifier_block *this, unsigned long code, void *x)
-{
-        /*
-         * Take the following action on reboot notify depending on value:
-         *    1 == Enter debugger
-         *    0 == [the default] detatch debug client
-         *   -1 == Do nothing... and use this until the board resets
-         */
-        switch (kgdbreboot) {
-        case 1:
-                kgdb_breakpoint();
-        case -1:
-                goto done;
-        }
-        if (!dbg_kdb_mode)
-                gdbstub_exit(code);
-done:
-        return NOTIFY_DONE;
-}
-
-static struct notifier_block dbg_reboot_notifier = {
-        .notifier_call          = dbg_notify_reboot,
-        .next                   = NULL,
-        .priority               = INT_MAX,
-};
-
 static void kgdb_register_callbacks(void)
 {
         if (!kgdb_io_module_registered) {
@@ -840,8 +791,6 @@ static void kgdb_register_callbacks(void)
                 kgdb_arch_init();
                 if (!dbg_is_early)
                         kgdb_arch_late();
-                register_module_notifier(&dbg_module_load_nb);
-                register_reboot_notifier(&dbg_reboot_notifier);
                 atomic_notifier_chain_register(&panic_notifier_list,
                                                &kgdb_panic_event_nb);
 #ifdef CONFIG_MAGIC_SYSRQ
@@ -863,8 +812,6 @@ static void kgdb_unregister_callbacks(void)
          */
         if (kgdb_io_module_registered) {
                 kgdb_io_module_registered = 0;
-                unregister_reboot_notifier(&dbg_reboot_notifier);
-                unregister_module_notifier(&dbg_module_load_nb);
                 atomic_notifier_chain_unregister(&panic_notifier_list,
                                                &kgdb_panic_event_nb);
                 kgdb_arch_exit();
diff --git a/kernel/debug/gdbstub.c b/kernel/debug/gdbstub.c
index ce615e06448..34872482315 100644
--- a/kernel/debug/gdbstub.c
+++ b/kernel/debug/gdbstub.c
@@ -217,7 +217,7 @@ void gdbstub_msg_write(const char *s, int len)
 
                 /* Pack in hex chars */
                 for (i = 0; i < wcount; i++)
-                        bufptr = hex_byte_pack(bufptr, s[i]);
+                        bufptr = pack_hex_byte(bufptr, s[i]);
                 *bufptr = '\0';
 
                 /* Move up */
@@ -249,7 +249,7 @@ char *kgdb_mem2hex(char *mem, char *buf, int count)
         if (err)
                 return NULL;
         while (count > 0) {
-                buf = hex_byte_pack(buf, *tmp);
+                buf = pack_hex_byte(buf, *tmp);
                 tmp++;
                 count--;
         }
@@ -411,14 +411,14 @@ static char *pack_threadid(char *pkt, unsigned char *id)
         limit = id + (BUF_THREAD_ID_SIZE / 2);
         while (id < limit) {
                 if (!lzero || *id != 0) {
-                        pkt = hex_byte_pack(pkt, *id);
+                        pkt = pack_hex_byte(pkt, *id);
                         lzero = 0;
                 }
                 id++;
         }
 
         if (lzero)
-                pkt = hex_byte_pack(pkt, 0);
+                pkt = pack_hex_byte(pkt, 0);
 
         return pkt;
 }
@@ -486,7 +486,7 @@ static void gdb_cmd_status(struct kgdb_state *ks)
         dbg_remove_all_break();
 
         remcom_out_buffer[0] = 'S';
-        hex_byte_pack(&remcom_out_buffer[1], ks->signo);
+        pack_hex_byte(&remcom_out_buffer[1], ks->signo);
 }
 
 static void gdb_get_regs_helper(struct kgdb_state *ks)
@@ -954,7 +954,7 @@ int gdb_serial_stub(struct kgdb_state *ks)
                 /* Reply to host that an exception has occurred */
                 ptr = remcom_out_buffer;
                 *ptr++ = 'T';
-                ptr = hex_byte_pack(ptr, ks->signo);
+                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);
@@ -1111,13 +1111,6 @@ void gdbstub_exit(int status)
         unsigned char checksum, ch, buffer[3];
         int loop;
 
-        if (!kgdb_connected)
-                return;
-        kgdb_connected = 0;
-
-        if (!dbg_io_ops || dbg_kdb_mode)
-                return;
-
         buffer[0] = 'W';
         buffer[1] = hex_asc_hi(status);
         buffer[2] = hex_asc_lo(status);
@@ -1136,6 +1129,5 @@ void gdbstub_exit(int status)
         dbg_io_ops->write_char(hex_asc_lo(checksum));
 
         /* make sure the output is flushed, lest the bootloader clobber it */
-        if (dbg_io_ops->flush)
-                dbg_io_ops->flush();
+        dbg_io_ops->flush();
 }
diff --git a/kernel/debug/kdb/kdb_bp.c b/kernel/debug/kdb/kdb_bp.c
index 8418c2f8ec5..20059ef4459 100644
--- a/kernel/debug/kdb/kdb_bp.c
+++ b/kernel/debug/kdb/kdb_bp.c
@@ -153,13 +153,6 @@ static int _kdb_bp_install(struct pt_regs *regs, kdb_bp_t *bp)
         } else {
                 kdb_printf("%s: failed to set breakpoint at 0x%lx\n",
                            __func__, bp->bp_addr);
-#ifdef CONFIG_DEBUG_RODATA
-                if (!bp->bp_type) {
-                        kdb_printf("Software breakpoints are unavailable.\n"
-                                   "  Change the kernel CONFIG_DEBUG_RODATA=n\n"
-                                   "  OR use hw breaks: help bph\n");
-                }
-#endif
                 return 1;
         }
         return 0;
diff --git a/kernel/debug/kdb/kdb_bt.c b/kernel/debug/kdb/kdb_bt.c
index b03e0e814e4..7179eac7b41 100644
--- a/kernel/debug/kdb/kdb_bt.c
+++ b/kernel/debug/kdb/kdb_bt.c
@@ -15,6 +15,7 @@
 #include <linux/sched.h>
 #include <linux/kdb.h>
 #include <linux/nmi.h>
+#include <asm/system.h>
 #include "kdb_private.h"
 
 
@@ -129,8 +130,6 @@ kdb_bt(int argc, const char **argv)
                 }
                 /* Now the inactive tasks */
                 kdb_do_each_thread(g, p) {
-                        if (KDB_FLAG(CMD_INTERRUPT))
-                                return 0;
                         if (task_curr(p))
                                 continue;
                         if (kdb_bt1(p, mask, argcount, btaprompt))
diff --git a/kernel/debug/kdb/kdb_debugger.c b/kernel/debug/kdb/kdb_debugger.c
index be7b33b73d3..d9ca9aa481e 100644
--- a/kernel/debug/kdb/kdb_debugger.c
+++ b/kernel/debug/kdb/kdb_debugger.c
@@ -11,8 +11,6 @@
 #include <linux/kgdb.h>
 #include <linux/kdb.h>
 #include <linux/kdebug.h>
-#include <linux/export.h>
-#include <linux/hardirq.h>
 #include "kdb_private.h"
 #include "../debug_core.h"
 
@@ -53,9 +51,6 @@ int kdb_stub(struct kgdb_state *ks)
         if (atomic_read(&kgdb_setting_breakpoint))
                 reason = KDB_REASON_KEYBOARD;
 
-        if (in_nmi())
-                reason = KDB_REASON_NMI;
-
         for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; i++, bp++) {
                 if ((bp->bp_enabled) && (bp->bp_addr == addr)) {
                         reason = KDB_REASON_BREAK;
diff --git a/kernel/debug/kdb/kdb_io.c b/kernel/debug/kdb/kdb_io.c
index 14ff4849262..4802eb5840e 100644
--- a/kernel/debug/kdb/kdb_io.c
+++ b/kernel/debug/kdb/kdb_io.c
@@ -552,7 +552,6 @@ int vkdb_printf(const char *fmt, va_list ap)
 {
         int diag;
         int linecount;
-        int colcount;
         int logging, saved_loglevel = 0;
         int saved_trap_printk;
         int got_printf_lock = 0;
@@ -585,10 +584,6 @@ int vkdb_printf(const char *fmt, va_list ap)
         if (diag || linecount <= 1)
                 linecount = 24;
 
-        diag = kdbgetintenv("COLUMNS", &colcount);
-        if (diag || colcount <= 1)
-                colcount = 80;
-
         diag = kdbgetintenv("LOGGING", &logging);
         if (diag)
                 logging = 0;
@@ -694,8 +689,8 @@ kdb_printit:
         if (!dbg_kdb_mode && kgdb_connected) {
                 gdbstub_msg_write(kdb_buffer, retlen);
         } else {
-                if (dbg_io_ops && !dbg_io_ops->is_console) {
-                        len = retlen;
+                if (!dbg_io_ops->is_console) {
+                        len = strlen(kdb_buffer);
                         cp = kdb_buffer;
                         while (len--) {
                                 dbg_io_ops->write_char(*cp);
@@ -714,30 +709,15 @@ kdb_printit:
                 printk(KERN_INFO "%s", kdb_buffer);
         }
 
-        if (KDB_STATE(PAGER)) {
-                /*
-                 * Check printed string to decide how to bump the
-                 * kdb_nextline to control when the more prompt should
-                 * show up.
-                 */
-                int got = 0;
-                len = retlen;
-                while (len--) {
-                        if (kdb_buffer[len] == '\n') {
-                                kdb_nextline++;
-                                got = 0;
-                        } else if (kdb_buffer[len] == '\r') {
-                                got = 0;
-                        } else {
-                                got++;
-                        }
-                }
-                kdb_nextline += got / (colcount + 1);
-        }
+        if (KDB_STATE(PAGER) && strchr(kdb_buffer, '\n'))
+                kdb_nextline++;
 
         /* check for having reached the LINES number of printed lines */
-        if (kdb_nextline >= linecount) {
+        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
@@ -752,10 +732,18 @@ kdb_printit:
                 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 && !dbg_io_ops->is_console) {
+                if (!dbg_io_ops->is_console) {
                         len = strlen(moreprompt);
                         cp = moreprompt;
                         while (len--) {
@@ -788,7 +776,7 @@ kdb_printit:
                         kdb_grepping_flag = 0;
                         kdb_printf("\n");
                 } else if (buf1[0] == ' ') {
-                        kdb_printf("\r");
+                        kdb_printf("\n");
                         suspend_grep = 1; /* for this recursion */
                 } else if (buf1[0] == '\n') {
                         kdb_nextline = linecount - 1;
diff --git a/kernel/debug/kdb/kdb_keyboard.c b/kernel/debug/kdb/kdb_keyboard.c
index 118527aa60e..4bca634975c 100644
--- a/kernel/debug/kdb/kdb_keyboard.c
+++ b/kernel/debug/kdb/kdb_keyboard.c
@@ -25,7 +25,6 @@
 #define KBD_STAT_MOUSE_OBF      0x20    /* Mouse output buffer full */
 
 static int kbd_exists;
-static int kbd_last_ret;
 
 /*
  * Check if the keyboard controller has a keypress for us.
@@ -91,11 +90,8 @@ int kdb_get_kbd_char(void)
                 return -1;
         }
 
-        if ((scancode & 0x80) != 0) {
-                if (scancode == 0x9c)
-                        kbd_last_ret = 0;
+        if ((scancode & 0x80) != 0)
                 return -1;
-        }
 
         scancode &= 0x7f;
 
@@ -182,82 +178,35 @@ int kdb_get_kbd_char(void)
                 return -1;      /* ignore unprintables */
         }
 
-        if (scancode == 0x1c) {
-                kbd_last_ret = 1;
-                return 13;
-        }
-
-        return keychar & 0xff;
-}
-EXPORT_SYMBOL_GPL(kdb_get_kbd_char);
-
-/*
- * Best effort cleanup of ENTER break codes on leaving KDB. Called on
- * exiting KDB, when we know we processed an ENTER or KP ENTER scan
- * code.
- */
-void kdb_kbd_cleanup_state(void)
-{
-        int scancode, scanstatus;
-
-        /*
-         * Nothing to clean up, since either
-         * ENTER was never pressed, or has already
-         * gotten cleaned up.
-         */
-        if (!kbd_last_ret)
-                return;
-
-        kbd_last_ret = 0;
-        /*
-         * Enter key. Need to absorb the break code here, lest it gets
-         * leaked out if we exit KDB as the result of processing 'g'.
-         *
-         * This has several interesting implications:
-         * + Need to handle KP ENTER, which has break code 0xe0 0x9c.
-         * + Need to handle repeat ENTER and repeat KP ENTER. Repeats
-         *   only get a break code at the end of the repeated
-         *   sequence. This means we can't propagate the repeated key
-         *   press, and must swallow it away.
-         * + Need to handle possible PS/2 mouse input.
-         * + Need to handle mashed keys.
-         */
-
-        while (1) {
+        if ((scancode & 0x7f) == 0x1c) {
+                /*
+                 * enter key.  All done.  Absorb the release scancode.
+                 */
                 while ((inb(KBD_STATUS_REG) & KBD_STAT_OBF) == 0)
-                        cpu_relax();
+                        ;
 
                 /*
-                 * Fetch the scancode.
+                 * Fetch the scancode
                  */
                 scancode = inb(KBD_DATA_REG);
                 scanstatus = inb(KBD_STATUS_REG);
 
-                /*
-                 * Skip mouse input.
-                 */
-                if (scanstatus & KBD_STAT_MOUSE_OBF)
-                        continue;
+                while (scanstatus & KBD_STAT_MOUSE_OBF) {
+                        scancode = inb(KBD_DATA_REG);
+                        scanstatus = inb(KBD_STATUS_REG);
+                }
 
-                /*
-                 * If we see 0xe0, this is either a break code for KP
-                 * ENTER, or a repeat make for KP ENTER. Either way,
-                 * since the second byte is equivalent to an ENTER,
-                 * skip the 0xe0 and try again.
-                 *
-                 * If we see 0x1c, this must be a repeat ENTER or KP
-                 * ENTER (and we swallowed 0xe0 before). Try again.
-                 *
-                 * We can also see make and break codes for other keys
-                 * mashed before or after pressing ENTER. Thus, if we
-                 * see anything other than 0x9c, we have to try again.
-                 *
-                 * Note, if you held some key as ENTER was depressed,
-                 * that break code would get leaked out.
-                 */
-                if (scancode != 0x9c)
-                        continue;
+                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;
+                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
index 4d5f8d5612f..63786e71a3c 100644
--- a/kernel/debug/kdb/kdb_main.c
+++ b/kernel/debug/kdb/kdb_main.c
@@ -14,14 +14,12 @@
 #include <linux/ctype.h>
 #include <linux/string.h>
 #include <linux/kernel.h>
-#include <linux/kmsg_dump.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/atomic.h>
 #include <linux/module.h>
 #include <linux/mm.h>
 #include <linux/init.h>
@@ -140,10 +138,11 @@ static const int __nkdb_err = sizeof(kdbmsgs) / sizeof(kdbmsg_t);
 static char *__env[] = {
 #if defined(CONFIG_SMP)
  "PROMPT=[%d]kdb> ",
+ "MOREPROMPT=[%d]more> ",
 #else
  "PROMPT=kdb> ",
-#endif
  "MOREPROMPT=more> ",
+#endif
  "RADIX=16",
  "MDCOUNT=8",                   /* lines of md output */
  KDB_PLATFORM_ENV,
@@ -1236,6 +1235,18 @@ static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs,
                 *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"),
@@ -1389,9 +1400,6 @@ int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
         if (KDB_STATE(DOING_SS))
                 KDB_STATE_CLEAR(SSBPT);
 
-        /* Clean up any keyboard devices before leaving */
-        kdb_kbd_cleanup_state();
-
         return result;
 }
 
@@ -1974,7 +1982,7 @@ static int kdb_lsmod(int argc, const char **argv)
                 kdb_printf("%-20s%8u  0x%p ", mod->name,
                            mod->core_size, (void *)mod);
 #ifdef CONFIG_MODULE_UNLOAD
-                kdb_printf("%4ld ", module_refcount(mod));
+                kdb_printf("%4d ", module_refcount(mod));
 #endif
                 if (mod->state == MODULE_STATE_GOING)
                         kdb_printf(" (Unloading)");
@@ -2029,15 +2037,8 @@ static int kdb_env(int argc, const char **argv)
  */
 static int kdb_dmesg(int argc, const char **argv)
 {
-        int diag;
-        int logging;
-        int lines = 0;
-        int adjust = 0;
-        int n = 0;
-        int skip = 0;
-        struct kmsg_dumper dumper = { .active = 1 };
-        size_t len;
-        char buf[201];
+        char *syslog_data[4], *start, *end, c = '\0', *p;
+        int diag, logging, logsize, lines = 0, adjust = 0, n;
 
         if (argc > 2)
                 return KDB_ARGCOUNT;
@@ -2060,10 +2061,22 @@ static int kdb_dmesg(int argc, const char **argv)
                 kdb_set(2, setargs);
         }
 
-        kmsg_dump_rewind_nolock(&dumper);
-        while (kmsg_dump_get_line_nolock(&dumper, 1, NULL, 0, NULL))
-                n++;
-
+        /* 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 "
@@ -2071,11 +2084,21 @@ static int kdb_dmesg(int argc, const char **argv)
                 else if (adjust - lines >= n)
                         kdb_printf("buffer only contains %d lines, last %d "
                                    "lines printed\n", n, n - adjust);
-                skip = adjust;
-                lines = abs(lines);
+                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) {
-                skip = n - lines - adjust;
-                lines = abs(lines);
+                int skip = n - (adjust + lines);
                 if (adjust >= n) {
                         kdb_printf("buffer only contains %d lines, "
                                    "nothing printed\n", n);
@@ -2086,56 +2109,39 @@ static int kdb_dmesg(int argc, const char **argv)
                         kdb_printf("buffer only contains %d lines, first "
                                    "%d lines printed\n", n, lines);
                 }
-        } else {
-                lines = n;
-        }
-
-        if (skip >= n || skip < 0)
-                return 0;
-
-        kmsg_dump_rewind_nolock(&dumper);
-        while (kmsg_dump_get_line_nolock(&dumper, 1, buf, sizeof(buf), &len)) {
-                if (skip) {
-                        skip--;
-                        continue;
+                for (; start < end && skip; ++start) {
+                        if (*KDB_WRAP(start) == '\n')
+                                --skip;
                 }
-                if (!lines--)
-                        break;
+                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;
-
-                kdb_printf("%.*s\n", (int)len - 1, buf);
+                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 */
-
-/* Make sure we balance enable/disable calls, must disable first. */
-static atomic_t kdb_nmi_disabled;
-
-static int kdb_disable_nmi(int argc, const char *argv[])
-{
-        if (atomic_read(&kdb_nmi_disabled))
-                return 0;
-        atomic_set(&kdb_nmi_disabled, 1);
-        arch_kgdb_ops.enable_nmi(0);
-        return 0;
-}
-
-static int kdb_param_enable_nmi(const char *val, const struct kernel_param *kp)
-{
-        if (!atomic_add_unless(&kdb_nmi_disabled, -1, 0))
-                return -EINVAL;
-        arch_kgdb_ops.enable_nmi(1);
-        return 0;
-}
-
-static const struct kernel_param_ops kdb_param_ops_enable_nmi = {
-        .set = kdb_param_enable_nmi,
-};
-module_param_cb(enable_nmi, &kdb_param_ops_enable_nmi, NULL, 0600);
-
 /*
  * kdb_cpu - This function implements the 'cpu' command.
  *      cpu     [<cpunum>]
@@ -2880,10 +2886,6 @@ static void __init kdb_inittab(void)
         kdb_register_repeat("dmesg", kdb_dmesg, "[lines]",
           "Display syslog buffer", 0, KDB_REPEAT_NONE);
 #endif
-        if (arch_kgdb_ops.enable_nmi) {
-                kdb_register_repeat("disable_nmi", kdb_disable_nmi, "",
-                  "Disable NMI entry to KDB", 0, KDB_REPEAT_NONE);
-        }
         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>",
diff --git a/kernel/debug/kdb/kdb_private.h b/kernel/debug/kdb/kdb_private.h
index 392ec6a2584..e381d105b40 100644
--- a/kernel/debug/kdb/kdb_private.h
+++ b/kernel/debug/kdb/kdb_private.h
@@ -205,6 +205,7 @@ 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,
@@ -245,13 +246,6 @@ extern void debug_kusage(void);
 
 extern void kdb_set_current_task(struct task_struct *);
 extern struct task_struct *kdb_current_task;
-
-#ifdef CONFIG_KDB_KEYBOARD
-extern void kdb_kbd_cleanup_state(void);
-#else /* ! CONFIG_KDB_KEYBOARD */
-#define kdb_kbd_cleanup_state()
-#endif /* ! CONFIG_KDB_KEYBOARD */
-
 #ifdef CONFIG_MODULES
 extern struct list_head *kdb_modules;
 #endif /* CONFIG_MODULES */
diff --git a/kernel/debug/kdb/kdb_support.c b/kernel/debug/kdb/kdb_support.c
index d35cc2d3a4c..5532dd37aa8 100644
--- a/kernel/debug/kdb/kdb_support.c
+++ b/kernel/debug/kdb/kdb_support.c
@@ -384,9 +384,9 @@ static int kdb_getphys(void *res, unsigned long addr, size_t size)
         if (!pfn_valid(pfn))
                 return 1;
         page = pfn_to_page(pfn);
-        vaddr = kmap_atomic(page);
+        vaddr = kmap_atomic(page, KM_KDB);
         memcpy(res, vaddr + (addr & (PAGE_SIZE - 1)), size);
-        kunmap_atomic(vaddr);
+        kunmap_atomic(vaddr, KM_KDB);
 
         return 0;
 }
@@ -636,7 +636,7 @@ char kdb_task_state_char (const struct task_struct *p)
                 (p->exit_state & EXIT_ZOMBIE) ? 'Z' :
                 (p->exit_state & EXIT_DEAD) ? 'E' :
                 (p->state & TASK_INTERRUPTIBLE) ? 'S' : '?';
-        if (is_idle_task(p)) {
+        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) {