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/reboot.h>
18 #include <linux/sched.h>
19 #include <linux/sysrq.h>
20 #include <linux/smp.h>
21 #include <linux/utsname.h>
22 #include <linux/vmalloc.h>
23 #include <linux/module.h>
25 #include <linux/init.h>
26 #include <linux/kallsyms.h>
27 #include <linux/kgdb.h>
28 #include <linux/kdb.h>
29 #include <linux/notifier.h>
30 #include <linux/interrupt.h>
31 #include <linux/delay.h>
32 #include <linux/nmi.h>
33 #include <linux/time.h>
34 #include <linux/ptrace.h>
35 #include <linux/sysctl.h>
36 #include <linux/cpu.h>
37 #include <linux/kdebug.h>
38 #include <linux/proc_fs.h>
39 #include <linux/uaccess.h>
40 #include <linux/slab.h>
41 #include "kdb_private.h"
44 char kdb_grep_string[GREP_LEN];
45 int kdb_grepping_flag;
46 EXPORT_SYMBOL(kdb_grepping_flag);
48 int kdb_grep_trailing;
51 * Kernel debugger state flags
57 * kdb_lock protects updates to kdb_initial_cpu. Used to
58 * single thread processors through the kernel debugger.
60 int kdb_initial_cpu = -1; /* cpu number that owns kdb */
62 int kdb_state; /* General KDB state */
64 struct task_struct *kdb_current_task;
65 EXPORT_SYMBOL(kdb_current_task);
66 struct pt_regs *kdb_current_regs;
68 const char *kdb_diemsg;
69 static int kdb_go_count;
70 #ifdef CONFIG_KDB_CONTINUE_CATASTROPHIC
71 static unsigned int kdb_continue_catastrophic =
72 CONFIG_KDB_CONTINUE_CATASTROPHIC;
74 static unsigned int kdb_continue_catastrophic;
77 /* kdb_commands describes the available commands. */
78 static kdbtab_t *kdb_commands;
79 #define KDB_BASE_CMD_MAX 50
80 static int kdb_max_commands = KDB_BASE_CMD_MAX;
81 static kdbtab_t kdb_base_commands[KDB_BASE_CMD_MAX];
82 #define for_each_kdbcmd(cmd, num) \
83 for ((cmd) = kdb_base_commands, (num) = 0; \
84 num < kdb_max_commands; \
85 num++, num == KDB_BASE_CMD_MAX ? cmd = kdb_commands : cmd++)
87 typedef struct _kdbmsg {
88 int km_diag; /* kdb diagnostic */
89 char *km_msg; /* Corresponding message text */
92 #define KDBMSG(msgnum, text) \
93 { KDB_##msgnum, text }
95 static kdbmsg_t kdbmsgs[] = {
96 KDBMSG(NOTFOUND, "Command Not Found"),
97 KDBMSG(ARGCOUNT, "Improper argument count, see usage."),
98 KDBMSG(BADWIDTH, "Illegal value for BYTESPERWORD use 1, 2, 4 or 8, "
99 "8 is only allowed on 64 bit systems"),
100 KDBMSG(BADRADIX, "Illegal value for RADIX use 8, 10 or 16"),
101 KDBMSG(NOTENV, "Cannot find environment variable"),
102 KDBMSG(NOENVVALUE, "Environment variable should have value"),
103 KDBMSG(NOTIMP, "Command not implemented"),
104 KDBMSG(ENVFULL, "Environment full"),
105 KDBMSG(ENVBUFFULL, "Environment buffer full"),
106 KDBMSG(TOOMANYBPT, "Too many breakpoints defined"),
107 #ifdef CONFIG_CPU_XSCALE
108 KDBMSG(TOOMANYDBREGS, "More breakpoints than ibcr registers defined"),
110 KDBMSG(TOOMANYDBREGS, "More breakpoints than db registers defined"),
112 KDBMSG(DUPBPT, "Duplicate breakpoint address"),
113 KDBMSG(BPTNOTFOUND, "Breakpoint not found"),
114 KDBMSG(BADMODE, "Invalid IDMODE"),
115 KDBMSG(BADINT, "Illegal numeric value"),
116 KDBMSG(INVADDRFMT, "Invalid symbolic address format"),
117 KDBMSG(BADREG, "Invalid register name"),
118 KDBMSG(BADCPUNUM, "Invalid cpu number"),
119 KDBMSG(BADLENGTH, "Invalid length field"),
120 KDBMSG(NOBP, "No Breakpoint exists"),
121 KDBMSG(BADADDR, "Invalid address"),
125 static const int __nkdb_err = sizeof(kdbmsgs) / sizeof(kdbmsg_t);
129 * Initial environment. This is all kept static and local to
130 * this file. We don't want to rely on the memory allocation
131 * mechanisms in the kernel, so we use a very limited allocate-only
132 * heap for new and altered environment variables. The entire
133 * environment is limited to a fixed number of entries (add more
134 * to __env[] if required) and a fixed amount of heap (add more to
135 * KDB_ENVBUFSIZE if required).
138 static char *__env[] = {
139 #if defined(CONFIG_SMP)
141 "MOREPROMPT=[%d]more> ",
147 "MDCOUNT=8", /* lines of md output */
148 "BTARGS=9", /* 9 possible args in bt */
177 static const int __nenv = (sizeof(__env) / sizeof(char *));
179 struct task_struct *kdb_curr_task(int cpu)
181 struct task_struct *p = curr_task(cpu);
183 if ((task_thread_info(p)->flags & _TIF_MCA_INIT) && KDB_TSK(cpu))
190 * kdbgetenv - This function will return the character string value of
191 * an environment variable.
193 * match A character string representing an environment variable.
195 * NULL No environment variable matches 'match'
196 * char* Pointer to string value of environment variable.
198 char *kdbgetenv(const char *match)
201 int matchlen = strlen(match);
204 for (i = 0; i < __nenv; i++) {
210 if ((strncmp(match, e, matchlen) == 0)
211 && ((e[matchlen] == '\0')
212 || (e[matchlen] == '='))) {
213 char *cp = strchr(e, '=');
214 return cp ? ++cp : "";
221 * kdballocenv - This function is used to allocate bytes for
222 * environment entries.
224 * match A character string representing a numeric value
226 * *value the unsigned long representation of the env variable 'match'
228 * Zero on success, a kdb diagnostic on failure.
230 * We use a static environment buffer (envbuffer) to hold the values
231 * of dynamically generated environment variables (see kdb_set). Buffer
232 * space once allocated is never free'd, so over time, the amount of space
233 * (currently 512 bytes) will be exhausted if env variables are changed
236 static char *kdballocenv(size_t bytes)
238 #define KDB_ENVBUFSIZE 512
239 static char envbuffer[KDB_ENVBUFSIZE];
240 static int envbufsize;
243 if ((KDB_ENVBUFSIZE - envbufsize) >= bytes) {
244 ep = &envbuffer[envbufsize];
251 * kdbgetulenv - This function will return the value of an unsigned
252 * long-valued environment variable.
254 * match A character string representing a numeric value
256 * *value the unsigned long represntation of the env variable 'match'
258 * Zero on success, a kdb diagnostic on failure.
260 static int kdbgetulenv(const char *match, unsigned long *value)
264 ep = kdbgetenv(match);
268 return KDB_NOENVVALUE;
270 *value = simple_strtoul(ep, NULL, 0);
276 * kdbgetintenv - This function will return the value of an
277 * integer-valued environment variable.
279 * match A character string representing an integer-valued env variable
281 * *value the integer representation of the environment variable 'match'
283 * Zero on success, a kdb diagnostic on failure.
285 int kdbgetintenv(const char *match, int *value)
290 diag = kdbgetulenv(match, &val);
297 * kdbgetularg - This function will convert a numeric string into an
298 * unsigned long value.
300 * arg A character string representing a numeric value
302 * *value the unsigned long represntation of arg.
304 * Zero on success, a kdb diagnostic on failure.
306 int kdbgetularg(const char *arg, unsigned long *value)
311 val = simple_strtoul(arg, &endp, 0);
315 * Also try base 16, for us folks too lazy to type the
318 val = simple_strtoul(arg, &endp, 16);
328 int kdbgetu64arg(const char *arg, u64 *value)
333 val = simple_strtoull(arg, &endp, 0);
337 val = simple_strtoull(arg, &endp, 16);
348 * kdb_set - This function implements the 'set' command. Alter an
349 * existing environment variable or create a new one.
351 int kdb_set(int argc, const char **argv)
355 size_t varlen, vallen;
358 * we can be invoked two ways:
359 * set var=value argv[1]="var", argv[2]="value"
360 * set var = value argv[1]="var", argv[2]="=", argv[3]="value"
361 * - if the latter, shift 'em down.
372 * Check for internal variables
374 if (strcmp(argv[1], "KDBDEBUG") == 0) {
375 unsigned int debugflags;
378 debugflags = simple_strtoul(argv[2], &cp, 0);
379 if (cp == argv[2] || debugflags & ~KDB_DEBUG_FLAG_MASK) {
380 kdb_printf("kdb: illegal debug flags '%s'\n",
384 kdb_flags = (kdb_flags &
385 ~(KDB_DEBUG_FLAG_MASK << KDB_DEBUG_FLAG_SHIFT))
386 | (debugflags << KDB_DEBUG_FLAG_SHIFT);
392 * Tokenizer squashed the '=' sign. argv[1] is variable
393 * name, argv[2] = value.
395 varlen = strlen(argv[1]);
396 vallen = strlen(argv[2]);
397 ep = kdballocenv(varlen + vallen + 2);
399 return KDB_ENVBUFFULL;
401 sprintf(ep, "%s=%s", argv[1], argv[2]);
403 ep[varlen+vallen+1] = '\0';
405 for (i = 0; i < __nenv; i++) {
407 && ((strncmp(__env[i], argv[1], varlen) == 0)
408 && ((__env[i][varlen] == '\0')
409 || (__env[i][varlen] == '=')))) {
416 * Wasn't existing variable. Fit into slot.
418 for (i = 0; i < __nenv-1; i++) {
419 if (__env[i] == (char *)0) {
428 static int kdb_check_regs(void)
430 if (!kdb_current_regs) {
431 kdb_printf("No current kdb registers."
432 " You may need to select another task\n");
439 * kdbgetaddrarg - This function is responsible for parsing an
440 * address-expression and returning the value of the expression,
441 * symbol name, and offset to the caller.
443 * The argument may consist of a numeric value (decimal or
444 * hexidecimal), a symbol name, a register name (preceeded by the
445 * percent sign), an environment variable with a numeric value
446 * (preceeded by a dollar sign) or a simple arithmetic expression
447 * consisting of a symbol name, +/-, and a numeric constant value
450 * argc - count of arguments in argv
451 * argv - argument vector
452 * *nextarg - index to next unparsed argument in argv[]
453 * regs - Register state at time of KDB entry
455 * *value - receives the value of the address-expression
456 * *offset - receives the offset specified, if any
457 * *name - receives the symbol name, if any
458 * *nextarg - index to next unparsed argument in argv[]
460 * zero is returned on success, a kdb diagnostic code is
463 int kdbgetaddrarg(int argc, const char **argv, int *nextarg,
464 unsigned long *value, long *offset,
468 unsigned long off = 0;
478 * Process arguments which follow the following syntax:
480 * symbol | numeric-address [+/- numeric-offset]
482 * $environment-variable
488 symname = (char *)argv[*nextarg];
491 * If there is no whitespace between the symbol
492 * or address and the '+' or '-' symbols, we
493 * remember the character and replace it with a
494 * null so the symbol/value can be properly parsed
496 cp = strpbrk(symname, "+-");
502 if (symname[0] == '$') {
503 diag = kdbgetulenv(&symname[1], &addr);
506 } else if (symname[0] == '%') {
507 diag = kdb_check_regs();
510 /* Implement register values with % at a later time as it is
515 found = kdbgetsymval(symname, &symtab);
517 addr = symtab.sym_start;
519 diag = kdbgetularg(argv[*nextarg], &addr);
526 found = kdbnearsym(addr, &symtab);
534 if (offset && name && *name)
535 *offset = addr - symtab.sym_start;
537 if ((*nextarg > argc)
542 * check for +/- and offset
545 if (symbol == '\0') {
546 if ((argv[*nextarg][0] != '+')
547 && (argv[*nextarg][0] != '-')) {
549 * Not our argument. Return.
553 positive = (argv[*nextarg][0] == '+');
557 positive = (symbol == '+');
560 * Now there must be an offset!
562 if ((*nextarg > argc)
563 && (symbol == '\0')) {
564 return KDB_INVADDRFMT;
568 cp = (char *)argv[*nextarg];
572 diag = kdbgetularg(cp, &off);
588 static void kdb_cmderror(int diag)
593 kdb_printf("no error detected (diagnostic is %d)\n", diag);
597 for (i = 0; i < __nkdb_err; i++) {
598 if (kdbmsgs[i].km_diag == diag) {
599 kdb_printf("diag: %d: %s\n", diag, kdbmsgs[i].km_msg);
604 kdb_printf("Unknown diag %d\n", -diag);
608 * kdb_defcmd, kdb_defcmd2 - This function implements the 'defcmd'
609 * command which defines one command as a set of other commands,
610 * terminated by endefcmd. kdb_defcmd processes the initial
611 * 'defcmd' command, kdb_defcmd2 is invoked from kdb_parse for
612 * the following commands until 'endefcmd'.
614 * argc argument count
615 * argv argument vector
617 * zero for success, a kdb diagnostic if error
627 static struct defcmd_set *defcmd_set;
628 static int defcmd_set_count;
629 static int defcmd_in_progress;
631 /* Forward references */
632 static int kdb_exec_defcmd(int argc, const char **argv);
634 static int kdb_defcmd2(const char *cmdstr, const char *argv0)
636 struct defcmd_set *s = defcmd_set + defcmd_set_count - 1;
637 char **save_command = s->command;
638 if (strcmp(argv0, "endefcmd") == 0) {
639 defcmd_in_progress = 0;
643 kdb_register(s->name, kdb_exec_defcmd,
644 s->usage, s->help, 0);
649 s->command = kzalloc((s->count + 1) * sizeof(*(s->command)), GFP_KDB);
651 kdb_printf("Could not allocate new kdb_defcmd table for %s\n",
656 memcpy(s->command, save_command, s->count * sizeof(*(s->command)));
657 s->command[s->count++] = kdb_strdup(cmdstr, GFP_KDB);
662 static int kdb_defcmd(int argc, const char **argv)
664 struct defcmd_set *save_defcmd_set = defcmd_set, *s;
665 if (defcmd_in_progress) {
666 kdb_printf("kdb: nested defcmd detected, assuming missing "
668 kdb_defcmd2("endefcmd", "endefcmd");
672 for (s = defcmd_set; s < defcmd_set + defcmd_set_count; ++s) {
673 kdb_printf("defcmd %s \"%s\" \"%s\"\n", s->name,
675 for (i = 0; i < s->count; ++i)
676 kdb_printf("%s", s->command[i]);
677 kdb_printf("endefcmd\n");
683 defcmd_set = kmalloc((defcmd_set_count + 1) * sizeof(*defcmd_set),
686 kdb_printf("Could not allocate new defcmd_set entry for %s\n",
688 defcmd_set = save_defcmd_set;
691 memcpy(defcmd_set, save_defcmd_set,
692 defcmd_set_count * sizeof(*defcmd_set));
693 kfree(save_defcmd_set);
694 s = defcmd_set + defcmd_set_count;
695 memset(s, 0, sizeof(*s));
697 s->name = kdb_strdup(argv[1], GFP_KDB);
698 s->usage = kdb_strdup(argv[2], GFP_KDB);
699 s->help = kdb_strdup(argv[3], GFP_KDB);
700 if (s->usage[0] == '"') {
701 strcpy(s->usage, s->usage+1);
702 s->usage[strlen(s->usage)-1] = '\0';
704 if (s->help[0] == '"') {
705 strcpy(s->help, s->help+1);
706 s->help[strlen(s->help)-1] = '\0';
709 defcmd_in_progress = 1;
714 * kdb_exec_defcmd - Execute the set of commands associated with this
717 * argc argument count
718 * argv argument vector
720 * zero for success, a kdb diagnostic if error
722 static int kdb_exec_defcmd(int argc, const char **argv)
725 struct defcmd_set *s;
728 for (s = defcmd_set, i = 0; i < defcmd_set_count; ++i, ++s) {
729 if (strcmp(s->name, argv[0]) == 0)
732 if (i == defcmd_set_count) {
733 kdb_printf("kdb_exec_defcmd: could not find commands for %s\n",
737 for (i = 0; i < s->count; ++i) {
738 /* Recursive use of kdb_parse, do not use argv after
741 kdb_printf("[%s]kdb> %s\n", s->name, s->command[i]);
742 ret = kdb_parse(s->command[i]);
749 /* Command history */
750 #define KDB_CMD_HISTORY_COUNT 32
751 #define CMD_BUFLEN 200 /* kdb_printf: max printline
753 static unsigned int cmd_head, cmd_tail;
754 static unsigned int cmdptr;
755 static char cmd_hist[KDB_CMD_HISTORY_COUNT][CMD_BUFLEN];
756 static char cmd_cur[CMD_BUFLEN];
759 * The "str" argument may point to something like | grep xyz
761 static void parse_grep(const char *str)
764 char *cp = (char *)str, *cp2;
766 /* sanity check: we should have been called with the \ first */
772 if (strncmp(cp, "grep ", 5)) {
773 kdb_printf("invalid 'pipe', see grephelp\n");
779 cp2 = strchr(cp, '\n');
781 *cp2 = '\0'; /* remove the trailing newline */
784 kdb_printf("invalid 'pipe', see grephelp\n");
787 /* now cp points to a nonzero length search string */
789 /* allow it be "x y z" by removing the "'s - there must
792 cp2 = strchr(cp, '"');
794 kdb_printf("invalid quoted string, see grephelp\n");
797 *cp2 = '\0'; /* end the string where the 2nd " was */
799 kdb_grep_leading = 0;
801 kdb_grep_leading = 1;
805 kdb_grep_trailing = 0;
806 if (*(cp+len-1) == '$') {
807 kdb_grep_trailing = 1;
813 if (len >= GREP_LEN) {
814 kdb_printf("search string too long\n");
817 strcpy(kdb_grep_string, cp);
823 * kdb_parse - Parse the command line, search the command table for a
824 * matching command and invoke the command function. This
825 * function may be called recursively, if it is, the second call
826 * will overwrite argv and cbuf. It is the caller's
827 * responsibility to save their argv if they recursively call
830 * cmdstr The input command line to be parsed.
831 * regs The registers at the time kdb was entered.
833 * Zero for success, a kdb diagnostic if failure.
835 * Limited to 20 tokens.
837 * Real rudimentary tokenization. Basically only whitespace
838 * is considered a token delimeter (but special consideration
839 * is taken of the '=' sign as used by the 'set' command).
841 * The algorithm used to tokenize the input string relies on
842 * there being at least one whitespace (or otherwise useless)
843 * character between tokens as the character immediately following
844 * the token is altered in-place to a null-byte to terminate the
850 int kdb_parse(const char *cmdstr)
852 static char *argv[MAXARGC];
854 static char cbuf[CMD_BUFLEN+2];
858 int i, escaped, ignore_errors = 0, check_grep;
861 * First tokenize the command string.
864 kdb_grepping_flag = check_grep = 0;
866 if (KDB_FLAG(CMD_INTERRUPT)) {
867 /* Previous command was interrupted, newline must not
868 * repeat the command */
869 KDB_FLAG_CLEAR(CMD_INTERRUPT);
870 KDB_STATE_SET(PAGER);
871 argc = 0; /* no repeat */
874 if (*cp != '\n' && *cp != '\0') {
878 /* skip whitespace */
881 if ((*cp == '\0') || (*cp == '\n') ||
882 (*cp == '#' && !defcmd_in_progress))
884 /* special case: check for | grep pattern */
889 if (cpp >= cbuf + CMD_BUFLEN) {
890 kdb_printf("kdb_parse: command buffer "
891 "overflow, command ignored\n%s\n",
895 if (argc >= MAXARGC - 1) {
896 kdb_printf("kdb_parse: too many arguments, "
897 "command ignored\n%s\n", cmdstr);
903 /* Copy to next unquoted and unescaped
904 * whitespace or '=' */
905 while (*cp && *cp != '\n' &&
906 (escaped || quoted || !isspace(*cp))) {
907 if (cpp >= cbuf + CMD_BUFLEN)
921 else if (*cp == '\'' || *cp == '"')
924 if (*cpp == '=' && !quoted)
928 *cpp++ = '\0'; /* Squash a ws or '=' character */
935 if (defcmd_in_progress) {
936 int result = kdb_defcmd2(cmdstr, argv[0]);
937 if (!defcmd_in_progress) {
938 argc = 0; /* avoid repeat on endefcmd */
943 if (argv[0][0] == '-' && argv[0][1] &&
944 (argv[0][1] < '0' || argv[0][1] > '9')) {
949 for_each_kdbcmd(tp, i) {
952 * If this command is allowed to be abbreviated,
953 * check to see if this is it.
957 && (strlen(argv[0]) <= tp->cmd_minlen)) {
960 tp->cmd_minlen) == 0) {
965 if (strcmp(argv[0], tp->cmd_name) == 0)
971 * If we don't find a command by this name, see if the first
972 * few characters of this match any of the known commands.
973 * e.g., md1c20 should match md.
975 if (i == kdb_max_commands) {
976 for_each_kdbcmd(tp, i) {
980 strlen(tp->cmd_name)) == 0) {
987 if (i < kdb_max_commands) {
990 result = (*tp->cmd_func)(argc-1, (const char **)argv);
991 if (result && ignore_errors && result > KDB_CMD_GO)
993 KDB_STATE_CLEAR(CMD);
994 switch (tp->cmd_repeat) {
995 case KDB_REPEAT_NONE:
1000 case KDB_REPEAT_NO_ARGS:
1005 case KDB_REPEAT_WITH_ARGS:
1012 * If the input with which we were presented does not
1013 * map to an existing command, attempt to parse it as an
1014 * address argument and display the result. Useful for
1015 * obtaining the address of a variable, or the nearest symbol
1016 * to an address contained in a register.
1019 unsigned long value;
1024 if (kdbgetaddrarg(0, (const char **)argv, &nextarg,
1025 &value, &offset, &name)) {
1026 return KDB_NOTFOUND;
1029 kdb_printf("%s = ", argv[0]);
1030 kdb_symbol_print(value, NULL, KDB_SP_DEFAULT);
1037 static int handle_ctrl_cmd(char *cmd)
1042 /* initial situation */
1043 if (cmd_head == cmd_tail)
1047 if (cmdptr != cmd_tail)
1048 cmdptr = (cmdptr-1) % KDB_CMD_HISTORY_COUNT;
1049 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1052 if (cmdptr != cmd_head)
1053 cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT;
1054 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1061 * kdb_reboot - This function implements the 'reboot' command. Reboot
1062 * the system immediately, or loop for ever on failure.
1064 static int kdb_reboot(int argc, const char **argv)
1066 emergency_restart();
1067 kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
1074 static void kdb_dumpregs(struct pt_regs *regs)
1076 int old_lvl = console_loglevel;
1077 console_loglevel = 15;
1082 console_loglevel = old_lvl;
1085 void kdb_set_current_task(struct task_struct *p)
1087 kdb_current_task = p;
1089 if (kdb_task_has_cpu(p)) {
1090 kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p));
1093 kdb_current_regs = NULL;
1097 * kdb_local - The main code for kdb. This routine is invoked on a
1098 * specific processor, it is not global. The main kdb() routine
1099 * ensures that only one processor at a time is in this routine.
1100 * This code is called with the real reason code on the first
1101 * entry to a kdb session, thereafter it is called with reason
1102 * SWITCH, even if the user goes back to the original cpu.
1104 * reason The reason KDB was invoked
1105 * error The hardware-defined error code
1106 * regs The exception frame at time of fault/breakpoint.
1107 * db_result Result code from the break or debug point.
1109 * 0 KDB was invoked for an event which it wasn't responsible
1110 * 1 KDB handled the event for which it was invoked.
1111 * KDB_CMD_GO User typed 'go'.
1112 * KDB_CMD_CPU User switched to another cpu.
1113 * KDB_CMD_SS Single step.
1114 * KDB_CMD_SSB Single step until branch.
1116 static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs,
1117 kdb_dbtrap_t db_result)
1121 struct task_struct *kdb_current =
1122 kdb_curr_task(raw_smp_processor_id());
1124 KDB_DEBUG_STATE("kdb_local 1", reason);
1126 if (reason == KDB_REASON_DEBUG) {
1127 /* special case below */
1129 kdb_printf("\nEntering kdb (current=0x%p, pid %d) ",
1130 kdb_current, kdb_current ? kdb_current->pid : 0);
1131 #if defined(CONFIG_SMP)
1132 kdb_printf("on processor %d ", raw_smp_processor_id());
1137 case KDB_REASON_DEBUG:
1140 * If re-entering kdb after a single step
1141 * command, don't print the message.
1143 switch (db_result) {
1145 kdb_printf("\nEntering kdb (0x%p, pid %d) ",
1146 kdb_current, kdb_current->pid);
1147 #if defined(CONFIG_SMP)
1148 kdb_printf("on processor %d ", raw_smp_processor_id());
1150 kdb_printf("due to Debug @ " kdb_machreg_fmt "\n",
1151 instruction_pointer(regs));
1155 * In the midst of ssb command. Just return.
1157 KDB_DEBUG_STATE("kdb_local 3", reason);
1158 return KDB_CMD_SSB; /* Continue with SSB command */
1164 KDB_DEBUG_STATE("kdb_local 4", reason);
1165 return 1; /* kdba_db_trap did the work */
1167 kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
1174 case KDB_REASON_ENTER:
1175 if (KDB_STATE(KEYBOARD))
1176 kdb_printf("due to Keyboard Entry\n");
1178 kdb_printf("due to KDB_ENTER()\n");
1180 case KDB_REASON_KEYBOARD:
1181 KDB_STATE_SET(KEYBOARD);
1182 kdb_printf("due to Keyboard Entry\n");
1184 case KDB_REASON_ENTER_SLAVE:
1185 /* drop through, slaves only get released via cpu switch */
1186 case KDB_REASON_SWITCH:
1187 kdb_printf("due to cpu switch\n");
1189 case KDB_REASON_OOPS:
1190 kdb_printf("Oops: %s\n", kdb_diemsg);
1191 kdb_printf("due to oops @ " kdb_machreg_fmt "\n",
1192 instruction_pointer(regs));
1195 case KDB_REASON_NMI:
1196 kdb_printf("due to NonMaskable Interrupt @ "
1197 kdb_machreg_fmt "\n",
1198 instruction_pointer(regs));
1201 case KDB_REASON_SSTEP:
1202 case KDB_REASON_BREAK:
1203 kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
1204 reason == KDB_REASON_BREAK ?
1205 "Breakpoint" : "SS trap", instruction_pointer(regs));
1207 * Determine if this breakpoint is one that we
1208 * are interested in.
1210 if (db_result != KDB_DB_BPT) {
1211 kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1213 KDB_DEBUG_STATE("kdb_local 6", reason);
1214 return 0; /* Not for us, dismiss it */
1217 case KDB_REASON_RECURSE:
1218 kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
1219 instruction_pointer(regs));
1222 kdb_printf("kdb: unexpected reason code: %d\n", reason);
1223 KDB_DEBUG_STATE("kdb_local 8", reason);
1224 return 0; /* Not for us, dismiss it */
1229 * Initialize pager context.
1232 KDB_STATE_CLEAR(SUPPRESS);
1236 *(cmd_hist[cmd_head]) = '\0';
1238 if (KDB_FLAG(ONLY_DO_DUMP)) {
1239 /* kdb is off but a catastrophic error requires a dump.
1240 * Take the dump and reboot.
1241 * Turn on logging so the kdb output appears in the log
1242 * buffer in the dump.
1244 const char *setargs[] = { "set", "LOGGING", "1" };
1245 kdb_set(2, setargs);
1246 kdb_reboot(0, NULL);
1251 #if defined(CONFIG_SMP)
1252 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
1253 raw_smp_processor_id());
1255 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"));
1257 if (defcmd_in_progress)
1258 strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
1261 * Fetch command from keyboard
1263 cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
1264 if (*cmdbuf != '\n') {
1266 if (cmdptr == cmd_head) {
1267 strncpy(cmd_hist[cmd_head], cmd_cur,
1269 *(cmd_hist[cmd_head] +
1270 strlen(cmd_hist[cmd_head])-1) = '\0';
1272 if (!handle_ctrl_cmd(cmdbuf))
1273 *(cmd_cur+strlen(cmd_cur)-1) = '\0';
1275 goto do_full_getstr;
1277 strncpy(cmd_hist[cmd_head], cmd_cur,
1281 cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
1282 if (cmd_head == cmd_tail)
1283 cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
1287 diag = kdb_parse(cmdbuf);
1288 if (diag == KDB_NOTFOUND) {
1289 kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
1292 if (diag == KDB_CMD_GO
1293 || diag == KDB_CMD_CPU
1294 || diag == KDB_CMD_SS
1295 || diag == KDB_CMD_SSB
1296 || diag == KDB_CMD_KGDB)
1302 KDB_DEBUG_STATE("kdb_local 9", diag);
1308 * kdb_print_state - Print the state data for the current processor
1311 * text Identifies the debug point
1312 * value Any integer value to be printed, e.g. reason code.
1314 void kdb_print_state(const char *text, int value)
1316 kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1317 text, raw_smp_processor_id(), value, kdb_initial_cpu,
1322 * kdb_main_loop - After initial setup and assignment of the
1323 * controlling cpu, all cpus are in this loop. One cpu is in
1324 * control and will issue the kdb prompt, the others will spin
1325 * until 'go' or cpu switch.
1327 * To get a consistent view of the kernel stacks for all
1328 * processes, this routine is invoked from the main kdb code via
1329 * an architecture specific routine. kdba_main_loop is
1330 * responsible for making the kernel stacks consistent for all
1331 * processes, there should be no difference between a blocked
1332 * process and a running process as far as kdb is concerned.
1334 * reason The reason KDB was invoked
1335 * error The hardware-defined error code
1336 * reason2 kdb's current reason code.
1337 * Initially error but can change
1338 * acording to kdb state.
1339 * db_result Result code from break or debug point.
1340 * regs The exception frame at time of fault/breakpoint.
1341 * should always be valid.
1343 * 0 KDB was invoked for an event which it wasn't responsible
1344 * 1 KDB handled the event for which it was invoked.
1346 int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
1347 kdb_dbtrap_t db_result, struct pt_regs *regs)
1350 /* Stay in kdb() until 'go', 'ss[b]' or an error */
1353 * All processors except the one that is in control
1356 KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1357 while (KDB_STATE(HOLD_CPU)) {
1358 /* state KDB is turned off by kdb_cpu to see if the
1359 * other cpus are still live, each cpu in this loop
1362 if (!KDB_STATE(KDB))
1366 KDB_STATE_CLEAR(SUPPRESS);
1367 KDB_DEBUG_STATE("kdb_main_loop 2", reason);
1368 if (KDB_STATE(LEAVING))
1369 break; /* Another cpu said 'go' */
1370 /* Still using kdb, this processor is in control */
1371 result = kdb_local(reason2, error, regs, db_result);
1372 KDB_DEBUG_STATE("kdb_main_loop 3", result);
1374 if (result == KDB_CMD_CPU)
1377 if (result == KDB_CMD_SS) {
1378 KDB_STATE_SET(DOING_SS);
1382 if (result == KDB_CMD_SSB) {
1383 KDB_STATE_SET(DOING_SS);
1384 KDB_STATE_SET(DOING_SSB);
1388 if (result == KDB_CMD_KGDB) {
1389 if (!(KDB_STATE(DOING_KGDB) || KDB_STATE(DOING_KGDB2)))
1390 kdb_printf("Entering please attach debugger "
1391 "or use $D#44+ or $3#33\n");
1394 if (result && result != 1 && result != KDB_CMD_GO)
1395 kdb_printf("\nUnexpected kdb_local return code %d\n",
1397 KDB_DEBUG_STATE("kdb_main_loop 4", reason);
1400 if (KDB_STATE(DOING_SS))
1401 KDB_STATE_CLEAR(SSBPT);
1407 * kdb_mdr - This function implements the guts of the 'mdr', memory
1409 * mdr <addr arg>,<byte count>
1411 * addr Start address
1412 * count Number of bytes
1414 * Always 0. Any errors are detected and printed by kdb_getarea.
1416 static int kdb_mdr(unsigned long addr, unsigned int count)
1420 if (kdb_getarea(c, addr))
1422 kdb_printf("%02x", c);
1430 * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1431 * 'md8' 'mdr' and 'mds' commands.
1433 * md|mds [<addr arg> [<line count> [<radix>]]]
1434 * mdWcN [<addr arg> [<line count> [<radix>]]]
1435 * where W = is the width (1, 2, 4 or 8) and N is the count.
1436 * for eg., md1c20 reads 20 bytes, 1 at a time.
1437 * mdr <addr arg>,<byte count>
1439 static void kdb_md_line(const char *fmtstr, unsigned long addr,
1440 int symbolic, int nosect, int bytesperword,
1441 int num, int repeat, int phys)
1443 /* print just one line of data */
1444 kdb_symtab_t symtab;
1450 memset(cbuf, '\0', sizeof(cbuf));
1452 kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1454 kdb_printf(kdb_machreg_fmt0 " ", addr);
1456 for (i = 0; i < num && repeat--; i++) {
1458 if (kdb_getphysword(&word, addr, bytesperword))
1460 } else if (kdb_getword(&word, addr, bytesperword))
1462 kdb_printf(fmtstr, word);
1464 kdbnearsym(word, &symtab);
1466 memset(&symtab, 0, sizeof(symtab));
1467 if (symtab.sym_name) {
1468 kdb_symbol_print(word, &symtab, 0);
1471 kdb_printf(" %s %s "
1474 kdb_machreg_fmt, symtab.mod_name,
1475 symtab.sec_name, symtab.sec_start,
1476 symtab.sym_start, symtab.sym_end);
1478 addr += bytesperword;
1486 cp = wc.c + 8 - bytesperword;
1491 #define printable_char(c) \
1492 ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1493 switch (bytesperword) {
1495 *c++ = printable_char(*cp++);
1496 *c++ = printable_char(*cp++);
1497 *c++ = printable_char(*cp++);
1498 *c++ = printable_char(*cp++);
1501 *c++ = printable_char(*cp++);
1502 *c++ = printable_char(*cp++);
1505 *c++ = printable_char(*cp++);
1508 *c++ = printable_char(*cp++);
1512 #undef printable_char
1515 kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1519 static int kdb_md(int argc, const char **argv)
1521 static unsigned long last_addr;
1522 static int last_radix, last_bytesperword, last_repeat;
1523 int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1525 char fmtchar, fmtstr[64];
1533 kdbgetintenv("MDCOUNT", &mdcount);
1534 kdbgetintenv("RADIX", &radix);
1535 kdbgetintenv("BYTESPERWORD", &bytesperword);
1537 /* Assume 'md <addr>' and start with environment values */
1538 repeat = mdcount * 16 / bytesperword;
1540 if (strcmp(argv[0], "mdr") == 0) {
1542 return KDB_ARGCOUNT;
1544 } else if (isdigit(argv[0][2])) {
1545 bytesperword = (int)(argv[0][2] - '0');
1546 if (bytesperword == 0) {
1547 bytesperword = last_bytesperword;
1548 if (bytesperword == 0)
1551 last_bytesperword = bytesperword;
1552 repeat = mdcount * 16 / bytesperword;
1555 else if (argv[0][3] == 'c' && argv[0][4]) {
1557 repeat = simple_strtoul(argv[0] + 4, &p, 10);
1558 mdcount = ((repeat * bytesperword) + 15) / 16;
1561 last_repeat = repeat;
1562 } else if (strcmp(argv[0], "md") == 0)
1564 else if (strcmp(argv[0], "mds") == 0)
1566 else if (strcmp(argv[0], "mdp") == 0) {
1570 return KDB_NOTFOUND;
1574 return KDB_ARGCOUNT;
1577 bytesperword = last_bytesperword;
1578 repeat = last_repeat;
1579 mdcount = ((repeat * bytesperword) + 15) / 16;
1584 int diag, nextarg = 1;
1585 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1589 if (argc > nextarg+2)
1590 return KDB_ARGCOUNT;
1592 if (argc >= nextarg) {
1593 diag = kdbgetularg(argv[nextarg], &val);
1595 mdcount = (int) val;
1596 repeat = mdcount * 16 / bytesperword;
1599 if (argc >= nextarg+1) {
1600 diag = kdbgetularg(argv[nextarg+1], &val);
1606 if (strcmp(argv[0], "mdr") == 0)
1607 return kdb_mdr(addr, mdcount);
1620 return KDB_BADRADIX;
1625 if (bytesperword > KDB_WORD_SIZE)
1626 return KDB_BADWIDTH;
1628 switch (bytesperword) {
1630 sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1633 sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1636 sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1639 sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1642 return KDB_BADWIDTH;
1645 last_repeat = repeat;
1646 last_bytesperword = bytesperword;
1648 if (strcmp(argv[0], "mds") == 0) {
1650 /* Do not save these changes as last_*, they are temporary mds
1653 bytesperword = KDB_WORD_SIZE;
1655 kdbgetintenv("NOSECT", &nosect);
1658 /* Round address down modulo BYTESPERWORD */
1660 addr &= ~(bytesperword-1);
1662 while (repeat > 0) {
1664 int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1666 if (KDB_FLAG(CMD_INTERRUPT))
1668 for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1670 if (kdb_getphysword(&word, a, bytesperword)
1673 } else if (kdb_getword(&word, a, bytesperword) || word)
1676 n = min(num, repeat);
1677 kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1679 addr += bytesperword * n;
1681 z = (z + num - 1) / num;
1683 int s = num * (z-2);
1684 kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1685 " zero suppressed\n",
1686 addr, addr + bytesperword * s - 1);
1687 addr += bytesperword * s;
1697 * kdb_mm - This function implements the 'mm' command.
1698 * mm address-expression new-value
1700 * mm works on machine words, mmW works on bytes.
1702 static int kdb_mm(int argc, const char **argv)
1707 unsigned long contents;
1711 if (argv[0][2] && !isdigit(argv[0][2]))
1712 return KDB_NOTFOUND;
1715 return KDB_ARGCOUNT;
1718 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1723 return KDB_ARGCOUNT;
1724 diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1728 if (nextarg != argc + 1)
1729 return KDB_ARGCOUNT;
1731 width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1732 diag = kdb_putword(addr, contents, width);
1736 kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1742 * kdb_go - This function implements the 'go' command.
1743 * go [address-expression]
1745 static int kdb_go(int argc, const char **argv)
1752 if (raw_smp_processor_id() != kdb_initial_cpu) {
1753 kdb_printf("go must execute on the entry cpu, "
1754 "please use \"cpu %d\" and then execute go\n",
1756 return KDB_BADCPUNUM;
1760 diag = kdbgetaddrarg(argc, argv, &nextarg,
1761 &addr, &offset, NULL);
1765 return KDB_ARGCOUNT;
1769 if (KDB_FLAG(CATASTROPHIC)) {
1770 kdb_printf("Catastrophic error detected\n");
1771 kdb_printf("kdb_continue_catastrophic=%d, ",
1772 kdb_continue_catastrophic);
1773 if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1774 kdb_printf("type go a second time if you really want "
1778 if (kdb_continue_catastrophic == 2) {
1779 kdb_printf("forcing reboot\n");
1780 kdb_reboot(0, NULL);
1782 kdb_printf("attempting to continue\n");
1788 * kdb_rd - This function implements the 'rd' command.
1790 static int kdb_rd(int argc, const char **argv)
1792 int len = kdb_check_regs();
1793 #if DBG_MAX_REG_NUM > 0
1805 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1806 rsize = dbg_reg_def[i].size * 2;
1809 if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
1814 len += kdb_printf(" ");
1815 switch(dbg_reg_def[i].size * 8) {
1817 rname = dbg_get_reg(i, ®8, kdb_current_regs);
1820 len += kdb_printf("%s: %02x", rname, reg8);
1823 rname = dbg_get_reg(i, ®16, kdb_current_regs);
1826 len += kdb_printf("%s: %04x", rname, reg16);
1829 rname = dbg_get_reg(i, ®32, kdb_current_regs);
1832 len += kdb_printf("%s: %08x", rname, reg32);
1835 rname = dbg_get_reg(i, ®64, kdb_current_regs);
1838 len += kdb_printf("%s: %016llx", rname, reg64);
1841 len += kdb_printf("%s: ??", dbg_reg_def[i].name);
1849 kdb_dumpregs(kdb_current_regs);
1855 * kdb_rm - This function implements the 'rm' (register modify) command.
1856 * rm register-name new-contents
1858 * Allows register modification with the same restrictions as gdb
1860 static int kdb_rm(int argc, const char **argv)
1862 #if DBG_MAX_REG_NUM > 0
1872 return KDB_ARGCOUNT;
1874 * Allow presence or absence of leading '%' symbol.
1880 diag = kdbgetu64arg(argv[2], ®64);
1884 diag = kdb_check_regs();
1889 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1890 if (strcmp(rname, dbg_reg_def[i].name) == 0) {
1896 switch(dbg_reg_def[i].size * 8) {
1899 dbg_set_reg(i, ®8, kdb_current_regs);
1903 dbg_set_reg(i, ®16, kdb_current_regs);
1907 dbg_set_reg(i, ®32, kdb_current_regs);
1910 dbg_set_reg(i, ®64, kdb_current_regs);
1916 kdb_printf("ERROR: Register set currently not implemented\n");
1921 #if defined(CONFIG_MAGIC_SYSRQ)
1923 * kdb_sr - This function implements the 'sr' (SYSRQ key) command
1924 * which interfaces to the soi-disant MAGIC SYSRQ functionality.
1925 * sr <magic-sysrq-code>
1927 static int kdb_sr(int argc, const char **argv)
1930 return KDB_ARGCOUNT;
1932 __handle_sysrq(*argv[1], false);
1937 #endif /* CONFIG_MAGIC_SYSRQ */
1940 * kdb_ef - This function implements the 'regs' (display exception
1941 * frame) command. This command takes an address and expects to
1942 * find an exception frame at that address, formats and prints
1944 * regs address-expression
1948 static int kdb_ef(int argc, const char **argv)
1956 return KDB_ARGCOUNT;
1959 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1962 show_regs((struct pt_regs *)addr);
1966 #if defined(CONFIG_MODULES)
1968 * kdb_lsmod - This function implements the 'lsmod' command. Lists
1969 * currently loaded kernel modules.
1970 * Mostly taken from userland lsmod.
1972 static int kdb_lsmod(int argc, const char **argv)
1977 return KDB_ARGCOUNT;
1979 kdb_printf("Module Size modstruct Used by\n");
1980 list_for_each_entry(mod, kdb_modules, list) {
1982 kdb_printf("%-20s%8u 0x%p ", mod->name,
1983 mod->core_size, (void *)mod);
1984 #ifdef CONFIG_MODULE_UNLOAD
1985 kdb_printf("%4d ", module_refcount(mod));
1987 if (mod->state == MODULE_STATE_GOING)
1988 kdb_printf(" (Unloading)");
1989 else if (mod->state == MODULE_STATE_COMING)
1990 kdb_printf(" (Loading)");
1992 kdb_printf(" (Live)");
1993 kdb_printf(" 0x%p", mod->module_core);
1995 #ifdef CONFIG_MODULE_UNLOAD
1997 struct module_use *use;
1999 list_for_each_entry(use, &mod->source_list,
2001 kdb_printf("%s ", use->target->name);
2010 #endif /* CONFIG_MODULES */
2013 * kdb_env - This function implements the 'env' command. Display the
2014 * current environment variables.
2017 static int kdb_env(int argc, const char **argv)
2021 for (i = 0; i < __nenv; i++) {
2023 kdb_printf("%s\n", __env[i]);
2026 if (KDB_DEBUG(MASK))
2027 kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
2032 #ifdef CONFIG_PRINTK
2034 * kdb_dmesg - This function implements the 'dmesg' command to display
2035 * the contents of the syslog buffer.
2036 * dmesg [lines] [adjust]
2038 static int kdb_dmesg(int argc, const char **argv)
2040 char *syslog_data[4], *start, *end, c = '\0', *p;
2041 int diag, logging, logsize, lines = 0, adjust = 0, n;
2044 return KDB_ARGCOUNT;
2047 lines = simple_strtol(argv[1], &cp, 0);
2051 adjust = simple_strtoul(argv[2], &cp, 0);
2052 if (*cp || adjust < 0)
2057 /* disable LOGGING if set */
2058 diag = kdbgetintenv("LOGGING", &logging);
2059 if (!diag && logging) {
2060 const char *setargs[] = { "set", "LOGGING", "0" };
2061 kdb_set(2, setargs);
2064 /* syslog_data[0,1] physical start, end+1. syslog_data[2,3]
2065 * logical start, end+1. */
2066 kdb_syslog_data(syslog_data);
2067 if (syslog_data[2] == syslog_data[3])
2069 logsize = syslog_data[1] - syslog_data[0];
2070 start = syslog_data[2];
2071 end = syslog_data[3];
2072 #define KDB_WRAP(p) (((p - syslog_data[0]) % logsize) + syslog_data[0])
2073 for (n = 0, p = start; p < end; ++p) {
2082 kdb_printf("buffer only contains %d lines, nothing "
2084 else if (adjust - lines >= n)
2085 kdb_printf("buffer only contains %d lines, last %d "
2086 "lines printed\n", n, n - adjust);
2088 for (; start < end && adjust; ++start) {
2089 if (*KDB_WRAP(start) == '\n')
2095 for (p = start; p < end && lines; ++p) {
2096 if (*KDB_WRAP(p) == '\n')
2100 } else if (lines > 0) {
2101 int skip = n - (adjust + lines);
2103 kdb_printf("buffer only contains %d lines, "
2104 "nothing printed\n", n);
2106 } else if (skip < 0) {
2109 kdb_printf("buffer only contains %d lines, first "
2110 "%d lines printed\n", n, lines);
2112 for (; start < end && skip; ++start) {
2113 if (*KDB_WRAP(start) == '\n')
2116 for (p = start; p < end && lines; ++p) {
2117 if (*KDB_WRAP(p) == '\n')
2122 /* Do a line at a time (max 200 chars) to reduce protocol overhead */
2124 while (start != end) {
2127 if (KDB_FLAG(CMD_INTERRUPT))
2129 while (start < end && (c = *KDB_WRAP(start)) &&
2130 (p - buf) < sizeof(buf)-1) {
2137 kdb_printf("%s", buf);
2144 #endif /* CONFIG_PRINTK */
2146 * kdb_cpu - This function implements the 'cpu' command.
2149 * KDB_CMD_CPU for success, a kdb diagnostic if error
2151 static void kdb_cpu_status(void)
2153 int i, start_cpu, first_print = 1;
2154 char state, prev_state = '?';
2156 kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2157 kdb_printf("Available cpus: ");
2158 for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2159 if (!cpu_online(i)) {
2160 state = 'F'; /* cpu is offline */
2162 state = ' '; /* cpu is responding to kdb */
2163 if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2164 state = 'I'; /* idle task */
2166 if (state != prev_state) {
2167 if (prev_state != '?') {
2171 kdb_printf("%d", start_cpu);
2172 if (start_cpu < i-1)
2173 kdb_printf("-%d", i-1);
2174 if (prev_state != ' ')
2175 kdb_printf("(%c)", prev_state);
2181 /* print the trailing cpus, ignoring them if they are all offline */
2182 if (prev_state != 'F') {
2185 kdb_printf("%d", start_cpu);
2186 if (start_cpu < i-1)
2187 kdb_printf("-%d", i-1);
2188 if (prev_state != ' ')
2189 kdb_printf("(%c)", prev_state);
2194 static int kdb_cpu(int argc, const char **argv)
2196 unsigned long cpunum;
2205 return KDB_ARGCOUNT;
2207 diag = kdbgetularg(argv[1], &cpunum);
2214 if ((cpunum > NR_CPUS) || !cpu_online(cpunum))
2215 return KDB_BADCPUNUM;
2217 dbg_switch_cpu = cpunum;
2220 * Switch to other cpu
2225 /* The user may not realize that ps/bta with no parameters does not print idle
2226 * or sleeping system daemon processes, so tell them how many were suppressed.
2228 void kdb_ps_suppressed(void)
2230 int idle = 0, daemon = 0;
2231 unsigned long mask_I = kdb_task_state_string("I"),
2232 mask_M = kdb_task_state_string("M");
2234 const struct task_struct *p, *g;
2235 for_each_online_cpu(cpu) {
2236 p = kdb_curr_task(cpu);
2237 if (kdb_task_state(p, mask_I))
2240 kdb_do_each_thread(g, p) {
2241 if (kdb_task_state(p, mask_M))
2243 } kdb_while_each_thread(g, p);
2244 if (idle || daemon) {
2246 kdb_printf("%d idle process%s (state I)%s\n",
2247 idle, idle == 1 ? "" : "es",
2248 daemon ? " and " : "");
2250 kdb_printf("%d sleeping system daemon (state M) "
2251 "process%s", daemon,
2252 daemon == 1 ? "" : "es");
2253 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2258 * kdb_ps - This function implements the 'ps' command which shows a
2259 * list of the active processes.
2260 * ps [DRSTCZEUIMA] All processes, optionally filtered by state
2262 void kdb_ps1(const struct task_struct *p)
2267 if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
2270 cpu = kdb_process_cpu(p);
2271 kdb_printf("0x%p %8d %8d %d %4d %c 0x%p %c%s\n",
2272 (void *)p, p->pid, p->parent->pid,
2273 kdb_task_has_cpu(p), kdb_process_cpu(p),
2274 kdb_task_state_char(p),
2275 (void *)(&p->thread),
2276 p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2278 if (kdb_task_has_cpu(p)) {
2279 if (!KDB_TSK(cpu)) {
2280 kdb_printf(" Error: no saved data for this cpu\n");
2282 if (KDB_TSK(cpu) != p)
2283 kdb_printf(" Error: does not match running "
2284 "process table (0x%p)\n", KDB_TSK(cpu));
2289 static int kdb_ps(int argc, const char **argv)
2291 struct task_struct *g, *p;
2292 unsigned long mask, cpu;
2295 kdb_ps_suppressed();
2296 kdb_printf("%-*s Pid Parent [*] cpu State %-*s Command\n",
2297 (int)(2*sizeof(void *))+2, "Task Addr",
2298 (int)(2*sizeof(void *))+2, "Thread");
2299 mask = kdb_task_state_string(argc ? argv[1] : NULL);
2300 /* Run the active tasks first */
2301 for_each_online_cpu(cpu) {
2302 if (KDB_FLAG(CMD_INTERRUPT))
2304 p = kdb_curr_task(cpu);
2305 if (kdb_task_state(p, mask))
2309 /* Now the real tasks */
2310 kdb_do_each_thread(g, p) {
2311 if (KDB_FLAG(CMD_INTERRUPT))
2313 if (kdb_task_state(p, mask))
2315 } kdb_while_each_thread(g, p);
2321 * kdb_pid - This function implements the 'pid' command which switches
2322 * the currently active process.
2325 static int kdb_pid(int argc, const char **argv)
2327 struct task_struct *p;
2332 return KDB_ARGCOUNT;
2335 if (strcmp(argv[1], "R") == 0) {
2336 p = KDB_TSK(kdb_initial_cpu);
2338 diag = kdbgetularg(argv[1], &val);
2342 p = find_task_by_pid_ns((pid_t)val, &init_pid_ns);
2344 kdb_printf("No task with pid=%d\n", (pid_t)val);
2348 kdb_set_current_task(p);
2350 kdb_printf("KDB current process is %s(pid=%d)\n",
2351 kdb_current_task->comm,
2352 kdb_current_task->pid);
2358 * kdb_ll - This function implements the 'll' command which follows a
2359 * linked list and executes an arbitrary command for each
2362 static int kdb_ll(int argc, const char **argv)
2368 unsigned long linkoffset;
2370 const char *command;
2373 return KDB_ARGCOUNT;
2376 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
2380 diag = kdbgetularg(argv[2], &linkoffset);
2385 * Using the starting address as
2386 * the first element in the list, and assuming that
2387 * the list ends with a null pointer.
2391 command = kdb_strdup(argv[3], GFP_KDB);
2393 kdb_printf("%s: cannot duplicate command\n", __func__);
2396 /* Recursive use of kdb_parse, do not use argv after this point */
2402 if (KDB_FLAG(CMD_INTERRUPT))
2405 sprintf(buf, "%s " kdb_machreg_fmt "\n", command, va);
2406 diag = kdb_parse(buf);
2410 addr = va + linkoffset;
2411 if (kdb_getword(&va, addr, sizeof(va)))
2420 static int kdb_kgdb(int argc, const char **argv)
2422 return KDB_CMD_KGDB;
2426 * kdb_help - This function implements the 'help' and '?' commands.
2428 static int kdb_help(int argc, const char **argv)
2433 kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2434 kdb_printf("-----------------------------"
2435 "-----------------------------\n");
2436 for_each_kdbcmd(kt, i) {
2438 kdb_printf("%-15.15s %-20.20s %s\n", kt->cmd_name,
2439 kt->cmd_usage, kt->cmd_help);
2440 if (KDB_FLAG(CMD_INTERRUPT))
2447 * kdb_kill - This function implements the 'kill' commands.
2449 static int kdb_kill(int argc, const char **argv)
2453 struct task_struct *p;
2454 struct siginfo info;
2457 return KDB_ARGCOUNT;
2459 sig = simple_strtol(argv[1], &endp, 0);
2463 kdb_printf("Invalid signal parameter.<-signal>\n");
2468 pid = simple_strtol(argv[2], &endp, 0);
2472 kdb_printf("Process ID must be large than 0.\n");
2476 /* Find the process. */
2477 p = find_task_by_pid_ns(pid, &init_pid_ns);
2479 kdb_printf("The specified process isn't found.\n");
2482 p = p->group_leader;
2483 info.si_signo = sig;
2485 info.si_code = SI_USER;
2486 info.si_pid = pid; /* same capabilities as process being signalled */
2487 info.si_uid = 0; /* kdb has root authority */
2488 kdb_send_sig_info(p, &info);
2493 int tm_sec; /* seconds */
2494 int tm_min; /* minutes */
2495 int tm_hour; /* hours */
2496 int tm_mday; /* day of the month */
2497 int tm_mon; /* month */
2498 int tm_year; /* year */
2501 static void kdb_gmtime(struct timespec *tv, struct kdb_tm *tm)
2503 /* This will work from 1970-2099, 2100 is not a leap year */
2504 static int mon_day[] = { 31, 29, 31, 30, 31, 30, 31,
2505 31, 30, 31, 30, 31 };
2506 memset(tm, 0, sizeof(*tm));
2507 tm->tm_sec = tv->tv_sec % (24 * 60 * 60);
2508 tm->tm_mday = tv->tv_sec / (24 * 60 * 60) +
2509 (2 * 365 + 1); /* shift base from 1970 to 1968 */
2510 tm->tm_min = tm->tm_sec / 60 % 60;
2511 tm->tm_hour = tm->tm_sec / 60 / 60;
2512 tm->tm_sec = tm->tm_sec % 60;
2513 tm->tm_year = 68 + 4*(tm->tm_mday / (4*365+1));
2514 tm->tm_mday %= (4*365+1);
2516 while (tm->tm_mday >= mon_day[tm->tm_mon]) {
2517 tm->tm_mday -= mon_day[tm->tm_mon];
2518 if (++tm->tm_mon == 12) {
2528 * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2529 * I cannot call that code directly from kdb, it has an unconditional
2530 * cli()/sti() and calls routines that take locks which can stop the debugger.
2532 static void kdb_sysinfo(struct sysinfo *val)
2534 struct timespec uptime;
2535 do_posix_clock_monotonic_gettime(&uptime);
2536 memset(val, 0, sizeof(*val));
2537 val->uptime = uptime.tv_sec;
2538 val->loads[0] = avenrun[0];
2539 val->loads[1] = avenrun[1];
2540 val->loads[2] = avenrun[2];
2541 val->procs = nr_threads-1;
2548 * kdb_summary - This function implements the 'summary' command.
2550 static int kdb_summary(int argc, const char **argv)
2552 struct timespec now;
2557 return KDB_ARGCOUNT;
2559 kdb_printf("sysname %s\n", init_uts_ns.name.sysname);
2560 kdb_printf("release %s\n", init_uts_ns.name.release);
2561 kdb_printf("version %s\n", init_uts_ns.name.version);
2562 kdb_printf("machine %s\n", init_uts_ns.name.machine);
2563 kdb_printf("nodename %s\n", init_uts_ns.name.nodename);
2564 kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2565 kdb_printf("ccversion %s\n", __stringify(CCVERSION));
2567 now = __current_kernel_time();
2568 kdb_gmtime(&now, &tm);
2569 kdb_printf("date %04d-%02d-%02d %02d:%02d:%02d "
2570 "tz_minuteswest %d\n",
2571 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2572 tm.tm_hour, tm.tm_min, tm.tm_sec,
2573 sys_tz.tz_minuteswest);
2576 kdb_printf("uptime ");
2577 if (val.uptime > (24*60*60)) {
2578 int days = val.uptime / (24*60*60);
2579 val.uptime %= (24*60*60);
2580 kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2582 kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2584 /* lifted from fs/proc/proc_misc.c::loadavg_read_proc() */
2586 #define LOAD_INT(x) ((x) >> FSHIFT)
2587 #define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
2588 kdb_printf("load avg %ld.%02ld %ld.%02ld %ld.%02ld\n",
2589 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2590 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2591 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2594 /* Display in kilobytes */
2595 #define K(x) ((x) << (PAGE_SHIFT - 10))
2596 kdb_printf("\nMemTotal: %8lu kB\nMemFree: %8lu kB\n"
2597 "Buffers: %8lu kB\n",
2598 val.totalram, val.freeram, val.bufferram);
2603 * kdb_per_cpu - This function implements the 'per_cpu' command.
2605 static int kdb_per_cpu(int argc, const char **argv)
2608 int cpu, diag, nextarg = 1;
2609 unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2611 if (argc < 1 || argc > 3)
2612 return KDB_ARGCOUNT;
2614 diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2619 diag = kdbgetularg(argv[2], &bytesperword);
2624 bytesperword = KDB_WORD_SIZE;
2625 else if (bytesperword > KDB_WORD_SIZE)
2626 return KDB_BADWIDTH;
2627 sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2629 diag = kdbgetularg(argv[3], &whichcpu);
2632 if (!cpu_online(whichcpu)) {
2633 kdb_printf("cpu %ld is not online\n", whichcpu);
2634 return KDB_BADCPUNUM;
2638 /* Most architectures use __per_cpu_offset[cpu], some use
2639 * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2641 #ifdef __per_cpu_offset
2642 #define KDB_PCU(cpu) __per_cpu_offset(cpu)
2645 #define KDB_PCU(cpu) __per_cpu_offset[cpu]
2647 #define KDB_PCU(cpu) 0
2650 for_each_online_cpu(cpu) {
2651 if (KDB_FLAG(CMD_INTERRUPT))
2654 if (whichcpu != ~0UL && whichcpu != cpu)
2656 addr = symaddr + KDB_PCU(cpu);
2657 diag = kdb_getword(&val, addr, bytesperword);
2659 kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2660 "read, diag=%d\n", cpu, addr, diag);
2663 kdb_printf("%5d ", cpu);
2664 kdb_md_line(fmtstr, addr,
2665 bytesperword == KDB_WORD_SIZE,
2666 1, bytesperword, 1, 1, 0);
2673 * display help for the use of cmd | grep pattern
2675 static int kdb_grep_help(int argc, const char **argv)
2677 kdb_printf("Usage of cmd args | grep pattern:\n");
2678 kdb_printf(" Any command's output may be filtered through an ");
2679 kdb_printf("emulated 'pipe'.\n");
2680 kdb_printf(" 'grep' is just a key word.\n");
2681 kdb_printf(" The pattern may include a very limited set of "
2682 "metacharacters:\n");
2683 kdb_printf(" pattern or ^pattern or pattern$ or ^pattern$\n");
2684 kdb_printf(" And if there are spaces in the pattern, you may "
2686 kdb_printf(" \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2687 " or \"^pat tern$\"\n");
2692 * kdb_register_repeat - This function is used to register a kernel
2696 * func Function to execute the command
2697 * usage A simple usage string showing arguments
2698 * help A simple help string describing command
2699 * repeat Does the command auto repeat on enter?
2701 * zero for success, one if a duplicate command.
2703 #define kdb_command_extend 50 /* arbitrary */
2704 int kdb_register_repeat(char *cmd,
2709 kdb_repeat_t repeat)
2715 * Brute force method to determine duplicates
2717 for_each_kdbcmd(kp, i) {
2718 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2719 kdb_printf("Duplicate kdb command registered: "
2720 "%s, func %p help %s\n", cmd, func, help);
2726 * Insert command into first available location in table
2728 for_each_kdbcmd(kp, i) {
2729 if (kp->cmd_name == NULL)
2733 if (i >= kdb_max_commands) {
2734 kdbtab_t *new = kmalloc((kdb_max_commands - KDB_BASE_CMD_MAX +
2735 kdb_command_extend) * sizeof(*new), GFP_KDB);
2737 kdb_printf("Could not allocate new kdb_command "
2742 memcpy(new, kdb_commands,
2743 (kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new));
2744 kfree(kdb_commands);
2746 memset(new + kdb_max_commands, 0,
2747 kdb_command_extend * sizeof(*new));
2749 kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX;
2750 kdb_max_commands += kdb_command_extend;
2754 kp->cmd_func = func;
2755 kp->cmd_usage = usage;
2756 kp->cmd_help = help;
2758 kp->cmd_minlen = minlen;
2759 kp->cmd_repeat = repeat;
2763 EXPORT_SYMBOL_GPL(kdb_register_repeat);
2767 * kdb_register - Compatibility register function for commands that do
2768 * not need to specify a repeat state. Equivalent to
2769 * kdb_register_repeat with KDB_REPEAT_NONE.
2772 * func Function to execute the command
2773 * usage A simple usage string showing arguments
2774 * help A simple help string describing command
2776 * zero for success, one if a duplicate command.
2778 int kdb_register(char *cmd,
2784 return kdb_register_repeat(cmd, func, usage, help, minlen,
2787 EXPORT_SYMBOL_GPL(kdb_register);
2790 * kdb_unregister - This function is used to unregister a kernel
2791 * debugger command. It is generally called when a module which
2792 * implements kdb commands is unloaded.
2796 * zero for success, one command not registered.
2798 int kdb_unregister(char *cmd)
2806 for_each_kdbcmd(kp, i) {
2807 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2808 kp->cmd_name = NULL;
2813 /* Couldn't find it. */
2816 EXPORT_SYMBOL_GPL(kdb_unregister);
2818 /* Initialize the kdb command table. */
2819 static void __init kdb_inittab(void)
2824 for_each_kdbcmd(kp, i)
2825 kp->cmd_name = NULL;
2827 kdb_register_repeat("md", kdb_md, "<vaddr>",
2828 "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2829 KDB_REPEAT_NO_ARGS);
2830 kdb_register_repeat("mdr", kdb_md, "<vaddr> <bytes>",
2831 "Display Raw Memory", 0, KDB_REPEAT_NO_ARGS);
2832 kdb_register_repeat("mdp", kdb_md, "<paddr> <bytes>",
2833 "Display Physical Memory", 0, KDB_REPEAT_NO_ARGS);
2834 kdb_register_repeat("mds", kdb_md, "<vaddr>",
2835 "Display Memory Symbolically", 0, KDB_REPEAT_NO_ARGS);
2836 kdb_register_repeat("mm", kdb_mm, "<vaddr> <contents>",
2837 "Modify Memory Contents", 0, KDB_REPEAT_NO_ARGS);
2838 kdb_register_repeat("go", kdb_go, "[<vaddr>]",
2839 "Continue Execution", 1, KDB_REPEAT_NONE);
2840 kdb_register_repeat("rd", kdb_rd, "",
2841 "Display Registers", 0, KDB_REPEAT_NONE);
2842 kdb_register_repeat("rm", kdb_rm, "<reg> <contents>",
2843 "Modify Registers", 0, KDB_REPEAT_NONE);
2844 kdb_register_repeat("ef", kdb_ef, "<vaddr>",
2845 "Display exception frame", 0, KDB_REPEAT_NONE);
2846 kdb_register_repeat("bt", kdb_bt, "[<vaddr>]",
2847 "Stack traceback", 1, KDB_REPEAT_NONE);
2848 kdb_register_repeat("btp", kdb_bt, "<pid>",
2849 "Display stack for process <pid>", 0, KDB_REPEAT_NONE);
2850 kdb_register_repeat("bta", kdb_bt, "[DRSTCZEUIMA]",
2851 "Display stack all processes", 0, KDB_REPEAT_NONE);
2852 kdb_register_repeat("btc", kdb_bt, "",
2853 "Backtrace current process on each cpu", 0, KDB_REPEAT_NONE);
2854 kdb_register_repeat("btt", kdb_bt, "<vaddr>",
2855 "Backtrace process given its struct task address", 0,
2857 kdb_register_repeat("ll", kdb_ll, "<first-element> <linkoffset> <cmd>",
2858 "Execute cmd for each element in linked list", 0, KDB_REPEAT_NONE);
2859 kdb_register_repeat("env", kdb_env, "",
2860 "Show environment variables", 0, KDB_REPEAT_NONE);
2861 kdb_register_repeat("set", kdb_set, "",
2862 "Set environment variables", 0, KDB_REPEAT_NONE);
2863 kdb_register_repeat("help", kdb_help, "",
2864 "Display Help Message", 1, KDB_REPEAT_NONE);
2865 kdb_register_repeat("?", kdb_help, "",
2866 "Display Help Message", 0, KDB_REPEAT_NONE);
2867 kdb_register_repeat("cpu", kdb_cpu, "<cpunum>",
2868 "Switch to new cpu", 0, KDB_REPEAT_NONE);
2869 kdb_register_repeat("kgdb", kdb_kgdb, "",
2870 "Enter kgdb mode", 0, KDB_REPEAT_NONE);
2871 kdb_register_repeat("ps", kdb_ps, "[<flags>|A]",
2872 "Display active task list", 0, KDB_REPEAT_NONE);
2873 kdb_register_repeat("pid", kdb_pid, "<pidnum>",
2874 "Switch to another task", 0, KDB_REPEAT_NONE);
2875 kdb_register_repeat("reboot", kdb_reboot, "",
2876 "Reboot the machine immediately", 0, KDB_REPEAT_NONE);
2877 #if defined(CONFIG_MODULES)
2878 kdb_register_repeat("lsmod", kdb_lsmod, "",
2879 "List loaded kernel modules", 0, KDB_REPEAT_NONE);
2881 #if defined(CONFIG_MAGIC_SYSRQ)
2882 kdb_register_repeat("sr", kdb_sr, "<key>",
2883 "Magic SysRq key", 0, KDB_REPEAT_NONE);
2885 #if defined(CONFIG_PRINTK)
2886 kdb_register_repeat("dmesg", kdb_dmesg, "[lines]",
2887 "Display syslog buffer", 0, KDB_REPEAT_NONE);
2889 kdb_register_repeat("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
2890 "Define a set of commands, down to endefcmd", 0, KDB_REPEAT_NONE);
2891 kdb_register_repeat("kill", kdb_kill, "<-signal> <pid>",
2892 "Send a signal to a process", 0, KDB_REPEAT_NONE);
2893 kdb_register_repeat("summary", kdb_summary, "",
2894 "Summarize the system", 4, KDB_REPEAT_NONE);
2895 kdb_register_repeat("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
2896 "Display per_cpu variables", 3, KDB_REPEAT_NONE);
2897 kdb_register_repeat("grephelp", kdb_grep_help, "",
2898 "Display help on | grep", 0, KDB_REPEAT_NONE);
2901 /* Execute any commands defined in kdb_cmds. */
2902 static void __init kdb_cmd_init(void)
2905 for (i = 0; kdb_cmds[i]; ++i) {
2906 diag = kdb_parse(kdb_cmds[i]);
2908 kdb_printf("kdb command %s failed, kdb diag %d\n",
2911 if (defcmd_in_progress) {
2912 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2913 kdb_parse("endefcmd");
2917 /* Initialize kdb_printf, breakpoint tables and kdb state */
2918 void __init kdb_init(int lvl)
2920 static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2923 if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2925 for (i = kdb_init_lvl; i < lvl; i++) {
2927 case KDB_NOT_INITIALIZED:
2928 kdb_inittab(); /* Initialize Command Table */
2929 kdb_initbptab(); /* Initialize Breakpoints */
2931 case KDB_INIT_EARLY:
2932 kdb_cmd_init(); /* Build kdb_cmds tables */