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 <linux/security.h>
49 #include "kdb_private.h"
51 #undef MODULE_PARAM_PREFIX
52 #define MODULE_PARAM_PREFIX "kdb."
54 static int kdb_cmd_enabled = CONFIG_KDB_DEFAULT_ENABLE;
55 module_param_named(cmd_enable, kdb_cmd_enabled, int, 0600);
57 char kdb_grep_string[KDB_GREP_STRLEN];
58 int kdb_grepping_flag;
59 EXPORT_SYMBOL(kdb_grepping_flag);
61 int kdb_grep_trailing;
64 * Kernel debugger state flags
66 unsigned int kdb_flags;
69 * kdb_lock protects updates to kdb_initial_cpu. Used to
70 * single thread processors through the kernel debugger.
72 int kdb_initial_cpu = -1; /* cpu number that owns kdb */
74 int kdb_state; /* General KDB state */
76 struct task_struct *kdb_current_task;
77 struct pt_regs *kdb_current_regs;
79 const char *kdb_diemsg;
80 static int kdb_go_count;
81 #ifdef CONFIG_KDB_CONTINUE_CATASTROPHIC
82 static unsigned int kdb_continue_catastrophic =
83 CONFIG_KDB_CONTINUE_CATASTROPHIC;
85 static unsigned int kdb_continue_catastrophic;
88 /* kdb_commands describes the available commands. */
89 static kdbtab_t *kdb_commands;
90 #define KDB_BASE_CMD_MAX 50
91 static int kdb_max_commands = KDB_BASE_CMD_MAX;
92 static kdbtab_t kdb_base_commands[KDB_BASE_CMD_MAX];
93 #define for_each_kdbcmd(cmd, num) \
94 for ((cmd) = kdb_base_commands, (num) = 0; \
95 num < kdb_max_commands; \
96 num++, num == KDB_BASE_CMD_MAX ? cmd = kdb_commands : cmd++)
98 typedef struct _kdbmsg {
99 int km_diag; /* kdb diagnostic */
100 char *km_msg; /* Corresponding message text */
103 #define KDBMSG(msgnum, text) \
104 { KDB_##msgnum, text }
106 static kdbmsg_t kdbmsgs[] = {
107 KDBMSG(NOTFOUND, "Command Not Found"),
108 KDBMSG(ARGCOUNT, "Improper argument count, see usage."),
109 KDBMSG(BADWIDTH, "Illegal value for BYTESPERWORD use 1, 2, 4 or 8, "
110 "8 is only allowed on 64 bit systems"),
111 KDBMSG(BADRADIX, "Illegal value for RADIX use 8, 10 or 16"),
112 KDBMSG(NOTENV, "Cannot find environment variable"),
113 KDBMSG(NOENVVALUE, "Environment variable should have value"),
114 KDBMSG(NOTIMP, "Command not implemented"),
115 KDBMSG(ENVFULL, "Environment full"),
116 KDBMSG(ENVBUFFULL, "Environment buffer full"),
117 KDBMSG(TOOMANYBPT, "Too many breakpoints defined"),
118 #ifdef CONFIG_CPU_XSCALE
119 KDBMSG(TOOMANYDBREGS, "More breakpoints than ibcr registers defined"),
121 KDBMSG(TOOMANYDBREGS, "More breakpoints than db registers defined"),
123 KDBMSG(DUPBPT, "Duplicate breakpoint address"),
124 KDBMSG(BPTNOTFOUND, "Breakpoint not found"),
125 KDBMSG(BADMODE, "Invalid IDMODE"),
126 KDBMSG(BADINT, "Illegal numeric value"),
127 KDBMSG(INVADDRFMT, "Invalid symbolic address format"),
128 KDBMSG(BADREG, "Invalid register name"),
129 KDBMSG(BADCPUNUM, "Invalid cpu number"),
130 KDBMSG(BADLENGTH, "Invalid length field"),
131 KDBMSG(NOBP, "No Breakpoint exists"),
132 KDBMSG(BADADDR, "Invalid address"),
133 KDBMSG(NOPERM, "Permission denied"),
137 static const int __nkdb_err = ARRAY_SIZE(kdbmsgs);
141 * Initial environment. This is all kept static and local to
142 * this file. We don't want to rely on the memory allocation
143 * mechanisms in the kernel, so we use a very limited allocate-only
144 * heap for new and altered environment variables. The entire
145 * environment is limited to a fixed number of entries (add more
146 * to __env[] if required) and a fixed amount of heap (add more to
147 * KDB_ENVBUFSIZE if required).
150 static char *__env[] = {
151 #if defined(CONFIG_SMP)
158 "MDCOUNT=8", /* lines of md output */
188 static const int __nenv = ARRAY_SIZE(__env);
190 struct task_struct *kdb_curr_task(int cpu)
192 struct task_struct *p = curr_task(cpu);
194 if ((task_thread_info(p)->flags & _TIF_MCA_INIT) && KDB_TSK(cpu))
201 * Update the permissions flags (kdb_cmd_enabled) to match the
202 * current lockdown state.
204 * Within this function the calls to security_locked_down() are "lazy". We
205 * avoid calling them if the current value of kdb_cmd_enabled already excludes
206 * flags that might be subject to lockdown. Additionally we deliberately check
207 * the lockdown flags independently (even though read lockdown implies write
208 * lockdown) since that results in both simpler code and clearer messages to
209 * the user on first-time debugger entry.
211 * The permission masks during a read+write lockdown permits the following
212 * flags: INSPECT, SIGNAL, REBOOT (and ALWAYS_SAFE).
214 * The INSPECT commands are not blocked during lockdown because they are
215 * not arbitrary memory reads. INSPECT covers the backtrace family (sometimes
216 * forcing them to have no arguments) and lsmod. These commands do expose
217 * some kernel state but do not allow the developer seated at the console to
218 * choose what state is reported. SIGNAL and REBOOT should not be controversial,
219 * given these are allowed for root during lockdown already.
221 static void kdb_check_for_lockdown(void)
223 const int write_flags = KDB_ENABLE_MEM_WRITE |
224 KDB_ENABLE_REG_WRITE |
225 KDB_ENABLE_FLOW_CTRL;
226 const int read_flags = KDB_ENABLE_MEM_READ |
229 bool need_to_lockdown_write = false;
230 bool need_to_lockdown_read = false;
232 if (kdb_cmd_enabled & (KDB_ENABLE_ALL | write_flags))
233 need_to_lockdown_write =
234 security_locked_down(LOCKDOWN_DBG_WRITE_KERNEL);
236 if (kdb_cmd_enabled & (KDB_ENABLE_ALL | read_flags))
237 need_to_lockdown_read =
238 security_locked_down(LOCKDOWN_DBG_READ_KERNEL);
240 /* De-compose KDB_ENABLE_ALL if required */
241 if (need_to_lockdown_write || need_to_lockdown_read)
242 if (kdb_cmd_enabled & KDB_ENABLE_ALL)
243 kdb_cmd_enabled = KDB_ENABLE_MASK & ~KDB_ENABLE_ALL;
245 if (need_to_lockdown_write)
246 kdb_cmd_enabled &= ~write_flags;
248 if (need_to_lockdown_read)
249 kdb_cmd_enabled &= ~read_flags;
253 * Check whether the flags of the current command, the permissions of the kdb
254 * console and the lockdown state allow a command to be run.
256 static bool kdb_check_flags(kdb_cmdflags_t flags, int permissions,
259 /* permissions comes from userspace so needs massaging slightly */
260 permissions &= KDB_ENABLE_MASK;
261 permissions |= KDB_ENABLE_ALWAYS_SAFE;
263 /* some commands change group when launched with no arguments */
265 permissions |= permissions << KDB_ENABLE_NO_ARGS_SHIFT;
267 flags |= KDB_ENABLE_ALL;
269 return permissions & flags;
273 * kdbgetenv - This function will return the character string value of
274 * an environment variable.
276 * match A character string representing an environment variable.
278 * NULL No environment variable matches 'match'
279 * char* Pointer to string value of environment variable.
281 char *kdbgetenv(const char *match)
284 int matchlen = strlen(match);
287 for (i = 0; i < __nenv; i++) {
293 if ((strncmp(match, e, matchlen) == 0)
294 && ((e[matchlen] == '\0')
295 || (e[matchlen] == '='))) {
296 char *cp = strchr(e, '=');
297 return cp ? ++cp : "";
304 * kdballocenv - This function is used to allocate bytes for
305 * environment entries.
307 * match A character string representing a numeric value
309 * *value the unsigned long representation of the env variable 'match'
311 * Zero on success, a kdb diagnostic on failure.
313 * We use a static environment buffer (envbuffer) to hold the values
314 * of dynamically generated environment variables (see kdb_set). Buffer
315 * space once allocated is never free'd, so over time, the amount of space
316 * (currently 512 bytes) will be exhausted if env variables are changed
319 static char *kdballocenv(size_t bytes)
321 #define KDB_ENVBUFSIZE 512
322 static char envbuffer[KDB_ENVBUFSIZE];
323 static int envbufsize;
326 if ((KDB_ENVBUFSIZE - envbufsize) >= bytes) {
327 ep = &envbuffer[envbufsize];
334 * kdbgetulenv - This function will return the value of an unsigned
335 * long-valued environment variable.
337 * match A character string representing a numeric value
339 * *value the unsigned long represntation of the env variable 'match'
341 * Zero on success, a kdb diagnostic on failure.
343 static int kdbgetulenv(const char *match, unsigned long *value)
347 ep = kdbgetenv(match);
351 return KDB_NOENVVALUE;
353 *value = simple_strtoul(ep, NULL, 0);
359 * kdbgetintenv - This function will return the value of an
360 * integer-valued environment variable.
362 * match A character string representing an integer-valued env variable
364 * *value the integer representation of the environment variable 'match'
366 * Zero on success, a kdb diagnostic on failure.
368 int kdbgetintenv(const char *match, int *value)
373 diag = kdbgetulenv(match, &val);
380 * kdbgetularg - This function will convert a numeric string into an
381 * unsigned long value.
383 * arg A character string representing a numeric value
385 * *value the unsigned long represntation of arg.
387 * Zero on success, a kdb diagnostic on failure.
389 int kdbgetularg(const char *arg, unsigned long *value)
394 val = simple_strtoul(arg, &endp, 0);
398 * Also try base 16, for us folks too lazy to type the
401 val = simple_strtoul(arg, &endp, 16);
411 int kdbgetu64arg(const char *arg, u64 *value)
416 val = simple_strtoull(arg, &endp, 0);
420 val = simple_strtoull(arg, &endp, 16);
431 * kdb_set - This function implements the 'set' command. Alter an
432 * existing environment variable or create a new one.
434 int kdb_set(int argc, const char **argv)
438 size_t varlen, vallen;
441 * we can be invoked two ways:
442 * set var=value argv[1]="var", argv[2]="value"
443 * set var = value argv[1]="var", argv[2]="=", argv[3]="value"
444 * - if the latter, shift 'em down.
455 * Censor sensitive variables
457 if (strcmp(argv[1], "PROMPT") == 0 &&
458 !kdb_check_flags(KDB_ENABLE_MEM_READ, kdb_cmd_enabled, false))
462 * Check for internal variables
464 if (strcmp(argv[1], "KDBDEBUG") == 0) {
465 unsigned int debugflags;
468 debugflags = simple_strtoul(argv[2], &cp, 0);
469 if (cp == argv[2] || debugflags & ~KDB_DEBUG_FLAG_MASK) {
470 kdb_printf("kdb: illegal debug flags '%s'\n",
474 kdb_flags = (kdb_flags & ~KDB_DEBUG(MASK))
475 | (debugflags << KDB_DEBUG_FLAG_SHIFT);
481 * Tokenizer squashed the '=' sign. argv[1] is variable
482 * name, argv[2] = value.
484 varlen = strlen(argv[1]);
485 vallen = strlen(argv[2]);
486 ep = kdballocenv(varlen + vallen + 2);
488 return KDB_ENVBUFFULL;
490 sprintf(ep, "%s=%s", argv[1], argv[2]);
492 ep[varlen+vallen+1] = '\0';
494 for (i = 0; i < __nenv; i++) {
496 && ((strncmp(__env[i], argv[1], varlen) == 0)
497 && ((__env[i][varlen] == '\0')
498 || (__env[i][varlen] == '=')))) {
505 * Wasn't existing variable. Fit into slot.
507 for (i = 0; i < __nenv-1; i++) {
508 if (__env[i] == (char *)0) {
517 static int kdb_check_regs(void)
519 if (!kdb_current_regs) {
520 kdb_printf("No current kdb registers."
521 " You may need to select another task\n");
528 * kdbgetaddrarg - This function is responsible for parsing an
529 * address-expression and returning the value of the expression,
530 * symbol name, and offset to the caller.
532 * The argument may consist of a numeric value (decimal or
533 * hexidecimal), a symbol name, a register name (preceded by the
534 * percent sign), an environment variable with a numeric value
535 * (preceded by a dollar sign) or a simple arithmetic expression
536 * consisting of a symbol name, +/-, and a numeric constant value
539 * argc - count of arguments in argv
540 * argv - argument vector
541 * *nextarg - index to next unparsed argument in argv[]
542 * regs - Register state at time of KDB entry
544 * *value - receives the value of the address-expression
545 * *offset - receives the offset specified, if any
546 * *name - receives the symbol name, if any
547 * *nextarg - index to next unparsed argument in argv[]
549 * zero is returned on success, a kdb diagnostic code is
552 int kdbgetaddrarg(int argc, const char **argv, int *nextarg,
553 unsigned long *value, long *offset,
557 unsigned long off = 0;
567 * If the enable flags prohibit both arbitrary memory access
568 * and flow control then there are no reasonable grounds to
569 * provide symbol lookup.
571 if (!kdb_check_flags(KDB_ENABLE_MEM_READ | KDB_ENABLE_FLOW_CTRL,
572 kdb_cmd_enabled, false))
576 * Process arguments which follow the following syntax:
578 * symbol | numeric-address [+/- numeric-offset]
580 * $environment-variable
586 symname = (char *)argv[*nextarg];
589 * If there is no whitespace between the symbol
590 * or address and the '+' or '-' symbols, we
591 * remember the character and replace it with a
592 * null so the symbol/value can be properly parsed
594 cp = strpbrk(symname, "+-");
600 if (symname[0] == '$') {
601 diag = kdbgetulenv(&symname[1], &addr);
604 } else if (symname[0] == '%') {
605 diag = kdb_check_regs();
608 /* Implement register values with % at a later time as it is
613 found = kdbgetsymval(symname, &symtab);
615 addr = symtab.sym_start;
617 diag = kdbgetularg(argv[*nextarg], &addr);
624 found = kdbnearsym(addr, &symtab);
632 if (offset && name && *name)
633 *offset = addr - symtab.sym_start;
635 if ((*nextarg > argc)
640 * check for +/- and offset
643 if (symbol == '\0') {
644 if ((argv[*nextarg][0] != '+')
645 && (argv[*nextarg][0] != '-')) {
647 * Not our argument. Return.
651 positive = (argv[*nextarg][0] == '+');
655 positive = (symbol == '+');
658 * Now there must be an offset!
660 if ((*nextarg > argc)
661 && (symbol == '\0')) {
662 return KDB_INVADDRFMT;
666 cp = (char *)argv[*nextarg];
670 diag = kdbgetularg(cp, &off);
686 static void kdb_cmderror(int diag)
691 kdb_printf("no error detected (diagnostic is %d)\n", diag);
695 for (i = 0; i < __nkdb_err; i++) {
696 if (kdbmsgs[i].km_diag == diag) {
697 kdb_printf("diag: %d: %s\n", diag, kdbmsgs[i].km_msg);
702 kdb_printf("Unknown diag %d\n", -diag);
706 * kdb_defcmd, kdb_defcmd2 - This function implements the 'defcmd'
707 * command which defines one command as a set of other commands,
708 * terminated by endefcmd. kdb_defcmd processes the initial
709 * 'defcmd' command, kdb_defcmd2 is invoked from kdb_parse for
710 * the following commands until 'endefcmd'.
712 * argc argument count
713 * argv argument vector
715 * zero for success, a kdb diagnostic if error
725 static struct defcmd_set *defcmd_set;
726 static int defcmd_set_count;
727 static bool defcmd_in_progress;
729 /* Forward references */
730 static int kdb_exec_defcmd(int argc, const char **argv);
732 static int kdb_defcmd2(const char *cmdstr, const char *argv0)
734 struct defcmd_set *s = defcmd_set + defcmd_set_count - 1;
735 char **save_command = s->command;
736 if (strcmp(argv0, "endefcmd") == 0) {
737 defcmd_in_progress = false;
741 /* macros are always safe because when executed each
742 * internal command re-enters kdb_parse() and is
743 * safety checked individually.
745 kdb_register_flags(s->name, kdb_exec_defcmd, s->usage,
747 KDB_ENABLE_ALWAYS_SAFE);
752 s->command = kcalloc(s->count + 1, sizeof(*(s->command)), GFP_KDB);
754 kdb_printf("Could not allocate new kdb_defcmd table for %s\n",
759 memcpy(s->command, save_command, s->count * sizeof(*(s->command)));
760 s->command[s->count++] = kdb_strdup(cmdstr, GFP_KDB);
765 static int kdb_defcmd(int argc, const char **argv)
767 struct defcmd_set *save_defcmd_set = defcmd_set, *s;
768 if (defcmd_in_progress) {
769 kdb_printf("kdb: nested defcmd detected, assuming missing "
771 kdb_defcmd2("endefcmd", "endefcmd");
775 for (s = defcmd_set; s < defcmd_set + defcmd_set_count; ++s) {
776 kdb_printf("defcmd %s \"%s\" \"%s\"\n", s->name,
778 for (i = 0; i < s->count; ++i)
779 kdb_printf("%s", s->command[i]);
780 kdb_printf("endefcmd\n");
786 if (in_dbg_master()) {
787 kdb_printf("Command only available during kdb_init()\n");
790 defcmd_set = kmalloc_array(defcmd_set_count + 1, sizeof(*defcmd_set),
794 memcpy(defcmd_set, save_defcmd_set,
795 defcmd_set_count * sizeof(*defcmd_set));
796 s = defcmd_set + defcmd_set_count;
797 memset(s, 0, sizeof(*s));
799 s->name = kdb_strdup(argv[1], GFP_KDB);
802 s->usage = kdb_strdup(argv[2], GFP_KDB);
805 s->help = kdb_strdup(argv[3], GFP_KDB);
808 if (s->usage[0] == '"') {
809 strcpy(s->usage, argv[2]+1);
810 s->usage[strlen(s->usage)-1] = '\0';
812 if (s->help[0] == '"') {
813 strcpy(s->help, argv[3]+1);
814 s->help[strlen(s->help)-1] = '\0';
817 defcmd_in_progress = true;
818 kfree(save_defcmd_set);
827 kdb_printf("Could not allocate new defcmd_set entry for %s\n", argv[1]);
828 defcmd_set = save_defcmd_set;
833 * kdb_exec_defcmd - Execute the set of commands associated with this
836 * argc argument count
837 * argv argument vector
839 * zero for success, a kdb diagnostic if error
841 static int kdb_exec_defcmd(int argc, const char **argv)
844 struct defcmd_set *s;
847 for (s = defcmd_set, i = 0; i < defcmd_set_count; ++i, ++s) {
848 if (strcmp(s->name, argv[0]) == 0)
851 if (i == defcmd_set_count) {
852 kdb_printf("kdb_exec_defcmd: could not find commands for %s\n",
856 for (i = 0; i < s->count; ++i) {
857 /* Recursive use of kdb_parse, do not use argv after
860 kdb_printf("[%s]kdb> %s\n", s->name, s->command[i]);
861 ret = kdb_parse(s->command[i]);
868 /* Command history */
869 #define KDB_CMD_HISTORY_COUNT 32
870 #define CMD_BUFLEN 200 /* kdb_printf: max printline
872 static unsigned int cmd_head, cmd_tail;
873 static unsigned int cmdptr;
874 static char cmd_hist[KDB_CMD_HISTORY_COUNT][CMD_BUFLEN];
875 static char cmd_cur[CMD_BUFLEN];
878 * The "str" argument may point to something like | grep xyz
880 static void parse_grep(const char *str)
883 char *cp = (char *)str, *cp2;
885 /* sanity check: we should have been called with the \ first */
891 if (!str_has_prefix(cp, "grep ")) {
892 kdb_printf("invalid 'pipe', see grephelp\n");
898 cp2 = strchr(cp, '\n');
900 *cp2 = '\0'; /* remove the trailing newline */
903 kdb_printf("invalid 'pipe', see grephelp\n");
906 /* now cp points to a nonzero length search string */
908 /* allow it be "x y z" by removing the "'s - there must
911 cp2 = strchr(cp, '"');
913 kdb_printf("invalid quoted string, see grephelp\n");
916 *cp2 = '\0'; /* end the string where the 2nd " was */
918 kdb_grep_leading = 0;
920 kdb_grep_leading = 1;
924 kdb_grep_trailing = 0;
925 if (*(cp+len-1) == '$') {
926 kdb_grep_trailing = 1;
932 if (len >= KDB_GREP_STRLEN) {
933 kdb_printf("search string too long\n");
936 strcpy(kdb_grep_string, cp);
942 * kdb_parse - Parse the command line, search the command table for a
943 * matching command and invoke the command function. This
944 * function may be called recursively, if it is, the second call
945 * will overwrite argv and cbuf. It is the caller's
946 * responsibility to save their argv if they recursively call
949 * cmdstr The input command line to be parsed.
950 * regs The registers at the time kdb was entered.
952 * Zero for success, a kdb diagnostic if failure.
954 * Limited to 20 tokens.
956 * Real rudimentary tokenization. Basically only whitespace
957 * is considered a token delimeter (but special consideration
958 * is taken of the '=' sign as used by the 'set' command).
960 * The algorithm used to tokenize the input string relies on
961 * there being at least one whitespace (or otherwise useless)
962 * character between tokens as the character immediately following
963 * the token is altered in-place to a null-byte to terminate the
969 int kdb_parse(const char *cmdstr)
971 static char *argv[MAXARGC];
973 static char cbuf[CMD_BUFLEN+2];
977 int i, escaped, ignore_errors = 0, check_grep = 0;
980 * First tokenize the command string.
984 if (KDB_FLAG(CMD_INTERRUPT)) {
985 /* Previous command was interrupted, newline must not
986 * repeat the command */
987 KDB_FLAG_CLEAR(CMD_INTERRUPT);
988 KDB_STATE_SET(PAGER);
989 argc = 0; /* no repeat */
992 if (*cp != '\n' && *cp != '\0') {
996 /* skip whitespace */
999 if ((*cp == '\0') || (*cp == '\n') ||
1000 (*cp == '#' && !defcmd_in_progress))
1002 /* special case: check for | grep pattern */
1007 if (cpp >= cbuf + CMD_BUFLEN) {
1008 kdb_printf("kdb_parse: command buffer "
1009 "overflow, command ignored\n%s\n",
1011 return KDB_NOTFOUND;
1013 if (argc >= MAXARGC - 1) {
1014 kdb_printf("kdb_parse: too many arguments, "
1015 "command ignored\n%s\n", cmdstr);
1016 return KDB_NOTFOUND;
1021 /* Copy to next unquoted and unescaped
1022 * whitespace or '=' */
1023 while (*cp && *cp != '\n' &&
1024 (escaped || quoted || !isspace(*cp))) {
1025 if (cpp >= cbuf + CMD_BUFLEN)
1039 else if (*cp == '\'' || *cp == '"')
1042 if (*cpp == '=' && !quoted)
1046 *cpp++ = '\0'; /* Squash a ws or '=' character */
1053 if (defcmd_in_progress) {
1054 int result = kdb_defcmd2(cmdstr, argv[0]);
1055 if (!defcmd_in_progress) {
1056 argc = 0; /* avoid repeat on endefcmd */
1061 if (argv[0][0] == '-' && argv[0][1] &&
1062 (argv[0][1] < '0' || argv[0][1] > '9')) {
1067 for_each_kdbcmd(tp, i) {
1070 * If this command is allowed to be abbreviated,
1071 * check to see if this is it.
1075 && (strlen(argv[0]) <= tp->cmd_minlen)) {
1076 if (strncmp(argv[0],
1078 tp->cmd_minlen) == 0) {
1083 if (strcmp(argv[0], tp->cmd_name) == 0)
1089 * If we don't find a command by this name, see if the first
1090 * few characters of this match any of the known commands.
1091 * e.g., md1c20 should match md.
1093 if (i == kdb_max_commands) {
1094 for_each_kdbcmd(tp, i) {
1096 if (strncmp(argv[0],
1098 strlen(tp->cmd_name)) == 0) {
1105 if (i < kdb_max_commands) {
1108 if (!kdb_check_flags(tp->cmd_flags, kdb_cmd_enabled, argc <= 1))
1112 result = (*tp->cmd_func)(argc-1, (const char **)argv);
1113 if (result && ignore_errors && result > KDB_CMD_GO)
1115 KDB_STATE_CLEAR(CMD);
1117 if (tp->cmd_flags & KDB_REPEAT_WITH_ARGS)
1120 argc = tp->cmd_flags & KDB_REPEAT_NO_ARGS ? 1 : 0;
1122 *(argv[argc]) = '\0';
1127 * If the input with which we were presented does not
1128 * map to an existing command, attempt to parse it as an
1129 * address argument and display the result. Useful for
1130 * obtaining the address of a variable, or the nearest symbol
1131 * to an address contained in a register.
1134 unsigned long value;
1139 if (kdbgetaddrarg(0, (const char **)argv, &nextarg,
1140 &value, &offset, &name)) {
1141 return KDB_NOTFOUND;
1144 kdb_printf("%s = ", argv[0]);
1145 kdb_symbol_print(value, NULL, KDB_SP_DEFAULT);
1152 static int handle_ctrl_cmd(char *cmd)
1157 /* initial situation */
1158 if (cmd_head == cmd_tail)
1162 if (cmdptr != cmd_tail)
1163 cmdptr = (cmdptr + KDB_CMD_HISTORY_COUNT - 1) %
1164 KDB_CMD_HISTORY_COUNT;
1165 strscpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1168 if (cmdptr != cmd_head)
1169 cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT;
1170 strscpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1177 * kdb_reboot - This function implements the 'reboot' command. Reboot
1178 * the system immediately, or loop for ever on failure.
1180 static int kdb_reboot(int argc, const char **argv)
1182 emergency_restart();
1183 kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
1190 static void kdb_dumpregs(struct pt_regs *regs)
1192 int old_lvl = console_loglevel;
1193 console_loglevel = CONSOLE_LOGLEVEL_MOTORMOUTH;
1198 console_loglevel = old_lvl;
1201 static void kdb_set_current_task(struct task_struct *p)
1203 kdb_current_task = p;
1205 if (kdb_task_has_cpu(p)) {
1206 kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p));
1209 kdb_current_regs = NULL;
1212 static void drop_newline(char *buf)
1214 size_t len = strlen(buf);
1218 if (*(buf + len - 1) == '\n')
1219 *(buf + len - 1) = '\0';
1223 * kdb_local - The main code for kdb. This routine is invoked on a
1224 * specific processor, it is not global. The main kdb() routine
1225 * ensures that only one processor at a time is in this routine.
1226 * This code is called with the real reason code on the first
1227 * entry to a kdb session, thereafter it is called with reason
1228 * SWITCH, even if the user goes back to the original cpu.
1230 * reason The reason KDB was invoked
1231 * error The hardware-defined error code
1232 * regs The exception frame at time of fault/breakpoint.
1233 * db_result Result code from the break or debug point.
1235 * 0 KDB was invoked for an event which it wasn't responsible
1236 * 1 KDB handled the event for which it was invoked.
1237 * KDB_CMD_GO User typed 'go'.
1238 * KDB_CMD_CPU User switched to another cpu.
1239 * KDB_CMD_SS Single step.
1241 static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs,
1242 kdb_dbtrap_t db_result)
1246 struct task_struct *kdb_current =
1247 kdb_curr_task(raw_smp_processor_id());
1249 KDB_DEBUG_STATE("kdb_local 1", reason);
1251 kdb_check_for_lockdown();
1254 if (reason == KDB_REASON_DEBUG) {
1255 /* special case below */
1257 kdb_printf("\nEntering kdb (current=0x%px, pid %d) ",
1258 kdb_current, kdb_current ? kdb_current->pid : 0);
1259 #if defined(CONFIG_SMP)
1260 kdb_printf("on processor %d ", raw_smp_processor_id());
1265 case KDB_REASON_DEBUG:
1268 * If re-entering kdb after a single step
1269 * command, don't print the message.
1271 switch (db_result) {
1273 kdb_printf("\nEntering kdb (0x%px, pid %d) ",
1274 kdb_current, kdb_current->pid);
1275 #if defined(CONFIG_SMP)
1276 kdb_printf("on processor %d ", raw_smp_processor_id());
1278 kdb_printf("due to Debug @ " kdb_machreg_fmt "\n",
1279 instruction_pointer(regs));
1284 KDB_DEBUG_STATE("kdb_local 4", reason);
1285 return 1; /* kdba_db_trap did the work */
1287 kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
1294 case KDB_REASON_ENTER:
1295 if (KDB_STATE(KEYBOARD))
1296 kdb_printf("due to Keyboard Entry\n");
1298 kdb_printf("due to KDB_ENTER()\n");
1300 case KDB_REASON_KEYBOARD:
1301 KDB_STATE_SET(KEYBOARD);
1302 kdb_printf("due to Keyboard Entry\n");
1304 case KDB_REASON_ENTER_SLAVE:
1305 /* drop through, slaves only get released via cpu switch */
1306 case KDB_REASON_SWITCH:
1307 kdb_printf("due to cpu switch\n");
1309 case KDB_REASON_OOPS:
1310 kdb_printf("Oops: %s\n", kdb_diemsg);
1311 kdb_printf("due to oops @ " kdb_machreg_fmt "\n",
1312 instruction_pointer(regs));
1315 case KDB_REASON_SYSTEM_NMI:
1316 kdb_printf("due to System NonMaskable Interrupt\n");
1318 case KDB_REASON_NMI:
1319 kdb_printf("due to NonMaskable Interrupt @ "
1320 kdb_machreg_fmt "\n",
1321 instruction_pointer(regs));
1323 case KDB_REASON_SSTEP:
1324 case KDB_REASON_BREAK:
1325 kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
1326 reason == KDB_REASON_BREAK ?
1327 "Breakpoint" : "SS trap", instruction_pointer(regs));
1329 * Determine if this breakpoint is one that we
1330 * are interested in.
1332 if (db_result != KDB_DB_BPT) {
1333 kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1335 KDB_DEBUG_STATE("kdb_local 6", reason);
1336 return 0; /* Not for us, dismiss it */
1339 case KDB_REASON_RECURSE:
1340 kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
1341 instruction_pointer(regs));
1344 kdb_printf("kdb: unexpected reason code: %d\n", reason);
1345 KDB_DEBUG_STATE("kdb_local 8", reason);
1346 return 0; /* Not for us, dismiss it */
1351 * Initialize pager context.
1354 KDB_STATE_CLEAR(SUPPRESS);
1355 kdb_grepping_flag = 0;
1356 /* ensure the old search does not leak into '/' commands */
1357 kdb_grep_string[0] = '\0';
1361 *(cmd_hist[cmd_head]) = '\0';
1364 /* PROMPT can only be set if we have MEM_READ permission. */
1365 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
1366 raw_smp_processor_id());
1369 * Fetch command from keyboard
1371 cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
1372 if (*cmdbuf != '\n') {
1374 if (cmdptr == cmd_head) {
1375 strscpy(cmd_hist[cmd_head], cmd_cur,
1377 *(cmd_hist[cmd_head] +
1378 strlen(cmd_hist[cmd_head])-1) = '\0';
1380 if (!handle_ctrl_cmd(cmdbuf))
1381 *(cmd_cur+strlen(cmd_cur)-1) = '\0';
1383 goto do_full_getstr;
1385 strscpy(cmd_hist[cmd_head], cmd_cur,
1389 cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
1390 if (cmd_head == cmd_tail)
1391 cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
1395 diag = kdb_parse(cmdbuf);
1396 if (diag == KDB_NOTFOUND) {
1397 drop_newline(cmdbuf);
1398 kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
1401 if (diag == KDB_CMD_GO
1402 || diag == KDB_CMD_CPU
1403 || diag == KDB_CMD_SS
1404 || diag == KDB_CMD_KGDB)
1410 KDB_DEBUG_STATE("kdb_local 9", diag);
1416 * kdb_print_state - Print the state data for the current processor
1419 * text Identifies the debug point
1420 * value Any integer value to be printed, e.g. reason code.
1422 void kdb_print_state(const char *text, int value)
1424 kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1425 text, raw_smp_processor_id(), value, kdb_initial_cpu,
1430 * kdb_main_loop - After initial setup and assignment of the
1431 * controlling cpu, all cpus are in this loop. One cpu is in
1432 * control and will issue the kdb prompt, the others will spin
1433 * until 'go' or cpu switch.
1435 * To get a consistent view of the kernel stacks for all
1436 * processes, this routine is invoked from the main kdb code via
1437 * an architecture specific routine. kdba_main_loop is
1438 * responsible for making the kernel stacks consistent for all
1439 * processes, there should be no difference between a blocked
1440 * process and a running process as far as kdb is concerned.
1442 * reason The reason KDB was invoked
1443 * error The hardware-defined error code
1444 * reason2 kdb's current reason code.
1445 * Initially error but can change
1446 * according to kdb state.
1447 * db_result Result code from break or debug point.
1448 * regs The exception frame at time of fault/breakpoint.
1449 * should always be valid.
1451 * 0 KDB was invoked for an event which it wasn't responsible
1452 * 1 KDB handled the event for which it was invoked.
1454 int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
1455 kdb_dbtrap_t db_result, struct pt_regs *regs)
1458 /* Stay in kdb() until 'go', 'ss[b]' or an error */
1461 * All processors except the one that is in control
1464 KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1465 while (KDB_STATE(HOLD_CPU)) {
1466 /* state KDB is turned off by kdb_cpu to see if the
1467 * other cpus are still live, each cpu in this loop
1470 if (!KDB_STATE(KDB))
1474 KDB_STATE_CLEAR(SUPPRESS);
1475 KDB_DEBUG_STATE("kdb_main_loop 2", reason);
1476 if (KDB_STATE(LEAVING))
1477 break; /* Another cpu said 'go' */
1478 /* Still using kdb, this processor is in control */
1479 result = kdb_local(reason2, error, regs, db_result);
1480 KDB_DEBUG_STATE("kdb_main_loop 3", result);
1482 if (result == KDB_CMD_CPU)
1485 if (result == KDB_CMD_SS) {
1486 KDB_STATE_SET(DOING_SS);
1490 if (result == KDB_CMD_KGDB) {
1491 if (!KDB_STATE(DOING_KGDB))
1492 kdb_printf("Entering please attach debugger "
1493 "or use $D#44+ or $3#33\n");
1496 if (result && result != 1 && result != KDB_CMD_GO)
1497 kdb_printf("\nUnexpected kdb_local return code %d\n",
1499 KDB_DEBUG_STATE("kdb_main_loop 4", reason);
1502 if (KDB_STATE(DOING_SS))
1503 KDB_STATE_CLEAR(SSBPT);
1505 /* Clean up any keyboard devices before leaving */
1506 kdb_kbd_cleanup_state();
1512 * kdb_mdr - This function implements the guts of the 'mdr', memory
1514 * mdr <addr arg>,<byte count>
1516 * addr Start address
1517 * count Number of bytes
1519 * Always 0. Any errors are detected and printed by kdb_getarea.
1521 static int kdb_mdr(unsigned long addr, unsigned int count)
1525 if (kdb_getarea(c, addr))
1527 kdb_printf("%02x", c);
1535 * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1536 * 'md8' 'mdr' and 'mds' commands.
1538 * md|mds [<addr arg> [<line count> [<radix>]]]
1539 * mdWcN [<addr arg> [<line count> [<radix>]]]
1540 * where W = is the width (1, 2, 4 or 8) and N is the count.
1541 * for eg., md1c20 reads 20 bytes, 1 at a time.
1542 * mdr <addr arg>,<byte count>
1544 static void kdb_md_line(const char *fmtstr, unsigned long addr,
1545 int symbolic, int nosect, int bytesperword,
1546 int num, int repeat, int phys)
1548 /* print just one line of data */
1549 kdb_symtab_t symtab;
1556 memset(cbuf, '\0', sizeof(cbuf));
1558 kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1560 kdb_printf(kdb_machreg_fmt0 " ", addr);
1562 for (i = 0; i < num && repeat--; i++) {
1564 if (kdb_getphysword(&word, addr, bytesperword))
1566 } else if (kdb_getword(&word, addr, bytesperword))
1568 kdb_printf(fmtstr, word);
1570 kdbnearsym(word, &symtab);
1572 memset(&symtab, 0, sizeof(symtab));
1573 if (symtab.sym_name) {
1574 kdb_symbol_print(word, &symtab, 0);
1577 kdb_printf(" %s %s "
1580 kdb_machreg_fmt, symtab.mod_name,
1581 symtab.sec_name, symtab.sec_start,
1582 symtab.sym_start, symtab.sym_end);
1584 addr += bytesperword;
1592 cp = wc.c + 8 - bytesperword;
1597 #define printable_char(c) \
1598 ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1599 for (j = 0; j < bytesperword; j++)
1600 *c++ = printable_char(*cp++);
1601 addr += bytesperword;
1602 #undef printable_char
1605 kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1609 static int kdb_md(int argc, const char **argv)
1611 static unsigned long last_addr;
1612 static int last_radix, last_bytesperword, last_repeat;
1613 int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1615 char fmtchar, fmtstr[64];
1624 kdbgetintenv("MDCOUNT", &mdcount);
1625 kdbgetintenv("RADIX", &radix);
1626 kdbgetintenv("BYTESPERWORD", &bytesperword);
1628 /* Assume 'md <addr>' and start with environment values */
1629 repeat = mdcount * 16 / bytesperword;
1631 if (strcmp(argv[0], "mdr") == 0) {
1632 if (argc == 2 || (argc == 0 && last_addr != 0))
1635 return KDB_ARGCOUNT;
1636 } else if (isdigit(argv[0][2])) {
1637 bytesperword = (int)(argv[0][2] - '0');
1638 if (bytesperword == 0) {
1639 bytesperword = last_bytesperword;
1640 if (bytesperword == 0)
1643 last_bytesperword = bytesperword;
1644 repeat = mdcount * 16 / bytesperword;
1647 else if (argv[0][3] == 'c' && argv[0][4]) {
1649 repeat = simple_strtoul(argv[0] + 4, &p, 10);
1650 mdcount = ((repeat * bytesperword) + 15) / 16;
1653 last_repeat = repeat;
1654 } else if (strcmp(argv[0], "md") == 0)
1656 else if (strcmp(argv[0], "mds") == 0)
1658 else if (strcmp(argv[0], "mdp") == 0) {
1662 return KDB_NOTFOUND;
1666 return KDB_ARGCOUNT;
1669 bytesperword = last_bytesperword;
1670 repeat = last_repeat;
1674 mdcount = ((repeat * bytesperword) + 15) / 16;
1679 int diag, nextarg = 1;
1680 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1684 if (argc > nextarg+2)
1685 return KDB_ARGCOUNT;
1687 if (argc >= nextarg) {
1688 diag = kdbgetularg(argv[nextarg], &val);
1690 mdcount = (int) val;
1694 repeat = mdcount * 16 / bytesperword;
1697 if (argc >= nextarg+1) {
1698 diag = kdbgetularg(argv[nextarg+1], &val);
1704 if (strcmp(argv[0], "mdr") == 0) {
1707 ret = kdb_mdr(addr, mdcount);
1708 last_addr += mdcount;
1709 last_repeat = mdcount;
1710 last_bytesperword = bytesperword; // to make REPEAT happy
1725 return KDB_BADRADIX;
1730 if (bytesperword > KDB_WORD_SIZE)
1731 return KDB_BADWIDTH;
1733 switch (bytesperword) {
1735 sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1738 sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1741 sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1744 sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1747 return KDB_BADWIDTH;
1750 last_repeat = repeat;
1751 last_bytesperword = bytesperword;
1753 if (strcmp(argv[0], "mds") == 0) {
1755 /* Do not save these changes as last_*, they are temporary mds
1758 bytesperword = KDB_WORD_SIZE;
1760 kdbgetintenv("NOSECT", &nosect);
1763 /* Round address down modulo BYTESPERWORD */
1765 addr &= ~(bytesperword-1);
1767 while (repeat > 0) {
1769 int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1771 if (KDB_FLAG(CMD_INTERRUPT))
1773 for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1775 if (kdb_getphysword(&word, a, bytesperword)
1778 } else if (kdb_getword(&word, a, bytesperword) || word)
1781 n = min(num, repeat);
1782 kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1784 addr += bytesperword * n;
1786 z = (z + num - 1) / num;
1788 int s = num * (z-2);
1789 kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1790 " zero suppressed\n",
1791 addr, addr + bytesperword * s - 1);
1792 addr += bytesperword * s;
1802 * kdb_mm - This function implements the 'mm' command.
1803 * mm address-expression new-value
1805 * mm works on machine words, mmW works on bytes.
1807 static int kdb_mm(int argc, const char **argv)
1812 unsigned long contents;
1816 if (argv[0][2] && !isdigit(argv[0][2]))
1817 return KDB_NOTFOUND;
1820 return KDB_ARGCOUNT;
1823 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1828 return KDB_ARGCOUNT;
1829 diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1833 if (nextarg != argc + 1)
1834 return KDB_ARGCOUNT;
1836 width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1837 diag = kdb_putword(addr, contents, width);
1841 kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1847 * kdb_go - This function implements the 'go' command.
1848 * go [address-expression]
1850 static int kdb_go(int argc, const char **argv)
1857 if (raw_smp_processor_id() != kdb_initial_cpu) {
1858 kdb_printf("go must execute on the entry cpu, "
1859 "please use \"cpu %d\" and then execute go\n",
1861 return KDB_BADCPUNUM;
1865 diag = kdbgetaddrarg(argc, argv, &nextarg,
1866 &addr, &offset, NULL);
1870 return KDB_ARGCOUNT;
1874 if (KDB_FLAG(CATASTROPHIC)) {
1875 kdb_printf("Catastrophic error detected\n");
1876 kdb_printf("kdb_continue_catastrophic=%d, ",
1877 kdb_continue_catastrophic);
1878 if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1879 kdb_printf("type go a second time if you really want "
1883 if (kdb_continue_catastrophic == 2) {
1884 kdb_printf("forcing reboot\n");
1885 kdb_reboot(0, NULL);
1887 kdb_printf("attempting to continue\n");
1893 * kdb_rd - This function implements the 'rd' command.
1895 static int kdb_rd(int argc, const char **argv)
1897 int len = kdb_check_regs();
1898 #if DBG_MAX_REG_NUM > 0
1910 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1911 rsize = dbg_reg_def[i].size * 2;
1914 if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
1919 len += kdb_printf(" ");
1920 switch(dbg_reg_def[i].size * 8) {
1922 rname = dbg_get_reg(i, ®8, kdb_current_regs);
1925 len += kdb_printf("%s: %02x", rname, reg8);
1928 rname = dbg_get_reg(i, ®16, kdb_current_regs);
1931 len += kdb_printf("%s: %04x", rname, reg16);
1934 rname = dbg_get_reg(i, ®32, kdb_current_regs);
1937 len += kdb_printf("%s: %08x", rname, reg32);
1940 rname = dbg_get_reg(i, ®64, kdb_current_regs);
1943 len += kdb_printf("%s: %016llx", rname, reg64);
1946 len += kdb_printf("%s: ??", dbg_reg_def[i].name);
1954 kdb_dumpregs(kdb_current_regs);
1960 * kdb_rm - This function implements the 'rm' (register modify) command.
1961 * rm register-name new-contents
1963 * Allows register modification with the same restrictions as gdb
1965 static int kdb_rm(int argc, const char **argv)
1967 #if DBG_MAX_REG_NUM > 0
1977 return KDB_ARGCOUNT;
1979 * Allow presence or absence of leading '%' symbol.
1985 diag = kdbgetu64arg(argv[2], ®64);
1989 diag = kdb_check_regs();
1994 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1995 if (strcmp(rname, dbg_reg_def[i].name) == 0) {
2001 switch(dbg_reg_def[i].size * 8) {
2004 dbg_set_reg(i, ®8, kdb_current_regs);
2008 dbg_set_reg(i, ®16, kdb_current_regs);
2012 dbg_set_reg(i, ®32, kdb_current_regs);
2015 dbg_set_reg(i, ®64, kdb_current_regs);
2021 kdb_printf("ERROR: Register set currently not implemented\n");
2026 #if defined(CONFIG_MAGIC_SYSRQ)
2028 * kdb_sr - This function implements the 'sr' (SYSRQ key) command
2029 * which interfaces to the soi-disant MAGIC SYSRQ functionality.
2030 * sr <magic-sysrq-code>
2032 static int kdb_sr(int argc, const char **argv)
2035 !kdb_check_flags(KDB_ENABLE_ALL, kdb_cmd_enabled, false);
2038 return KDB_ARGCOUNT;
2041 __handle_sysrq(*argv[1], check_mask);
2046 #endif /* CONFIG_MAGIC_SYSRQ */
2049 * kdb_ef - This function implements the 'regs' (display exception
2050 * frame) command. This command takes an address and expects to
2051 * find an exception frame at that address, formats and prints
2053 * regs address-expression
2057 static int kdb_ef(int argc, const char **argv)
2065 return KDB_ARGCOUNT;
2068 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
2071 show_regs((struct pt_regs *)addr);
2075 #if defined(CONFIG_MODULES)
2077 * kdb_lsmod - This function implements the 'lsmod' command. Lists
2078 * currently loaded kernel modules.
2079 * Mostly taken from userland lsmod.
2081 static int kdb_lsmod(int argc, const char **argv)
2086 return KDB_ARGCOUNT;
2088 kdb_printf("Module Size modstruct Used by\n");
2089 list_for_each_entry(mod, kdb_modules, list) {
2090 if (mod->state == MODULE_STATE_UNFORMED)
2093 kdb_printf("%-20s%8u 0x%px ", mod->name,
2094 mod->core_layout.size, (void *)mod);
2095 #ifdef CONFIG_MODULE_UNLOAD
2096 kdb_printf("%4d ", module_refcount(mod));
2098 if (mod->state == MODULE_STATE_GOING)
2099 kdb_printf(" (Unloading)");
2100 else if (mod->state == MODULE_STATE_COMING)
2101 kdb_printf(" (Loading)");
2103 kdb_printf(" (Live)");
2104 kdb_printf(" 0x%px", mod->core_layout.base);
2106 #ifdef CONFIG_MODULE_UNLOAD
2108 struct module_use *use;
2110 list_for_each_entry(use, &mod->source_list,
2112 kdb_printf("%s ", use->target->name);
2121 #endif /* CONFIG_MODULES */
2124 * kdb_env - This function implements the 'env' command. Display the
2125 * current environment variables.
2128 static int kdb_env(int argc, const char **argv)
2132 for (i = 0; i < __nenv; i++) {
2134 kdb_printf("%s\n", __env[i]);
2137 if (KDB_DEBUG(MASK))
2138 kdb_printf("KDBDEBUG=0x%x\n",
2139 (kdb_flags & KDB_DEBUG(MASK)) >> KDB_DEBUG_FLAG_SHIFT);
2144 #ifdef CONFIG_PRINTK
2146 * kdb_dmesg - This function implements the 'dmesg' command to display
2147 * the contents of the syslog buffer.
2148 * dmesg [lines] [adjust]
2150 static int kdb_dmesg(int argc, const char **argv)
2158 struct kmsg_dumper dumper = { .active = 1 };
2163 return KDB_ARGCOUNT;
2166 lines = simple_strtol(argv[1], &cp, 0);
2170 adjust = simple_strtoul(argv[2], &cp, 0);
2171 if (*cp || adjust < 0)
2176 /* disable LOGGING if set */
2177 diag = kdbgetintenv("LOGGING", &logging);
2178 if (!diag && logging) {
2179 const char *setargs[] = { "set", "LOGGING", "0" };
2180 kdb_set(2, setargs);
2183 kmsg_dump_rewind_nolock(&dumper);
2184 while (kmsg_dump_get_line_nolock(&dumper, 1, NULL, 0, NULL))
2189 kdb_printf("buffer only contains %d lines, nothing "
2191 else if (adjust - lines >= n)
2192 kdb_printf("buffer only contains %d lines, last %d "
2193 "lines printed\n", n, n - adjust);
2196 } else if (lines > 0) {
2197 skip = n - lines - adjust;
2200 kdb_printf("buffer only contains %d lines, "
2201 "nothing printed\n", n);
2203 } else if (skip < 0) {
2206 kdb_printf("buffer only contains %d lines, first "
2207 "%d lines printed\n", n, lines);
2213 if (skip >= n || skip < 0)
2216 kmsg_dump_rewind_nolock(&dumper);
2217 while (kmsg_dump_get_line_nolock(&dumper, 1, buf, sizeof(buf), &len)) {
2224 if (KDB_FLAG(CMD_INTERRUPT))
2227 kdb_printf("%.*s\n", (int)len - 1, buf);
2232 #endif /* CONFIG_PRINTK */
2234 /* Make sure we balance enable/disable calls, must disable first. */
2235 static atomic_t kdb_nmi_disabled;
2237 static int kdb_disable_nmi(int argc, const char *argv[])
2239 if (atomic_read(&kdb_nmi_disabled))
2241 atomic_set(&kdb_nmi_disabled, 1);
2242 arch_kgdb_ops.enable_nmi(0);
2246 static int kdb_param_enable_nmi(const char *val, const struct kernel_param *kp)
2248 if (!atomic_add_unless(&kdb_nmi_disabled, -1, 0))
2250 arch_kgdb_ops.enable_nmi(1);
2254 static const struct kernel_param_ops kdb_param_ops_enable_nmi = {
2255 .set = kdb_param_enable_nmi,
2257 module_param_cb(enable_nmi, &kdb_param_ops_enable_nmi, NULL, 0600);
2260 * kdb_cpu - This function implements the 'cpu' command.
2263 * KDB_CMD_CPU for success, a kdb diagnostic if error
2265 static void kdb_cpu_status(void)
2267 int i, start_cpu, first_print = 1;
2268 char state, prev_state = '?';
2270 kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2271 kdb_printf("Available cpus: ");
2272 for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2273 if (!cpu_online(i)) {
2274 state = 'F'; /* cpu is offline */
2275 } else if (!kgdb_info[i].enter_kgdb) {
2276 state = 'D'; /* cpu is online but unresponsive */
2278 state = ' '; /* cpu is responding to kdb */
2279 if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2280 state = 'I'; /* idle task */
2282 if (state != prev_state) {
2283 if (prev_state != '?') {
2287 kdb_printf("%d", start_cpu);
2288 if (start_cpu < i-1)
2289 kdb_printf("-%d", i-1);
2290 if (prev_state != ' ')
2291 kdb_printf("(%c)", prev_state);
2297 /* print the trailing cpus, ignoring them if they are all offline */
2298 if (prev_state != 'F') {
2301 kdb_printf("%d", start_cpu);
2302 if (start_cpu < i-1)
2303 kdb_printf("-%d", i-1);
2304 if (prev_state != ' ')
2305 kdb_printf("(%c)", prev_state);
2310 static int kdb_cpu(int argc, const char **argv)
2312 unsigned long cpunum;
2321 return KDB_ARGCOUNT;
2323 diag = kdbgetularg(argv[1], &cpunum);
2330 if ((cpunum >= CONFIG_NR_CPUS) || !kgdb_info[cpunum].enter_kgdb)
2331 return KDB_BADCPUNUM;
2333 dbg_switch_cpu = cpunum;
2336 * Switch to other cpu
2341 /* The user may not realize that ps/bta with no parameters does not print idle
2342 * or sleeping system daemon processes, so tell them how many were suppressed.
2344 void kdb_ps_suppressed(void)
2346 int idle = 0, daemon = 0;
2347 unsigned long mask_I = kdb_task_state_string("I"),
2348 mask_M = kdb_task_state_string("M");
2350 const struct task_struct *p, *g;
2351 for_each_online_cpu(cpu) {
2352 p = kdb_curr_task(cpu);
2353 if (kdb_task_state(p, mask_I))
2356 for_each_process_thread(g, p) {
2357 if (kdb_task_state(p, mask_M))
2360 if (idle || daemon) {
2362 kdb_printf("%d idle process%s (state I)%s\n",
2363 idle, idle == 1 ? "" : "es",
2364 daemon ? " and " : "");
2366 kdb_printf("%d sleeping system daemon (state M) "
2367 "process%s", daemon,
2368 daemon == 1 ? "" : "es");
2369 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2374 * kdb_ps - This function implements the 'ps' command which shows a
2375 * list of the active processes.
2376 * ps [DRSTCZEUIMA] All processes, optionally filtered by state
2378 void kdb_ps1(const struct task_struct *p)
2384 copy_from_kernel_nofault(&tmp, (char *)p, sizeof(unsigned long)))
2387 cpu = kdb_process_cpu(p);
2388 kdb_printf("0x%px %8d %8d %d %4d %c 0x%px %c%s\n",
2389 (void *)p, p->pid, p->parent->pid,
2390 kdb_task_has_cpu(p), kdb_process_cpu(p),
2391 kdb_task_state_char(p),
2392 (void *)(&p->thread),
2393 p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2395 if (kdb_task_has_cpu(p)) {
2396 if (!KDB_TSK(cpu)) {
2397 kdb_printf(" Error: no saved data for this cpu\n");
2399 if (KDB_TSK(cpu) != p)
2400 kdb_printf(" Error: does not match running "
2401 "process table (0x%px)\n", KDB_TSK(cpu));
2406 static int kdb_ps(int argc, const char **argv)
2408 struct task_struct *g, *p;
2409 unsigned long mask, cpu;
2412 kdb_ps_suppressed();
2413 kdb_printf("%-*s Pid Parent [*] cpu State %-*s Command\n",
2414 (int)(2*sizeof(void *))+2, "Task Addr",
2415 (int)(2*sizeof(void *))+2, "Thread");
2416 mask = kdb_task_state_string(argc ? argv[1] : NULL);
2417 /* Run the active tasks first */
2418 for_each_online_cpu(cpu) {
2419 if (KDB_FLAG(CMD_INTERRUPT))
2421 p = kdb_curr_task(cpu);
2422 if (kdb_task_state(p, mask))
2426 /* Now the real tasks */
2427 for_each_process_thread(g, p) {
2428 if (KDB_FLAG(CMD_INTERRUPT))
2430 if (kdb_task_state(p, mask))
2438 * kdb_pid - This function implements the 'pid' command which switches
2439 * the currently active process.
2442 static int kdb_pid(int argc, const char **argv)
2444 struct task_struct *p;
2449 return KDB_ARGCOUNT;
2452 if (strcmp(argv[1], "R") == 0) {
2453 p = KDB_TSK(kdb_initial_cpu);
2455 diag = kdbgetularg(argv[1], &val);
2459 p = find_task_by_pid_ns((pid_t)val, &init_pid_ns);
2461 kdb_printf("No task with pid=%d\n", (pid_t)val);
2465 kdb_set_current_task(p);
2467 kdb_printf("KDB current process is %s(pid=%d)\n",
2468 kdb_current_task->comm,
2469 kdb_current_task->pid);
2474 static int kdb_kgdb(int argc, const char **argv)
2476 return KDB_CMD_KGDB;
2480 * kdb_help - This function implements the 'help' and '?' commands.
2482 static int kdb_help(int argc, const char **argv)
2487 kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2488 kdb_printf("-----------------------------"
2489 "-----------------------------\n");
2490 for_each_kdbcmd(kt, i) {
2492 if (KDB_FLAG(CMD_INTERRUPT))
2496 if (!kdb_check_flags(kt->cmd_flags, kdb_cmd_enabled, true))
2498 if (strlen(kt->cmd_usage) > 20)
2500 kdb_printf("%-15.15s %-20s%s%s\n", kt->cmd_name,
2501 kt->cmd_usage, space, kt->cmd_help);
2507 * kdb_kill - This function implements the 'kill' commands.
2509 static int kdb_kill(int argc, const char **argv)
2513 struct task_struct *p;
2516 return KDB_ARGCOUNT;
2518 sig = simple_strtol(argv[1], &endp, 0);
2521 if ((sig >= 0) || !valid_signal(-sig)) {
2522 kdb_printf("Invalid signal parameter.<-signal>\n");
2527 pid = simple_strtol(argv[2], &endp, 0);
2531 kdb_printf("Process ID must be large than 0.\n");
2535 /* Find the process. */
2536 p = find_task_by_pid_ns(pid, &init_pid_ns);
2538 kdb_printf("The specified process isn't found.\n");
2541 p = p->group_leader;
2542 kdb_send_sig(p, sig);
2547 * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2548 * I cannot call that code directly from kdb, it has an unconditional
2549 * cli()/sti() and calls routines that take locks which can stop the debugger.
2551 static void kdb_sysinfo(struct sysinfo *val)
2553 u64 uptime = ktime_get_mono_fast_ns();
2555 memset(val, 0, sizeof(*val));
2556 val->uptime = div_u64(uptime, NSEC_PER_SEC);
2557 val->loads[0] = avenrun[0];
2558 val->loads[1] = avenrun[1];
2559 val->loads[2] = avenrun[2];
2560 val->procs = nr_threads-1;
2567 * kdb_summary - This function implements the 'summary' command.
2569 static int kdb_summary(int argc, const char **argv)
2576 return KDB_ARGCOUNT;
2578 kdb_printf("sysname %s\n", init_uts_ns.name.sysname);
2579 kdb_printf("release %s\n", init_uts_ns.name.release);
2580 kdb_printf("version %s\n", init_uts_ns.name.version);
2581 kdb_printf("machine %s\n", init_uts_ns.name.machine);
2582 kdb_printf("nodename %s\n", init_uts_ns.name.nodename);
2583 kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2585 now = __ktime_get_real_seconds();
2586 time64_to_tm(now, 0, &tm);
2587 kdb_printf("date %04ld-%02d-%02d %02d:%02d:%02d "
2588 "tz_minuteswest %d\n",
2589 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2590 tm.tm_hour, tm.tm_min, tm.tm_sec,
2591 sys_tz.tz_minuteswest);
2594 kdb_printf("uptime ");
2595 if (val.uptime > (24*60*60)) {
2596 int days = val.uptime / (24*60*60);
2597 val.uptime %= (24*60*60);
2598 kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2600 kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2602 kdb_printf("load avg %ld.%02ld %ld.%02ld %ld.%02ld\n",
2603 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2604 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2605 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2607 /* Display in kilobytes */
2608 #define K(x) ((x) << (PAGE_SHIFT - 10))
2609 kdb_printf("\nMemTotal: %8lu kB\nMemFree: %8lu kB\n"
2610 "Buffers: %8lu kB\n",
2611 K(val.totalram), K(val.freeram), K(val.bufferram));
2616 * kdb_per_cpu - This function implements the 'per_cpu' command.
2618 static int kdb_per_cpu(int argc, const char **argv)
2621 int cpu, diag, nextarg = 1;
2622 unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2624 if (argc < 1 || argc > 3)
2625 return KDB_ARGCOUNT;
2627 diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2632 diag = kdbgetularg(argv[2], &bytesperword);
2637 bytesperword = KDB_WORD_SIZE;
2638 else if (bytesperword > KDB_WORD_SIZE)
2639 return KDB_BADWIDTH;
2640 sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2642 diag = kdbgetularg(argv[3], &whichcpu);
2645 if (whichcpu >= nr_cpu_ids || !cpu_online(whichcpu)) {
2646 kdb_printf("cpu %ld is not online\n", whichcpu);
2647 return KDB_BADCPUNUM;
2651 /* Most architectures use __per_cpu_offset[cpu], some use
2652 * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2654 #ifdef __per_cpu_offset
2655 #define KDB_PCU(cpu) __per_cpu_offset(cpu)
2658 #define KDB_PCU(cpu) __per_cpu_offset[cpu]
2660 #define KDB_PCU(cpu) 0
2663 for_each_online_cpu(cpu) {
2664 if (KDB_FLAG(CMD_INTERRUPT))
2667 if (whichcpu != ~0UL && whichcpu != cpu)
2669 addr = symaddr + KDB_PCU(cpu);
2670 diag = kdb_getword(&val, addr, bytesperword);
2672 kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2673 "read, diag=%d\n", cpu, addr, diag);
2676 kdb_printf("%5d ", cpu);
2677 kdb_md_line(fmtstr, addr,
2678 bytesperword == KDB_WORD_SIZE,
2679 1, bytesperword, 1, 1, 0);
2686 * display help for the use of cmd | grep pattern
2688 static int kdb_grep_help(int argc, const char **argv)
2690 kdb_printf("Usage of cmd args | grep pattern:\n");
2691 kdb_printf(" Any command's output may be filtered through an ");
2692 kdb_printf("emulated 'pipe'.\n");
2693 kdb_printf(" 'grep' is just a key word.\n");
2694 kdb_printf(" The pattern may include a very limited set of "
2695 "metacharacters:\n");
2696 kdb_printf(" pattern or ^pattern or pattern$ or ^pattern$\n");
2697 kdb_printf(" And if there are spaces in the pattern, you may "
2699 kdb_printf(" \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2700 " or \"^pat tern$\"\n");
2705 * kdb_register_flags - This function is used to register a kernel
2709 * func Function to execute the command
2710 * usage A simple usage string showing arguments
2711 * help A simple help string describing command
2712 * repeat Does the command auto repeat on enter?
2714 * zero for success, one if a duplicate command.
2716 #define kdb_command_extend 50 /* arbitrary */
2717 int kdb_register_flags(char *cmd,
2722 kdb_cmdflags_t flags)
2728 * Brute force method to determine duplicates
2730 for_each_kdbcmd(kp, i) {
2731 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2732 kdb_printf("Duplicate kdb command registered: "
2733 "%s, func %px help %s\n", cmd, func, help);
2739 * Insert command into first available location in table
2741 for_each_kdbcmd(kp, i) {
2742 if (kp->cmd_name == NULL)
2746 if (i >= kdb_max_commands) {
2747 kdbtab_t *new = kmalloc_array(kdb_max_commands -
2753 kdb_printf("Could not allocate new kdb_command "
2758 memcpy(new, kdb_commands,
2759 (kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new));
2760 kfree(kdb_commands);
2762 memset(new + kdb_max_commands - KDB_BASE_CMD_MAX, 0,
2763 kdb_command_extend * sizeof(*new));
2765 kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX;
2766 kdb_max_commands += kdb_command_extend;
2770 kp->cmd_func = func;
2771 kp->cmd_usage = usage;
2772 kp->cmd_help = help;
2773 kp->cmd_minlen = minlen;
2774 kp->cmd_flags = flags;
2778 EXPORT_SYMBOL_GPL(kdb_register_flags);
2782 * kdb_register - Compatibility register function for commands that do
2783 * not need to specify a repeat state. Equivalent to
2784 * kdb_register_flags with flags set to 0.
2787 * func Function to execute the command
2788 * usage A simple usage string showing arguments
2789 * help A simple help string describing command
2791 * zero for success, one if a duplicate command.
2793 int kdb_register(char *cmd,
2799 return kdb_register_flags(cmd, func, usage, help, minlen, 0);
2801 EXPORT_SYMBOL_GPL(kdb_register);
2804 * kdb_unregister - This function is used to unregister a kernel
2805 * debugger command. It is generally called when a module which
2806 * implements kdb commands is unloaded.
2810 * zero for success, one command not registered.
2812 int kdb_unregister(char *cmd)
2820 for_each_kdbcmd(kp, i) {
2821 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2822 kp->cmd_name = NULL;
2827 /* Couldn't find it. */
2830 EXPORT_SYMBOL_GPL(kdb_unregister);
2832 /* Initialize the kdb command table. */
2833 static void __init kdb_inittab(void)
2838 for_each_kdbcmd(kp, i)
2839 kp->cmd_name = NULL;
2841 kdb_register_flags("md", kdb_md, "<vaddr>",
2842 "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2843 KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2844 kdb_register_flags("mdr", kdb_md, "<vaddr> <bytes>",
2845 "Display Raw Memory", 0,
2846 KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2847 kdb_register_flags("mdp", kdb_md, "<paddr> <bytes>",
2848 "Display Physical Memory", 0,
2849 KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2850 kdb_register_flags("mds", kdb_md, "<vaddr>",
2851 "Display Memory Symbolically", 0,
2852 KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2853 kdb_register_flags("mm", kdb_mm, "<vaddr> <contents>",
2854 "Modify Memory Contents", 0,
2855 KDB_ENABLE_MEM_WRITE | KDB_REPEAT_NO_ARGS);
2856 kdb_register_flags("go", kdb_go, "[<vaddr>]",
2857 "Continue Execution", 1,
2858 KDB_ENABLE_REG_WRITE | KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
2859 kdb_register_flags("rd", kdb_rd, "",
2860 "Display Registers", 0,
2861 KDB_ENABLE_REG_READ);
2862 kdb_register_flags("rm", kdb_rm, "<reg> <contents>",
2863 "Modify Registers", 0,
2864 KDB_ENABLE_REG_WRITE);
2865 kdb_register_flags("ef", kdb_ef, "<vaddr>",
2866 "Display exception frame", 0,
2867 KDB_ENABLE_MEM_READ);
2868 kdb_register_flags("bt", kdb_bt, "[<vaddr>]",
2869 "Stack traceback", 1,
2870 KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS);
2871 kdb_register_flags("btp", kdb_bt, "<pid>",
2872 "Display stack for process <pid>", 0,
2873 KDB_ENABLE_INSPECT);
2874 kdb_register_flags("bta", kdb_bt, "[D|R|S|T|C|Z|E|U|I|M|A]",
2875 "Backtrace all processes matching state flag", 0,
2876 KDB_ENABLE_INSPECT);
2877 kdb_register_flags("btc", kdb_bt, "",
2878 "Backtrace current process on each cpu", 0,
2879 KDB_ENABLE_INSPECT);
2880 kdb_register_flags("btt", kdb_bt, "<vaddr>",
2881 "Backtrace process given its struct task address", 0,
2882 KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS);
2883 kdb_register_flags("env", kdb_env, "",
2884 "Show environment variables", 0,
2885 KDB_ENABLE_ALWAYS_SAFE);
2886 kdb_register_flags("set", kdb_set, "",
2887 "Set environment variables", 0,
2888 KDB_ENABLE_ALWAYS_SAFE);
2889 kdb_register_flags("help", kdb_help, "",
2890 "Display Help Message", 1,
2891 KDB_ENABLE_ALWAYS_SAFE);
2892 kdb_register_flags("?", kdb_help, "",
2893 "Display Help Message", 0,
2894 KDB_ENABLE_ALWAYS_SAFE);
2895 kdb_register_flags("cpu", kdb_cpu, "<cpunum>",
2896 "Switch to new cpu", 0,
2897 KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
2898 kdb_register_flags("kgdb", kdb_kgdb, "",
2899 "Enter kgdb mode", 0, 0);
2900 kdb_register_flags("ps", kdb_ps, "[<flags>|A]",
2901 "Display active task list", 0,
2902 KDB_ENABLE_INSPECT);
2903 kdb_register_flags("pid", kdb_pid, "<pidnum>",
2904 "Switch to another task", 0,
2905 KDB_ENABLE_INSPECT);
2906 kdb_register_flags("reboot", kdb_reboot, "",
2907 "Reboot the machine immediately", 0,
2909 #if defined(CONFIG_MODULES)
2910 kdb_register_flags("lsmod", kdb_lsmod, "",
2911 "List loaded kernel modules", 0,
2912 KDB_ENABLE_INSPECT);
2914 #if defined(CONFIG_MAGIC_SYSRQ)
2915 kdb_register_flags("sr", kdb_sr, "<key>",
2916 "Magic SysRq key", 0,
2917 KDB_ENABLE_ALWAYS_SAFE);
2919 #if defined(CONFIG_PRINTK)
2920 kdb_register_flags("dmesg", kdb_dmesg, "[lines]",
2921 "Display syslog buffer", 0,
2922 KDB_ENABLE_ALWAYS_SAFE);
2924 if (arch_kgdb_ops.enable_nmi) {
2925 kdb_register_flags("disable_nmi", kdb_disable_nmi, "",
2926 "Disable NMI entry to KDB", 0,
2927 KDB_ENABLE_ALWAYS_SAFE);
2929 kdb_register_flags("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
2930 "Define a set of commands, down to endefcmd", 0,
2931 KDB_ENABLE_ALWAYS_SAFE);
2932 kdb_register_flags("kill", kdb_kill, "<-signal> <pid>",
2933 "Send a signal to a process", 0,
2935 kdb_register_flags("summary", kdb_summary, "",
2936 "Summarize the system", 4,
2937 KDB_ENABLE_ALWAYS_SAFE);
2938 kdb_register_flags("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
2939 "Display per_cpu variables", 3,
2940 KDB_ENABLE_MEM_READ);
2941 kdb_register_flags("grephelp", kdb_grep_help, "",
2942 "Display help on | grep", 0,
2943 KDB_ENABLE_ALWAYS_SAFE);
2946 /* Execute any commands defined in kdb_cmds. */
2947 static void __init kdb_cmd_init(void)
2950 for (i = 0; kdb_cmds[i]; ++i) {
2951 diag = kdb_parse(kdb_cmds[i]);
2953 kdb_printf("kdb command %s failed, kdb diag %d\n",
2956 if (defcmd_in_progress) {
2957 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2958 kdb_parse("endefcmd");
2962 /* Initialize kdb_printf, breakpoint tables and kdb state */
2963 void __init kdb_init(int lvl)
2965 static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2968 if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2970 for (i = kdb_init_lvl; i < lvl; i++) {
2972 case KDB_NOT_INITIALIZED:
2973 kdb_inittab(); /* Initialize Command Table */
2974 kdb_initbptab(); /* Initialize Breakpoints */
2976 case KDB_INIT_EARLY:
2977 kdb_cmd_init(); /* Build kdb_cmds tables */