2 * Kernel Debugger Architecture Independent Main Code
4 * This file is subject to the terms and conditions of the GNU General Public
5 * License. See the file "COPYING" in the main directory of this archive
8 * Copyright (C) 1999-2004 Silicon Graphics, Inc. All Rights Reserved.
9 * Copyright (C) 2000 Stephane Eranian <eranian@hpl.hp.com>
10 * Xscale (R) modifications copyright (C) 2003 Intel Corporation.
11 * Copyright (c) 2009 Wind River Systems, Inc. All Rights Reserved.
14 #include <linux/ctype.h>
15 #include <linux/string.h>
16 #include <linux/kernel.h>
17 #include <linux/kmsg_dump.h>
18 #include <linux/reboot.h>
19 #include <linux/sched.h>
20 #include <linux/sysrq.h>
21 #include <linux/smp.h>
22 #include <linux/utsname.h>
23 #include <linux/vmalloc.h>
24 #include <linux/module.h>
26 #include <linux/init.h>
27 #include <linux/kallsyms.h>
28 #include <linux/kgdb.h>
29 #include <linux/kdb.h>
30 #include <linux/notifier.h>
31 #include <linux/interrupt.h>
32 #include <linux/delay.h>
33 #include <linux/nmi.h>
34 #include <linux/time.h>
35 #include <linux/ptrace.h>
36 #include <linux/sysctl.h>
37 #include <linux/cpu.h>
38 #include <linux/kdebug.h>
39 #include <linux/proc_fs.h>
40 #include <linux/uaccess.h>
41 #include <linux/slab.h>
42 #include "kdb_private.h"
45 char kdb_grep_string[GREP_LEN];
46 int kdb_grepping_flag;
47 EXPORT_SYMBOL(kdb_grepping_flag);
49 int kdb_grep_trailing;
52 * Kernel debugger state flags
58 * kdb_lock protects updates to kdb_initial_cpu. Used to
59 * single thread processors through the kernel debugger.
61 int kdb_initial_cpu = -1; /* cpu number that owns kdb */
63 int kdb_state; /* General KDB state */
65 struct task_struct *kdb_current_task;
66 EXPORT_SYMBOL(kdb_current_task);
67 struct pt_regs *kdb_current_regs;
69 const char *kdb_diemsg;
70 static int kdb_go_count;
71 #ifdef CONFIG_KDB_CONTINUE_CATASTROPHIC
72 static unsigned int kdb_continue_catastrophic =
73 CONFIG_KDB_CONTINUE_CATASTROPHIC;
75 static unsigned int kdb_continue_catastrophic;
78 /* kdb_commands describes the available commands. */
79 static kdbtab_t *kdb_commands;
80 #define KDB_BASE_CMD_MAX 50
81 static int kdb_max_commands = KDB_BASE_CMD_MAX;
82 static kdbtab_t kdb_base_commands[KDB_BASE_CMD_MAX];
83 #define for_each_kdbcmd(cmd, num) \
84 for ((cmd) = kdb_base_commands, (num) = 0; \
85 num < kdb_max_commands; \
86 num++, num == KDB_BASE_CMD_MAX ? cmd = kdb_commands : cmd++)
88 typedef struct _kdbmsg {
89 int km_diag; /* kdb diagnostic */
90 char *km_msg; /* Corresponding message text */
93 #define KDBMSG(msgnum, text) \
94 { KDB_##msgnum, text }
96 static kdbmsg_t kdbmsgs[] = {
97 KDBMSG(NOTFOUND, "Command Not Found"),
98 KDBMSG(ARGCOUNT, "Improper argument count, see usage."),
99 KDBMSG(BADWIDTH, "Illegal value for BYTESPERWORD use 1, 2, 4 or 8, "
100 "8 is only allowed on 64 bit systems"),
101 KDBMSG(BADRADIX, "Illegal value for RADIX use 8, 10 or 16"),
102 KDBMSG(NOTENV, "Cannot find environment variable"),
103 KDBMSG(NOENVVALUE, "Environment variable should have value"),
104 KDBMSG(NOTIMP, "Command not implemented"),
105 KDBMSG(ENVFULL, "Environment full"),
106 KDBMSG(ENVBUFFULL, "Environment buffer full"),
107 KDBMSG(TOOMANYBPT, "Too many breakpoints defined"),
108 #ifdef CONFIG_CPU_XSCALE
109 KDBMSG(TOOMANYDBREGS, "More breakpoints than ibcr registers defined"),
111 KDBMSG(TOOMANYDBREGS, "More breakpoints than db registers defined"),
113 KDBMSG(DUPBPT, "Duplicate breakpoint address"),
114 KDBMSG(BPTNOTFOUND, "Breakpoint not found"),
115 KDBMSG(BADMODE, "Invalid IDMODE"),
116 KDBMSG(BADINT, "Illegal numeric value"),
117 KDBMSG(INVADDRFMT, "Invalid symbolic address format"),
118 KDBMSG(BADREG, "Invalid register name"),
119 KDBMSG(BADCPUNUM, "Invalid cpu number"),
120 KDBMSG(BADLENGTH, "Invalid length field"),
121 KDBMSG(NOBP, "No Breakpoint exists"),
122 KDBMSG(BADADDR, "Invalid address"),
126 static const int __nkdb_err = sizeof(kdbmsgs) / sizeof(kdbmsg_t);
130 * Initial environment. This is all kept static and local to
131 * this file. We don't want to rely on the memory allocation
132 * mechanisms in the kernel, so we use a very limited allocate-only
133 * heap for new and altered environment variables. The entire
134 * environment is limited to a fixed number of entries (add more
135 * to __env[] if required) and a fixed amount of heap (add more to
136 * KDB_ENVBUFSIZE if required).
139 static char *__env[] = {
140 #if defined(CONFIG_SMP)
142 "MOREPROMPT=[%d]more> ",
148 "MDCOUNT=8", /* lines of md output */
178 static const int __nenv = (sizeof(__env) / sizeof(char *));
180 struct task_struct *kdb_curr_task(int cpu)
182 struct task_struct *p = curr_task(cpu);
184 if ((task_thread_info(p)->flags & _TIF_MCA_INIT) && KDB_TSK(cpu))
191 * kdbgetenv - This function will return the character string value of
192 * an environment variable.
194 * match A character string representing an environment variable.
196 * NULL No environment variable matches 'match'
197 * char* Pointer to string value of environment variable.
199 char *kdbgetenv(const char *match)
202 int matchlen = strlen(match);
205 for (i = 0; i < __nenv; i++) {
211 if ((strncmp(match, e, matchlen) == 0)
212 && ((e[matchlen] == '\0')
213 || (e[matchlen] == '='))) {
214 char *cp = strchr(e, '=');
215 return cp ? ++cp : "";
222 * kdballocenv - This function is used to allocate bytes for
223 * environment entries.
225 * match A character string representing a numeric value
227 * *value the unsigned long representation of the env variable 'match'
229 * Zero on success, a kdb diagnostic on failure.
231 * We use a static environment buffer (envbuffer) to hold the values
232 * of dynamically generated environment variables (see kdb_set). Buffer
233 * space once allocated is never free'd, so over time, the amount of space
234 * (currently 512 bytes) will be exhausted if env variables are changed
237 static char *kdballocenv(size_t bytes)
239 #define KDB_ENVBUFSIZE 512
240 static char envbuffer[KDB_ENVBUFSIZE];
241 static int envbufsize;
244 if ((KDB_ENVBUFSIZE - envbufsize) >= bytes) {
245 ep = &envbuffer[envbufsize];
252 * kdbgetulenv - This function will return the value of an unsigned
253 * long-valued environment variable.
255 * match A character string representing a numeric value
257 * *value the unsigned long represntation of the env variable 'match'
259 * Zero on success, a kdb diagnostic on failure.
261 static int kdbgetulenv(const char *match, unsigned long *value)
265 ep = kdbgetenv(match);
269 return KDB_NOENVVALUE;
271 *value = simple_strtoul(ep, NULL, 0);
277 * kdbgetintenv - This function will return the value of an
278 * integer-valued environment variable.
280 * match A character string representing an integer-valued env variable
282 * *value the integer representation of the environment variable 'match'
284 * Zero on success, a kdb diagnostic on failure.
286 int kdbgetintenv(const char *match, int *value)
291 diag = kdbgetulenv(match, &val);
298 * kdbgetularg - This function will convert a numeric string into an
299 * unsigned long value.
301 * arg A character string representing a numeric value
303 * *value the unsigned long represntation of arg.
305 * Zero on success, a kdb diagnostic on failure.
307 int kdbgetularg(const char *arg, unsigned long *value)
312 val = simple_strtoul(arg, &endp, 0);
316 * Also try base 16, for us folks too lazy to type the
319 val = simple_strtoul(arg, &endp, 16);
329 int kdbgetu64arg(const char *arg, u64 *value)
334 val = simple_strtoull(arg, &endp, 0);
338 val = simple_strtoull(arg, &endp, 16);
349 * kdb_set - This function implements the 'set' command. Alter an
350 * existing environment variable or create a new one.
352 int kdb_set(int argc, const char **argv)
356 size_t varlen, vallen;
359 * we can be invoked two ways:
360 * set var=value argv[1]="var", argv[2]="value"
361 * set var = value argv[1]="var", argv[2]="=", argv[3]="value"
362 * - if the latter, shift 'em down.
373 * Check for internal variables
375 if (strcmp(argv[1], "KDBDEBUG") == 0) {
376 unsigned int debugflags;
379 debugflags = simple_strtoul(argv[2], &cp, 0);
380 if (cp == argv[2] || debugflags & ~KDB_DEBUG_FLAG_MASK) {
381 kdb_printf("kdb: illegal debug flags '%s'\n",
385 kdb_flags = (kdb_flags &
386 ~(KDB_DEBUG_FLAG_MASK << KDB_DEBUG_FLAG_SHIFT))
387 | (debugflags << KDB_DEBUG_FLAG_SHIFT);
393 * Tokenizer squashed the '=' sign. argv[1] is variable
394 * name, argv[2] = value.
396 varlen = strlen(argv[1]);
397 vallen = strlen(argv[2]);
398 ep = kdballocenv(varlen + vallen + 2);
400 return KDB_ENVBUFFULL;
402 sprintf(ep, "%s=%s", argv[1], argv[2]);
404 ep[varlen+vallen+1] = '\0';
406 for (i = 0; i < __nenv; i++) {
408 && ((strncmp(__env[i], argv[1], varlen) == 0)
409 && ((__env[i][varlen] == '\0')
410 || (__env[i][varlen] == '=')))) {
417 * Wasn't existing variable. Fit into slot.
419 for (i = 0; i < __nenv-1; i++) {
420 if (__env[i] == (char *)0) {
429 static int kdb_check_regs(void)
431 if (!kdb_current_regs) {
432 kdb_printf("No current kdb registers."
433 " You may need to select another task\n");
440 * kdbgetaddrarg - This function is responsible for parsing an
441 * address-expression and returning the value of the expression,
442 * symbol name, and offset to the caller.
444 * The argument may consist of a numeric value (decimal or
445 * hexidecimal), a symbol name, a register name (preceded by the
446 * percent sign), an environment variable with a numeric value
447 * (preceded by a dollar sign) or a simple arithmetic expression
448 * consisting of a symbol name, +/-, and a numeric constant value
451 * argc - count of arguments in argv
452 * argv - argument vector
453 * *nextarg - index to next unparsed argument in argv[]
454 * regs - Register state at time of KDB entry
456 * *value - receives the value of the address-expression
457 * *offset - receives the offset specified, if any
458 * *name - receives the symbol name, if any
459 * *nextarg - index to next unparsed argument in argv[]
461 * zero is returned on success, a kdb diagnostic code is
464 int kdbgetaddrarg(int argc, const char **argv, int *nextarg,
465 unsigned long *value, long *offset,
469 unsigned long off = 0;
479 * Process arguments which follow the following syntax:
481 * symbol | numeric-address [+/- numeric-offset]
483 * $environment-variable
489 symname = (char *)argv[*nextarg];
492 * If there is no whitespace between the symbol
493 * or address and the '+' or '-' symbols, we
494 * remember the character and replace it with a
495 * null so the symbol/value can be properly parsed
497 cp = strpbrk(symname, "+-");
503 if (symname[0] == '$') {
504 diag = kdbgetulenv(&symname[1], &addr);
507 } else if (symname[0] == '%') {
508 diag = kdb_check_regs();
511 /* Implement register values with % at a later time as it is
516 found = kdbgetsymval(symname, &symtab);
518 addr = symtab.sym_start;
520 diag = kdbgetularg(argv[*nextarg], &addr);
527 found = kdbnearsym(addr, &symtab);
535 if (offset && name && *name)
536 *offset = addr - symtab.sym_start;
538 if ((*nextarg > argc)
543 * check for +/- and offset
546 if (symbol == '\0') {
547 if ((argv[*nextarg][0] != '+')
548 && (argv[*nextarg][0] != '-')) {
550 * Not our argument. Return.
554 positive = (argv[*nextarg][0] == '+');
558 positive = (symbol == '+');
561 * Now there must be an offset!
563 if ((*nextarg > argc)
564 && (symbol == '\0')) {
565 return KDB_INVADDRFMT;
569 cp = (char *)argv[*nextarg];
573 diag = kdbgetularg(cp, &off);
589 static void kdb_cmderror(int diag)
594 kdb_printf("no error detected (diagnostic is %d)\n", diag);
598 for (i = 0; i < __nkdb_err; i++) {
599 if (kdbmsgs[i].km_diag == diag) {
600 kdb_printf("diag: %d: %s\n", diag, kdbmsgs[i].km_msg);
605 kdb_printf("Unknown diag %d\n", -diag);
609 * kdb_defcmd, kdb_defcmd2 - This function implements the 'defcmd'
610 * command which defines one command as a set of other commands,
611 * terminated by endefcmd. kdb_defcmd processes the initial
612 * 'defcmd' command, kdb_defcmd2 is invoked from kdb_parse for
613 * the following commands until 'endefcmd'.
615 * argc argument count
616 * argv argument vector
618 * zero for success, a kdb diagnostic if error
628 static struct defcmd_set *defcmd_set;
629 static int defcmd_set_count;
630 static int defcmd_in_progress;
632 /* Forward references */
633 static int kdb_exec_defcmd(int argc, const char **argv);
635 static int kdb_defcmd2(const char *cmdstr, const char *argv0)
637 struct defcmd_set *s = defcmd_set + defcmd_set_count - 1;
638 char **save_command = s->command;
639 if (strcmp(argv0, "endefcmd") == 0) {
640 defcmd_in_progress = 0;
644 kdb_register(s->name, kdb_exec_defcmd,
645 s->usage, s->help, 0);
650 s->command = kzalloc((s->count + 1) * sizeof(*(s->command)), GFP_KDB);
652 kdb_printf("Could not allocate new kdb_defcmd table for %s\n",
657 memcpy(s->command, save_command, s->count * sizeof(*(s->command)));
658 s->command[s->count++] = kdb_strdup(cmdstr, GFP_KDB);
663 static int kdb_defcmd(int argc, const char **argv)
665 struct defcmd_set *save_defcmd_set = defcmd_set, *s;
666 if (defcmd_in_progress) {
667 kdb_printf("kdb: nested defcmd detected, assuming missing "
669 kdb_defcmd2("endefcmd", "endefcmd");
673 for (s = defcmd_set; s < defcmd_set + defcmd_set_count; ++s) {
674 kdb_printf("defcmd %s \"%s\" \"%s\"\n", s->name,
676 for (i = 0; i < s->count; ++i)
677 kdb_printf("%s", s->command[i]);
678 kdb_printf("endefcmd\n");
684 defcmd_set = kmalloc((defcmd_set_count + 1) * sizeof(*defcmd_set),
687 kdb_printf("Could not allocate new defcmd_set entry for %s\n",
689 defcmd_set = save_defcmd_set;
692 memcpy(defcmd_set, save_defcmd_set,
693 defcmd_set_count * sizeof(*defcmd_set));
694 kfree(save_defcmd_set);
695 s = defcmd_set + defcmd_set_count;
696 memset(s, 0, sizeof(*s));
698 s->name = kdb_strdup(argv[1], GFP_KDB);
699 s->usage = kdb_strdup(argv[2], GFP_KDB);
700 s->help = kdb_strdup(argv[3], GFP_KDB);
701 if (s->usage[0] == '"') {
702 strcpy(s->usage, s->usage+1);
703 s->usage[strlen(s->usage)-1] = '\0';
705 if (s->help[0] == '"') {
706 strcpy(s->help, s->help+1);
707 s->help[strlen(s->help)-1] = '\0';
710 defcmd_in_progress = 1;
715 * kdb_exec_defcmd - Execute the set of commands associated with this
718 * argc argument count
719 * argv argument vector
721 * zero for success, a kdb diagnostic if error
723 static int kdb_exec_defcmd(int argc, const char **argv)
726 struct defcmd_set *s;
729 for (s = defcmd_set, i = 0; i < defcmd_set_count; ++i, ++s) {
730 if (strcmp(s->name, argv[0]) == 0)
733 if (i == defcmd_set_count) {
734 kdb_printf("kdb_exec_defcmd: could not find commands for %s\n",
738 for (i = 0; i < s->count; ++i) {
739 /* Recursive use of kdb_parse, do not use argv after
742 kdb_printf("[%s]kdb> %s\n", s->name, s->command[i]);
743 ret = kdb_parse(s->command[i]);
750 /* Command history */
751 #define KDB_CMD_HISTORY_COUNT 32
752 #define CMD_BUFLEN 200 /* kdb_printf: max printline
754 static unsigned int cmd_head, cmd_tail;
755 static unsigned int cmdptr;
756 static char cmd_hist[KDB_CMD_HISTORY_COUNT][CMD_BUFLEN];
757 static char cmd_cur[CMD_BUFLEN];
760 * The "str" argument may point to something like | grep xyz
762 static void parse_grep(const char *str)
765 char *cp = (char *)str, *cp2;
767 /* sanity check: we should have been called with the \ first */
773 if (strncmp(cp, "grep ", 5)) {
774 kdb_printf("invalid 'pipe', see grephelp\n");
780 cp2 = strchr(cp, '\n');
782 *cp2 = '\0'; /* remove the trailing newline */
785 kdb_printf("invalid 'pipe', see grephelp\n");
788 /* now cp points to a nonzero length search string */
790 /* allow it be "x y z" by removing the "'s - there must
793 cp2 = strchr(cp, '"');
795 kdb_printf("invalid quoted string, see grephelp\n");
798 *cp2 = '\0'; /* end the string where the 2nd " was */
800 kdb_grep_leading = 0;
802 kdb_grep_leading = 1;
806 kdb_grep_trailing = 0;
807 if (*(cp+len-1) == '$') {
808 kdb_grep_trailing = 1;
814 if (len >= GREP_LEN) {
815 kdb_printf("search string too long\n");
818 strcpy(kdb_grep_string, cp);
824 * kdb_parse - Parse the command line, search the command table for a
825 * matching command and invoke the command function. This
826 * function may be called recursively, if it is, the second call
827 * will overwrite argv and cbuf. It is the caller's
828 * responsibility to save their argv if they recursively call
831 * cmdstr The input command line to be parsed.
832 * regs The registers at the time kdb was entered.
834 * Zero for success, a kdb diagnostic if failure.
836 * Limited to 20 tokens.
838 * Real rudimentary tokenization. Basically only whitespace
839 * is considered a token delimeter (but special consideration
840 * is taken of the '=' sign as used by the 'set' command).
842 * The algorithm used to tokenize the input string relies on
843 * there being at least one whitespace (or otherwise useless)
844 * character between tokens as the character immediately following
845 * the token is altered in-place to a null-byte to terminate the
851 int kdb_parse(const char *cmdstr)
853 static char *argv[MAXARGC];
855 static char cbuf[CMD_BUFLEN+2];
859 int i, escaped, ignore_errors = 0, check_grep;
862 * First tokenize the command string.
865 kdb_grepping_flag = check_grep = 0;
867 if (KDB_FLAG(CMD_INTERRUPT)) {
868 /* Previous command was interrupted, newline must not
869 * repeat the command */
870 KDB_FLAG_CLEAR(CMD_INTERRUPT);
871 KDB_STATE_SET(PAGER);
872 argc = 0; /* no repeat */
875 if (*cp != '\n' && *cp != '\0') {
879 /* skip whitespace */
882 if ((*cp == '\0') || (*cp == '\n') ||
883 (*cp == '#' && !defcmd_in_progress))
885 /* special case: check for | grep pattern */
890 if (cpp >= cbuf + CMD_BUFLEN) {
891 kdb_printf("kdb_parse: command buffer "
892 "overflow, command ignored\n%s\n",
896 if (argc >= MAXARGC - 1) {
897 kdb_printf("kdb_parse: too many arguments, "
898 "command ignored\n%s\n", cmdstr);
904 /* Copy to next unquoted and unescaped
905 * whitespace or '=' */
906 while (*cp && *cp != '\n' &&
907 (escaped || quoted || !isspace(*cp))) {
908 if (cpp >= cbuf + CMD_BUFLEN)
922 else if (*cp == '\'' || *cp == '"')
925 if (*cpp == '=' && !quoted)
929 *cpp++ = '\0'; /* Squash a ws or '=' character */
936 if (defcmd_in_progress) {
937 int result = kdb_defcmd2(cmdstr, argv[0]);
938 if (!defcmd_in_progress) {
939 argc = 0; /* avoid repeat on endefcmd */
944 if (argv[0][0] == '-' && argv[0][1] &&
945 (argv[0][1] < '0' || argv[0][1] > '9')) {
950 for_each_kdbcmd(tp, i) {
953 * If this command is allowed to be abbreviated,
954 * check to see if this is it.
958 && (strlen(argv[0]) <= tp->cmd_minlen)) {
961 tp->cmd_minlen) == 0) {
966 if (strcmp(argv[0], tp->cmd_name) == 0)
972 * If we don't find a command by this name, see if the first
973 * few characters of this match any of the known commands.
974 * e.g., md1c20 should match md.
976 if (i == kdb_max_commands) {
977 for_each_kdbcmd(tp, i) {
981 strlen(tp->cmd_name)) == 0) {
988 if (i < kdb_max_commands) {
991 result = (*tp->cmd_func)(argc-1, (const char **)argv);
992 if (result && ignore_errors && result > KDB_CMD_GO)
994 KDB_STATE_CLEAR(CMD);
995 switch (tp->cmd_repeat) {
996 case KDB_REPEAT_NONE:
1001 case KDB_REPEAT_NO_ARGS:
1006 case KDB_REPEAT_WITH_ARGS:
1013 * If the input with which we were presented does not
1014 * map to an existing command, attempt to parse it as an
1015 * address argument and display the result. Useful for
1016 * obtaining the address of a variable, or the nearest symbol
1017 * to an address contained in a register.
1020 unsigned long value;
1025 if (kdbgetaddrarg(0, (const char **)argv, &nextarg,
1026 &value, &offset, &name)) {
1027 return KDB_NOTFOUND;
1030 kdb_printf("%s = ", argv[0]);
1031 kdb_symbol_print(value, NULL, KDB_SP_DEFAULT);
1038 static int handle_ctrl_cmd(char *cmd)
1043 /* initial situation */
1044 if (cmd_head == cmd_tail)
1048 if (cmdptr != cmd_tail)
1049 cmdptr = (cmdptr-1) % KDB_CMD_HISTORY_COUNT;
1050 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1053 if (cmdptr != cmd_head)
1054 cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT;
1055 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1062 * kdb_reboot - This function implements the 'reboot' command. Reboot
1063 * the system immediately, or loop for ever on failure.
1065 static int kdb_reboot(int argc, const char **argv)
1067 emergency_restart();
1068 kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
1075 static void kdb_dumpregs(struct pt_regs *regs)
1077 int old_lvl = console_loglevel;
1078 console_loglevel = 15;
1083 console_loglevel = old_lvl;
1086 void kdb_set_current_task(struct task_struct *p)
1088 kdb_current_task = p;
1090 if (kdb_task_has_cpu(p)) {
1091 kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p));
1094 kdb_current_regs = NULL;
1098 * kdb_local - The main code for kdb. This routine is invoked on a
1099 * specific processor, it is not global. The main kdb() routine
1100 * ensures that only one processor at a time is in this routine.
1101 * This code is called with the real reason code on the first
1102 * entry to a kdb session, thereafter it is called with reason
1103 * SWITCH, even if the user goes back to the original cpu.
1105 * reason The reason KDB was invoked
1106 * error The hardware-defined error code
1107 * regs The exception frame at time of fault/breakpoint.
1108 * db_result Result code from the break or debug point.
1110 * 0 KDB was invoked for an event which it wasn't responsible
1111 * 1 KDB handled the event for which it was invoked.
1112 * KDB_CMD_GO User typed 'go'.
1113 * KDB_CMD_CPU User switched to another cpu.
1114 * KDB_CMD_SS Single step.
1115 * KDB_CMD_SSB Single step until branch.
1117 static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs,
1118 kdb_dbtrap_t db_result)
1122 struct task_struct *kdb_current =
1123 kdb_curr_task(raw_smp_processor_id());
1125 KDB_DEBUG_STATE("kdb_local 1", reason);
1127 if (reason == KDB_REASON_DEBUG) {
1128 /* special case below */
1130 kdb_printf("\nEntering kdb (current=0x%p, pid %d) ",
1131 kdb_current, kdb_current ? kdb_current->pid : 0);
1132 #if defined(CONFIG_SMP)
1133 kdb_printf("on processor %d ", raw_smp_processor_id());
1138 case KDB_REASON_DEBUG:
1141 * If re-entering kdb after a single step
1142 * command, don't print the message.
1144 switch (db_result) {
1146 kdb_printf("\nEntering kdb (0x%p, pid %d) ",
1147 kdb_current, kdb_current->pid);
1148 #if defined(CONFIG_SMP)
1149 kdb_printf("on processor %d ", raw_smp_processor_id());
1151 kdb_printf("due to Debug @ " kdb_machreg_fmt "\n",
1152 instruction_pointer(regs));
1156 * In the midst of ssb command. Just return.
1158 KDB_DEBUG_STATE("kdb_local 3", reason);
1159 return KDB_CMD_SSB; /* Continue with SSB command */
1165 KDB_DEBUG_STATE("kdb_local 4", reason);
1166 return 1; /* kdba_db_trap did the work */
1168 kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
1175 case KDB_REASON_ENTER:
1176 if (KDB_STATE(KEYBOARD))
1177 kdb_printf("due to Keyboard Entry\n");
1179 kdb_printf("due to KDB_ENTER()\n");
1181 case KDB_REASON_KEYBOARD:
1182 KDB_STATE_SET(KEYBOARD);
1183 kdb_printf("due to Keyboard Entry\n");
1185 case KDB_REASON_ENTER_SLAVE:
1186 /* drop through, slaves only get released via cpu switch */
1187 case KDB_REASON_SWITCH:
1188 kdb_printf("due to cpu switch\n");
1190 case KDB_REASON_OOPS:
1191 kdb_printf("Oops: %s\n", kdb_diemsg);
1192 kdb_printf("due to oops @ " kdb_machreg_fmt "\n",
1193 instruction_pointer(regs));
1196 case KDB_REASON_NMI:
1197 kdb_printf("due to NonMaskable Interrupt @ "
1198 kdb_machreg_fmt "\n",
1199 instruction_pointer(regs));
1202 case KDB_REASON_SSTEP:
1203 case KDB_REASON_BREAK:
1204 kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
1205 reason == KDB_REASON_BREAK ?
1206 "Breakpoint" : "SS trap", instruction_pointer(regs));
1208 * Determine if this breakpoint is one that we
1209 * are interested in.
1211 if (db_result != KDB_DB_BPT) {
1212 kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1214 KDB_DEBUG_STATE("kdb_local 6", reason);
1215 return 0; /* Not for us, dismiss it */
1218 case KDB_REASON_RECURSE:
1219 kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
1220 instruction_pointer(regs));
1223 kdb_printf("kdb: unexpected reason code: %d\n", reason);
1224 KDB_DEBUG_STATE("kdb_local 8", reason);
1225 return 0; /* Not for us, dismiss it */
1230 * Initialize pager context.
1233 KDB_STATE_CLEAR(SUPPRESS);
1237 *(cmd_hist[cmd_head]) = '\0';
1239 if (KDB_FLAG(ONLY_DO_DUMP)) {
1240 /* kdb is off but a catastrophic error requires a dump.
1241 * Take the dump and reboot.
1242 * Turn on logging so the kdb output appears in the log
1243 * buffer in the dump.
1245 const char *setargs[] = { "set", "LOGGING", "1" };
1246 kdb_set(2, setargs);
1247 kdb_reboot(0, NULL);
1252 #if defined(CONFIG_SMP)
1253 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
1254 raw_smp_processor_id());
1256 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"));
1258 if (defcmd_in_progress)
1259 strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
1262 * Fetch command from keyboard
1264 cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
1265 if (*cmdbuf != '\n') {
1267 if (cmdptr == cmd_head) {
1268 strncpy(cmd_hist[cmd_head], cmd_cur,
1270 *(cmd_hist[cmd_head] +
1271 strlen(cmd_hist[cmd_head])-1) = '\0';
1273 if (!handle_ctrl_cmd(cmdbuf))
1274 *(cmd_cur+strlen(cmd_cur)-1) = '\0';
1276 goto do_full_getstr;
1278 strncpy(cmd_hist[cmd_head], cmd_cur,
1282 cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
1283 if (cmd_head == cmd_tail)
1284 cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
1288 diag = kdb_parse(cmdbuf);
1289 if (diag == KDB_NOTFOUND) {
1290 kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
1293 if (diag == KDB_CMD_GO
1294 || diag == KDB_CMD_CPU
1295 || diag == KDB_CMD_SS
1296 || diag == KDB_CMD_SSB
1297 || diag == KDB_CMD_KGDB)
1303 KDB_DEBUG_STATE("kdb_local 9", diag);
1309 * kdb_print_state - Print the state data for the current processor
1312 * text Identifies the debug point
1313 * value Any integer value to be printed, e.g. reason code.
1315 void kdb_print_state(const char *text, int value)
1317 kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1318 text, raw_smp_processor_id(), value, kdb_initial_cpu,
1323 * kdb_main_loop - After initial setup and assignment of the
1324 * controlling cpu, all cpus are in this loop. One cpu is in
1325 * control and will issue the kdb prompt, the others will spin
1326 * until 'go' or cpu switch.
1328 * To get a consistent view of the kernel stacks for all
1329 * processes, this routine is invoked from the main kdb code via
1330 * an architecture specific routine. kdba_main_loop is
1331 * responsible for making the kernel stacks consistent for all
1332 * processes, there should be no difference between a blocked
1333 * process and a running process as far as kdb is concerned.
1335 * reason The reason KDB was invoked
1336 * error The hardware-defined error code
1337 * reason2 kdb's current reason code.
1338 * Initially error but can change
1339 * according to kdb state.
1340 * db_result Result code from break or debug point.
1341 * regs The exception frame at time of fault/breakpoint.
1342 * should always be valid.
1344 * 0 KDB was invoked for an event which it wasn't responsible
1345 * 1 KDB handled the event for which it was invoked.
1347 int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
1348 kdb_dbtrap_t db_result, struct pt_regs *regs)
1351 /* Stay in kdb() until 'go', 'ss[b]' or an error */
1354 * All processors except the one that is in control
1357 KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1358 while (KDB_STATE(HOLD_CPU)) {
1359 /* state KDB is turned off by kdb_cpu to see if the
1360 * other cpus are still live, each cpu in this loop
1363 if (!KDB_STATE(KDB))
1367 KDB_STATE_CLEAR(SUPPRESS);
1368 KDB_DEBUG_STATE("kdb_main_loop 2", reason);
1369 if (KDB_STATE(LEAVING))
1370 break; /* Another cpu said 'go' */
1371 /* Still using kdb, this processor is in control */
1372 result = kdb_local(reason2, error, regs, db_result);
1373 KDB_DEBUG_STATE("kdb_main_loop 3", result);
1375 if (result == KDB_CMD_CPU)
1378 if (result == KDB_CMD_SS) {
1379 KDB_STATE_SET(DOING_SS);
1383 if (result == KDB_CMD_SSB) {
1384 KDB_STATE_SET(DOING_SS);
1385 KDB_STATE_SET(DOING_SSB);
1389 if (result == KDB_CMD_KGDB) {
1390 if (!KDB_STATE(DOING_KGDB))
1391 kdb_printf("Entering please attach debugger "
1392 "or use $D#44+ or $3#33\n");
1395 if (result && result != 1 && result != KDB_CMD_GO)
1396 kdb_printf("\nUnexpected kdb_local return code %d\n",
1398 KDB_DEBUG_STATE("kdb_main_loop 4", reason);
1401 if (KDB_STATE(DOING_SS))
1402 KDB_STATE_CLEAR(SSBPT);
1404 /* Clean up any keyboard devices before leaving */
1405 kdb_kbd_cleanup_state();
1411 * kdb_mdr - This function implements the guts of the 'mdr', memory
1413 * mdr <addr arg>,<byte count>
1415 * addr Start address
1416 * count Number of bytes
1418 * Always 0. Any errors are detected and printed by kdb_getarea.
1420 static int kdb_mdr(unsigned long addr, unsigned int count)
1424 if (kdb_getarea(c, addr))
1426 kdb_printf("%02x", c);
1434 * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1435 * 'md8' 'mdr' and 'mds' commands.
1437 * md|mds [<addr arg> [<line count> [<radix>]]]
1438 * mdWcN [<addr arg> [<line count> [<radix>]]]
1439 * where W = is the width (1, 2, 4 or 8) and N is the count.
1440 * for eg., md1c20 reads 20 bytes, 1 at a time.
1441 * mdr <addr arg>,<byte count>
1443 static void kdb_md_line(const char *fmtstr, unsigned long addr,
1444 int symbolic, int nosect, int bytesperword,
1445 int num, int repeat, int phys)
1447 /* print just one line of data */
1448 kdb_symtab_t symtab;
1454 memset(cbuf, '\0', sizeof(cbuf));
1456 kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1458 kdb_printf(kdb_machreg_fmt0 " ", addr);
1460 for (i = 0; i < num && repeat--; i++) {
1462 if (kdb_getphysword(&word, addr, bytesperword))
1464 } else if (kdb_getword(&word, addr, bytesperword))
1466 kdb_printf(fmtstr, word);
1468 kdbnearsym(word, &symtab);
1470 memset(&symtab, 0, sizeof(symtab));
1471 if (symtab.sym_name) {
1472 kdb_symbol_print(word, &symtab, 0);
1475 kdb_printf(" %s %s "
1478 kdb_machreg_fmt, symtab.mod_name,
1479 symtab.sec_name, symtab.sec_start,
1480 symtab.sym_start, symtab.sym_end);
1482 addr += bytesperword;
1490 cp = wc.c + 8 - bytesperword;
1495 #define printable_char(c) \
1496 ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1497 switch (bytesperword) {
1499 *c++ = printable_char(*cp++);
1500 *c++ = printable_char(*cp++);
1501 *c++ = printable_char(*cp++);
1502 *c++ = printable_char(*cp++);
1505 *c++ = printable_char(*cp++);
1506 *c++ = printable_char(*cp++);
1509 *c++ = printable_char(*cp++);
1512 *c++ = printable_char(*cp++);
1516 #undef printable_char
1519 kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1523 static int kdb_md(int argc, const char **argv)
1525 static unsigned long last_addr;
1526 static int last_radix, last_bytesperword, last_repeat;
1527 int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1529 char fmtchar, fmtstr[64];
1537 kdbgetintenv("MDCOUNT", &mdcount);
1538 kdbgetintenv("RADIX", &radix);
1539 kdbgetintenv("BYTESPERWORD", &bytesperword);
1541 /* Assume 'md <addr>' and start with environment values */
1542 repeat = mdcount * 16 / bytesperword;
1544 if (strcmp(argv[0], "mdr") == 0) {
1546 return KDB_ARGCOUNT;
1548 } else if (isdigit(argv[0][2])) {
1549 bytesperword = (int)(argv[0][2] - '0');
1550 if (bytesperword == 0) {
1551 bytesperword = last_bytesperword;
1552 if (bytesperword == 0)
1555 last_bytesperword = bytesperword;
1556 repeat = mdcount * 16 / bytesperword;
1559 else if (argv[0][3] == 'c' && argv[0][4]) {
1561 repeat = simple_strtoul(argv[0] + 4, &p, 10);
1562 mdcount = ((repeat * bytesperword) + 15) / 16;
1565 last_repeat = repeat;
1566 } else if (strcmp(argv[0], "md") == 0)
1568 else if (strcmp(argv[0], "mds") == 0)
1570 else if (strcmp(argv[0], "mdp") == 0) {
1574 return KDB_NOTFOUND;
1578 return KDB_ARGCOUNT;
1581 bytesperword = last_bytesperword;
1582 repeat = last_repeat;
1583 mdcount = ((repeat * bytesperword) + 15) / 16;
1588 int diag, nextarg = 1;
1589 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1593 if (argc > nextarg+2)
1594 return KDB_ARGCOUNT;
1596 if (argc >= nextarg) {
1597 diag = kdbgetularg(argv[nextarg], &val);
1599 mdcount = (int) val;
1600 repeat = mdcount * 16 / bytesperword;
1603 if (argc >= nextarg+1) {
1604 diag = kdbgetularg(argv[nextarg+1], &val);
1610 if (strcmp(argv[0], "mdr") == 0)
1611 return kdb_mdr(addr, mdcount);
1624 return KDB_BADRADIX;
1629 if (bytesperword > KDB_WORD_SIZE)
1630 return KDB_BADWIDTH;
1632 switch (bytesperword) {
1634 sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1637 sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1640 sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1643 sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1646 return KDB_BADWIDTH;
1649 last_repeat = repeat;
1650 last_bytesperword = bytesperword;
1652 if (strcmp(argv[0], "mds") == 0) {
1654 /* Do not save these changes as last_*, they are temporary mds
1657 bytesperword = KDB_WORD_SIZE;
1659 kdbgetintenv("NOSECT", &nosect);
1662 /* Round address down modulo BYTESPERWORD */
1664 addr &= ~(bytesperword-1);
1666 while (repeat > 0) {
1668 int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1670 if (KDB_FLAG(CMD_INTERRUPT))
1672 for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1674 if (kdb_getphysword(&word, a, bytesperword)
1677 } else if (kdb_getword(&word, a, bytesperword) || word)
1680 n = min(num, repeat);
1681 kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1683 addr += bytesperword * n;
1685 z = (z + num - 1) / num;
1687 int s = num * (z-2);
1688 kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1689 " zero suppressed\n",
1690 addr, addr + bytesperword * s - 1);
1691 addr += bytesperword * s;
1701 * kdb_mm - This function implements the 'mm' command.
1702 * mm address-expression new-value
1704 * mm works on machine words, mmW works on bytes.
1706 static int kdb_mm(int argc, const char **argv)
1711 unsigned long contents;
1715 if (argv[0][2] && !isdigit(argv[0][2]))
1716 return KDB_NOTFOUND;
1719 return KDB_ARGCOUNT;
1722 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1727 return KDB_ARGCOUNT;
1728 diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1732 if (nextarg != argc + 1)
1733 return KDB_ARGCOUNT;
1735 width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1736 diag = kdb_putword(addr, contents, width);
1740 kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1746 * kdb_go - This function implements the 'go' command.
1747 * go [address-expression]
1749 static int kdb_go(int argc, const char **argv)
1756 if (raw_smp_processor_id() != kdb_initial_cpu) {
1757 kdb_printf("go must execute on the entry cpu, "
1758 "please use \"cpu %d\" and then execute go\n",
1760 return KDB_BADCPUNUM;
1764 diag = kdbgetaddrarg(argc, argv, &nextarg,
1765 &addr, &offset, NULL);
1769 return KDB_ARGCOUNT;
1773 if (KDB_FLAG(CATASTROPHIC)) {
1774 kdb_printf("Catastrophic error detected\n");
1775 kdb_printf("kdb_continue_catastrophic=%d, ",
1776 kdb_continue_catastrophic);
1777 if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1778 kdb_printf("type go a second time if you really want "
1782 if (kdb_continue_catastrophic == 2) {
1783 kdb_printf("forcing reboot\n");
1784 kdb_reboot(0, NULL);
1786 kdb_printf("attempting to continue\n");
1792 * kdb_rd - This function implements the 'rd' command.
1794 static int kdb_rd(int argc, const char **argv)
1796 int len = kdb_check_regs();
1797 #if DBG_MAX_REG_NUM > 0
1809 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1810 rsize = dbg_reg_def[i].size * 2;
1813 if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
1818 len += kdb_printf(" ");
1819 switch(dbg_reg_def[i].size * 8) {
1821 rname = dbg_get_reg(i, ®8, kdb_current_regs);
1824 len += kdb_printf("%s: %02x", rname, reg8);
1827 rname = dbg_get_reg(i, ®16, kdb_current_regs);
1830 len += kdb_printf("%s: %04x", rname, reg16);
1833 rname = dbg_get_reg(i, ®32, kdb_current_regs);
1836 len += kdb_printf("%s: %08x", rname, reg32);
1839 rname = dbg_get_reg(i, ®64, kdb_current_regs);
1842 len += kdb_printf("%s: %016llx", rname, reg64);
1845 len += kdb_printf("%s: ??", dbg_reg_def[i].name);
1853 kdb_dumpregs(kdb_current_regs);
1859 * kdb_rm - This function implements the 'rm' (register modify) command.
1860 * rm register-name new-contents
1862 * Allows register modification with the same restrictions as gdb
1864 static int kdb_rm(int argc, const char **argv)
1866 #if DBG_MAX_REG_NUM > 0
1876 return KDB_ARGCOUNT;
1878 * Allow presence or absence of leading '%' symbol.
1884 diag = kdbgetu64arg(argv[2], ®64);
1888 diag = kdb_check_regs();
1893 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1894 if (strcmp(rname, dbg_reg_def[i].name) == 0) {
1900 switch(dbg_reg_def[i].size * 8) {
1903 dbg_set_reg(i, ®8, kdb_current_regs);
1907 dbg_set_reg(i, ®16, kdb_current_regs);
1911 dbg_set_reg(i, ®32, kdb_current_regs);
1914 dbg_set_reg(i, ®64, kdb_current_regs);
1920 kdb_printf("ERROR: Register set currently not implemented\n");
1925 #if defined(CONFIG_MAGIC_SYSRQ)
1927 * kdb_sr - This function implements the 'sr' (SYSRQ key) command
1928 * which interfaces to the soi-disant MAGIC SYSRQ functionality.
1929 * sr <magic-sysrq-code>
1931 static int kdb_sr(int argc, const char **argv)
1934 return KDB_ARGCOUNT;
1936 __handle_sysrq(*argv[1], false);
1941 #endif /* CONFIG_MAGIC_SYSRQ */
1944 * kdb_ef - This function implements the 'regs' (display exception
1945 * frame) command. This command takes an address and expects to
1946 * find an exception frame at that address, formats and prints
1948 * regs address-expression
1952 static int kdb_ef(int argc, const char **argv)
1960 return KDB_ARGCOUNT;
1963 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1966 show_regs((struct pt_regs *)addr);
1970 #if defined(CONFIG_MODULES)
1972 * kdb_lsmod - This function implements the 'lsmod' command. Lists
1973 * currently loaded kernel modules.
1974 * Mostly taken from userland lsmod.
1976 static int kdb_lsmod(int argc, const char **argv)
1981 return KDB_ARGCOUNT;
1983 kdb_printf("Module Size modstruct Used by\n");
1984 list_for_each_entry(mod, kdb_modules, list) {
1986 kdb_printf("%-20s%8u 0x%p ", mod->name,
1987 mod->core_size, (void *)mod);
1988 #ifdef CONFIG_MODULE_UNLOAD
1989 kdb_printf("%4ld ", module_refcount(mod));
1991 if (mod->state == MODULE_STATE_GOING)
1992 kdb_printf(" (Unloading)");
1993 else if (mod->state == MODULE_STATE_COMING)
1994 kdb_printf(" (Loading)");
1996 kdb_printf(" (Live)");
1997 kdb_printf(" 0x%p", mod->module_core);
1999 #ifdef CONFIG_MODULE_UNLOAD
2001 struct module_use *use;
2003 list_for_each_entry(use, &mod->source_list,
2005 kdb_printf("%s ", use->target->name);
2014 #endif /* CONFIG_MODULES */
2017 * kdb_env - This function implements the 'env' command. Display the
2018 * current environment variables.
2021 static int kdb_env(int argc, const char **argv)
2025 for (i = 0; i < __nenv; i++) {
2027 kdb_printf("%s\n", __env[i]);
2030 if (KDB_DEBUG(MASK))
2031 kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
2036 #ifdef CONFIG_PRINTK
2038 * kdb_dmesg - This function implements the 'dmesg' command to display
2039 * the contents of the syslog buffer.
2040 * dmesg [lines] [adjust]
2042 static int kdb_dmesg(int argc, const char **argv)
2050 struct kmsg_dumper dumper = { .active = 1 };
2055 return KDB_ARGCOUNT;
2058 lines = simple_strtol(argv[1], &cp, 0);
2062 adjust = simple_strtoul(argv[2], &cp, 0);
2063 if (*cp || adjust < 0)
2068 /* disable LOGGING if set */
2069 diag = kdbgetintenv("LOGGING", &logging);
2070 if (!diag && logging) {
2071 const char *setargs[] = { "set", "LOGGING", "0" };
2072 kdb_set(2, setargs);
2075 kmsg_dump_rewind(&dumper);
2076 while (kmsg_dump_get_line(&dumper, 1, NULL, 0, NULL))
2081 kdb_printf("buffer only contains %d lines, nothing "
2083 else if (adjust - lines >= n)
2084 kdb_printf("buffer only contains %d lines, last %d "
2085 "lines printed\n", n, n - adjust);
2088 } else if (lines > 0) {
2089 skip = n - lines - adjust;
2092 kdb_printf("buffer only contains %d lines, "
2093 "nothing printed\n", n);
2095 } else if (skip < 0) {
2098 kdb_printf("buffer only contains %d lines, first "
2099 "%d lines printed\n", n, lines);
2105 if (skip >= n || skip < 0)
2108 kmsg_dump_rewind(&dumper);
2109 while (kmsg_dump_get_line(&dumper, 1, buf, sizeof(buf), &len)) {
2117 kdb_printf("%.*s\n", (int)len - 1, buf);
2122 #endif /* CONFIG_PRINTK */
2124 * kdb_cpu - This function implements the 'cpu' command.
2127 * KDB_CMD_CPU for success, a kdb diagnostic if error
2129 static void kdb_cpu_status(void)
2131 int i, start_cpu, first_print = 1;
2132 char state, prev_state = '?';
2134 kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2135 kdb_printf("Available cpus: ");
2136 for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2137 if (!cpu_online(i)) {
2138 state = 'F'; /* cpu is offline */
2140 state = ' '; /* cpu is responding to kdb */
2141 if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2142 state = 'I'; /* idle task */
2144 if (state != prev_state) {
2145 if (prev_state != '?') {
2149 kdb_printf("%d", start_cpu);
2150 if (start_cpu < i-1)
2151 kdb_printf("-%d", i-1);
2152 if (prev_state != ' ')
2153 kdb_printf("(%c)", prev_state);
2159 /* print the trailing cpus, ignoring them if they are all offline */
2160 if (prev_state != 'F') {
2163 kdb_printf("%d", start_cpu);
2164 if (start_cpu < i-1)
2165 kdb_printf("-%d", i-1);
2166 if (prev_state != ' ')
2167 kdb_printf("(%c)", prev_state);
2172 static int kdb_cpu(int argc, const char **argv)
2174 unsigned long cpunum;
2183 return KDB_ARGCOUNT;
2185 diag = kdbgetularg(argv[1], &cpunum);
2192 if ((cpunum > NR_CPUS) || !cpu_online(cpunum))
2193 return KDB_BADCPUNUM;
2195 dbg_switch_cpu = cpunum;
2198 * Switch to other cpu
2203 /* The user may not realize that ps/bta with no parameters does not print idle
2204 * or sleeping system daemon processes, so tell them how many were suppressed.
2206 void kdb_ps_suppressed(void)
2208 int idle = 0, daemon = 0;
2209 unsigned long mask_I = kdb_task_state_string("I"),
2210 mask_M = kdb_task_state_string("M");
2212 const struct task_struct *p, *g;
2213 for_each_online_cpu(cpu) {
2214 p = kdb_curr_task(cpu);
2215 if (kdb_task_state(p, mask_I))
2218 kdb_do_each_thread(g, p) {
2219 if (kdb_task_state(p, mask_M))
2221 } kdb_while_each_thread(g, p);
2222 if (idle || daemon) {
2224 kdb_printf("%d idle process%s (state I)%s\n",
2225 idle, idle == 1 ? "" : "es",
2226 daemon ? " and " : "");
2228 kdb_printf("%d sleeping system daemon (state M) "
2229 "process%s", daemon,
2230 daemon == 1 ? "" : "es");
2231 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2236 * kdb_ps - This function implements the 'ps' command which shows a
2237 * list of the active processes.
2238 * ps [DRSTCZEUIMA] All processes, optionally filtered by state
2240 void kdb_ps1(const struct task_struct *p)
2245 if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
2248 cpu = kdb_process_cpu(p);
2249 kdb_printf("0x%p %8d %8d %d %4d %c 0x%p %c%s\n",
2250 (void *)p, p->pid, p->parent->pid,
2251 kdb_task_has_cpu(p), kdb_process_cpu(p),
2252 kdb_task_state_char(p),
2253 (void *)(&p->thread),
2254 p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2256 if (kdb_task_has_cpu(p)) {
2257 if (!KDB_TSK(cpu)) {
2258 kdb_printf(" Error: no saved data for this cpu\n");
2260 if (KDB_TSK(cpu) != p)
2261 kdb_printf(" Error: does not match running "
2262 "process table (0x%p)\n", KDB_TSK(cpu));
2267 static int kdb_ps(int argc, const char **argv)
2269 struct task_struct *g, *p;
2270 unsigned long mask, cpu;
2273 kdb_ps_suppressed();
2274 kdb_printf("%-*s Pid Parent [*] cpu State %-*s Command\n",
2275 (int)(2*sizeof(void *))+2, "Task Addr",
2276 (int)(2*sizeof(void *))+2, "Thread");
2277 mask = kdb_task_state_string(argc ? argv[1] : NULL);
2278 /* Run the active tasks first */
2279 for_each_online_cpu(cpu) {
2280 if (KDB_FLAG(CMD_INTERRUPT))
2282 p = kdb_curr_task(cpu);
2283 if (kdb_task_state(p, mask))
2287 /* Now the real tasks */
2288 kdb_do_each_thread(g, p) {
2289 if (KDB_FLAG(CMD_INTERRUPT))
2291 if (kdb_task_state(p, mask))
2293 } kdb_while_each_thread(g, p);
2299 * kdb_pid - This function implements the 'pid' command which switches
2300 * the currently active process.
2303 static int kdb_pid(int argc, const char **argv)
2305 struct task_struct *p;
2310 return KDB_ARGCOUNT;
2313 if (strcmp(argv[1], "R") == 0) {
2314 p = KDB_TSK(kdb_initial_cpu);
2316 diag = kdbgetularg(argv[1], &val);
2320 p = find_task_by_pid_ns((pid_t)val, &init_pid_ns);
2322 kdb_printf("No task with pid=%d\n", (pid_t)val);
2326 kdb_set_current_task(p);
2328 kdb_printf("KDB current process is %s(pid=%d)\n",
2329 kdb_current_task->comm,
2330 kdb_current_task->pid);
2336 * kdb_ll - This function implements the 'll' command which follows a
2337 * linked list and executes an arbitrary command for each
2340 static int kdb_ll(int argc, const char **argv)
2346 unsigned long linkoffset;
2348 const char *command;
2351 return KDB_ARGCOUNT;
2354 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
2358 diag = kdbgetularg(argv[2], &linkoffset);
2363 * Using the starting address as
2364 * the first element in the list, and assuming that
2365 * the list ends with a null pointer.
2369 command = kdb_strdup(argv[3], GFP_KDB);
2371 kdb_printf("%s: cannot duplicate command\n", __func__);
2374 /* Recursive use of kdb_parse, do not use argv after this point */
2380 if (KDB_FLAG(CMD_INTERRUPT))
2383 sprintf(buf, "%s " kdb_machreg_fmt "\n", command, va);
2384 diag = kdb_parse(buf);
2388 addr = va + linkoffset;
2389 if (kdb_getword(&va, addr, sizeof(va)))
2398 static int kdb_kgdb(int argc, const char **argv)
2400 return KDB_CMD_KGDB;
2404 * kdb_help - This function implements the 'help' and '?' commands.
2406 static int kdb_help(int argc, const char **argv)
2411 kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2412 kdb_printf("-----------------------------"
2413 "-----------------------------\n");
2414 for_each_kdbcmd(kt, i) {
2416 kdb_printf("%-15.15s %-20.20s %s\n", kt->cmd_name,
2417 kt->cmd_usage, kt->cmd_help);
2418 if (KDB_FLAG(CMD_INTERRUPT))
2425 * kdb_kill - This function implements the 'kill' commands.
2427 static int kdb_kill(int argc, const char **argv)
2431 struct task_struct *p;
2432 struct siginfo info;
2435 return KDB_ARGCOUNT;
2437 sig = simple_strtol(argv[1], &endp, 0);
2441 kdb_printf("Invalid signal parameter.<-signal>\n");
2446 pid = simple_strtol(argv[2], &endp, 0);
2450 kdb_printf("Process ID must be large than 0.\n");
2454 /* Find the process. */
2455 p = find_task_by_pid_ns(pid, &init_pid_ns);
2457 kdb_printf("The specified process isn't found.\n");
2460 p = p->group_leader;
2461 info.si_signo = sig;
2463 info.si_code = SI_USER;
2464 info.si_pid = pid; /* same capabilities as process being signalled */
2465 info.si_uid = 0; /* kdb has root authority */
2466 kdb_send_sig_info(p, &info);
2471 int tm_sec; /* seconds */
2472 int tm_min; /* minutes */
2473 int tm_hour; /* hours */
2474 int tm_mday; /* day of the month */
2475 int tm_mon; /* month */
2476 int tm_year; /* year */
2479 static void kdb_gmtime(struct timespec *tv, struct kdb_tm *tm)
2481 /* This will work from 1970-2099, 2100 is not a leap year */
2482 static int mon_day[] = { 31, 29, 31, 30, 31, 30, 31,
2483 31, 30, 31, 30, 31 };
2484 memset(tm, 0, sizeof(*tm));
2485 tm->tm_sec = tv->tv_sec % (24 * 60 * 60);
2486 tm->tm_mday = tv->tv_sec / (24 * 60 * 60) +
2487 (2 * 365 + 1); /* shift base from 1970 to 1968 */
2488 tm->tm_min = tm->tm_sec / 60 % 60;
2489 tm->tm_hour = tm->tm_sec / 60 / 60;
2490 tm->tm_sec = tm->tm_sec % 60;
2491 tm->tm_year = 68 + 4*(tm->tm_mday / (4*365+1));
2492 tm->tm_mday %= (4*365+1);
2494 while (tm->tm_mday >= mon_day[tm->tm_mon]) {
2495 tm->tm_mday -= mon_day[tm->tm_mon];
2496 if (++tm->tm_mon == 12) {
2506 * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2507 * I cannot call that code directly from kdb, it has an unconditional
2508 * cli()/sti() and calls routines that take locks which can stop the debugger.
2510 static void kdb_sysinfo(struct sysinfo *val)
2512 struct timespec uptime;
2513 do_posix_clock_monotonic_gettime(&uptime);
2514 memset(val, 0, sizeof(*val));
2515 val->uptime = uptime.tv_sec;
2516 val->loads[0] = avenrun[0];
2517 val->loads[1] = avenrun[1];
2518 val->loads[2] = avenrun[2];
2519 val->procs = nr_threads-1;
2526 * kdb_summary - This function implements the 'summary' command.
2528 static int kdb_summary(int argc, const char **argv)
2530 struct timespec now;
2535 return KDB_ARGCOUNT;
2537 kdb_printf("sysname %s\n", init_uts_ns.name.sysname);
2538 kdb_printf("release %s\n", init_uts_ns.name.release);
2539 kdb_printf("version %s\n", init_uts_ns.name.version);
2540 kdb_printf("machine %s\n", init_uts_ns.name.machine);
2541 kdb_printf("nodename %s\n", init_uts_ns.name.nodename);
2542 kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2543 kdb_printf("ccversion %s\n", __stringify(CCVERSION));
2545 now = __current_kernel_time();
2546 kdb_gmtime(&now, &tm);
2547 kdb_printf("date %04d-%02d-%02d %02d:%02d:%02d "
2548 "tz_minuteswest %d\n",
2549 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2550 tm.tm_hour, tm.tm_min, tm.tm_sec,
2551 sys_tz.tz_minuteswest);
2554 kdb_printf("uptime ");
2555 if (val.uptime > (24*60*60)) {
2556 int days = val.uptime / (24*60*60);
2557 val.uptime %= (24*60*60);
2558 kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2560 kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2562 /* lifted from fs/proc/proc_misc.c::loadavg_read_proc() */
2564 #define LOAD_INT(x) ((x) >> FSHIFT)
2565 #define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
2566 kdb_printf("load avg %ld.%02ld %ld.%02ld %ld.%02ld\n",
2567 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2568 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2569 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2572 /* Display in kilobytes */
2573 #define K(x) ((x) << (PAGE_SHIFT - 10))
2574 kdb_printf("\nMemTotal: %8lu kB\nMemFree: %8lu kB\n"
2575 "Buffers: %8lu kB\n",
2576 val.totalram, val.freeram, val.bufferram);
2581 * kdb_per_cpu - This function implements the 'per_cpu' command.
2583 static int kdb_per_cpu(int argc, const char **argv)
2586 int cpu, diag, nextarg = 1;
2587 unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2589 if (argc < 1 || argc > 3)
2590 return KDB_ARGCOUNT;
2592 diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2597 diag = kdbgetularg(argv[2], &bytesperword);
2602 bytesperword = KDB_WORD_SIZE;
2603 else if (bytesperword > KDB_WORD_SIZE)
2604 return KDB_BADWIDTH;
2605 sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2607 diag = kdbgetularg(argv[3], &whichcpu);
2610 if (!cpu_online(whichcpu)) {
2611 kdb_printf("cpu %ld is not online\n", whichcpu);
2612 return KDB_BADCPUNUM;
2616 /* Most architectures use __per_cpu_offset[cpu], some use
2617 * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2619 #ifdef __per_cpu_offset
2620 #define KDB_PCU(cpu) __per_cpu_offset(cpu)
2623 #define KDB_PCU(cpu) __per_cpu_offset[cpu]
2625 #define KDB_PCU(cpu) 0
2628 for_each_online_cpu(cpu) {
2629 if (KDB_FLAG(CMD_INTERRUPT))
2632 if (whichcpu != ~0UL && whichcpu != cpu)
2634 addr = symaddr + KDB_PCU(cpu);
2635 diag = kdb_getword(&val, addr, bytesperword);
2637 kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2638 "read, diag=%d\n", cpu, addr, diag);
2641 kdb_printf("%5d ", cpu);
2642 kdb_md_line(fmtstr, addr,
2643 bytesperword == KDB_WORD_SIZE,
2644 1, bytesperword, 1, 1, 0);
2651 * display help for the use of cmd | grep pattern
2653 static int kdb_grep_help(int argc, const char **argv)
2655 kdb_printf("Usage of cmd args | grep pattern:\n");
2656 kdb_printf(" Any command's output may be filtered through an ");
2657 kdb_printf("emulated 'pipe'.\n");
2658 kdb_printf(" 'grep' is just a key word.\n");
2659 kdb_printf(" The pattern may include a very limited set of "
2660 "metacharacters:\n");
2661 kdb_printf(" pattern or ^pattern or pattern$ or ^pattern$\n");
2662 kdb_printf(" And if there are spaces in the pattern, you may "
2664 kdb_printf(" \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2665 " or \"^pat tern$\"\n");
2670 * kdb_register_repeat - This function is used to register a kernel
2674 * func Function to execute the command
2675 * usage A simple usage string showing arguments
2676 * help A simple help string describing command
2677 * repeat Does the command auto repeat on enter?
2679 * zero for success, one if a duplicate command.
2681 #define kdb_command_extend 50 /* arbitrary */
2682 int kdb_register_repeat(char *cmd,
2687 kdb_repeat_t repeat)
2693 * Brute force method to determine duplicates
2695 for_each_kdbcmd(kp, i) {
2696 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2697 kdb_printf("Duplicate kdb command registered: "
2698 "%s, func %p help %s\n", cmd, func, help);
2704 * Insert command into first available location in table
2706 for_each_kdbcmd(kp, i) {
2707 if (kp->cmd_name == NULL)
2711 if (i >= kdb_max_commands) {
2712 kdbtab_t *new = kmalloc((kdb_max_commands - KDB_BASE_CMD_MAX +
2713 kdb_command_extend) * sizeof(*new), GFP_KDB);
2715 kdb_printf("Could not allocate new kdb_command "
2720 memcpy(new, kdb_commands,
2721 (kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new));
2722 kfree(kdb_commands);
2724 memset(new + kdb_max_commands, 0,
2725 kdb_command_extend * sizeof(*new));
2727 kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX;
2728 kdb_max_commands += kdb_command_extend;
2732 kp->cmd_func = func;
2733 kp->cmd_usage = usage;
2734 kp->cmd_help = help;
2736 kp->cmd_minlen = minlen;
2737 kp->cmd_repeat = repeat;
2741 EXPORT_SYMBOL_GPL(kdb_register_repeat);
2745 * kdb_register - Compatibility register function for commands that do
2746 * not need to specify a repeat state. Equivalent to
2747 * kdb_register_repeat with KDB_REPEAT_NONE.
2750 * func Function to execute the command
2751 * usage A simple usage string showing arguments
2752 * help A simple help string describing command
2754 * zero for success, one if a duplicate command.
2756 int kdb_register(char *cmd,
2762 return kdb_register_repeat(cmd, func, usage, help, minlen,
2765 EXPORT_SYMBOL_GPL(kdb_register);
2768 * kdb_unregister - This function is used to unregister a kernel
2769 * debugger command. It is generally called when a module which
2770 * implements kdb commands is unloaded.
2774 * zero for success, one command not registered.
2776 int kdb_unregister(char *cmd)
2784 for_each_kdbcmd(kp, i) {
2785 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2786 kp->cmd_name = NULL;
2791 /* Couldn't find it. */
2794 EXPORT_SYMBOL_GPL(kdb_unregister);
2796 /* Initialize the kdb command table. */
2797 static void __init kdb_inittab(void)
2802 for_each_kdbcmd(kp, i)
2803 kp->cmd_name = NULL;
2805 kdb_register_repeat("md", kdb_md, "<vaddr>",
2806 "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2807 KDB_REPEAT_NO_ARGS);
2808 kdb_register_repeat("mdr", kdb_md, "<vaddr> <bytes>",
2809 "Display Raw Memory", 0, KDB_REPEAT_NO_ARGS);
2810 kdb_register_repeat("mdp", kdb_md, "<paddr> <bytes>",
2811 "Display Physical Memory", 0, KDB_REPEAT_NO_ARGS);
2812 kdb_register_repeat("mds", kdb_md, "<vaddr>",
2813 "Display Memory Symbolically", 0, KDB_REPEAT_NO_ARGS);
2814 kdb_register_repeat("mm", kdb_mm, "<vaddr> <contents>",
2815 "Modify Memory Contents", 0, KDB_REPEAT_NO_ARGS);
2816 kdb_register_repeat("go", kdb_go, "[<vaddr>]",
2817 "Continue Execution", 1, KDB_REPEAT_NONE);
2818 kdb_register_repeat("rd", kdb_rd, "",
2819 "Display Registers", 0, KDB_REPEAT_NONE);
2820 kdb_register_repeat("rm", kdb_rm, "<reg> <contents>",
2821 "Modify Registers", 0, KDB_REPEAT_NONE);
2822 kdb_register_repeat("ef", kdb_ef, "<vaddr>",
2823 "Display exception frame", 0, KDB_REPEAT_NONE);
2824 kdb_register_repeat("bt", kdb_bt, "[<vaddr>]",
2825 "Stack traceback", 1, KDB_REPEAT_NONE);
2826 kdb_register_repeat("btp", kdb_bt, "<pid>",
2827 "Display stack for process <pid>", 0, KDB_REPEAT_NONE);
2828 kdb_register_repeat("bta", kdb_bt, "[DRSTCZEUIMA]",
2829 "Display stack all processes", 0, KDB_REPEAT_NONE);
2830 kdb_register_repeat("btc", kdb_bt, "",
2831 "Backtrace current process on each cpu", 0, KDB_REPEAT_NONE);
2832 kdb_register_repeat("btt", kdb_bt, "<vaddr>",
2833 "Backtrace process given its struct task address", 0,
2835 kdb_register_repeat("ll", kdb_ll, "<first-element> <linkoffset> <cmd>",
2836 "Execute cmd for each element in linked list", 0, KDB_REPEAT_NONE);
2837 kdb_register_repeat("env", kdb_env, "",
2838 "Show environment variables", 0, KDB_REPEAT_NONE);
2839 kdb_register_repeat("set", kdb_set, "",
2840 "Set environment variables", 0, KDB_REPEAT_NONE);
2841 kdb_register_repeat("help", kdb_help, "",
2842 "Display Help Message", 1, KDB_REPEAT_NONE);
2843 kdb_register_repeat("?", kdb_help, "",
2844 "Display Help Message", 0, KDB_REPEAT_NONE);
2845 kdb_register_repeat("cpu", kdb_cpu, "<cpunum>",
2846 "Switch to new cpu", 0, KDB_REPEAT_NONE);
2847 kdb_register_repeat("kgdb", kdb_kgdb, "",
2848 "Enter kgdb mode", 0, KDB_REPEAT_NONE);
2849 kdb_register_repeat("ps", kdb_ps, "[<flags>|A]",
2850 "Display active task list", 0, KDB_REPEAT_NONE);
2851 kdb_register_repeat("pid", kdb_pid, "<pidnum>",
2852 "Switch to another task", 0, KDB_REPEAT_NONE);
2853 kdb_register_repeat("reboot", kdb_reboot, "",
2854 "Reboot the machine immediately", 0, KDB_REPEAT_NONE);
2855 #if defined(CONFIG_MODULES)
2856 kdb_register_repeat("lsmod", kdb_lsmod, "",
2857 "List loaded kernel modules", 0, KDB_REPEAT_NONE);
2859 #if defined(CONFIG_MAGIC_SYSRQ)
2860 kdb_register_repeat("sr", kdb_sr, "<key>",
2861 "Magic SysRq key", 0, KDB_REPEAT_NONE);
2863 #if defined(CONFIG_PRINTK)
2864 kdb_register_repeat("dmesg", kdb_dmesg, "[lines]",
2865 "Display syslog buffer", 0, KDB_REPEAT_NONE);
2867 kdb_register_repeat("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
2868 "Define a set of commands, down to endefcmd", 0, KDB_REPEAT_NONE);
2869 kdb_register_repeat("kill", kdb_kill, "<-signal> <pid>",
2870 "Send a signal to a process", 0, KDB_REPEAT_NONE);
2871 kdb_register_repeat("summary", kdb_summary, "",
2872 "Summarize the system", 4, KDB_REPEAT_NONE);
2873 kdb_register_repeat("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
2874 "Display per_cpu variables", 3, KDB_REPEAT_NONE);
2875 kdb_register_repeat("grephelp", kdb_grep_help, "",
2876 "Display help on | grep", 0, KDB_REPEAT_NONE);
2879 /* Execute any commands defined in kdb_cmds. */
2880 static void __init kdb_cmd_init(void)
2883 for (i = 0; kdb_cmds[i]; ++i) {
2884 diag = kdb_parse(kdb_cmds[i]);
2886 kdb_printf("kdb command %s failed, kdb diag %d\n",
2889 if (defcmd_in_progress) {
2890 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2891 kdb_parse("endefcmd");
2895 /* Initialize kdb_printf, breakpoint tables and kdb state */
2896 void __init kdb_init(int lvl)
2898 static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2901 if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2903 for (i = kdb_init_lvl; i < lvl; i++) {
2905 case KDB_NOT_INITIALIZED:
2906 kdb_inittab(); /* Initialize Command Table */
2907 kdb_initbptab(); /* Initialize Breakpoints */
2909 case KDB_INIT_EARLY:
2910 kdb_cmd_init(); /* Build kdb_cmds tables */