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/atomic.h>
25 #include <linux/module.h>
27 #include <linux/init.h>
28 #include <linux/kallsyms.h>
29 #include <linux/kgdb.h>
30 #include <linux/kdb.h>
31 #include <linux/notifier.h>
32 #include <linux/interrupt.h>
33 #include <linux/delay.h>
34 #include <linux/nmi.h>
35 #include <linux/time.h>
36 #include <linux/ptrace.h>
37 #include <linux/sysctl.h>
38 #include <linux/cpu.h>
39 #include <linux/kdebug.h>
40 #include <linux/proc_fs.h>
41 #include <linux/uaccess.h>
42 #include <linux/slab.h>
43 #include "kdb_private.h"
46 char kdb_grep_string[GREP_LEN];
47 int kdb_grepping_flag;
48 EXPORT_SYMBOL(kdb_grepping_flag);
50 int kdb_grep_trailing;
53 * Kernel debugger state flags
59 * kdb_lock protects updates to kdb_initial_cpu. Used to
60 * single thread processors through the kernel debugger.
62 int kdb_initial_cpu = -1; /* cpu number that owns kdb */
64 int kdb_state; /* General KDB state */
66 struct task_struct *kdb_current_task;
67 EXPORT_SYMBOL(kdb_current_task);
68 struct pt_regs *kdb_current_regs;
70 const char *kdb_diemsg;
71 static int kdb_go_count;
72 #ifdef CONFIG_KDB_CONTINUE_CATASTROPHIC
73 static unsigned int kdb_continue_catastrophic =
74 CONFIG_KDB_CONTINUE_CATASTROPHIC;
76 static unsigned int kdb_continue_catastrophic;
79 /* kdb_commands describes the available commands. */
80 static kdbtab_t *kdb_commands;
81 #define KDB_BASE_CMD_MAX 50
82 static int kdb_max_commands = KDB_BASE_CMD_MAX;
83 static kdbtab_t kdb_base_commands[KDB_BASE_CMD_MAX];
84 #define for_each_kdbcmd(cmd, num) \
85 for ((cmd) = kdb_base_commands, (num) = 0; \
86 num < kdb_max_commands; \
87 num++, num == KDB_BASE_CMD_MAX ? cmd = kdb_commands : cmd++)
89 typedef struct _kdbmsg {
90 int km_diag; /* kdb diagnostic */
91 char *km_msg; /* Corresponding message text */
94 #define KDBMSG(msgnum, text) \
95 { KDB_##msgnum, text }
97 static kdbmsg_t kdbmsgs[] = {
98 KDBMSG(NOTFOUND, "Command Not Found"),
99 KDBMSG(ARGCOUNT, "Improper argument count, see usage."),
100 KDBMSG(BADWIDTH, "Illegal value for BYTESPERWORD use 1, 2, 4 or 8, "
101 "8 is only allowed on 64 bit systems"),
102 KDBMSG(BADRADIX, "Illegal value for RADIX use 8, 10 or 16"),
103 KDBMSG(NOTENV, "Cannot find environment variable"),
104 KDBMSG(NOENVVALUE, "Environment variable should have value"),
105 KDBMSG(NOTIMP, "Command not implemented"),
106 KDBMSG(ENVFULL, "Environment full"),
107 KDBMSG(ENVBUFFULL, "Environment buffer full"),
108 KDBMSG(TOOMANYBPT, "Too many breakpoints defined"),
109 #ifdef CONFIG_CPU_XSCALE
110 KDBMSG(TOOMANYDBREGS, "More breakpoints than ibcr registers defined"),
112 KDBMSG(TOOMANYDBREGS, "More breakpoints than db registers defined"),
114 KDBMSG(DUPBPT, "Duplicate breakpoint address"),
115 KDBMSG(BPTNOTFOUND, "Breakpoint not found"),
116 KDBMSG(BADMODE, "Invalid IDMODE"),
117 KDBMSG(BADINT, "Illegal numeric value"),
118 KDBMSG(INVADDRFMT, "Invalid symbolic address format"),
119 KDBMSG(BADREG, "Invalid register name"),
120 KDBMSG(BADCPUNUM, "Invalid cpu number"),
121 KDBMSG(BADLENGTH, "Invalid length field"),
122 KDBMSG(NOBP, "No Breakpoint exists"),
123 KDBMSG(BADADDR, "Invalid address"),
127 static const int __nkdb_err = sizeof(kdbmsgs) / sizeof(kdbmsg_t);
131 * Initial environment. This is all kept static and local to
132 * this file. We don't want to rely on the memory allocation
133 * mechanisms in the kernel, so we use a very limited allocate-only
134 * heap for new and altered environment variables. The entire
135 * environment is limited to a fixed number of entries (add more
136 * to __env[] if required) and a fixed amount of heap (add more to
137 * KDB_ENVBUFSIZE if required).
140 static char *__env[] = {
141 #if defined(CONFIG_SMP)
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';
1240 #if defined(CONFIG_SMP)
1241 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
1242 raw_smp_processor_id());
1244 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"));
1246 if (defcmd_in_progress)
1247 strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
1250 * Fetch command from keyboard
1252 cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
1253 if (*cmdbuf != '\n') {
1255 if (cmdptr == cmd_head) {
1256 strncpy(cmd_hist[cmd_head], cmd_cur,
1258 *(cmd_hist[cmd_head] +
1259 strlen(cmd_hist[cmd_head])-1) = '\0';
1261 if (!handle_ctrl_cmd(cmdbuf))
1262 *(cmd_cur+strlen(cmd_cur)-1) = '\0';
1264 goto do_full_getstr;
1266 strncpy(cmd_hist[cmd_head], cmd_cur,
1270 cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
1271 if (cmd_head == cmd_tail)
1272 cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
1276 diag = kdb_parse(cmdbuf);
1277 if (diag == KDB_NOTFOUND) {
1278 kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
1281 if (diag == KDB_CMD_GO
1282 || diag == KDB_CMD_CPU
1283 || diag == KDB_CMD_SS
1284 || diag == KDB_CMD_SSB
1285 || diag == KDB_CMD_KGDB)
1291 KDB_DEBUG_STATE("kdb_local 9", diag);
1297 * kdb_print_state - Print the state data for the current processor
1300 * text Identifies the debug point
1301 * value Any integer value to be printed, e.g. reason code.
1303 void kdb_print_state(const char *text, int value)
1305 kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1306 text, raw_smp_processor_id(), value, kdb_initial_cpu,
1311 * kdb_main_loop - After initial setup and assignment of the
1312 * controlling cpu, all cpus are in this loop. One cpu is in
1313 * control and will issue the kdb prompt, the others will spin
1314 * until 'go' or cpu switch.
1316 * To get a consistent view of the kernel stacks for all
1317 * processes, this routine is invoked from the main kdb code via
1318 * an architecture specific routine. kdba_main_loop is
1319 * responsible for making the kernel stacks consistent for all
1320 * processes, there should be no difference between a blocked
1321 * process and a running process as far as kdb is concerned.
1323 * reason The reason KDB was invoked
1324 * error The hardware-defined error code
1325 * reason2 kdb's current reason code.
1326 * Initially error but can change
1327 * according to kdb state.
1328 * db_result Result code from break or debug point.
1329 * regs The exception frame at time of fault/breakpoint.
1330 * should always be valid.
1332 * 0 KDB was invoked for an event which it wasn't responsible
1333 * 1 KDB handled the event for which it was invoked.
1335 int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
1336 kdb_dbtrap_t db_result, struct pt_regs *regs)
1339 /* Stay in kdb() until 'go', 'ss[b]' or an error */
1342 * All processors except the one that is in control
1345 KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1346 while (KDB_STATE(HOLD_CPU)) {
1347 /* state KDB is turned off by kdb_cpu to see if the
1348 * other cpus are still live, each cpu in this loop
1351 if (!KDB_STATE(KDB))
1355 KDB_STATE_CLEAR(SUPPRESS);
1356 KDB_DEBUG_STATE("kdb_main_loop 2", reason);
1357 if (KDB_STATE(LEAVING))
1358 break; /* Another cpu said 'go' */
1359 /* Still using kdb, this processor is in control */
1360 result = kdb_local(reason2, error, regs, db_result);
1361 KDB_DEBUG_STATE("kdb_main_loop 3", result);
1363 if (result == KDB_CMD_CPU)
1366 if (result == KDB_CMD_SS) {
1367 KDB_STATE_SET(DOING_SS);
1371 if (result == KDB_CMD_SSB) {
1372 KDB_STATE_SET(DOING_SS);
1373 KDB_STATE_SET(DOING_SSB);
1377 if (result == KDB_CMD_KGDB) {
1378 if (!KDB_STATE(DOING_KGDB))
1379 kdb_printf("Entering please attach debugger "
1380 "or use $D#44+ or $3#33\n");
1383 if (result && result != 1 && result != KDB_CMD_GO)
1384 kdb_printf("\nUnexpected kdb_local return code %d\n",
1386 KDB_DEBUG_STATE("kdb_main_loop 4", reason);
1389 if (KDB_STATE(DOING_SS))
1390 KDB_STATE_CLEAR(SSBPT);
1392 /* Clean up any keyboard devices before leaving */
1393 kdb_kbd_cleanup_state();
1399 * kdb_mdr - This function implements the guts of the 'mdr', memory
1401 * mdr <addr arg>,<byte count>
1403 * addr Start address
1404 * count Number of bytes
1406 * Always 0. Any errors are detected and printed by kdb_getarea.
1408 static int kdb_mdr(unsigned long addr, unsigned int count)
1412 if (kdb_getarea(c, addr))
1414 kdb_printf("%02x", c);
1422 * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1423 * 'md8' 'mdr' and 'mds' commands.
1425 * md|mds [<addr arg> [<line count> [<radix>]]]
1426 * mdWcN [<addr arg> [<line count> [<radix>]]]
1427 * where W = is the width (1, 2, 4 or 8) and N is the count.
1428 * for eg., md1c20 reads 20 bytes, 1 at a time.
1429 * mdr <addr arg>,<byte count>
1431 static void kdb_md_line(const char *fmtstr, unsigned long addr,
1432 int symbolic, int nosect, int bytesperword,
1433 int num, int repeat, int phys)
1435 /* print just one line of data */
1436 kdb_symtab_t symtab;
1442 memset(cbuf, '\0', sizeof(cbuf));
1444 kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1446 kdb_printf(kdb_machreg_fmt0 " ", addr);
1448 for (i = 0; i < num && repeat--; i++) {
1450 if (kdb_getphysword(&word, addr, bytesperword))
1452 } else if (kdb_getword(&word, addr, bytesperword))
1454 kdb_printf(fmtstr, word);
1456 kdbnearsym(word, &symtab);
1458 memset(&symtab, 0, sizeof(symtab));
1459 if (symtab.sym_name) {
1460 kdb_symbol_print(word, &symtab, 0);
1463 kdb_printf(" %s %s "
1466 kdb_machreg_fmt, symtab.mod_name,
1467 symtab.sec_name, symtab.sec_start,
1468 symtab.sym_start, symtab.sym_end);
1470 addr += bytesperword;
1478 cp = wc.c + 8 - bytesperword;
1483 #define printable_char(c) \
1484 ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1485 switch (bytesperword) {
1487 *c++ = printable_char(*cp++);
1488 *c++ = printable_char(*cp++);
1489 *c++ = printable_char(*cp++);
1490 *c++ = printable_char(*cp++);
1493 *c++ = printable_char(*cp++);
1494 *c++ = printable_char(*cp++);
1497 *c++ = printable_char(*cp++);
1500 *c++ = printable_char(*cp++);
1504 #undef printable_char
1507 kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1511 static int kdb_md(int argc, const char **argv)
1513 static unsigned long last_addr;
1514 static int last_radix, last_bytesperword, last_repeat;
1515 int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1517 char fmtchar, fmtstr[64];
1525 kdbgetintenv("MDCOUNT", &mdcount);
1526 kdbgetintenv("RADIX", &radix);
1527 kdbgetintenv("BYTESPERWORD", &bytesperword);
1529 /* Assume 'md <addr>' and start with environment values */
1530 repeat = mdcount * 16 / bytesperword;
1532 if (strcmp(argv[0], "mdr") == 0) {
1534 return KDB_ARGCOUNT;
1536 } else if (isdigit(argv[0][2])) {
1537 bytesperword = (int)(argv[0][2] - '0');
1538 if (bytesperword == 0) {
1539 bytesperword = last_bytesperword;
1540 if (bytesperword == 0)
1543 last_bytesperword = bytesperword;
1544 repeat = mdcount * 16 / bytesperword;
1547 else if (argv[0][3] == 'c' && argv[0][4]) {
1549 repeat = simple_strtoul(argv[0] + 4, &p, 10);
1550 mdcount = ((repeat * bytesperword) + 15) / 16;
1553 last_repeat = repeat;
1554 } else if (strcmp(argv[0], "md") == 0)
1556 else if (strcmp(argv[0], "mds") == 0)
1558 else if (strcmp(argv[0], "mdp") == 0) {
1562 return KDB_NOTFOUND;
1566 return KDB_ARGCOUNT;
1569 bytesperword = last_bytesperword;
1570 repeat = last_repeat;
1571 mdcount = ((repeat * bytesperword) + 15) / 16;
1576 int diag, nextarg = 1;
1577 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1581 if (argc > nextarg+2)
1582 return KDB_ARGCOUNT;
1584 if (argc >= nextarg) {
1585 diag = kdbgetularg(argv[nextarg], &val);
1587 mdcount = (int) val;
1588 repeat = mdcount * 16 / bytesperword;
1591 if (argc >= nextarg+1) {
1592 diag = kdbgetularg(argv[nextarg+1], &val);
1598 if (strcmp(argv[0], "mdr") == 0)
1599 return kdb_mdr(addr, mdcount);
1612 return KDB_BADRADIX;
1617 if (bytesperword > KDB_WORD_SIZE)
1618 return KDB_BADWIDTH;
1620 switch (bytesperword) {
1622 sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1625 sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1628 sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1631 sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1634 return KDB_BADWIDTH;
1637 last_repeat = repeat;
1638 last_bytesperword = bytesperword;
1640 if (strcmp(argv[0], "mds") == 0) {
1642 /* Do not save these changes as last_*, they are temporary mds
1645 bytesperword = KDB_WORD_SIZE;
1647 kdbgetintenv("NOSECT", &nosect);
1650 /* Round address down modulo BYTESPERWORD */
1652 addr &= ~(bytesperword-1);
1654 while (repeat > 0) {
1656 int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1658 if (KDB_FLAG(CMD_INTERRUPT))
1660 for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1662 if (kdb_getphysword(&word, a, bytesperword)
1665 } else if (kdb_getword(&word, a, bytesperword) || word)
1668 n = min(num, repeat);
1669 kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1671 addr += bytesperword * n;
1673 z = (z + num - 1) / num;
1675 int s = num * (z-2);
1676 kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1677 " zero suppressed\n",
1678 addr, addr + bytesperword * s - 1);
1679 addr += bytesperword * s;
1689 * kdb_mm - This function implements the 'mm' command.
1690 * mm address-expression new-value
1692 * mm works on machine words, mmW works on bytes.
1694 static int kdb_mm(int argc, const char **argv)
1699 unsigned long contents;
1703 if (argv[0][2] && !isdigit(argv[0][2]))
1704 return KDB_NOTFOUND;
1707 return KDB_ARGCOUNT;
1710 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1715 return KDB_ARGCOUNT;
1716 diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1720 if (nextarg != argc + 1)
1721 return KDB_ARGCOUNT;
1723 width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1724 diag = kdb_putword(addr, contents, width);
1728 kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1734 * kdb_go - This function implements the 'go' command.
1735 * go [address-expression]
1737 static int kdb_go(int argc, const char **argv)
1744 if (raw_smp_processor_id() != kdb_initial_cpu) {
1745 kdb_printf("go must execute on the entry cpu, "
1746 "please use \"cpu %d\" and then execute go\n",
1748 return KDB_BADCPUNUM;
1752 diag = kdbgetaddrarg(argc, argv, &nextarg,
1753 &addr, &offset, NULL);
1757 return KDB_ARGCOUNT;
1761 if (KDB_FLAG(CATASTROPHIC)) {
1762 kdb_printf("Catastrophic error detected\n");
1763 kdb_printf("kdb_continue_catastrophic=%d, ",
1764 kdb_continue_catastrophic);
1765 if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1766 kdb_printf("type go a second time if you really want "
1770 if (kdb_continue_catastrophic == 2) {
1771 kdb_printf("forcing reboot\n");
1772 kdb_reboot(0, NULL);
1774 kdb_printf("attempting to continue\n");
1780 * kdb_rd - This function implements the 'rd' command.
1782 static int kdb_rd(int argc, const char **argv)
1784 int len = kdb_check_regs();
1785 #if DBG_MAX_REG_NUM > 0
1797 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1798 rsize = dbg_reg_def[i].size * 2;
1801 if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
1806 len += kdb_printf(" ");
1807 switch(dbg_reg_def[i].size * 8) {
1809 rname = dbg_get_reg(i, ®8, kdb_current_regs);
1812 len += kdb_printf("%s: %02x", rname, reg8);
1815 rname = dbg_get_reg(i, ®16, kdb_current_regs);
1818 len += kdb_printf("%s: %04x", rname, reg16);
1821 rname = dbg_get_reg(i, ®32, kdb_current_regs);
1824 len += kdb_printf("%s: %08x", rname, reg32);
1827 rname = dbg_get_reg(i, ®64, kdb_current_regs);
1830 len += kdb_printf("%s: %016llx", rname, reg64);
1833 len += kdb_printf("%s: ??", dbg_reg_def[i].name);
1841 kdb_dumpregs(kdb_current_regs);
1847 * kdb_rm - This function implements the 'rm' (register modify) command.
1848 * rm register-name new-contents
1850 * Allows register modification with the same restrictions as gdb
1852 static int kdb_rm(int argc, const char **argv)
1854 #if DBG_MAX_REG_NUM > 0
1864 return KDB_ARGCOUNT;
1866 * Allow presence or absence of leading '%' symbol.
1872 diag = kdbgetu64arg(argv[2], ®64);
1876 diag = kdb_check_regs();
1881 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1882 if (strcmp(rname, dbg_reg_def[i].name) == 0) {
1888 switch(dbg_reg_def[i].size * 8) {
1891 dbg_set_reg(i, ®8, kdb_current_regs);
1895 dbg_set_reg(i, ®16, kdb_current_regs);
1899 dbg_set_reg(i, ®32, kdb_current_regs);
1902 dbg_set_reg(i, ®64, kdb_current_regs);
1908 kdb_printf("ERROR: Register set currently not implemented\n");
1913 #if defined(CONFIG_MAGIC_SYSRQ)
1915 * kdb_sr - This function implements the 'sr' (SYSRQ key) command
1916 * which interfaces to the soi-disant MAGIC SYSRQ functionality.
1917 * sr <magic-sysrq-code>
1919 static int kdb_sr(int argc, const char **argv)
1922 return KDB_ARGCOUNT;
1924 __handle_sysrq(*argv[1], false);
1929 #endif /* CONFIG_MAGIC_SYSRQ */
1932 * kdb_ef - This function implements the 'regs' (display exception
1933 * frame) command. This command takes an address and expects to
1934 * find an exception frame at that address, formats and prints
1936 * regs address-expression
1940 static int kdb_ef(int argc, const char **argv)
1948 return KDB_ARGCOUNT;
1951 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1954 show_regs((struct pt_regs *)addr);
1958 #if defined(CONFIG_MODULES)
1960 * kdb_lsmod - This function implements the 'lsmod' command. Lists
1961 * currently loaded kernel modules.
1962 * Mostly taken from userland lsmod.
1964 static int kdb_lsmod(int argc, const char **argv)
1969 return KDB_ARGCOUNT;
1971 kdb_printf("Module Size modstruct Used by\n");
1972 list_for_each_entry(mod, kdb_modules, list) {
1974 kdb_printf("%-20s%8u 0x%p ", mod->name,
1975 mod->core_size, (void *)mod);
1976 #ifdef CONFIG_MODULE_UNLOAD
1977 kdb_printf("%4ld ", module_refcount(mod));
1979 if (mod->state == MODULE_STATE_GOING)
1980 kdb_printf(" (Unloading)");
1981 else if (mod->state == MODULE_STATE_COMING)
1982 kdb_printf(" (Loading)");
1984 kdb_printf(" (Live)");
1985 kdb_printf(" 0x%p", mod->module_core);
1987 #ifdef CONFIG_MODULE_UNLOAD
1989 struct module_use *use;
1991 list_for_each_entry(use, &mod->source_list,
1993 kdb_printf("%s ", use->target->name);
2002 #endif /* CONFIG_MODULES */
2005 * kdb_env - This function implements the 'env' command. Display the
2006 * current environment variables.
2009 static int kdb_env(int argc, const char **argv)
2013 for (i = 0; i < __nenv; i++) {
2015 kdb_printf("%s\n", __env[i]);
2018 if (KDB_DEBUG(MASK))
2019 kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
2024 #ifdef CONFIG_PRINTK
2026 * kdb_dmesg - This function implements the 'dmesg' command to display
2027 * the contents of the syslog buffer.
2028 * dmesg [lines] [adjust]
2030 static int kdb_dmesg(int argc, const char **argv)
2038 struct kmsg_dumper dumper = { .active = 1 };
2043 return KDB_ARGCOUNT;
2046 lines = simple_strtol(argv[1], &cp, 0);
2050 adjust = simple_strtoul(argv[2], &cp, 0);
2051 if (*cp || adjust < 0)
2056 /* disable LOGGING if set */
2057 diag = kdbgetintenv("LOGGING", &logging);
2058 if (!diag && logging) {
2059 const char *setargs[] = { "set", "LOGGING", "0" };
2060 kdb_set(2, setargs);
2063 kmsg_dump_rewind_nolock(&dumper);
2064 while (kmsg_dump_get_line_nolock(&dumper, 1, NULL, 0, NULL))
2069 kdb_printf("buffer only contains %d lines, nothing "
2071 else if (adjust - lines >= n)
2072 kdb_printf("buffer only contains %d lines, last %d "
2073 "lines printed\n", n, n - adjust);
2076 } else if (lines > 0) {
2077 skip = n - lines - adjust;
2080 kdb_printf("buffer only contains %d lines, "
2081 "nothing printed\n", n);
2083 } else if (skip < 0) {
2086 kdb_printf("buffer only contains %d lines, first "
2087 "%d lines printed\n", n, lines);
2093 if (skip >= n || skip < 0)
2096 kmsg_dump_rewind_nolock(&dumper);
2097 while (kmsg_dump_get_line_nolock(&dumper, 1, buf, sizeof(buf), &len)) {
2104 if (KDB_FLAG(CMD_INTERRUPT))
2107 kdb_printf("%.*s\n", (int)len - 1, buf);
2112 #endif /* CONFIG_PRINTK */
2114 /* Make sure we balance enable/disable calls, must disable first. */
2115 static atomic_t kdb_nmi_disabled;
2117 static int kdb_disable_nmi(int argc, const char *argv[])
2119 if (atomic_read(&kdb_nmi_disabled))
2121 atomic_set(&kdb_nmi_disabled, 1);
2122 arch_kgdb_ops.enable_nmi(0);
2126 static int kdb_param_enable_nmi(const char *val, const struct kernel_param *kp)
2128 if (!atomic_add_unless(&kdb_nmi_disabled, -1, 0))
2130 arch_kgdb_ops.enable_nmi(1);
2134 static const struct kernel_param_ops kdb_param_ops_enable_nmi = {
2135 .set = kdb_param_enable_nmi,
2137 module_param_cb(enable_nmi, &kdb_param_ops_enable_nmi, NULL, 0600);
2140 * kdb_cpu - This function implements the 'cpu' command.
2143 * KDB_CMD_CPU for success, a kdb diagnostic if error
2145 static void kdb_cpu_status(void)
2147 int i, start_cpu, first_print = 1;
2148 char state, prev_state = '?';
2150 kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2151 kdb_printf("Available cpus: ");
2152 for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2153 if (!cpu_online(i)) {
2154 state = 'F'; /* cpu is offline */
2156 state = ' '; /* cpu is responding to kdb */
2157 if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2158 state = 'I'; /* idle task */
2160 if (state != prev_state) {
2161 if (prev_state != '?') {
2165 kdb_printf("%d", start_cpu);
2166 if (start_cpu < i-1)
2167 kdb_printf("-%d", i-1);
2168 if (prev_state != ' ')
2169 kdb_printf("(%c)", prev_state);
2175 /* print the trailing cpus, ignoring them if they are all offline */
2176 if (prev_state != 'F') {
2179 kdb_printf("%d", start_cpu);
2180 if (start_cpu < i-1)
2181 kdb_printf("-%d", i-1);
2182 if (prev_state != ' ')
2183 kdb_printf("(%c)", prev_state);
2188 static int kdb_cpu(int argc, const char **argv)
2190 unsigned long cpunum;
2199 return KDB_ARGCOUNT;
2201 diag = kdbgetularg(argv[1], &cpunum);
2208 if ((cpunum > NR_CPUS) || !cpu_online(cpunum))
2209 return KDB_BADCPUNUM;
2211 dbg_switch_cpu = cpunum;
2214 * Switch to other cpu
2219 /* The user may not realize that ps/bta with no parameters does not print idle
2220 * or sleeping system daemon processes, so tell them how many were suppressed.
2222 void kdb_ps_suppressed(void)
2224 int idle = 0, daemon = 0;
2225 unsigned long mask_I = kdb_task_state_string("I"),
2226 mask_M = kdb_task_state_string("M");
2228 const struct task_struct *p, *g;
2229 for_each_online_cpu(cpu) {
2230 p = kdb_curr_task(cpu);
2231 if (kdb_task_state(p, mask_I))
2234 kdb_do_each_thread(g, p) {
2235 if (kdb_task_state(p, mask_M))
2237 } kdb_while_each_thread(g, p);
2238 if (idle || daemon) {
2240 kdb_printf("%d idle process%s (state I)%s\n",
2241 idle, idle == 1 ? "" : "es",
2242 daemon ? " and " : "");
2244 kdb_printf("%d sleeping system daemon (state M) "
2245 "process%s", daemon,
2246 daemon == 1 ? "" : "es");
2247 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2252 * kdb_ps - This function implements the 'ps' command which shows a
2253 * list of the active processes.
2254 * ps [DRSTCZEUIMA] All processes, optionally filtered by state
2256 void kdb_ps1(const struct task_struct *p)
2261 if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
2264 cpu = kdb_process_cpu(p);
2265 kdb_printf("0x%p %8d %8d %d %4d %c 0x%p %c%s\n",
2266 (void *)p, p->pid, p->parent->pid,
2267 kdb_task_has_cpu(p), kdb_process_cpu(p),
2268 kdb_task_state_char(p),
2269 (void *)(&p->thread),
2270 p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2272 if (kdb_task_has_cpu(p)) {
2273 if (!KDB_TSK(cpu)) {
2274 kdb_printf(" Error: no saved data for this cpu\n");
2276 if (KDB_TSK(cpu) != p)
2277 kdb_printf(" Error: does not match running "
2278 "process table (0x%p)\n", KDB_TSK(cpu));
2283 static int kdb_ps(int argc, const char **argv)
2285 struct task_struct *g, *p;
2286 unsigned long mask, cpu;
2289 kdb_ps_suppressed();
2290 kdb_printf("%-*s Pid Parent [*] cpu State %-*s Command\n",
2291 (int)(2*sizeof(void *))+2, "Task Addr",
2292 (int)(2*sizeof(void *))+2, "Thread");
2293 mask = kdb_task_state_string(argc ? argv[1] : NULL);
2294 /* Run the active tasks first */
2295 for_each_online_cpu(cpu) {
2296 if (KDB_FLAG(CMD_INTERRUPT))
2298 p = kdb_curr_task(cpu);
2299 if (kdb_task_state(p, mask))
2303 /* Now the real tasks */
2304 kdb_do_each_thread(g, p) {
2305 if (KDB_FLAG(CMD_INTERRUPT))
2307 if (kdb_task_state(p, mask))
2309 } kdb_while_each_thread(g, p);
2315 * kdb_pid - This function implements the 'pid' command which switches
2316 * the currently active process.
2319 static int kdb_pid(int argc, const char **argv)
2321 struct task_struct *p;
2326 return KDB_ARGCOUNT;
2329 if (strcmp(argv[1], "R") == 0) {
2330 p = KDB_TSK(kdb_initial_cpu);
2332 diag = kdbgetularg(argv[1], &val);
2336 p = find_task_by_pid_ns((pid_t)val, &init_pid_ns);
2338 kdb_printf("No task with pid=%d\n", (pid_t)val);
2342 kdb_set_current_task(p);
2344 kdb_printf("KDB current process is %s(pid=%d)\n",
2345 kdb_current_task->comm,
2346 kdb_current_task->pid);
2352 * kdb_ll - This function implements the 'll' command which follows a
2353 * linked list and executes an arbitrary command for each
2356 static int kdb_ll(int argc, const char **argv)
2362 unsigned long linkoffset;
2364 const char *command;
2367 return KDB_ARGCOUNT;
2370 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
2374 diag = kdbgetularg(argv[2], &linkoffset);
2379 * Using the starting address as
2380 * the first element in the list, and assuming that
2381 * the list ends with a null pointer.
2385 command = kdb_strdup(argv[3], GFP_KDB);
2387 kdb_printf("%s: cannot duplicate command\n", __func__);
2390 /* Recursive use of kdb_parse, do not use argv after this point */
2396 if (KDB_FLAG(CMD_INTERRUPT))
2399 sprintf(buf, "%s " kdb_machreg_fmt "\n", command, va);
2400 diag = kdb_parse(buf);
2404 addr = va + linkoffset;
2405 if (kdb_getword(&va, addr, sizeof(va)))
2414 static int kdb_kgdb(int argc, const char **argv)
2416 return KDB_CMD_KGDB;
2420 * kdb_help - This function implements the 'help' and '?' commands.
2422 static int kdb_help(int argc, const char **argv)
2427 kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2428 kdb_printf("-----------------------------"
2429 "-----------------------------\n");
2430 for_each_kdbcmd(kt, i) {
2432 kdb_printf("%-15.15s %-20.20s %s\n", kt->cmd_name,
2433 kt->cmd_usage, kt->cmd_help);
2434 if (KDB_FLAG(CMD_INTERRUPT))
2441 * kdb_kill - This function implements the 'kill' commands.
2443 static int kdb_kill(int argc, const char **argv)
2447 struct task_struct *p;
2448 struct siginfo info;
2451 return KDB_ARGCOUNT;
2453 sig = simple_strtol(argv[1], &endp, 0);
2457 kdb_printf("Invalid signal parameter.<-signal>\n");
2462 pid = simple_strtol(argv[2], &endp, 0);
2466 kdb_printf("Process ID must be large than 0.\n");
2470 /* Find the process. */
2471 p = find_task_by_pid_ns(pid, &init_pid_ns);
2473 kdb_printf("The specified process isn't found.\n");
2476 p = p->group_leader;
2477 info.si_signo = sig;
2479 info.si_code = SI_USER;
2480 info.si_pid = pid; /* same capabilities as process being signalled */
2481 info.si_uid = 0; /* kdb has root authority */
2482 kdb_send_sig_info(p, &info);
2487 int tm_sec; /* seconds */
2488 int tm_min; /* minutes */
2489 int tm_hour; /* hours */
2490 int tm_mday; /* day of the month */
2491 int tm_mon; /* month */
2492 int tm_year; /* year */
2495 static void kdb_gmtime(struct timespec *tv, struct kdb_tm *tm)
2497 /* This will work from 1970-2099, 2100 is not a leap year */
2498 static int mon_day[] = { 31, 29, 31, 30, 31, 30, 31,
2499 31, 30, 31, 30, 31 };
2500 memset(tm, 0, sizeof(*tm));
2501 tm->tm_sec = tv->tv_sec % (24 * 60 * 60);
2502 tm->tm_mday = tv->tv_sec / (24 * 60 * 60) +
2503 (2 * 365 + 1); /* shift base from 1970 to 1968 */
2504 tm->tm_min = tm->tm_sec / 60 % 60;
2505 tm->tm_hour = tm->tm_sec / 60 / 60;
2506 tm->tm_sec = tm->tm_sec % 60;
2507 tm->tm_year = 68 + 4*(tm->tm_mday / (4*365+1));
2508 tm->tm_mday %= (4*365+1);
2510 while (tm->tm_mday >= mon_day[tm->tm_mon]) {
2511 tm->tm_mday -= mon_day[tm->tm_mon];
2512 if (++tm->tm_mon == 12) {
2522 * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2523 * I cannot call that code directly from kdb, it has an unconditional
2524 * cli()/sti() and calls routines that take locks which can stop the debugger.
2526 static void kdb_sysinfo(struct sysinfo *val)
2528 struct timespec uptime;
2529 do_posix_clock_monotonic_gettime(&uptime);
2530 memset(val, 0, sizeof(*val));
2531 val->uptime = uptime.tv_sec;
2532 val->loads[0] = avenrun[0];
2533 val->loads[1] = avenrun[1];
2534 val->loads[2] = avenrun[2];
2535 val->procs = nr_threads-1;
2542 * kdb_summary - This function implements the 'summary' command.
2544 static int kdb_summary(int argc, const char **argv)
2546 struct timespec now;
2551 return KDB_ARGCOUNT;
2553 kdb_printf("sysname %s\n", init_uts_ns.name.sysname);
2554 kdb_printf("release %s\n", init_uts_ns.name.release);
2555 kdb_printf("version %s\n", init_uts_ns.name.version);
2556 kdb_printf("machine %s\n", init_uts_ns.name.machine);
2557 kdb_printf("nodename %s\n", init_uts_ns.name.nodename);
2558 kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2559 kdb_printf("ccversion %s\n", __stringify(CCVERSION));
2561 now = __current_kernel_time();
2562 kdb_gmtime(&now, &tm);
2563 kdb_printf("date %04d-%02d-%02d %02d:%02d:%02d "
2564 "tz_minuteswest %d\n",
2565 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2566 tm.tm_hour, tm.tm_min, tm.tm_sec,
2567 sys_tz.tz_minuteswest);
2570 kdb_printf("uptime ");
2571 if (val.uptime > (24*60*60)) {
2572 int days = val.uptime / (24*60*60);
2573 val.uptime %= (24*60*60);
2574 kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2576 kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2578 /* lifted from fs/proc/proc_misc.c::loadavg_read_proc() */
2580 #define LOAD_INT(x) ((x) >> FSHIFT)
2581 #define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
2582 kdb_printf("load avg %ld.%02ld %ld.%02ld %ld.%02ld\n",
2583 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2584 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2585 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2588 /* Display in kilobytes */
2589 #define K(x) ((x) << (PAGE_SHIFT - 10))
2590 kdb_printf("\nMemTotal: %8lu kB\nMemFree: %8lu kB\n"
2591 "Buffers: %8lu kB\n",
2592 val.totalram, val.freeram, val.bufferram);
2597 * kdb_per_cpu - This function implements the 'per_cpu' command.
2599 static int kdb_per_cpu(int argc, const char **argv)
2602 int cpu, diag, nextarg = 1;
2603 unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2605 if (argc < 1 || argc > 3)
2606 return KDB_ARGCOUNT;
2608 diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2613 diag = kdbgetularg(argv[2], &bytesperword);
2618 bytesperword = KDB_WORD_SIZE;
2619 else if (bytesperword > KDB_WORD_SIZE)
2620 return KDB_BADWIDTH;
2621 sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2623 diag = kdbgetularg(argv[3], &whichcpu);
2626 if (!cpu_online(whichcpu)) {
2627 kdb_printf("cpu %ld is not online\n", whichcpu);
2628 return KDB_BADCPUNUM;
2632 /* Most architectures use __per_cpu_offset[cpu], some use
2633 * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2635 #ifdef __per_cpu_offset
2636 #define KDB_PCU(cpu) __per_cpu_offset(cpu)
2639 #define KDB_PCU(cpu) __per_cpu_offset[cpu]
2641 #define KDB_PCU(cpu) 0
2644 for_each_online_cpu(cpu) {
2645 if (KDB_FLAG(CMD_INTERRUPT))
2648 if (whichcpu != ~0UL && whichcpu != cpu)
2650 addr = symaddr + KDB_PCU(cpu);
2651 diag = kdb_getword(&val, addr, bytesperword);
2653 kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2654 "read, diag=%d\n", cpu, addr, diag);
2657 kdb_printf("%5d ", cpu);
2658 kdb_md_line(fmtstr, addr,
2659 bytesperword == KDB_WORD_SIZE,
2660 1, bytesperword, 1, 1, 0);
2667 * display help for the use of cmd | grep pattern
2669 static int kdb_grep_help(int argc, const char **argv)
2671 kdb_printf("Usage of cmd args | grep pattern:\n");
2672 kdb_printf(" Any command's output may be filtered through an ");
2673 kdb_printf("emulated 'pipe'.\n");
2674 kdb_printf(" 'grep' is just a key word.\n");
2675 kdb_printf(" The pattern may include a very limited set of "
2676 "metacharacters:\n");
2677 kdb_printf(" pattern or ^pattern or pattern$ or ^pattern$\n");
2678 kdb_printf(" And if there are spaces in the pattern, you may "
2680 kdb_printf(" \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2681 " or \"^pat tern$\"\n");
2686 * kdb_register_repeat - This function is used to register a kernel
2690 * func Function to execute the command
2691 * usage A simple usage string showing arguments
2692 * help A simple help string describing command
2693 * repeat Does the command auto repeat on enter?
2695 * zero for success, one if a duplicate command.
2697 #define kdb_command_extend 50 /* arbitrary */
2698 int kdb_register_repeat(char *cmd,
2703 kdb_repeat_t repeat)
2709 * Brute force method to determine duplicates
2711 for_each_kdbcmd(kp, i) {
2712 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2713 kdb_printf("Duplicate kdb command registered: "
2714 "%s, func %p help %s\n", cmd, func, help);
2720 * Insert command into first available location in table
2722 for_each_kdbcmd(kp, i) {
2723 if (kp->cmd_name == NULL)
2727 if (i >= kdb_max_commands) {
2728 kdbtab_t *new = kmalloc((kdb_max_commands - KDB_BASE_CMD_MAX +
2729 kdb_command_extend) * sizeof(*new), GFP_KDB);
2731 kdb_printf("Could not allocate new kdb_command "
2736 memcpy(new, kdb_commands,
2737 (kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new));
2738 kfree(kdb_commands);
2740 memset(new + kdb_max_commands, 0,
2741 kdb_command_extend * sizeof(*new));
2743 kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX;
2744 kdb_max_commands += kdb_command_extend;
2748 kp->cmd_func = func;
2749 kp->cmd_usage = usage;
2750 kp->cmd_help = help;
2752 kp->cmd_minlen = minlen;
2753 kp->cmd_repeat = repeat;
2757 EXPORT_SYMBOL_GPL(kdb_register_repeat);
2761 * kdb_register - Compatibility register function for commands that do
2762 * not need to specify a repeat state. Equivalent to
2763 * kdb_register_repeat with KDB_REPEAT_NONE.
2766 * func Function to execute the command
2767 * usage A simple usage string showing arguments
2768 * help A simple help string describing command
2770 * zero for success, one if a duplicate command.
2772 int kdb_register(char *cmd,
2778 return kdb_register_repeat(cmd, func, usage, help, minlen,
2781 EXPORT_SYMBOL_GPL(kdb_register);
2784 * kdb_unregister - This function is used to unregister a kernel
2785 * debugger command. It is generally called when a module which
2786 * implements kdb commands is unloaded.
2790 * zero for success, one command not registered.
2792 int kdb_unregister(char *cmd)
2800 for_each_kdbcmd(kp, i) {
2801 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2802 kp->cmd_name = NULL;
2807 /* Couldn't find it. */
2810 EXPORT_SYMBOL_GPL(kdb_unregister);
2812 /* Initialize the kdb command table. */
2813 static void __init kdb_inittab(void)
2818 for_each_kdbcmd(kp, i)
2819 kp->cmd_name = NULL;
2821 kdb_register_repeat("md", kdb_md, "<vaddr>",
2822 "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2823 KDB_REPEAT_NO_ARGS);
2824 kdb_register_repeat("mdr", kdb_md, "<vaddr> <bytes>",
2825 "Display Raw Memory", 0, KDB_REPEAT_NO_ARGS);
2826 kdb_register_repeat("mdp", kdb_md, "<paddr> <bytes>",
2827 "Display Physical Memory", 0, KDB_REPEAT_NO_ARGS);
2828 kdb_register_repeat("mds", kdb_md, "<vaddr>",
2829 "Display Memory Symbolically", 0, KDB_REPEAT_NO_ARGS);
2830 kdb_register_repeat("mm", kdb_mm, "<vaddr> <contents>",
2831 "Modify Memory Contents", 0, KDB_REPEAT_NO_ARGS);
2832 kdb_register_repeat("go", kdb_go, "[<vaddr>]",
2833 "Continue Execution", 1, KDB_REPEAT_NONE);
2834 kdb_register_repeat("rd", kdb_rd, "",
2835 "Display Registers", 0, KDB_REPEAT_NONE);
2836 kdb_register_repeat("rm", kdb_rm, "<reg> <contents>",
2837 "Modify Registers", 0, KDB_REPEAT_NONE);
2838 kdb_register_repeat("ef", kdb_ef, "<vaddr>",
2839 "Display exception frame", 0, KDB_REPEAT_NONE);
2840 kdb_register_repeat("bt", kdb_bt, "[<vaddr>]",
2841 "Stack traceback", 1, KDB_REPEAT_NONE);
2842 kdb_register_repeat("btp", kdb_bt, "<pid>",
2843 "Display stack for process <pid>", 0, KDB_REPEAT_NONE);
2844 kdb_register_repeat("bta", kdb_bt, "[DRSTCZEUIMA]",
2845 "Display stack all processes", 0, KDB_REPEAT_NONE);
2846 kdb_register_repeat("btc", kdb_bt, "",
2847 "Backtrace current process on each cpu", 0, KDB_REPEAT_NONE);
2848 kdb_register_repeat("btt", kdb_bt, "<vaddr>",
2849 "Backtrace process given its struct task address", 0,
2851 kdb_register_repeat("ll", kdb_ll, "<first-element> <linkoffset> <cmd>",
2852 "Execute cmd for each element in linked list", 0, KDB_REPEAT_NONE);
2853 kdb_register_repeat("env", kdb_env, "",
2854 "Show environment variables", 0, KDB_REPEAT_NONE);
2855 kdb_register_repeat("set", kdb_set, "",
2856 "Set environment variables", 0, KDB_REPEAT_NONE);
2857 kdb_register_repeat("help", kdb_help, "",
2858 "Display Help Message", 1, KDB_REPEAT_NONE);
2859 kdb_register_repeat("?", kdb_help, "",
2860 "Display Help Message", 0, KDB_REPEAT_NONE);
2861 kdb_register_repeat("cpu", kdb_cpu, "<cpunum>",
2862 "Switch to new cpu", 0, KDB_REPEAT_NONE);
2863 kdb_register_repeat("kgdb", kdb_kgdb, "",
2864 "Enter kgdb mode", 0, KDB_REPEAT_NONE);
2865 kdb_register_repeat("ps", kdb_ps, "[<flags>|A]",
2866 "Display active task list", 0, KDB_REPEAT_NONE);
2867 kdb_register_repeat("pid", kdb_pid, "<pidnum>",
2868 "Switch to another task", 0, KDB_REPEAT_NONE);
2869 kdb_register_repeat("reboot", kdb_reboot, "",
2870 "Reboot the machine immediately", 0, KDB_REPEAT_NONE);
2871 #if defined(CONFIG_MODULES)
2872 kdb_register_repeat("lsmod", kdb_lsmod, "",
2873 "List loaded kernel modules", 0, KDB_REPEAT_NONE);
2875 #if defined(CONFIG_MAGIC_SYSRQ)
2876 kdb_register_repeat("sr", kdb_sr, "<key>",
2877 "Magic SysRq key", 0, KDB_REPEAT_NONE);
2879 #if defined(CONFIG_PRINTK)
2880 kdb_register_repeat("dmesg", kdb_dmesg, "[lines]",
2881 "Display syslog buffer", 0, KDB_REPEAT_NONE);
2883 if (arch_kgdb_ops.enable_nmi) {
2884 kdb_register_repeat("disable_nmi", kdb_disable_nmi, "",
2885 "Disable NMI entry to KDB", 0, KDB_REPEAT_NONE);
2887 kdb_register_repeat("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
2888 "Define a set of commands, down to endefcmd", 0, KDB_REPEAT_NONE);
2889 kdb_register_repeat("kill", kdb_kill, "<-signal> <pid>",
2890 "Send a signal to a process", 0, KDB_REPEAT_NONE);
2891 kdb_register_repeat("summary", kdb_summary, "",
2892 "Summarize the system", 4, KDB_REPEAT_NONE);
2893 kdb_register_repeat("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
2894 "Display per_cpu variables", 3, KDB_REPEAT_NONE);
2895 kdb_register_repeat("grephelp", kdb_grep_help, "",
2896 "Display help on | grep", 0, KDB_REPEAT_NONE);
2899 /* Execute any commands defined in kdb_cmds. */
2900 static void __init kdb_cmd_init(void)
2903 for (i = 0; kdb_cmds[i]; ++i) {
2904 diag = kdb_parse(kdb_cmds[i]);
2906 kdb_printf("kdb command %s failed, kdb diag %d\n",
2909 if (defcmd_in_progress) {
2910 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2911 kdb_parse("endefcmd");
2915 /* Initialize kdb_printf, breakpoint tables and kdb state */
2916 void __init kdb_init(int lvl)
2918 static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2921 if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2923 for (i = kdb_init_lvl; i < lvl; i++) {
2925 case KDB_NOT_INITIALIZED:
2926 kdb_inittab(); /* Initialize Command Table */
2927 kdb_initbptab(); /* Initialize Breakpoints */
2929 case KDB_INIT_EARLY:
2930 kdb_cmd_init(); /* Build kdb_cmds tables */