Patched in Tegra support.

8 files changed, 117 insertions, 197 deletions

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) {