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/types.h>
16 #include <linux/string.h>
17 #include <linux/kernel.h>
18 #include <linux/kmsg_dump.h>
19 #include <linux/reboot.h>
20 #include <linux/sched.h>
21 #include <linux/sched/loadavg.h>
22 #include <linux/sched/stat.h>
23 #include <linux/sched/debug.h>
24 #include <linux/sysrq.h>
25 #include <linux/smp.h>
26 #include <linux/utsname.h>
27 #include <linux/vmalloc.h>
28 #include <linux/atomic.h>
29 #include <linux/module.h>
30 #include <linux/moduleparam.h>
32 #include <linux/init.h>
33 #include <linux/kallsyms.h>
34 #include <linux/kgdb.h>
35 #include <linux/kdb.h>
36 #include <linux/notifier.h>
37 #include <linux/interrupt.h>
38 #include <linux/delay.h>
39 #include <linux/nmi.h>
40 #include <linux/time.h>
41 #include <linux/ptrace.h>
42 #include <linux/sysctl.h>
43 #include <linux/cpu.h>
44 #include <linux/kdebug.h>
45 #include <linux/proc_fs.h>
46 #include <linux/uaccess.h>
47 #include <linux/slab.h>
48 #include "kdb_private.h"
50 #undef MODULE_PARAM_PREFIX
51 #define MODULE_PARAM_PREFIX "kdb."
53 static int kdb_cmd_enabled = CONFIG_KDB_DEFAULT_ENABLE;
54 module_param_named(cmd_enable, kdb_cmd_enabled, int, 0600);
56 char kdb_grep_string[KDB_GREP_STRLEN];
57 int kdb_grepping_flag;
58 EXPORT_SYMBOL(kdb_grepping_flag);
60 int kdb_grep_trailing;
63 * Kernel debugger state flags
68 * kdb_lock protects updates to kdb_initial_cpu. Used to
69 * single thread processors through the kernel debugger.
71 int kdb_initial_cpu = -1; /* cpu number that owns kdb */
73 int kdb_state; /* General KDB state */
75 struct task_struct *kdb_current_task;
76 struct pt_regs *kdb_current_regs;
78 const char *kdb_diemsg;
79 static int kdb_go_count;
80 #ifdef CONFIG_KDB_CONTINUE_CATASTROPHIC
81 static unsigned int kdb_continue_catastrophic =
82 CONFIG_KDB_CONTINUE_CATASTROPHIC;
84 static unsigned int kdb_continue_catastrophic;
87 /* kdb_commands describes the available commands. */
88 static kdbtab_t *kdb_commands;
89 #define KDB_BASE_CMD_MAX 50
90 static int kdb_max_commands = KDB_BASE_CMD_MAX;
91 static kdbtab_t kdb_base_commands[KDB_BASE_CMD_MAX];
92 #define for_each_kdbcmd(cmd, num) \
93 for ((cmd) = kdb_base_commands, (num) = 0; \
94 num < kdb_max_commands; \
95 num++, num == KDB_BASE_CMD_MAX ? cmd = kdb_commands : cmd++)
97 typedef struct _kdbmsg {
98 int km_diag; /* kdb diagnostic */
99 char *km_msg; /* Corresponding message text */
102 #define KDBMSG(msgnum, text) \
103 { KDB_##msgnum, text }
105 static kdbmsg_t kdbmsgs[] = {
106 KDBMSG(NOTFOUND, "Command Not Found"),
107 KDBMSG(ARGCOUNT, "Improper argument count, see usage."),
108 KDBMSG(BADWIDTH, "Illegal value for BYTESPERWORD use 1, 2, 4 or 8, "
109 "8 is only allowed on 64 bit systems"),
110 KDBMSG(BADRADIX, "Illegal value for RADIX use 8, 10 or 16"),
111 KDBMSG(NOTENV, "Cannot find environment variable"),
112 KDBMSG(NOENVVALUE, "Environment variable should have value"),
113 KDBMSG(NOTIMP, "Command not implemented"),
114 KDBMSG(ENVFULL, "Environment full"),
115 KDBMSG(ENVBUFFULL, "Environment buffer full"),
116 KDBMSG(TOOMANYBPT, "Too many breakpoints defined"),
117 #ifdef CONFIG_CPU_XSCALE
118 KDBMSG(TOOMANYDBREGS, "More breakpoints than ibcr registers defined"),
120 KDBMSG(TOOMANYDBREGS, "More breakpoints than db registers defined"),
122 KDBMSG(DUPBPT, "Duplicate breakpoint address"),
123 KDBMSG(BPTNOTFOUND, "Breakpoint not found"),
124 KDBMSG(BADMODE, "Invalid IDMODE"),
125 KDBMSG(BADINT, "Illegal numeric value"),
126 KDBMSG(INVADDRFMT, "Invalid symbolic address format"),
127 KDBMSG(BADREG, "Invalid register name"),
128 KDBMSG(BADCPUNUM, "Invalid cpu number"),
129 KDBMSG(BADLENGTH, "Invalid length field"),
130 KDBMSG(NOBP, "No Breakpoint exists"),
131 KDBMSG(BADADDR, "Invalid address"),
132 KDBMSG(NOPERM, "Permission denied"),
136 static const int __nkdb_err = ARRAY_SIZE(kdbmsgs);
140 * Initial environment. This is all kept static and local to
141 * this file. We don't want to rely on the memory allocation
142 * mechanisms in the kernel, so we use a very limited allocate-only
143 * heap for new and altered environment variables. The entire
144 * environment is limited to a fixed number of entries (add more
145 * to __env[] if required) and a fixed amount of heap (add more to
146 * KDB_ENVBUFSIZE if required).
149 static char *__env[] = {
150 #if defined(CONFIG_SMP)
157 "MDCOUNT=8", /* lines of md output */
187 static const int __nenv = ARRAY_SIZE(__env);
189 struct task_struct *kdb_curr_task(int cpu)
191 struct task_struct *p = curr_task(cpu);
193 if ((task_thread_info(p)->flags & _TIF_MCA_INIT) && KDB_TSK(cpu))
200 * Check whether the flags of the current command and the permissions
201 * of the kdb console has allow a command to be run.
203 static inline bool kdb_check_flags(kdb_cmdflags_t flags, int permissions,
206 /* permissions comes from userspace so needs massaging slightly */
207 permissions &= KDB_ENABLE_MASK;
208 permissions |= KDB_ENABLE_ALWAYS_SAFE;
210 /* some commands change group when launched with no arguments */
212 permissions |= permissions << KDB_ENABLE_NO_ARGS_SHIFT;
214 flags |= KDB_ENABLE_ALL;
216 return permissions & flags;
220 * kdbgetenv - This function will return the character string value of
221 * an environment variable.
223 * match A character string representing an environment variable.
225 * NULL No environment variable matches 'match'
226 * char* Pointer to string value of environment variable.
228 char *kdbgetenv(const char *match)
231 int matchlen = strlen(match);
234 for (i = 0; i < __nenv; i++) {
240 if ((strncmp(match, e, matchlen) == 0)
241 && ((e[matchlen] == '\0')
242 || (e[matchlen] == '='))) {
243 char *cp = strchr(e, '=');
244 return cp ? ++cp : "";
251 * kdballocenv - This function is used to allocate bytes for
252 * environment entries.
254 * match A character string representing a numeric value
256 * *value the unsigned long representation of the env variable 'match'
258 * Zero on success, a kdb diagnostic on failure.
260 * We use a static environment buffer (envbuffer) to hold the values
261 * of dynamically generated environment variables (see kdb_set). Buffer
262 * space once allocated is never free'd, so over time, the amount of space
263 * (currently 512 bytes) will be exhausted if env variables are changed
266 static char *kdballocenv(size_t bytes)
268 #define KDB_ENVBUFSIZE 512
269 static char envbuffer[KDB_ENVBUFSIZE];
270 static int envbufsize;
273 if ((KDB_ENVBUFSIZE - envbufsize) >= bytes) {
274 ep = &envbuffer[envbufsize];
281 * kdbgetulenv - This function will return the value of an unsigned
282 * long-valued environment variable.
284 * match A character string representing a numeric value
286 * *value the unsigned long represntation of the env variable 'match'
288 * Zero on success, a kdb diagnostic on failure.
290 static int kdbgetulenv(const char *match, unsigned long *value)
294 ep = kdbgetenv(match);
298 return KDB_NOENVVALUE;
300 *value = simple_strtoul(ep, NULL, 0);
306 * kdbgetintenv - This function will return the value of an
307 * integer-valued environment variable.
309 * match A character string representing an integer-valued env variable
311 * *value the integer representation of the environment variable 'match'
313 * Zero on success, a kdb diagnostic on failure.
315 int kdbgetintenv(const char *match, int *value)
320 diag = kdbgetulenv(match, &val);
327 * kdbgetularg - This function will convert a numeric string into an
328 * unsigned long value.
330 * arg A character string representing a numeric value
332 * *value the unsigned long represntation of arg.
334 * Zero on success, a kdb diagnostic on failure.
336 int kdbgetularg(const char *arg, unsigned long *value)
341 val = simple_strtoul(arg, &endp, 0);
345 * Also try base 16, for us folks too lazy to type the
348 val = simple_strtoul(arg, &endp, 16);
358 int kdbgetu64arg(const char *arg, u64 *value)
363 val = simple_strtoull(arg, &endp, 0);
367 val = simple_strtoull(arg, &endp, 16);
378 * kdb_set - This function implements the 'set' command. Alter an
379 * existing environment variable or create a new one.
381 int kdb_set(int argc, const char **argv)
385 size_t varlen, vallen;
388 * we can be invoked two ways:
389 * set var=value argv[1]="var", argv[2]="value"
390 * set var = value argv[1]="var", argv[2]="=", argv[3]="value"
391 * - if the latter, shift 'em down.
402 * Censor sensitive variables
404 if (strcmp(argv[1], "PROMPT") == 0 &&
405 !kdb_check_flags(KDB_ENABLE_MEM_READ, kdb_cmd_enabled, false))
409 * Check for internal variables
411 if (strcmp(argv[1], "KDBDEBUG") == 0) {
412 unsigned int debugflags;
415 debugflags = simple_strtoul(argv[2], &cp, 0);
416 if (cp == argv[2] || debugflags & ~KDB_DEBUG_FLAG_MASK) {
417 kdb_printf("kdb: illegal debug flags '%s'\n",
421 kdb_flags = (kdb_flags &
422 ~(KDB_DEBUG_FLAG_MASK << KDB_DEBUG_FLAG_SHIFT))
423 | (debugflags << KDB_DEBUG_FLAG_SHIFT);
429 * Tokenizer squashed the '=' sign. argv[1] is variable
430 * name, argv[2] = value.
432 varlen = strlen(argv[1]);
433 vallen = strlen(argv[2]);
434 ep = kdballocenv(varlen + vallen + 2);
436 return KDB_ENVBUFFULL;
438 sprintf(ep, "%s=%s", argv[1], argv[2]);
440 ep[varlen+vallen+1] = '\0';
442 for (i = 0; i < __nenv; i++) {
444 && ((strncmp(__env[i], argv[1], varlen) == 0)
445 && ((__env[i][varlen] == '\0')
446 || (__env[i][varlen] == '=')))) {
453 * Wasn't existing variable. Fit into slot.
455 for (i = 0; i < __nenv-1; i++) {
456 if (__env[i] == (char *)0) {
465 static int kdb_check_regs(void)
467 if (!kdb_current_regs) {
468 kdb_printf("No current kdb registers."
469 " You may need to select another task\n");
476 * kdbgetaddrarg - This function is responsible for parsing an
477 * address-expression and returning the value of the expression,
478 * symbol name, and offset to the caller.
480 * The argument may consist of a numeric value (decimal or
481 * hexidecimal), a symbol name, a register name (preceded by the
482 * percent sign), an environment variable with a numeric value
483 * (preceded by a dollar sign) or a simple arithmetic expression
484 * consisting of a symbol name, +/-, and a numeric constant value
487 * argc - count of arguments in argv
488 * argv - argument vector
489 * *nextarg - index to next unparsed argument in argv[]
490 * regs - Register state at time of KDB entry
492 * *value - receives the value of the address-expression
493 * *offset - receives the offset specified, if any
494 * *name - receives the symbol name, if any
495 * *nextarg - index to next unparsed argument in argv[]
497 * zero is returned on success, a kdb diagnostic code is
500 int kdbgetaddrarg(int argc, const char **argv, int *nextarg,
501 unsigned long *value, long *offset,
505 unsigned long off = 0;
515 * If the enable flags prohibit both arbitrary memory access
516 * and flow control then there are no reasonable grounds to
517 * provide symbol lookup.
519 if (!kdb_check_flags(KDB_ENABLE_MEM_READ | KDB_ENABLE_FLOW_CTRL,
520 kdb_cmd_enabled, false))
524 * Process arguments which follow the following syntax:
526 * symbol | numeric-address [+/- numeric-offset]
528 * $environment-variable
534 symname = (char *)argv[*nextarg];
537 * If there is no whitespace between the symbol
538 * or address and the '+' or '-' symbols, we
539 * remember the character and replace it with a
540 * null so the symbol/value can be properly parsed
542 cp = strpbrk(symname, "+-");
548 if (symname[0] == '$') {
549 diag = kdbgetulenv(&symname[1], &addr);
552 } else if (symname[0] == '%') {
553 diag = kdb_check_regs();
556 /* Implement register values with % at a later time as it is
561 found = kdbgetsymval(symname, &symtab);
563 addr = symtab.sym_start;
565 diag = kdbgetularg(argv[*nextarg], &addr);
572 found = kdbnearsym(addr, &symtab);
580 if (offset && name && *name)
581 *offset = addr - symtab.sym_start;
583 if ((*nextarg > argc)
588 * check for +/- and offset
591 if (symbol == '\0') {
592 if ((argv[*nextarg][0] != '+')
593 && (argv[*nextarg][0] != '-')) {
595 * Not our argument. Return.
599 positive = (argv[*nextarg][0] == '+');
603 positive = (symbol == '+');
606 * Now there must be an offset!
608 if ((*nextarg > argc)
609 && (symbol == '\0')) {
610 return KDB_INVADDRFMT;
614 cp = (char *)argv[*nextarg];
618 diag = kdbgetularg(cp, &off);
634 static void kdb_cmderror(int diag)
639 kdb_printf("no error detected (diagnostic is %d)\n", diag);
643 for (i = 0; i < __nkdb_err; i++) {
644 if (kdbmsgs[i].km_diag == diag) {
645 kdb_printf("diag: %d: %s\n", diag, kdbmsgs[i].km_msg);
650 kdb_printf("Unknown diag %d\n", -diag);
654 * kdb_defcmd, kdb_defcmd2 - This function implements the 'defcmd'
655 * command which defines one command as a set of other commands,
656 * terminated by endefcmd. kdb_defcmd processes the initial
657 * 'defcmd' command, kdb_defcmd2 is invoked from kdb_parse for
658 * the following commands until 'endefcmd'.
660 * argc argument count
661 * argv argument vector
663 * zero for success, a kdb diagnostic if error
673 static struct defcmd_set *defcmd_set;
674 static int defcmd_set_count;
675 static bool defcmd_in_progress;
677 /* Forward references */
678 static int kdb_exec_defcmd(int argc, const char **argv);
680 static int kdb_defcmd2(const char *cmdstr, const char *argv0)
682 struct defcmd_set *s = defcmd_set + defcmd_set_count - 1;
683 char **save_command = s->command;
684 if (strcmp(argv0, "endefcmd") == 0) {
685 defcmd_in_progress = false;
689 /* macros are always safe because when executed each
690 * internal command re-enters kdb_parse() and is
691 * safety checked individually.
693 kdb_register_flags(s->name, kdb_exec_defcmd, s->usage,
695 KDB_ENABLE_ALWAYS_SAFE);
700 s->command = kcalloc(s->count + 1, sizeof(*(s->command)), GFP_KDB);
702 kdb_printf("Could not allocate new kdb_defcmd table for %s\n",
707 memcpy(s->command, save_command, s->count * sizeof(*(s->command)));
708 s->command[s->count++] = kdb_strdup(cmdstr, GFP_KDB);
713 static int kdb_defcmd(int argc, const char **argv)
715 struct defcmd_set *save_defcmd_set = defcmd_set, *s;
716 if (defcmd_in_progress) {
717 kdb_printf("kdb: nested defcmd detected, assuming missing "
719 kdb_defcmd2("endefcmd", "endefcmd");
723 for (s = defcmd_set; s < defcmd_set + defcmd_set_count; ++s) {
724 kdb_printf("defcmd %s \"%s\" \"%s\"\n", s->name,
726 for (i = 0; i < s->count; ++i)
727 kdb_printf("%s", s->command[i]);
728 kdb_printf("endefcmd\n");
734 if (in_dbg_master()) {
735 kdb_printf("Command only available during kdb_init()\n");
738 defcmd_set = kmalloc_array(defcmd_set_count + 1, sizeof(*defcmd_set),
742 memcpy(defcmd_set, save_defcmd_set,
743 defcmd_set_count * sizeof(*defcmd_set));
744 s = defcmd_set + defcmd_set_count;
745 memset(s, 0, sizeof(*s));
747 s->name = kdb_strdup(argv[1], GFP_KDB);
750 s->usage = kdb_strdup(argv[2], GFP_KDB);
753 s->help = kdb_strdup(argv[3], GFP_KDB);
756 if (s->usage[0] == '"') {
757 strcpy(s->usage, argv[2]+1);
758 s->usage[strlen(s->usage)-1] = '\0';
760 if (s->help[0] == '"') {
761 strcpy(s->help, argv[3]+1);
762 s->help[strlen(s->help)-1] = '\0';
765 defcmd_in_progress = true;
766 kfree(save_defcmd_set);
775 kdb_printf("Could not allocate new defcmd_set entry for %s\n", argv[1]);
776 defcmd_set = save_defcmd_set;
781 * kdb_exec_defcmd - Execute the set of commands associated with this
784 * argc argument count
785 * argv argument vector
787 * zero for success, a kdb diagnostic if error
789 static int kdb_exec_defcmd(int argc, const char **argv)
792 struct defcmd_set *s;
795 for (s = defcmd_set, i = 0; i < defcmd_set_count; ++i, ++s) {
796 if (strcmp(s->name, argv[0]) == 0)
799 if (i == defcmd_set_count) {
800 kdb_printf("kdb_exec_defcmd: could not find commands for %s\n",
804 for (i = 0; i < s->count; ++i) {
805 /* Recursive use of kdb_parse, do not use argv after
808 kdb_printf("[%s]kdb> %s\n", s->name, s->command[i]);
809 ret = kdb_parse(s->command[i]);
816 /* Command history */
817 #define KDB_CMD_HISTORY_COUNT 32
818 #define CMD_BUFLEN 200 /* kdb_printf: max printline
820 static unsigned int cmd_head, cmd_tail;
821 static unsigned int cmdptr;
822 static char cmd_hist[KDB_CMD_HISTORY_COUNT][CMD_BUFLEN];
823 static char cmd_cur[CMD_BUFLEN];
826 * The "str" argument may point to something like | grep xyz
828 static void parse_grep(const char *str)
831 char *cp = (char *)str, *cp2;
833 /* sanity check: we should have been called with the \ first */
839 if (!str_has_prefix(cp, "grep ")) {
840 kdb_printf("invalid 'pipe', see grephelp\n");
846 cp2 = strchr(cp, '\n');
848 *cp2 = '\0'; /* remove the trailing newline */
851 kdb_printf("invalid 'pipe', see grephelp\n");
854 /* now cp points to a nonzero length search string */
856 /* allow it be "x y z" by removing the "'s - there must
859 cp2 = strchr(cp, '"');
861 kdb_printf("invalid quoted string, see grephelp\n");
864 *cp2 = '\0'; /* end the string where the 2nd " was */
866 kdb_grep_leading = 0;
868 kdb_grep_leading = 1;
872 kdb_grep_trailing = 0;
873 if (*(cp+len-1) == '$') {
874 kdb_grep_trailing = 1;
880 if (len >= KDB_GREP_STRLEN) {
881 kdb_printf("search string too long\n");
884 strcpy(kdb_grep_string, cp);
890 * kdb_parse - Parse the command line, search the command table for a
891 * matching command and invoke the command function. This
892 * function may be called recursively, if it is, the second call
893 * will overwrite argv and cbuf. It is the caller's
894 * responsibility to save their argv if they recursively call
897 * cmdstr The input command line to be parsed.
898 * regs The registers at the time kdb was entered.
900 * Zero for success, a kdb diagnostic if failure.
902 * Limited to 20 tokens.
904 * Real rudimentary tokenization. Basically only whitespace
905 * is considered a token delimeter (but special consideration
906 * is taken of the '=' sign as used by the 'set' command).
908 * The algorithm used to tokenize the input string relies on
909 * there being at least one whitespace (or otherwise useless)
910 * character between tokens as the character immediately following
911 * the token is altered in-place to a null-byte to terminate the
917 int kdb_parse(const char *cmdstr)
919 static char *argv[MAXARGC];
921 static char cbuf[CMD_BUFLEN+2];
925 int i, escaped, ignore_errors = 0, check_grep = 0;
928 * First tokenize the command string.
932 if (KDB_FLAG(CMD_INTERRUPT)) {
933 /* Previous command was interrupted, newline must not
934 * repeat the command */
935 KDB_FLAG_CLEAR(CMD_INTERRUPT);
936 KDB_STATE_SET(PAGER);
937 argc = 0; /* no repeat */
940 if (*cp != '\n' && *cp != '\0') {
944 /* skip whitespace */
947 if ((*cp == '\0') || (*cp == '\n') ||
948 (*cp == '#' && !defcmd_in_progress))
950 /* special case: check for | grep pattern */
955 if (cpp >= cbuf + CMD_BUFLEN) {
956 kdb_printf("kdb_parse: command buffer "
957 "overflow, command ignored\n%s\n",
961 if (argc >= MAXARGC - 1) {
962 kdb_printf("kdb_parse: too many arguments, "
963 "command ignored\n%s\n", cmdstr);
969 /* Copy to next unquoted and unescaped
970 * whitespace or '=' */
971 while (*cp && *cp != '\n' &&
972 (escaped || quoted || !isspace(*cp))) {
973 if (cpp >= cbuf + CMD_BUFLEN)
987 else if (*cp == '\'' || *cp == '"')
990 if (*cpp == '=' && !quoted)
994 *cpp++ = '\0'; /* Squash a ws or '=' character */
1001 if (defcmd_in_progress) {
1002 int result = kdb_defcmd2(cmdstr, argv[0]);
1003 if (!defcmd_in_progress) {
1004 argc = 0; /* avoid repeat on endefcmd */
1009 if (argv[0][0] == '-' && argv[0][1] &&
1010 (argv[0][1] < '0' || argv[0][1] > '9')) {
1015 for_each_kdbcmd(tp, i) {
1018 * If this command is allowed to be abbreviated,
1019 * check to see if this is it.
1023 && (strlen(argv[0]) <= tp->cmd_minlen)) {
1024 if (strncmp(argv[0],
1026 tp->cmd_minlen) == 0) {
1031 if (strcmp(argv[0], tp->cmd_name) == 0)
1037 * If we don't find a command by this name, see if the first
1038 * few characters of this match any of the known commands.
1039 * e.g., md1c20 should match md.
1041 if (i == kdb_max_commands) {
1042 for_each_kdbcmd(tp, i) {
1044 if (strncmp(argv[0],
1046 strlen(tp->cmd_name)) == 0) {
1053 if (i < kdb_max_commands) {
1056 if (!kdb_check_flags(tp->cmd_flags, kdb_cmd_enabled, argc <= 1))
1060 result = (*tp->cmd_func)(argc-1, (const char **)argv);
1061 if (result && ignore_errors && result > KDB_CMD_GO)
1063 KDB_STATE_CLEAR(CMD);
1065 if (tp->cmd_flags & KDB_REPEAT_WITH_ARGS)
1068 argc = tp->cmd_flags & KDB_REPEAT_NO_ARGS ? 1 : 0;
1070 *(argv[argc]) = '\0';
1075 * If the input with which we were presented does not
1076 * map to an existing command, attempt to parse it as an
1077 * address argument and display the result. Useful for
1078 * obtaining the address of a variable, or the nearest symbol
1079 * to an address contained in a register.
1082 unsigned long value;
1087 if (kdbgetaddrarg(0, (const char **)argv, &nextarg,
1088 &value, &offset, &name)) {
1089 return KDB_NOTFOUND;
1092 kdb_printf("%s = ", argv[0]);
1093 kdb_symbol_print(value, NULL, KDB_SP_DEFAULT);
1100 static int handle_ctrl_cmd(char *cmd)
1105 /* initial situation */
1106 if (cmd_head == cmd_tail)
1110 if (cmdptr != cmd_tail)
1111 cmdptr = (cmdptr-1) % KDB_CMD_HISTORY_COUNT;
1112 strscpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1115 if (cmdptr != cmd_head)
1116 cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT;
1117 strscpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1124 * kdb_reboot - This function implements the 'reboot' command. Reboot
1125 * the system immediately, or loop for ever on failure.
1127 static int kdb_reboot(int argc, const char **argv)
1129 emergency_restart();
1130 kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
1137 static void kdb_dumpregs(struct pt_regs *regs)
1139 int old_lvl = console_loglevel;
1140 console_loglevel = CONSOLE_LOGLEVEL_MOTORMOUTH;
1145 console_loglevel = old_lvl;
1148 static void kdb_set_current_task(struct task_struct *p)
1150 kdb_current_task = p;
1152 if (kdb_task_has_cpu(p)) {
1153 kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p));
1156 kdb_current_regs = NULL;
1159 static void drop_newline(char *buf)
1161 size_t len = strlen(buf);
1165 if (*(buf + len - 1) == '\n')
1166 *(buf + len - 1) = '\0';
1170 * kdb_local - The main code for kdb. This routine is invoked on a
1171 * specific processor, it is not global. The main kdb() routine
1172 * ensures that only one processor at a time is in this routine.
1173 * This code is called with the real reason code on the first
1174 * entry to a kdb session, thereafter it is called with reason
1175 * SWITCH, even if the user goes back to the original cpu.
1177 * reason The reason KDB was invoked
1178 * error The hardware-defined error code
1179 * regs The exception frame at time of fault/breakpoint.
1180 * db_result Result code from the break or debug point.
1182 * 0 KDB was invoked for an event which it wasn't responsible
1183 * 1 KDB handled the event for which it was invoked.
1184 * KDB_CMD_GO User typed 'go'.
1185 * KDB_CMD_CPU User switched to another cpu.
1186 * KDB_CMD_SS Single step.
1188 static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs,
1189 kdb_dbtrap_t db_result)
1193 struct task_struct *kdb_current =
1194 kdb_curr_task(raw_smp_processor_id());
1196 KDB_DEBUG_STATE("kdb_local 1", reason);
1198 if (reason == KDB_REASON_DEBUG) {
1199 /* special case below */
1201 kdb_printf("\nEntering kdb (current=0x%px, pid %d) ",
1202 kdb_current, kdb_current ? kdb_current->pid : 0);
1203 #if defined(CONFIG_SMP)
1204 kdb_printf("on processor %d ", raw_smp_processor_id());
1209 case KDB_REASON_DEBUG:
1212 * If re-entering kdb after a single step
1213 * command, don't print the message.
1215 switch (db_result) {
1217 kdb_printf("\nEntering kdb (0x%px, pid %d) ",
1218 kdb_current, kdb_current->pid);
1219 #if defined(CONFIG_SMP)
1220 kdb_printf("on processor %d ", raw_smp_processor_id());
1222 kdb_printf("due to Debug @ " kdb_machreg_fmt "\n",
1223 instruction_pointer(regs));
1228 KDB_DEBUG_STATE("kdb_local 4", reason);
1229 return 1; /* kdba_db_trap did the work */
1231 kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
1238 case KDB_REASON_ENTER:
1239 if (KDB_STATE(KEYBOARD))
1240 kdb_printf("due to Keyboard Entry\n");
1242 kdb_printf("due to KDB_ENTER()\n");
1244 case KDB_REASON_KEYBOARD:
1245 KDB_STATE_SET(KEYBOARD);
1246 kdb_printf("due to Keyboard Entry\n");
1248 case KDB_REASON_ENTER_SLAVE:
1249 /* drop through, slaves only get released via cpu switch */
1250 case KDB_REASON_SWITCH:
1251 kdb_printf("due to cpu switch\n");
1253 case KDB_REASON_OOPS:
1254 kdb_printf("Oops: %s\n", kdb_diemsg);
1255 kdb_printf("due to oops @ " kdb_machreg_fmt "\n",
1256 instruction_pointer(regs));
1259 case KDB_REASON_SYSTEM_NMI:
1260 kdb_printf("due to System NonMaskable Interrupt\n");
1262 case KDB_REASON_NMI:
1263 kdb_printf("due to NonMaskable Interrupt @ "
1264 kdb_machreg_fmt "\n",
1265 instruction_pointer(regs));
1267 case KDB_REASON_SSTEP:
1268 case KDB_REASON_BREAK:
1269 kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
1270 reason == KDB_REASON_BREAK ?
1271 "Breakpoint" : "SS trap", instruction_pointer(regs));
1273 * Determine if this breakpoint is one that we
1274 * are interested in.
1276 if (db_result != KDB_DB_BPT) {
1277 kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1279 KDB_DEBUG_STATE("kdb_local 6", reason);
1280 return 0; /* Not for us, dismiss it */
1283 case KDB_REASON_RECURSE:
1284 kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
1285 instruction_pointer(regs));
1288 kdb_printf("kdb: unexpected reason code: %d\n", reason);
1289 KDB_DEBUG_STATE("kdb_local 8", reason);
1290 return 0; /* Not for us, dismiss it */
1295 * Initialize pager context.
1298 KDB_STATE_CLEAR(SUPPRESS);
1299 kdb_grepping_flag = 0;
1300 /* ensure the old search does not leak into '/' commands */
1301 kdb_grep_string[0] = '\0';
1305 *(cmd_hist[cmd_head]) = '\0';
1308 /* PROMPT can only be set if we have MEM_READ permission. */
1309 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
1310 raw_smp_processor_id());
1311 if (defcmd_in_progress)
1312 strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
1315 * Fetch command from keyboard
1317 cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
1318 if (*cmdbuf != '\n') {
1320 if (cmdptr == cmd_head) {
1321 strscpy(cmd_hist[cmd_head], cmd_cur,
1323 *(cmd_hist[cmd_head] +
1324 strlen(cmd_hist[cmd_head])-1) = '\0';
1326 if (!handle_ctrl_cmd(cmdbuf))
1327 *(cmd_cur+strlen(cmd_cur)-1) = '\0';
1329 goto do_full_getstr;
1331 strscpy(cmd_hist[cmd_head], cmd_cur,
1335 cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
1336 if (cmd_head == cmd_tail)
1337 cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
1341 diag = kdb_parse(cmdbuf);
1342 if (diag == KDB_NOTFOUND) {
1343 drop_newline(cmdbuf);
1344 kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
1347 if (diag == KDB_CMD_GO
1348 || diag == KDB_CMD_CPU
1349 || diag == KDB_CMD_SS
1350 || diag == KDB_CMD_KGDB)
1356 KDB_DEBUG_STATE("kdb_local 9", diag);
1362 * kdb_print_state - Print the state data for the current processor
1365 * text Identifies the debug point
1366 * value Any integer value to be printed, e.g. reason code.
1368 void kdb_print_state(const char *text, int value)
1370 kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1371 text, raw_smp_processor_id(), value, kdb_initial_cpu,
1376 * kdb_main_loop - After initial setup and assignment of the
1377 * controlling cpu, all cpus are in this loop. One cpu is in
1378 * control and will issue the kdb prompt, the others will spin
1379 * until 'go' or cpu switch.
1381 * To get a consistent view of the kernel stacks for all
1382 * processes, this routine is invoked from the main kdb code via
1383 * an architecture specific routine. kdba_main_loop is
1384 * responsible for making the kernel stacks consistent for all
1385 * processes, there should be no difference between a blocked
1386 * process and a running process as far as kdb is concerned.
1388 * reason The reason KDB was invoked
1389 * error The hardware-defined error code
1390 * reason2 kdb's current reason code.
1391 * Initially error but can change
1392 * according to kdb state.
1393 * db_result Result code from break or debug point.
1394 * regs The exception frame at time of fault/breakpoint.
1395 * should always be valid.
1397 * 0 KDB was invoked for an event which it wasn't responsible
1398 * 1 KDB handled the event for which it was invoked.
1400 int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
1401 kdb_dbtrap_t db_result, struct pt_regs *regs)
1404 /* Stay in kdb() until 'go', 'ss[b]' or an error */
1407 * All processors except the one that is in control
1410 KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1411 while (KDB_STATE(HOLD_CPU)) {
1412 /* state KDB is turned off by kdb_cpu to see if the
1413 * other cpus are still live, each cpu in this loop
1416 if (!KDB_STATE(KDB))
1420 KDB_STATE_CLEAR(SUPPRESS);
1421 KDB_DEBUG_STATE("kdb_main_loop 2", reason);
1422 if (KDB_STATE(LEAVING))
1423 break; /* Another cpu said 'go' */
1424 /* Still using kdb, this processor is in control */
1425 result = kdb_local(reason2, error, regs, db_result);
1426 KDB_DEBUG_STATE("kdb_main_loop 3", result);
1428 if (result == KDB_CMD_CPU)
1431 if (result == KDB_CMD_SS) {
1432 KDB_STATE_SET(DOING_SS);
1436 if (result == KDB_CMD_KGDB) {
1437 if (!KDB_STATE(DOING_KGDB))
1438 kdb_printf("Entering please attach debugger "
1439 "or use $D#44+ or $3#33\n");
1442 if (result && result != 1 && result != KDB_CMD_GO)
1443 kdb_printf("\nUnexpected kdb_local return code %d\n",
1445 KDB_DEBUG_STATE("kdb_main_loop 4", reason);
1448 if (KDB_STATE(DOING_SS))
1449 KDB_STATE_CLEAR(SSBPT);
1451 /* Clean up any keyboard devices before leaving */
1452 kdb_kbd_cleanup_state();
1458 * kdb_mdr - This function implements the guts of the 'mdr', memory
1460 * mdr <addr arg>,<byte count>
1462 * addr Start address
1463 * count Number of bytes
1465 * Always 0. Any errors are detected and printed by kdb_getarea.
1467 static int kdb_mdr(unsigned long addr, unsigned int count)
1471 if (kdb_getarea(c, addr))
1473 kdb_printf("%02x", c);
1481 * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1482 * 'md8' 'mdr' and 'mds' commands.
1484 * md|mds [<addr arg> [<line count> [<radix>]]]
1485 * mdWcN [<addr arg> [<line count> [<radix>]]]
1486 * where W = is the width (1, 2, 4 or 8) and N is the count.
1487 * for eg., md1c20 reads 20 bytes, 1 at a time.
1488 * mdr <addr arg>,<byte count>
1490 static void kdb_md_line(const char *fmtstr, unsigned long addr,
1491 int symbolic, int nosect, int bytesperword,
1492 int num, int repeat, int phys)
1494 /* print just one line of data */
1495 kdb_symtab_t symtab;
1502 memset(cbuf, '\0', sizeof(cbuf));
1504 kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1506 kdb_printf(kdb_machreg_fmt0 " ", addr);
1508 for (i = 0; i < num && repeat--; i++) {
1510 if (kdb_getphysword(&word, addr, bytesperword))
1512 } else if (kdb_getword(&word, addr, bytesperword))
1514 kdb_printf(fmtstr, word);
1516 kdbnearsym(word, &symtab);
1518 memset(&symtab, 0, sizeof(symtab));
1519 if (symtab.sym_name) {
1520 kdb_symbol_print(word, &symtab, 0);
1523 kdb_printf(" %s %s "
1526 kdb_machreg_fmt, symtab.mod_name,
1527 symtab.sec_name, symtab.sec_start,
1528 symtab.sym_start, symtab.sym_end);
1530 addr += bytesperword;
1538 cp = wc.c + 8 - bytesperword;
1543 #define printable_char(c) \
1544 ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1545 for (j = 0; j < bytesperword; j++)
1546 *c++ = printable_char(*cp++);
1547 addr += bytesperword;
1548 #undef printable_char
1551 kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1555 static int kdb_md(int argc, const char **argv)
1557 static unsigned long last_addr;
1558 static int last_radix, last_bytesperword, last_repeat;
1559 int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1561 char fmtchar, fmtstr[64];
1570 kdbgetintenv("MDCOUNT", &mdcount);
1571 kdbgetintenv("RADIX", &radix);
1572 kdbgetintenv("BYTESPERWORD", &bytesperword);
1574 /* Assume 'md <addr>' and start with environment values */
1575 repeat = mdcount * 16 / bytesperword;
1577 if (strcmp(argv[0], "mdr") == 0) {
1578 if (argc == 2 || (argc == 0 && last_addr != 0))
1581 return KDB_ARGCOUNT;
1582 } else if (isdigit(argv[0][2])) {
1583 bytesperword = (int)(argv[0][2] - '0');
1584 if (bytesperword == 0) {
1585 bytesperword = last_bytesperword;
1586 if (bytesperword == 0)
1589 last_bytesperword = bytesperword;
1590 repeat = mdcount * 16 / bytesperword;
1593 else if (argv[0][3] == 'c' && argv[0][4]) {
1595 repeat = simple_strtoul(argv[0] + 4, &p, 10);
1596 mdcount = ((repeat * bytesperword) + 15) / 16;
1599 last_repeat = repeat;
1600 } else if (strcmp(argv[0], "md") == 0)
1602 else if (strcmp(argv[0], "mds") == 0)
1604 else if (strcmp(argv[0], "mdp") == 0) {
1608 return KDB_NOTFOUND;
1612 return KDB_ARGCOUNT;
1615 bytesperword = last_bytesperword;
1616 repeat = last_repeat;
1620 mdcount = ((repeat * bytesperword) + 15) / 16;
1625 int diag, nextarg = 1;
1626 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1630 if (argc > nextarg+2)
1631 return KDB_ARGCOUNT;
1633 if (argc >= nextarg) {
1634 diag = kdbgetularg(argv[nextarg], &val);
1636 mdcount = (int) val;
1640 repeat = mdcount * 16 / bytesperword;
1643 if (argc >= nextarg+1) {
1644 diag = kdbgetularg(argv[nextarg+1], &val);
1650 if (strcmp(argv[0], "mdr") == 0) {
1653 ret = kdb_mdr(addr, mdcount);
1654 last_addr += mdcount;
1655 last_repeat = mdcount;
1656 last_bytesperword = bytesperword; // to make REPEAT happy
1671 return KDB_BADRADIX;
1676 if (bytesperword > KDB_WORD_SIZE)
1677 return KDB_BADWIDTH;
1679 switch (bytesperword) {
1681 sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1684 sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1687 sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1690 sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1693 return KDB_BADWIDTH;
1696 last_repeat = repeat;
1697 last_bytesperword = bytesperword;
1699 if (strcmp(argv[0], "mds") == 0) {
1701 /* Do not save these changes as last_*, they are temporary mds
1704 bytesperword = KDB_WORD_SIZE;
1706 kdbgetintenv("NOSECT", &nosect);
1709 /* Round address down modulo BYTESPERWORD */
1711 addr &= ~(bytesperword-1);
1713 while (repeat > 0) {
1715 int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1717 if (KDB_FLAG(CMD_INTERRUPT))
1719 for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1721 if (kdb_getphysword(&word, a, bytesperword)
1724 } else if (kdb_getword(&word, a, bytesperword) || word)
1727 n = min(num, repeat);
1728 kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1730 addr += bytesperword * n;
1732 z = (z + num - 1) / num;
1734 int s = num * (z-2);
1735 kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1736 " zero suppressed\n",
1737 addr, addr + bytesperword * s - 1);
1738 addr += bytesperword * s;
1748 * kdb_mm - This function implements the 'mm' command.
1749 * mm address-expression new-value
1751 * mm works on machine words, mmW works on bytes.
1753 static int kdb_mm(int argc, const char **argv)
1758 unsigned long contents;
1762 if (argv[0][2] && !isdigit(argv[0][2]))
1763 return KDB_NOTFOUND;
1766 return KDB_ARGCOUNT;
1769 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1774 return KDB_ARGCOUNT;
1775 diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1779 if (nextarg != argc + 1)
1780 return KDB_ARGCOUNT;
1782 width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1783 diag = kdb_putword(addr, contents, width);
1787 kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1793 * kdb_go - This function implements the 'go' command.
1794 * go [address-expression]
1796 static int kdb_go(int argc, const char **argv)
1803 if (raw_smp_processor_id() != kdb_initial_cpu) {
1804 kdb_printf("go must execute on the entry cpu, "
1805 "please use \"cpu %d\" and then execute go\n",
1807 return KDB_BADCPUNUM;
1811 diag = kdbgetaddrarg(argc, argv, &nextarg,
1812 &addr, &offset, NULL);
1816 return KDB_ARGCOUNT;
1820 if (KDB_FLAG(CATASTROPHIC)) {
1821 kdb_printf("Catastrophic error detected\n");
1822 kdb_printf("kdb_continue_catastrophic=%d, ",
1823 kdb_continue_catastrophic);
1824 if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1825 kdb_printf("type go a second time if you really want "
1829 if (kdb_continue_catastrophic == 2) {
1830 kdb_printf("forcing reboot\n");
1831 kdb_reboot(0, NULL);
1833 kdb_printf("attempting to continue\n");
1839 * kdb_rd - This function implements the 'rd' command.
1841 static int kdb_rd(int argc, const char **argv)
1843 int len = kdb_check_regs();
1844 #if DBG_MAX_REG_NUM > 0
1856 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1857 rsize = dbg_reg_def[i].size * 2;
1860 if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
1865 len += kdb_printf(" ");
1866 switch(dbg_reg_def[i].size * 8) {
1868 rname = dbg_get_reg(i, ®8, kdb_current_regs);
1871 len += kdb_printf("%s: %02x", rname, reg8);
1874 rname = dbg_get_reg(i, ®16, kdb_current_regs);
1877 len += kdb_printf("%s: %04x", rname, reg16);
1880 rname = dbg_get_reg(i, ®32, kdb_current_regs);
1883 len += kdb_printf("%s: %08x", rname, reg32);
1886 rname = dbg_get_reg(i, ®64, kdb_current_regs);
1889 len += kdb_printf("%s: %016llx", rname, reg64);
1892 len += kdb_printf("%s: ??", dbg_reg_def[i].name);
1900 kdb_dumpregs(kdb_current_regs);
1906 * kdb_rm - This function implements the 'rm' (register modify) command.
1907 * rm register-name new-contents
1909 * Allows register modification with the same restrictions as gdb
1911 static int kdb_rm(int argc, const char **argv)
1913 #if DBG_MAX_REG_NUM > 0
1923 return KDB_ARGCOUNT;
1925 * Allow presence or absence of leading '%' symbol.
1931 diag = kdbgetu64arg(argv[2], ®64);
1935 diag = kdb_check_regs();
1940 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1941 if (strcmp(rname, dbg_reg_def[i].name) == 0) {
1947 switch(dbg_reg_def[i].size * 8) {
1950 dbg_set_reg(i, ®8, kdb_current_regs);
1954 dbg_set_reg(i, ®16, kdb_current_regs);
1958 dbg_set_reg(i, ®32, kdb_current_regs);
1961 dbg_set_reg(i, ®64, kdb_current_regs);
1967 kdb_printf("ERROR: Register set currently not implemented\n");
1972 #if defined(CONFIG_MAGIC_SYSRQ)
1974 * kdb_sr - This function implements the 'sr' (SYSRQ key) command
1975 * which interfaces to the soi-disant MAGIC SYSRQ functionality.
1976 * sr <magic-sysrq-code>
1978 static int kdb_sr(int argc, const char **argv)
1981 !kdb_check_flags(KDB_ENABLE_ALL, kdb_cmd_enabled, false);
1984 return KDB_ARGCOUNT;
1987 __handle_sysrq(*argv[1], check_mask);
1992 #endif /* CONFIG_MAGIC_SYSRQ */
1995 * kdb_ef - This function implements the 'regs' (display exception
1996 * frame) command. This command takes an address and expects to
1997 * find an exception frame at that address, formats and prints
1999 * regs address-expression
2003 static int kdb_ef(int argc, const char **argv)
2011 return KDB_ARGCOUNT;
2014 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
2017 show_regs((struct pt_regs *)addr);
2021 #if defined(CONFIG_MODULES)
2023 * kdb_lsmod - This function implements the 'lsmod' command. Lists
2024 * currently loaded kernel modules.
2025 * Mostly taken from userland lsmod.
2027 static int kdb_lsmod(int argc, const char **argv)
2032 return KDB_ARGCOUNT;
2034 kdb_printf("Module Size modstruct Used by\n");
2035 list_for_each_entry(mod, kdb_modules, list) {
2036 if (mod->state == MODULE_STATE_UNFORMED)
2039 kdb_printf("%-20s%8u 0x%px ", mod->name,
2040 mod->core_layout.size, (void *)mod);
2041 #ifdef CONFIG_MODULE_UNLOAD
2042 kdb_printf("%4d ", module_refcount(mod));
2044 if (mod->state == MODULE_STATE_GOING)
2045 kdb_printf(" (Unloading)");
2046 else if (mod->state == MODULE_STATE_COMING)
2047 kdb_printf(" (Loading)");
2049 kdb_printf(" (Live)");
2050 kdb_printf(" 0x%px", mod->core_layout.base);
2052 #ifdef CONFIG_MODULE_UNLOAD
2054 struct module_use *use;
2056 list_for_each_entry(use, &mod->source_list,
2058 kdb_printf("%s ", use->target->name);
2067 #endif /* CONFIG_MODULES */
2070 * kdb_env - This function implements the 'env' command. Display the
2071 * current environment variables.
2074 static int kdb_env(int argc, const char **argv)
2078 for (i = 0; i < __nenv; i++) {
2080 kdb_printf("%s\n", __env[i]);
2083 if (KDB_DEBUG(MASK))
2084 kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
2089 #ifdef CONFIG_PRINTK
2091 * kdb_dmesg - This function implements the 'dmesg' command to display
2092 * the contents of the syslog buffer.
2093 * dmesg [lines] [adjust]
2095 static int kdb_dmesg(int argc, const char **argv)
2103 struct kmsg_dumper dumper = { .active = 1 };
2108 return KDB_ARGCOUNT;
2111 lines = simple_strtol(argv[1], &cp, 0);
2115 adjust = simple_strtoul(argv[2], &cp, 0);
2116 if (*cp || adjust < 0)
2121 /* disable LOGGING if set */
2122 diag = kdbgetintenv("LOGGING", &logging);
2123 if (!diag && logging) {
2124 const char *setargs[] = { "set", "LOGGING", "0" };
2125 kdb_set(2, setargs);
2128 kmsg_dump_rewind_nolock(&dumper);
2129 while (kmsg_dump_get_line_nolock(&dumper, 1, NULL, 0, NULL))
2134 kdb_printf("buffer only contains %d lines, nothing "
2136 else if (adjust - lines >= n)
2137 kdb_printf("buffer only contains %d lines, last %d "
2138 "lines printed\n", n, n - adjust);
2141 } else if (lines > 0) {
2142 skip = n - lines - adjust;
2145 kdb_printf("buffer only contains %d lines, "
2146 "nothing printed\n", n);
2148 } else if (skip < 0) {
2151 kdb_printf("buffer only contains %d lines, first "
2152 "%d lines printed\n", n, lines);
2158 if (skip >= n || skip < 0)
2161 kmsg_dump_rewind_nolock(&dumper);
2162 while (kmsg_dump_get_line_nolock(&dumper, 1, buf, sizeof(buf), &len)) {
2169 if (KDB_FLAG(CMD_INTERRUPT))
2172 kdb_printf("%.*s\n", (int)len - 1, buf);
2177 #endif /* CONFIG_PRINTK */
2179 /* Make sure we balance enable/disable calls, must disable first. */
2180 static atomic_t kdb_nmi_disabled;
2182 static int kdb_disable_nmi(int argc, const char *argv[])
2184 if (atomic_read(&kdb_nmi_disabled))
2186 atomic_set(&kdb_nmi_disabled, 1);
2187 arch_kgdb_ops.enable_nmi(0);
2191 static int kdb_param_enable_nmi(const char *val, const struct kernel_param *kp)
2193 if (!atomic_add_unless(&kdb_nmi_disabled, -1, 0))
2195 arch_kgdb_ops.enable_nmi(1);
2199 static const struct kernel_param_ops kdb_param_ops_enable_nmi = {
2200 .set = kdb_param_enable_nmi,
2202 module_param_cb(enable_nmi, &kdb_param_ops_enable_nmi, NULL, 0600);
2205 * kdb_cpu - This function implements the 'cpu' command.
2208 * KDB_CMD_CPU for success, a kdb diagnostic if error
2210 static void kdb_cpu_status(void)
2212 int i, start_cpu, first_print = 1;
2213 char state, prev_state = '?';
2215 kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2216 kdb_printf("Available cpus: ");
2217 for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2218 if (!cpu_online(i)) {
2219 state = 'F'; /* cpu is offline */
2220 } else if (!kgdb_info[i].enter_kgdb) {
2221 state = 'D'; /* cpu is online but unresponsive */
2223 state = ' '; /* cpu is responding to kdb */
2224 if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2225 state = 'I'; /* idle task */
2227 if (state != prev_state) {
2228 if (prev_state != '?') {
2232 kdb_printf("%d", start_cpu);
2233 if (start_cpu < i-1)
2234 kdb_printf("-%d", i-1);
2235 if (prev_state != ' ')
2236 kdb_printf("(%c)", prev_state);
2242 /* print the trailing cpus, ignoring them if they are all offline */
2243 if (prev_state != 'F') {
2246 kdb_printf("%d", start_cpu);
2247 if (start_cpu < i-1)
2248 kdb_printf("-%d", i-1);
2249 if (prev_state != ' ')
2250 kdb_printf("(%c)", prev_state);
2255 static int kdb_cpu(int argc, const char **argv)
2257 unsigned long cpunum;
2266 return KDB_ARGCOUNT;
2268 diag = kdbgetularg(argv[1], &cpunum);
2275 if ((cpunum >= CONFIG_NR_CPUS) || !kgdb_info[cpunum].enter_kgdb)
2276 return KDB_BADCPUNUM;
2278 dbg_switch_cpu = cpunum;
2281 * Switch to other cpu
2286 /* The user may not realize that ps/bta with no parameters does not print idle
2287 * or sleeping system daemon processes, so tell them how many were suppressed.
2289 void kdb_ps_suppressed(void)
2291 int idle = 0, daemon = 0;
2292 unsigned long mask_I = kdb_task_state_string("I"),
2293 mask_M = kdb_task_state_string("M");
2295 const struct task_struct *p, *g;
2296 for_each_online_cpu(cpu) {
2297 p = kdb_curr_task(cpu);
2298 if (kdb_task_state(p, mask_I))
2301 kdb_do_each_thread(g, p) {
2302 if (kdb_task_state(p, mask_M))
2304 } kdb_while_each_thread(g, p);
2305 if (idle || daemon) {
2307 kdb_printf("%d idle process%s (state I)%s\n",
2308 idle, idle == 1 ? "" : "es",
2309 daemon ? " and " : "");
2311 kdb_printf("%d sleeping system daemon (state M) "
2312 "process%s", daemon,
2313 daemon == 1 ? "" : "es");
2314 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2319 * kdb_ps - This function implements the 'ps' command which shows a
2320 * list of the active processes.
2321 * ps [DRSTCZEUIMA] All processes, optionally filtered by state
2323 void kdb_ps1(const struct task_struct *p)
2328 if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
2331 cpu = kdb_process_cpu(p);
2332 kdb_printf("0x%px %8d %8d %d %4d %c 0x%px %c%s\n",
2333 (void *)p, p->pid, p->parent->pid,
2334 kdb_task_has_cpu(p), kdb_process_cpu(p),
2335 kdb_task_state_char(p),
2336 (void *)(&p->thread),
2337 p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2339 if (kdb_task_has_cpu(p)) {
2340 if (!KDB_TSK(cpu)) {
2341 kdb_printf(" Error: no saved data for this cpu\n");
2343 if (KDB_TSK(cpu) != p)
2344 kdb_printf(" Error: does not match running "
2345 "process table (0x%px)\n", KDB_TSK(cpu));
2350 static int kdb_ps(int argc, const char **argv)
2352 struct task_struct *g, *p;
2353 unsigned long mask, cpu;
2356 kdb_ps_suppressed();
2357 kdb_printf("%-*s Pid Parent [*] cpu State %-*s Command\n",
2358 (int)(2*sizeof(void *))+2, "Task Addr",
2359 (int)(2*sizeof(void *))+2, "Thread");
2360 mask = kdb_task_state_string(argc ? argv[1] : NULL);
2361 /* Run the active tasks first */
2362 for_each_online_cpu(cpu) {
2363 if (KDB_FLAG(CMD_INTERRUPT))
2365 p = kdb_curr_task(cpu);
2366 if (kdb_task_state(p, mask))
2370 /* Now the real tasks */
2371 kdb_do_each_thread(g, p) {
2372 if (KDB_FLAG(CMD_INTERRUPT))
2374 if (kdb_task_state(p, mask))
2376 } kdb_while_each_thread(g, p);
2382 * kdb_pid - This function implements the 'pid' command which switches
2383 * the currently active process.
2386 static int kdb_pid(int argc, const char **argv)
2388 struct task_struct *p;
2393 return KDB_ARGCOUNT;
2396 if (strcmp(argv[1], "R") == 0) {
2397 p = KDB_TSK(kdb_initial_cpu);
2399 diag = kdbgetularg(argv[1], &val);
2403 p = find_task_by_pid_ns((pid_t)val, &init_pid_ns);
2405 kdb_printf("No task with pid=%d\n", (pid_t)val);
2409 kdb_set_current_task(p);
2411 kdb_printf("KDB current process is %s(pid=%d)\n",
2412 kdb_current_task->comm,
2413 kdb_current_task->pid);
2418 static int kdb_kgdb(int argc, const char **argv)
2420 return KDB_CMD_KGDB;
2424 * kdb_help - This function implements the 'help' and '?' commands.
2426 static int kdb_help(int argc, const char **argv)
2431 kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2432 kdb_printf("-----------------------------"
2433 "-----------------------------\n");
2434 for_each_kdbcmd(kt, i) {
2436 if (KDB_FLAG(CMD_INTERRUPT))
2440 if (!kdb_check_flags(kt->cmd_flags, kdb_cmd_enabled, true))
2442 if (strlen(kt->cmd_usage) > 20)
2444 kdb_printf("%-15.15s %-20s%s%s\n", kt->cmd_name,
2445 kt->cmd_usage, space, kt->cmd_help);
2451 * kdb_kill - This function implements the 'kill' commands.
2453 static int kdb_kill(int argc, const char **argv)
2457 struct task_struct *p;
2460 return KDB_ARGCOUNT;
2462 sig = simple_strtol(argv[1], &endp, 0);
2465 if ((sig >= 0) || !valid_signal(-sig)) {
2466 kdb_printf("Invalid signal parameter.<-signal>\n");
2471 pid = simple_strtol(argv[2], &endp, 0);
2475 kdb_printf("Process ID must be large than 0.\n");
2479 /* Find the process. */
2480 p = find_task_by_pid_ns(pid, &init_pid_ns);
2482 kdb_printf("The specified process isn't found.\n");
2485 p = p->group_leader;
2486 kdb_send_sig(p, sig);
2491 * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2492 * I cannot call that code directly from kdb, it has an unconditional
2493 * cli()/sti() and calls routines that take locks which can stop the debugger.
2495 static void kdb_sysinfo(struct sysinfo *val)
2497 u64 uptime = ktime_get_mono_fast_ns();
2499 memset(val, 0, sizeof(*val));
2500 val->uptime = div_u64(uptime, NSEC_PER_SEC);
2501 val->loads[0] = avenrun[0];
2502 val->loads[1] = avenrun[1];
2503 val->loads[2] = avenrun[2];
2504 val->procs = nr_threads-1;
2511 * kdb_summary - This function implements the 'summary' command.
2513 static int kdb_summary(int argc, const char **argv)
2520 return KDB_ARGCOUNT;
2522 kdb_printf("sysname %s\n", init_uts_ns.name.sysname);
2523 kdb_printf("release %s\n", init_uts_ns.name.release);
2524 kdb_printf("version %s\n", init_uts_ns.name.version);
2525 kdb_printf("machine %s\n", init_uts_ns.name.machine);
2526 kdb_printf("nodename %s\n", init_uts_ns.name.nodename);
2527 kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2529 now = __ktime_get_real_seconds();
2530 time64_to_tm(now, 0, &tm);
2531 kdb_printf("date %04ld-%02d-%02d %02d:%02d:%02d "
2532 "tz_minuteswest %d\n",
2533 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2534 tm.tm_hour, tm.tm_min, tm.tm_sec,
2535 sys_tz.tz_minuteswest);
2538 kdb_printf("uptime ");
2539 if (val.uptime > (24*60*60)) {
2540 int days = val.uptime / (24*60*60);
2541 val.uptime %= (24*60*60);
2542 kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2544 kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2546 kdb_printf("load avg %ld.%02ld %ld.%02ld %ld.%02ld\n",
2547 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2548 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2549 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2551 /* Display in kilobytes */
2552 #define K(x) ((x) << (PAGE_SHIFT - 10))
2553 kdb_printf("\nMemTotal: %8lu kB\nMemFree: %8lu kB\n"
2554 "Buffers: %8lu kB\n",
2555 K(val.totalram), K(val.freeram), K(val.bufferram));
2560 * kdb_per_cpu - This function implements the 'per_cpu' command.
2562 static int kdb_per_cpu(int argc, const char **argv)
2565 int cpu, diag, nextarg = 1;
2566 unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2568 if (argc < 1 || argc > 3)
2569 return KDB_ARGCOUNT;
2571 diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2576 diag = kdbgetularg(argv[2], &bytesperword);
2581 bytesperword = KDB_WORD_SIZE;
2582 else if (bytesperword > KDB_WORD_SIZE)
2583 return KDB_BADWIDTH;
2584 sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2586 diag = kdbgetularg(argv[3], &whichcpu);
2589 if (whichcpu >= nr_cpu_ids || !cpu_online(whichcpu)) {
2590 kdb_printf("cpu %ld is not online\n", whichcpu);
2591 return KDB_BADCPUNUM;
2595 /* Most architectures use __per_cpu_offset[cpu], some use
2596 * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2598 #ifdef __per_cpu_offset
2599 #define KDB_PCU(cpu) __per_cpu_offset(cpu)
2602 #define KDB_PCU(cpu) __per_cpu_offset[cpu]
2604 #define KDB_PCU(cpu) 0
2607 for_each_online_cpu(cpu) {
2608 if (KDB_FLAG(CMD_INTERRUPT))
2611 if (whichcpu != ~0UL && whichcpu != cpu)
2613 addr = symaddr + KDB_PCU(cpu);
2614 diag = kdb_getword(&val, addr, bytesperword);
2616 kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2617 "read, diag=%d\n", cpu, addr, diag);
2620 kdb_printf("%5d ", cpu);
2621 kdb_md_line(fmtstr, addr,
2622 bytesperword == KDB_WORD_SIZE,
2623 1, bytesperword, 1, 1, 0);
2630 * display help for the use of cmd | grep pattern
2632 static int kdb_grep_help(int argc, const char **argv)
2634 kdb_printf("Usage of cmd args | grep pattern:\n");
2635 kdb_printf(" Any command's output may be filtered through an ");
2636 kdb_printf("emulated 'pipe'.\n");
2637 kdb_printf(" 'grep' is just a key word.\n");
2638 kdb_printf(" The pattern may include a very limited set of "
2639 "metacharacters:\n");
2640 kdb_printf(" pattern or ^pattern or pattern$ or ^pattern$\n");
2641 kdb_printf(" And if there are spaces in the pattern, you may "
2643 kdb_printf(" \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2644 " or \"^pat tern$\"\n");
2649 * kdb_register_flags - This function is used to register a kernel
2653 * func Function to execute the command
2654 * usage A simple usage string showing arguments
2655 * help A simple help string describing command
2656 * repeat Does the command auto repeat on enter?
2658 * zero for success, one if a duplicate command.
2660 #define kdb_command_extend 50 /* arbitrary */
2661 int kdb_register_flags(char *cmd,
2666 kdb_cmdflags_t flags)
2672 * Brute force method to determine duplicates
2674 for_each_kdbcmd(kp, i) {
2675 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2676 kdb_printf("Duplicate kdb command registered: "
2677 "%s, func %px help %s\n", cmd, func, help);
2683 * Insert command into first available location in table
2685 for_each_kdbcmd(kp, i) {
2686 if (kp->cmd_name == NULL)
2690 if (i >= kdb_max_commands) {
2691 kdbtab_t *new = kmalloc_array(kdb_max_commands -
2697 kdb_printf("Could not allocate new kdb_command "
2702 memcpy(new, kdb_commands,
2703 (kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new));
2704 kfree(kdb_commands);
2706 memset(new + kdb_max_commands - KDB_BASE_CMD_MAX, 0,
2707 kdb_command_extend * sizeof(*new));
2709 kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX;
2710 kdb_max_commands += kdb_command_extend;
2714 kp->cmd_func = func;
2715 kp->cmd_usage = usage;
2716 kp->cmd_help = help;
2717 kp->cmd_minlen = minlen;
2718 kp->cmd_flags = flags;
2722 EXPORT_SYMBOL_GPL(kdb_register_flags);
2726 * kdb_register - Compatibility register function for commands that do
2727 * not need to specify a repeat state. Equivalent to
2728 * kdb_register_flags with flags set to 0.
2731 * func Function to execute the command
2732 * usage A simple usage string showing arguments
2733 * help A simple help string describing command
2735 * zero for success, one if a duplicate command.
2737 int kdb_register(char *cmd,
2743 return kdb_register_flags(cmd, func, usage, help, minlen, 0);
2745 EXPORT_SYMBOL_GPL(kdb_register);
2748 * kdb_unregister - This function is used to unregister a kernel
2749 * debugger command. It is generally called when a module which
2750 * implements kdb commands is unloaded.
2754 * zero for success, one command not registered.
2756 int kdb_unregister(char *cmd)
2764 for_each_kdbcmd(kp, i) {
2765 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2766 kp->cmd_name = NULL;
2771 /* Couldn't find it. */
2774 EXPORT_SYMBOL_GPL(kdb_unregister);
2776 /* Initialize the kdb command table. */
2777 static void __init kdb_inittab(void)
2782 for_each_kdbcmd(kp, i)
2783 kp->cmd_name = NULL;
2785 kdb_register_flags("md", kdb_md, "<vaddr>",
2786 "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2787 KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2788 kdb_register_flags("mdr", kdb_md, "<vaddr> <bytes>",
2789 "Display Raw Memory", 0,
2790 KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2791 kdb_register_flags("mdp", kdb_md, "<paddr> <bytes>",
2792 "Display Physical Memory", 0,
2793 KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2794 kdb_register_flags("mds", kdb_md, "<vaddr>",
2795 "Display Memory Symbolically", 0,
2796 KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2797 kdb_register_flags("mm", kdb_mm, "<vaddr> <contents>",
2798 "Modify Memory Contents", 0,
2799 KDB_ENABLE_MEM_WRITE | KDB_REPEAT_NO_ARGS);
2800 kdb_register_flags("go", kdb_go, "[<vaddr>]",
2801 "Continue Execution", 1,
2802 KDB_ENABLE_REG_WRITE | KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
2803 kdb_register_flags("rd", kdb_rd, "",
2804 "Display Registers", 0,
2805 KDB_ENABLE_REG_READ);
2806 kdb_register_flags("rm", kdb_rm, "<reg> <contents>",
2807 "Modify Registers", 0,
2808 KDB_ENABLE_REG_WRITE);
2809 kdb_register_flags("ef", kdb_ef, "<vaddr>",
2810 "Display exception frame", 0,
2811 KDB_ENABLE_MEM_READ);
2812 kdb_register_flags("bt", kdb_bt, "[<vaddr>]",
2813 "Stack traceback", 1,
2814 KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS);
2815 kdb_register_flags("btp", kdb_bt, "<pid>",
2816 "Display stack for process <pid>", 0,
2817 KDB_ENABLE_INSPECT);
2818 kdb_register_flags("bta", kdb_bt, "[D|R|S|T|C|Z|E|U|I|M|A]",
2819 "Backtrace all processes matching state flag", 0,
2820 KDB_ENABLE_INSPECT);
2821 kdb_register_flags("btc", kdb_bt, "",
2822 "Backtrace current process on each cpu", 0,
2823 KDB_ENABLE_INSPECT);
2824 kdb_register_flags("btt", kdb_bt, "<vaddr>",
2825 "Backtrace process given its struct task address", 0,
2826 KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS);
2827 kdb_register_flags("env", kdb_env, "",
2828 "Show environment variables", 0,
2829 KDB_ENABLE_ALWAYS_SAFE);
2830 kdb_register_flags("set", kdb_set, "",
2831 "Set environment variables", 0,
2832 KDB_ENABLE_ALWAYS_SAFE);
2833 kdb_register_flags("help", kdb_help, "",
2834 "Display Help Message", 1,
2835 KDB_ENABLE_ALWAYS_SAFE);
2836 kdb_register_flags("?", kdb_help, "",
2837 "Display Help Message", 0,
2838 KDB_ENABLE_ALWAYS_SAFE);
2839 kdb_register_flags("cpu", kdb_cpu, "<cpunum>",
2840 "Switch to new cpu", 0,
2841 KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
2842 kdb_register_flags("kgdb", kdb_kgdb, "",
2843 "Enter kgdb mode", 0, 0);
2844 kdb_register_flags("ps", kdb_ps, "[<flags>|A]",
2845 "Display active task list", 0,
2846 KDB_ENABLE_INSPECT);
2847 kdb_register_flags("pid", kdb_pid, "<pidnum>",
2848 "Switch to another task", 0,
2849 KDB_ENABLE_INSPECT);
2850 kdb_register_flags("reboot", kdb_reboot, "",
2851 "Reboot the machine immediately", 0,
2853 #if defined(CONFIG_MODULES)
2854 kdb_register_flags("lsmod", kdb_lsmod, "",
2855 "List loaded kernel modules", 0,
2856 KDB_ENABLE_INSPECT);
2858 #if defined(CONFIG_MAGIC_SYSRQ)
2859 kdb_register_flags("sr", kdb_sr, "<key>",
2860 "Magic SysRq key", 0,
2861 KDB_ENABLE_ALWAYS_SAFE);
2863 #if defined(CONFIG_PRINTK)
2864 kdb_register_flags("dmesg", kdb_dmesg, "[lines]",
2865 "Display syslog buffer", 0,
2866 KDB_ENABLE_ALWAYS_SAFE);
2868 if (arch_kgdb_ops.enable_nmi) {
2869 kdb_register_flags("disable_nmi", kdb_disable_nmi, "",
2870 "Disable NMI entry to KDB", 0,
2871 KDB_ENABLE_ALWAYS_SAFE);
2873 kdb_register_flags("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
2874 "Define a set of commands, down to endefcmd", 0,
2875 KDB_ENABLE_ALWAYS_SAFE);
2876 kdb_register_flags("kill", kdb_kill, "<-signal> <pid>",
2877 "Send a signal to a process", 0,
2879 kdb_register_flags("summary", kdb_summary, "",
2880 "Summarize the system", 4,
2881 KDB_ENABLE_ALWAYS_SAFE);
2882 kdb_register_flags("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
2883 "Display per_cpu variables", 3,
2884 KDB_ENABLE_MEM_READ);
2885 kdb_register_flags("grephelp", kdb_grep_help, "",
2886 "Display help on | grep", 0,
2887 KDB_ENABLE_ALWAYS_SAFE);
2890 /* Execute any commands defined in kdb_cmds. */
2891 static void __init kdb_cmd_init(void)
2894 for (i = 0; kdb_cmds[i]; ++i) {
2895 diag = kdb_parse(kdb_cmds[i]);
2897 kdb_printf("kdb command %s failed, kdb diag %d\n",
2900 if (defcmd_in_progress) {
2901 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2902 kdb_parse("endefcmd");
2906 /* Initialize kdb_printf, breakpoint tables and kdb state */
2907 void __init kdb_init(int lvl)
2909 static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2912 if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2914 for (i = kdb_init_lvl; i < lvl; i++) {
2916 case KDB_NOT_INITIALIZED:
2917 kdb_inittab(); /* Initialize Command Table */
2918 kdb_initbptab(); /* Initialize Breakpoints */
2920 case KDB_INIT_EARLY:
2921 kdb_cmd_init(); /* Build kdb_cmds tables */