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/sysrq.h>
22 #include <linux/smp.h>
23 #include <linux/utsname.h>
24 #include <linux/vmalloc.h>
25 #include <linux/atomic.h>
26 #include <linux/module.h>
27 #include <linux/moduleparam.h>
29 #include <linux/init.h>
30 #include <linux/kallsyms.h>
31 #include <linux/kgdb.h>
32 #include <linux/kdb.h>
33 #include <linux/notifier.h>
34 #include <linux/interrupt.h>
35 #include <linux/delay.h>
36 #include <linux/nmi.h>
37 #include <linux/time.h>
38 #include <linux/ptrace.h>
39 #include <linux/sysctl.h>
40 #include <linux/cpu.h>
41 #include <linux/kdebug.h>
42 #include <linux/proc_fs.h>
43 #include <linux/uaccess.h>
44 #include <linux/slab.h>
45 #include "kdb_private.h"
47 #undef MODULE_PARAM_PREFIX
48 #define MODULE_PARAM_PREFIX "kdb."
50 static int kdb_cmd_enabled = CONFIG_KDB_DEFAULT_ENABLE;
51 module_param_named(cmd_enable, kdb_cmd_enabled, int, 0600);
53 char kdb_grep_string[KDB_GREP_STRLEN];
54 int kdb_grepping_flag;
55 EXPORT_SYMBOL(kdb_grepping_flag);
57 int kdb_grep_trailing;
60 * Kernel debugger state flags
66 * kdb_lock protects updates to kdb_initial_cpu. Used to
67 * single thread processors through the kernel debugger.
69 int kdb_initial_cpu = -1; /* cpu number that owns kdb */
71 int kdb_state; /* General KDB state */
73 struct task_struct *kdb_current_task;
74 EXPORT_SYMBOL(kdb_current_task);
75 struct pt_regs *kdb_current_regs;
77 const char *kdb_diemsg;
78 static int kdb_go_count;
79 #ifdef CONFIG_KDB_CONTINUE_CATASTROPHIC
80 static unsigned int kdb_continue_catastrophic =
81 CONFIG_KDB_CONTINUE_CATASTROPHIC;
83 static unsigned int kdb_continue_catastrophic;
86 /* kdb_commands describes the available commands. */
87 static kdbtab_t *kdb_commands;
88 #define KDB_BASE_CMD_MAX 50
89 static int kdb_max_commands = KDB_BASE_CMD_MAX;
90 static kdbtab_t kdb_base_commands[KDB_BASE_CMD_MAX];
91 #define for_each_kdbcmd(cmd, num) \
92 for ((cmd) = kdb_base_commands, (num) = 0; \
93 num < kdb_max_commands; \
94 num++, num == KDB_BASE_CMD_MAX ? cmd = kdb_commands : cmd++)
96 typedef struct _kdbmsg {
97 int km_diag; /* kdb diagnostic */
98 char *km_msg; /* Corresponding message text */
101 #define KDBMSG(msgnum, text) \
102 { KDB_##msgnum, text }
104 static kdbmsg_t kdbmsgs[] = {
105 KDBMSG(NOTFOUND, "Command Not Found"),
106 KDBMSG(ARGCOUNT, "Improper argument count, see usage."),
107 KDBMSG(BADWIDTH, "Illegal value for BYTESPERWORD use 1, 2, 4 or 8, "
108 "8 is only allowed on 64 bit systems"),
109 KDBMSG(BADRADIX, "Illegal value for RADIX use 8, 10 or 16"),
110 KDBMSG(NOTENV, "Cannot find environment variable"),
111 KDBMSG(NOENVVALUE, "Environment variable should have value"),
112 KDBMSG(NOTIMP, "Command not implemented"),
113 KDBMSG(ENVFULL, "Environment full"),
114 KDBMSG(ENVBUFFULL, "Environment buffer full"),
115 KDBMSG(TOOMANYBPT, "Too many breakpoints defined"),
116 #ifdef CONFIG_CPU_XSCALE
117 KDBMSG(TOOMANYDBREGS, "More breakpoints than ibcr registers defined"),
119 KDBMSG(TOOMANYDBREGS, "More breakpoints than db registers defined"),
121 KDBMSG(DUPBPT, "Duplicate breakpoint address"),
122 KDBMSG(BPTNOTFOUND, "Breakpoint not found"),
123 KDBMSG(BADMODE, "Invalid IDMODE"),
124 KDBMSG(BADINT, "Illegal numeric value"),
125 KDBMSG(INVADDRFMT, "Invalid symbolic address format"),
126 KDBMSG(BADREG, "Invalid register name"),
127 KDBMSG(BADCPUNUM, "Invalid cpu number"),
128 KDBMSG(BADLENGTH, "Invalid length field"),
129 KDBMSG(NOBP, "No Breakpoint exists"),
130 KDBMSG(BADADDR, "Invalid address"),
131 KDBMSG(NOPERM, "Permission denied"),
135 static const int __nkdb_err = ARRAY_SIZE(kdbmsgs);
139 * Initial environment. This is all kept static and local to
140 * this file. We don't want to rely on the memory allocation
141 * mechanisms in the kernel, so we use a very limited allocate-only
142 * heap for new and altered environment variables. The entire
143 * environment is limited to a fixed number of entries (add more
144 * to __env[] if required) and a fixed amount of heap (add more to
145 * KDB_ENVBUFSIZE if required).
148 static char *__env[] = {
149 #if defined(CONFIG_SMP)
156 "MDCOUNT=8", /* lines of md output */
186 static const int __nenv = ARRAY_SIZE(__env);
188 struct task_struct *kdb_curr_task(int cpu)
190 struct task_struct *p = curr_task(cpu);
192 if ((task_thread_info(p)->flags & _TIF_MCA_INIT) && KDB_TSK(cpu))
199 * Check whether the flags of the current command and the permissions
200 * of the kdb console has allow a command to be run.
202 static inline bool kdb_check_flags(kdb_cmdflags_t flags, int permissions,
205 /* permissions comes from userspace so needs massaging slightly */
206 permissions &= KDB_ENABLE_MASK;
207 permissions |= KDB_ENABLE_ALWAYS_SAFE;
209 /* some commands change group when launched with no arguments */
211 permissions |= permissions << KDB_ENABLE_NO_ARGS_SHIFT;
213 flags |= KDB_ENABLE_ALL;
215 return permissions & flags;
219 * kdbgetenv - This function will return the character string value of
220 * an environment variable.
222 * match A character string representing an environment variable.
224 * NULL No environment variable matches 'match'
225 * char* Pointer to string value of environment variable.
227 char *kdbgetenv(const char *match)
230 int matchlen = strlen(match);
233 for (i = 0; i < __nenv; i++) {
239 if ((strncmp(match, e, matchlen) == 0)
240 && ((e[matchlen] == '\0')
241 || (e[matchlen] == '='))) {
242 char *cp = strchr(e, '=');
243 return cp ? ++cp : "";
250 * kdballocenv - This function is used to allocate bytes for
251 * environment entries.
253 * match A character string representing a numeric value
255 * *value the unsigned long representation of the env variable 'match'
257 * Zero on success, a kdb diagnostic on failure.
259 * We use a static environment buffer (envbuffer) to hold the values
260 * of dynamically generated environment variables (see kdb_set). Buffer
261 * space once allocated is never free'd, so over time, the amount of space
262 * (currently 512 bytes) will be exhausted if env variables are changed
265 static char *kdballocenv(size_t bytes)
267 #define KDB_ENVBUFSIZE 512
268 static char envbuffer[KDB_ENVBUFSIZE];
269 static int envbufsize;
272 if ((KDB_ENVBUFSIZE - envbufsize) >= bytes) {
273 ep = &envbuffer[envbufsize];
280 * kdbgetulenv - This function will return the value of an unsigned
281 * long-valued environment variable.
283 * match A character string representing a numeric value
285 * *value the unsigned long represntation of the env variable 'match'
287 * Zero on success, a kdb diagnostic on failure.
289 static int kdbgetulenv(const char *match, unsigned long *value)
293 ep = kdbgetenv(match);
297 return KDB_NOENVVALUE;
299 *value = simple_strtoul(ep, NULL, 0);
305 * kdbgetintenv - This function will return the value of an
306 * integer-valued environment variable.
308 * match A character string representing an integer-valued env variable
310 * *value the integer representation of the environment variable 'match'
312 * Zero on success, a kdb diagnostic on failure.
314 int kdbgetintenv(const char *match, int *value)
319 diag = kdbgetulenv(match, &val);
326 * kdbgetularg - This function will convert a numeric string into an
327 * unsigned long value.
329 * arg A character string representing a numeric value
331 * *value the unsigned long represntation of arg.
333 * Zero on success, a kdb diagnostic on failure.
335 int kdbgetularg(const char *arg, unsigned long *value)
340 val = simple_strtoul(arg, &endp, 0);
344 * Also try base 16, for us folks too lazy to type the
347 val = simple_strtoul(arg, &endp, 16);
357 int kdbgetu64arg(const char *arg, u64 *value)
362 val = simple_strtoull(arg, &endp, 0);
366 val = simple_strtoull(arg, &endp, 16);
377 * kdb_set - This function implements the 'set' command. Alter an
378 * existing environment variable or create a new one.
380 int kdb_set(int argc, const char **argv)
384 size_t varlen, vallen;
387 * we can be invoked two ways:
388 * set var=value argv[1]="var", argv[2]="value"
389 * set var = value argv[1]="var", argv[2]="=", argv[3]="value"
390 * - if the latter, shift 'em down.
401 * Check for internal variables
403 if (strcmp(argv[1], "KDBDEBUG") == 0) {
404 unsigned int debugflags;
407 debugflags = simple_strtoul(argv[2], &cp, 0);
408 if (cp == argv[2] || debugflags & ~KDB_DEBUG_FLAG_MASK) {
409 kdb_printf("kdb: illegal debug flags '%s'\n",
413 kdb_flags = (kdb_flags &
414 ~(KDB_DEBUG_FLAG_MASK << KDB_DEBUG_FLAG_SHIFT))
415 | (debugflags << KDB_DEBUG_FLAG_SHIFT);
421 * Tokenizer squashed the '=' sign. argv[1] is variable
422 * name, argv[2] = value.
424 varlen = strlen(argv[1]);
425 vallen = strlen(argv[2]);
426 ep = kdballocenv(varlen + vallen + 2);
428 return KDB_ENVBUFFULL;
430 sprintf(ep, "%s=%s", argv[1], argv[2]);
432 ep[varlen+vallen+1] = '\0';
434 for (i = 0; i < __nenv; i++) {
436 && ((strncmp(__env[i], argv[1], varlen) == 0)
437 && ((__env[i][varlen] == '\0')
438 || (__env[i][varlen] == '=')))) {
445 * Wasn't existing variable. Fit into slot.
447 for (i = 0; i < __nenv-1; i++) {
448 if (__env[i] == (char *)0) {
457 static int kdb_check_regs(void)
459 if (!kdb_current_regs) {
460 kdb_printf("No current kdb registers."
461 " You may need to select another task\n");
468 * kdbgetaddrarg - This function is responsible for parsing an
469 * address-expression and returning the value of the expression,
470 * symbol name, and offset to the caller.
472 * The argument may consist of a numeric value (decimal or
473 * hexidecimal), a symbol name, a register name (preceded by the
474 * percent sign), an environment variable with a numeric value
475 * (preceded by a dollar sign) or a simple arithmetic expression
476 * consisting of a symbol name, +/-, and a numeric constant value
479 * argc - count of arguments in argv
480 * argv - argument vector
481 * *nextarg - index to next unparsed argument in argv[]
482 * regs - Register state at time of KDB entry
484 * *value - receives the value of the address-expression
485 * *offset - receives the offset specified, if any
486 * *name - receives the symbol name, if any
487 * *nextarg - index to next unparsed argument in argv[]
489 * zero is returned on success, a kdb diagnostic code is
492 int kdbgetaddrarg(int argc, const char **argv, int *nextarg,
493 unsigned long *value, long *offset,
497 unsigned long off = 0;
507 * If the enable flags prohibit both arbitrary memory access
508 * and flow control then there are no reasonable grounds to
509 * provide symbol lookup.
511 if (!kdb_check_flags(KDB_ENABLE_MEM_READ | KDB_ENABLE_FLOW_CTRL,
512 kdb_cmd_enabled, false))
516 * Process arguments which follow the following syntax:
518 * symbol | numeric-address [+/- numeric-offset]
520 * $environment-variable
526 symname = (char *)argv[*nextarg];
529 * If there is no whitespace between the symbol
530 * or address and the '+' or '-' symbols, we
531 * remember the character and replace it with a
532 * null so the symbol/value can be properly parsed
534 cp = strpbrk(symname, "+-");
540 if (symname[0] == '$') {
541 diag = kdbgetulenv(&symname[1], &addr);
544 } else if (symname[0] == '%') {
545 diag = kdb_check_regs();
548 /* Implement register values with % at a later time as it is
553 found = kdbgetsymval(symname, &symtab);
555 addr = symtab.sym_start;
557 diag = kdbgetularg(argv[*nextarg], &addr);
564 found = kdbnearsym(addr, &symtab);
572 if (offset && name && *name)
573 *offset = addr - symtab.sym_start;
575 if ((*nextarg > argc)
580 * check for +/- and offset
583 if (symbol == '\0') {
584 if ((argv[*nextarg][0] != '+')
585 && (argv[*nextarg][0] != '-')) {
587 * Not our argument. Return.
591 positive = (argv[*nextarg][0] == '+');
595 positive = (symbol == '+');
598 * Now there must be an offset!
600 if ((*nextarg > argc)
601 && (symbol == '\0')) {
602 return KDB_INVADDRFMT;
606 cp = (char *)argv[*nextarg];
610 diag = kdbgetularg(cp, &off);
626 static void kdb_cmderror(int diag)
631 kdb_printf("no error detected (diagnostic is %d)\n", diag);
635 for (i = 0; i < __nkdb_err; i++) {
636 if (kdbmsgs[i].km_diag == diag) {
637 kdb_printf("diag: %d: %s\n", diag, kdbmsgs[i].km_msg);
642 kdb_printf("Unknown diag %d\n", -diag);
646 * kdb_defcmd, kdb_defcmd2 - This function implements the 'defcmd'
647 * command which defines one command as a set of other commands,
648 * terminated by endefcmd. kdb_defcmd processes the initial
649 * 'defcmd' command, kdb_defcmd2 is invoked from kdb_parse for
650 * the following commands until 'endefcmd'.
652 * argc argument count
653 * argv argument vector
655 * zero for success, a kdb diagnostic if error
665 static struct defcmd_set *defcmd_set;
666 static int defcmd_set_count;
667 static int defcmd_in_progress;
669 /* Forward references */
670 static int kdb_exec_defcmd(int argc, const char **argv);
672 static int kdb_defcmd2(const char *cmdstr, const char *argv0)
674 struct defcmd_set *s = defcmd_set + defcmd_set_count - 1;
675 char **save_command = s->command;
676 if (strcmp(argv0, "endefcmd") == 0) {
677 defcmd_in_progress = 0;
681 /* macros are always safe because when executed each
682 * internal command re-enters kdb_parse() and is
683 * safety checked individually.
685 kdb_register_flags(s->name, kdb_exec_defcmd, s->usage,
687 KDB_ENABLE_ALWAYS_SAFE);
692 s->command = kzalloc((s->count + 1) * sizeof(*(s->command)), GFP_KDB);
694 kdb_printf("Could not allocate new kdb_defcmd table for %s\n",
699 memcpy(s->command, save_command, s->count * sizeof(*(s->command)));
700 s->command[s->count++] = kdb_strdup(cmdstr, GFP_KDB);
705 static int kdb_defcmd(int argc, const char **argv)
707 struct defcmd_set *save_defcmd_set = defcmd_set, *s;
708 if (defcmd_in_progress) {
709 kdb_printf("kdb: nested defcmd detected, assuming missing "
711 kdb_defcmd2("endefcmd", "endefcmd");
715 for (s = defcmd_set; s < defcmd_set + defcmd_set_count; ++s) {
716 kdb_printf("defcmd %s \"%s\" \"%s\"\n", s->name,
718 for (i = 0; i < s->count; ++i)
719 kdb_printf("%s", s->command[i]);
720 kdb_printf("endefcmd\n");
726 if (in_dbg_master()) {
727 kdb_printf("Command only available during kdb_init()\n");
730 defcmd_set = kmalloc((defcmd_set_count + 1) * sizeof(*defcmd_set),
734 memcpy(defcmd_set, save_defcmd_set,
735 defcmd_set_count * sizeof(*defcmd_set));
736 s = defcmd_set + defcmd_set_count;
737 memset(s, 0, sizeof(*s));
739 s->name = kdb_strdup(argv[1], GFP_KDB);
742 s->usage = kdb_strdup(argv[2], GFP_KDB);
745 s->help = kdb_strdup(argv[3], GFP_KDB);
748 if (s->usage[0] == '"') {
749 strcpy(s->usage, argv[2]+1);
750 s->usage[strlen(s->usage)-1] = '\0';
752 if (s->help[0] == '"') {
753 strcpy(s->help, argv[3]+1);
754 s->help[strlen(s->help)-1] = '\0';
757 defcmd_in_progress = 1;
758 kfree(save_defcmd_set);
767 kdb_printf("Could not allocate new defcmd_set entry for %s\n", argv[1]);
768 defcmd_set = save_defcmd_set;
773 * kdb_exec_defcmd - Execute the set of commands associated with this
776 * argc argument count
777 * argv argument vector
779 * zero for success, a kdb diagnostic if error
781 static int kdb_exec_defcmd(int argc, const char **argv)
784 struct defcmd_set *s;
787 for (s = defcmd_set, i = 0; i < defcmd_set_count; ++i, ++s) {
788 if (strcmp(s->name, argv[0]) == 0)
791 if (i == defcmd_set_count) {
792 kdb_printf("kdb_exec_defcmd: could not find commands for %s\n",
796 for (i = 0; i < s->count; ++i) {
797 /* Recursive use of kdb_parse, do not use argv after
800 kdb_printf("[%s]kdb> %s\n", s->name, s->command[i]);
801 ret = kdb_parse(s->command[i]);
808 /* Command history */
809 #define KDB_CMD_HISTORY_COUNT 32
810 #define CMD_BUFLEN 200 /* kdb_printf: max printline
812 static unsigned int cmd_head, cmd_tail;
813 static unsigned int cmdptr;
814 static char cmd_hist[KDB_CMD_HISTORY_COUNT][CMD_BUFLEN];
815 static char cmd_cur[CMD_BUFLEN];
818 * The "str" argument may point to something like | grep xyz
820 static void parse_grep(const char *str)
823 char *cp = (char *)str, *cp2;
825 /* sanity check: we should have been called with the \ first */
831 if (strncmp(cp, "grep ", 5)) {
832 kdb_printf("invalid 'pipe', see grephelp\n");
838 cp2 = strchr(cp, '\n');
840 *cp2 = '\0'; /* remove the trailing newline */
843 kdb_printf("invalid 'pipe', see grephelp\n");
846 /* now cp points to a nonzero length search string */
848 /* allow it be "x y z" by removing the "'s - there must
851 cp2 = strchr(cp, '"');
853 kdb_printf("invalid quoted string, see grephelp\n");
856 *cp2 = '\0'; /* end the string where the 2nd " was */
858 kdb_grep_leading = 0;
860 kdb_grep_leading = 1;
864 kdb_grep_trailing = 0;
865 if (*(cp+len-1) == '$') {
866 kdb_grep_trailing = 1;
872 if (len >= KDB_GREP_STRLEN) {
873 kdb_printf("search string too long\n");
876 strcpy(kdb_grep_string, cp);
882 * kdb_parse - Parse the command line, search the command table for a
883 * matching command and invoke the command function. This
884 * function may be called recursively, if it is, the second call
885 * will overwrite argv and cbuf. It is the caller's
886 * responsibility to save their argv if they recursively call
889 * cmdstr The input command line to be parsed.
890 * regs The registers at the time kdb was entered.
892 * Zero for success, a kdb diagnostic if failure.
894 * Limited to 20 tokens.
896 * Real rudimentary tokenization. Basically only whitespace
897 * is considered a token delimeter (but special consideration
898 * is taken of the '=' sign as used by the 'set' command).
900 * The algorithm used to tokenize the input string relies on
901 * there being at least one whitespace (or otherwise useless)
902 * character between tokens as the character immediately following
903 * the token is altered in-place to a null-byte to terminate the
909 int kdb_parse(const char *cmdstr)
911 static char *argv[MAXARGC];
913 static char cbuf[CMD_BUFLEN+2];
917 int i, escaped, ignore_errors = 0, check_grep = 0;
920 * First tokenize the command string.
924 if (KDB_FLAG(CMD_INTERRUPT)) {
925 /* Previous command was interrupted, newline must not
926 * repeat the command */
927 KDB_FLAG_CLEAR(CMD_INTERRUPT);
928 KDB_STATE_SET(PAGER);
929 argc = 0; /* no repeat */
932 if (*cp != '\n' && *cp != '\0') {
936 /* skip whitespace */
939 if ((*cp == '\0') || (*cp == '\n') ||
940 (*cp == '#' && !defcmd_in_progress))
942 /* special case: check for | grep pattern */
947 if (cpp >= cbuf + CMD_BUFLEN) {
948 kdb_printf("kdb_parse: command buffer "
949 "overflow, command ignored\n%s\n",
953 if (argc >= MAXARGC - 1) {
954 kdb_printf("kdb_parse: too many arguments, "
955 "command ignored\n%s\n", cmdstr);
961 /* Copy to next unquoted and unescaped
962 * whitespace or '=' */
963 while (*cp && *cp != '\n' &&
964 (escaped || quoted || !isspace(*cp))) {
965 if (cpp >= cbuf + CMD_BUFLEN)
979 else if (*cp == '\'' || *cp == '"')
982 if (*cpp == '=' && !quoted)
986 *cpp++ = '\0'; /* Squash a ws or '=' character */
993 if (defcmd_in_progress) {
994 int result = kdb_defcmd2(cmdstr, argv[0]);
995 if (!defcmd_in_progress) {
996 argc = 0; /* avoid repeat on endefcmd */
1001 if (argv[0][0] == '-' && argv[0][1] &&
1002 (argv[0][1] < '0' || argv[0][1] > '9')) {
1007 for_each_kdbcmd(tp, i) {
1010 * If this command is allowed to be abbreviated,
1011 * check to see if this is it.
1015 && (strlen(argv[0]) <= tp->cmd_minlen)) {
1016 if (strncmp(argv[0],
1018 tp->cmd_minlen) == 0) {
1023 if (strcmp(argv[0], tp->cmd_name) == 0)
1029 * If we don't find a command by this name, see if the first
1030 * few characters of this match any of the known commands.
1031 * e.g., md1c20 should match md.
1033 if (i == kdb_max_commands) {
1034 for_each_kdbcmd(tp, i) {
1036 if (strncmp(argv[0],
1038 strlen(tp->cmd_name)) == 0) {
1045 if (i < kdb_max_commands) {
1048 if (!kdb_check_flags(tp->cmd_flags, kdb_cmd_enabled, argc <= 1))
1052 result = (*tp->cmd_func)(argc-1, (const char **)argv);
1053 if (result && ignore_errors && result > KDB_CMD_GO)
1055 KDB_STATE_CLEAR(CMD);
1057 if (tp->cmd_flags & KDB_REPEAT_WITH_ARGS)
1060 argc = tp->cmd_flags & KDB_REPEAT_NO_ARGS ? 1 : 0;
1062 *(argv[argc]) = '\0';
1067 * If the input with which we were presented does not
1068 * map to an existing command, attempt to parse it as an
1069 * address argument and display the result. Useful for
1070 * obtaining the address of a variable, or the nearest symbol
1071 * to an address contained in a register.
1074 unsigned long value;
1079 if (kdbgetaddrarg(0, (const char **)argv, &nextarg,
1080 &value, &offset, &name)) {
1081 return KDB_NOTFOUND;
1084 kdb_printf("%s = ", argv[0]);
1085 kdb_symbol_print(value, NULL, KDB_SP_DEFAULT);
1092 static int handle_ctrl_cmd(char *cmd)
1097 /* initial situation */
1098 if (cmd_head == cmd_tail)
1102 if (cmdptr != cmd_tail)
1103 cmdptr = (cmdptr-1) % KDB_CMD_HISTORY_COUNT;
1104 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1107 if (cmdptr != cmd_head)
1108 cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT;
1109 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1116 * kdb_reboot - This function implements the 'reboot' command. Reboot
1117 * the system immediately, or loop for ever on failure.
1119 static int kdb_reboot(int argc, const char **argv)
1121 emergency_restart();
1122 kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
1129 static void kdb_dumpregs(struct pt_regs *regs)
1131 int old_lvl = console_loglevel;
1132 console_loglevel = CONSOLE_LOGLEVEL_MOTORMOUTH;
1137 console_loglevel = old_lvl;
1140 void kdb_set_current_task(struct task_struct *p)
1142 kdb_current_task = p;
1144 if (kdb_task_has_cpu(p)) {
1145 kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p));
1148 kdb_current_regs = NULL;
1152 * kdb_local - The main code for kdb. This routine is invoked on a
1153 * specific processor, it is not global. The main kdb() routine
1154 * ensures that only one processor at a time is in this routine.
1155 * This code is called with the real reason code on the first
1156 * entry to a kdb session, thereafter it is called with reason
1157 * SWITCH, even if the user goes back to the original cpu.
1159 * reason The reason KDB was invoked
1160 * error The hardware-defined error code
1161 * regs The exception frame at time of fault/breakpoint.
1162 * db_result Result code from the break or debug point.
1164 * 0 KDB was invoked for an event which it wasn't responsible
1165 * 1 KDB handled the event for which it was invoked.
1166 * KDB_CMD_GO User typed 'go'.
1167 * KDB_CMD_CPU User switched to another cpu.
1168 * KDB_CMD_SS Single step.
1170 static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs,
1171 kdb_dbtrap_t db_result)
1175 struct task_struct *kdb_current =
1176 kdb_curr_task(raw_smp_processor_id());
1178 KDB_DEBUG_STATE("kdb_local 1", reason);
1180 if (reason == KDB_REASON_DEBUG) {
1181 /* special case below */
1183 kdb_printf("\nEntering kdb (current=0x%p, pid %d) ",
1184 kdb_current, kdb_current ? kdb_current->pid : 0);
1185 #if defined(CONFIG_SMP)
1186 kdb_printf("on processor %d ", raw_smp_processor_id());
1191 case KDB_REASON_DEBUG:
1194 * If re-entering kdb after a single step
1195 * command, don't print the message.
1197 switch (db_result) {
1199 kdb_printf("\nEntering kdb (0x%p, pid %d) ",
1200 kdb_current, kdb_current->pid);
1201 #if defined(CONFIG_SMP)
1202 kdb_printf("on processor %d ", raw_smp_processor_id());
1204 kdb_printf("due to Debug @ " kdb_machreg_fmt "\n",
1205 instruction_pointer(regs));
1210 KDB_DEBUG_STATE("kdb_local 4", reason);
1211 return 1; /* kdba_db_trap did the work */
1213 kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
1220 case KDB_REASON_ENTER:
1221 if (KDB_STATE(KEYBOARD))
1222 kdb_printf("due to Keyboard Entry\n");
1224 kdb_printf("due to KDB_ENTER()\n");
1226 case KDB_REASON_KEYBOARD:
1227 KDB_STATE_SET(KEYBOARD);
1228 kdb_printf("due to Keyboard Entry\n");
1230 case KDB_REASON_ENTER_SLAVE:
1231 /* drop through, slaves only get released via cpu switch */
1232 case KDB_REASON_SWITCH:
1233 kdb_printf("due to cpu switch\n");
1235 case KDB_REASON_OOPS:
1236 kdb_printf("Oops: %s\n", kdb_diemsg);
1237 kdb_printf("due to oops @ " kdb_machreg_fmt "\n",
1238 instruction_pointer(regs));
1241 case KDB_REASON_SYSTEM_NMI:
1242 kdb_printf("due to System NonMaskable Interrupt\n");
1244 case KDB_REASON_NMI:
1245 kdb_printf("due to NonMaskable Interrupt @ "
1246 kdb_machreg_fmt "\n",
1247 instruction_pointer(regs));
1249 case KDB_REASON_SSTEP:
1250 case KDB_REASON_BREAK:
1251 kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
1252 reason == KDB_REASON_BREAK ?
1253 "Breakpoint" : "SS trap", instruction_pointer(regs));
1255 * Determine if this breakpoint is one that we
1256 * are interested in.
1258 if (db_result != KDB_DB_BPT) {
1259 kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1261 KDB_DEBUG_STATE("kdb_local 6", reason);
1262 return 0; /* Not for us, dismiss it */
1265 case KDB_REASON_RECURSE:
1266 kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
1267 instruction_pointer(regs));
1270 kdb_printf("kdb: unexpected reason code: %d\n", reason);
1271 KDB_DEBUG_STATE("kdb_local 8", reason);
1272 return 0; /* Not for us, dismiss it */
1277 * Initialize pager context.
1280 KDB_STATE_CLEAR(SUPPRESS);
1281 kdb_grepping_flag = 0;
1282 /* ensure the old search does not leak into '/' commands */
1283 kdb_grep_string[0] = '\0';
1287 *(cmd_hist[cmd_head]) = '\0';
1290 #if defined(CONFIG_SMP)
1291 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
1292 raw_smp_processor_id());
1294 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"));
1296 if (defcmd_in_progress)
1297 strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
1300 * Fetch command from keyboard
1302 cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
1303 if (*cmdbuf != '\n') {
1305 if (cmdptr == cmd_head) {
1306 strncpy(cmd_hist[cmd_head], cmd_cur,
1308 *(cmd_hist[cmd_head] +
1309 strlen(cmd_hist[cmd_head])-1) = '\0';
1311 if (!handle_ctrl_cmd(cmdbuf))
1312 *(cmd_cur+strlen(cmd_cur)-1) = '\0';
1314 goto do_full_getstr;
1316 strncpy(cmd_hist[cmd_head], cmd_cur,
1320 cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
1321 if (cmd_head == cmd_tail)
1322 cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
1326 diag = kdb_parse(cmdbuf);
1327 if (diag == KDB_NOTFOUND) {
1328 kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
1331 if (diag == KDB_CMD_GO
1332 || diag == KDB_CMD_CPU
1333 || diag == KDB_CMD_SS
1334 || diag == KDB_CMD_KGDB)
1340 KDB_DEBUG_STATE("kdb_local 9", diag);
1346 * kdb_print_state - Print the state data for the current processor
1349 * text Identifies the debug point
1350 * value Any integer value to be printed, e.g. reason code.
1352 void kdb_print_state(const char *text, int value)
1354 kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1355 text, raw_smp_processor_id(), value, kdb_initial_cpu,
1360 * kdb_main_loop - After initial setup and assignment of the
1361 * controlling cpu, all cpus are in this loop. One cpu is in
1362 * control and will issue the kdb prompt, the others will spin
1363 * until 'go' or cpu switch.
1365 * To get a consistent view of the kernel stacks for all
1366 * processes, this routine is invoked from the main kdb code via
1367 * an architecture specific routine. kdba_main_loop is
1368 * responsible for making the kernel stacks consistent for all
1369 * processes, there should be no difference between a blocked
1370 * process and a running process as far as kdb is concerned.
1372 * reason The reason KDB was invoked
1373 * error The hardware-defined error code
1374 * reason2 kdb's current reason code.
1375 * Initially error but can change
1376 * according to kdb state.
1377 * db_result Result code from break or debug point.
1378 * regs The exception frame at time of fault/breakpoint.
1379 * should always be valid.
1381 * 0 KDB was invoked for an event which it wasn't responsible
1382 * 1 KDB handled the event for which it was invoked.
1384 int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
1385 kdb_dbtrap_t db_result, struct pt_regs *regs)
1388 /* Stay in kdb() until 'go', 'ss[b]' or an error */
1391 * All processors except the one that is in control
1394 KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1395 while (KDB_STATE(HOLD_CPU)) {
1396 /* state KDB is turned off by kdb_cpu to see if the
1397 * other cpus are still live, each cpu in this loop
1400 if (!KDB_STATE(KDB))
1404 KDB_STATE_CLEAR(SUPPRESS);
1405 KDB_DEBUG_STATE("kdb_main_loop 2", reason);
1406 if (KDB_STATE(LEAVING))
1407 break; /* Another cpu said 'go' */
1408 /* Still using kdb, this processor is in control */
1409 result = kdb_local(reason2, error, regs, db_result);
1410 KDB_DEBUG_STATE("kdb_main_loop 3", result);
1412 if (result == KDB_CMD_CPU)
1415 if (result == KDB_CMD_SS) {
1416 KDB_STATE_SET(DOING_SS);
1420 if (result == KDB_CMD_KGDB) {
1421 if (!KDB_STATE(DOING_KGDB))
1422 kdb_printf("Entering please attach debugger "
1423 "or use $D#44+ or $3#33\n");
1426 if (result && result != 1 && result != KDB_CMD_GO)
1427 kdb_printf("\nUnexpected kdb_local return code %d\n",
1429 KDB_DEBUG_STATE("kdb_main_loop 4", reason);
1432 if (KDB_STATE(DOING_SS))
1433 KDB_STATE_CLEAR(SSBPT);
1435 /* Clean up any keyboard devices before leaving */
1436 kdb_kbd_cleanup_state();
1442 * kdb_mdr - This function implements the guts of the 'mdr', memory
1444 * mdr <addr arg>,<byte count>
1446 * addr Start address
1447 * count Number of bytes
1449 * Always 0. Any errors are detected and printed by kdb_getarea.
1451 static int kdb_mdr(unsigned long addr, unsigned int count)
1455 if (kdb_getarea(c, addr))
1457 kdb_printf("%02x", c);
1465 * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1466 * 'md8' 'mdr' and 'mds' commands.
1468 * md|mds [<addr arg> [<line count> [<radix>]]]
1469 * mdWcN [<addr arg> [<line count> [<radix>]]]
1470 * where W = is the width (1, 2, 4 or 8) and N is the count.
1471 * for eg., md1c20 reads 20 bytes, 1 at a time.
1472 * mdr <addr arg>,<byte count>
1474 static void kdb_md_line(const char *fmtstr, unsigned long addr,
1475 int symbolic, int nosect, int bytesperword,
1476 int num, int repeat, int phys)
1478 /* print just one line of data */
1479 kdb_symtab_t symtab;
1485 memset(cbuf, '\0', sizeof(cbuf));
1487 kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1489 kdb_printf(kdb_machreg_fmt0 " ", addr);
1491 for (i = 0; i < num && repeat--; i++) {
1493 if (kdb_getphysword(&word, addr, bytesperword))
1495 } else if (kdb_getword(&word, addr, bytesperword))
1497 kdb_printf(fmtstr, word);
1499 kdbnearsym(word, &symtab);
1501 memset(&symtab, 0, sizeof(symtab));
1502 if (symtab.sym_name) {
1503 kdb_symbol_print(word, &symtab, 0);
1506 kdb_printf(" %s %s "
1509 kdb_machreg_fmt, symtab.mod_name,
1510 symtab.sec_name, symtab.sec_start,
1511 symtab.sym_start, symtab.sym_end);
1513 addr += bytesperword;
1521 cp = wc.c + 8 - bytesperword;
1526 #define printable_char(c) \
1527 ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1528 switch (bytesperword) {
1530 *c++ = printable_char(*cp++);
1531 *c++ = printable_char(*cp++);
1532 *c++ = printable_char(*cp++);
1533 *c++ = printable_char(*cp++);
1536 *c++ = printable_char(*cp++);
1537 *c++ = printable_char(*cp++);
1540 *c++ = printable_char(*cp++);
1543 *c++ = printable_char(*cp++);
1547 #undef printable_char
1550 kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1554 static int kdb_md(int argc, const char **argv)
1556 static unsigned long last_addr;
1557 static int last_radix, last_bytesperword, last_repeat;
1558 int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1560 char fmtchar, fmtstr[64];
1569 kdbgetintenv("MDCOUNT", &mdcount);
1570 kdbgetintenv("RADIX", &radix);
1571 kdbgetintenv("BYTESPERWORD", &bytesperword);
1573 /* Assume 'md <addr>' and start with environment values */
1574 repeat = mdcount * 16 / bytesperword;
1576 if (strcmp(argv[0], "mdr") == 0) {
1577 if (argc == 2 || (argc == 0 && last_addr != 0))
1580 return KDB_ARGCOUNT;
1581 } else if (isdigit(argv[0][2])) {
1582 bytesperword = (int)(argv[0][2] - '0');
1583 if (bytesperword == 0) {
1584 bytesperword = last_bytesperword;
1585 if (bytesperword == 0)
1588 last_bytesperword = bytesperword;
1589 repeat = mdcount * 16 / bytesperword;
1592 else if (argv[0][3] == 'c' && argv[0][4]) {
1594 repeat = simple_strtoul(argv[0] + 4, &p, 10);
1595 mdcount = ((repeat * bytesperword) + 15) / 16;
1598 last_repeat = repeat;
1599 } else if (strcmp(argv[0], "md") == 0)
1601 else if (strcmp(argv[0], "mds") == 0)
1603 else if (strcmp(argv[0], "mdp") == 0) {
1607 return KDB_NOTFOUND;
1611 return KDB_ARGCOUNT;
1614 bytesperword = last_bytesperword;
1615 repeat = last_repeat;
1619 mdcount = ((repeat * bytesperword) + 15) / 16;
1624 int diag, nextarg = 1;
1625 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1629 if (argc > nextarg+2)
1630 return KDB_ARGCOUNT;
1632 if (argc >= nextarg) {
1633 diag = kdbgetularg(argv[nextarg], &val);
1635 mdcount = (int) val;
1639 repeat = mdcount * 16 / bytesperword;
1642 if (argc >= nextarg+1) {
1643 diag = kdbgetularg(argv[nextarg+1], &val);
1649 if (strcmp(argv[0], "mdr") == 0) {
1652 ret = kdb_mdr(addr, mdcount);
1653 last_addr += mdcount;
1654 last_repeat = mdcount;
1655 last_bytesperword = bytesperword; // to make REPEAT happy
1670 return KDB_BADRADIX;
1675 if (bytesperword > KDB_WORD_SIZE)
1676 return KDB_BADWIDTH;
1678 switch (bytesperword) {
1680 sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1683 sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1686 sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1689 sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1692 return KDB_BADWIDTH;
1695 last_repeat = repeat;
1696 last_bytesperword = bytesperword;
1698 if (strcmp(argv[0], "mds") == 0) {
1700 /* Do not save these changes as last_*, they are temporary mds
1703 bytesperword = KDB_WORD_SIZE;
1705 kdbgetintenv("NOSECT", &nosect);
1708 /* Round address down modulo BYTESPERWORD */
1710 addr &= ~(bytesperword-1);
1712 while (repeat > 0) {
1714 int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1716 if (KDB_FLAG(CMD_INTERRUPT))
1718 for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1720 if (kdb_getphysword(&word, a, bytesperword)
1723 } else if (kdb_getword(&word, a, bytesperword) || word)
1726 n = min(num, repeat);
1727 kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1729 addr += bytesperword * n;
1731 z = (z + num - 1) / num;
1733 int s = num * (z-2);
1734 kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1735 " zero suppressed\n",
1736 addr, addr + bytesperword * s - 1);
1737 addr += bytesperword * s;
1747 * kdb_mm - This function implements the 'mm' command.
1748 * mm address-expression new-value
1750 * mm works on machine words, mmW works on bytes.
1752 static int kdb_mm(int argc, const char **argv)
1757 unsigned long contents;
1761 if (argv[0][2] && !isdigit(argv[0][2]))
1762 return KDB_NOTFOUND;
1765 return KDB_ARGCOUNT;
1768 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1773 return KDB_ARGCOUNT;
1774 diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1778 if (nextarg != argc + 1)
1779 return KDB_ARGCOUNT;
1781 width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1782 diag = kdb_putword(addr, contents, width);
1786 kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1792 * kdb_go - This function implements the 'go' command.
1793 * go [address-expression]
1795 static int kdb_go(int argc, const char **argv)
1802 if (raw_smp_processor_id() != kdb_initial_cpu) {
1803 kdb_printf("go must execute on the entry cpu, "
1804 "please use \"cpu %d\" and then execute go\n",
1806 return KDB_BADCPUNUM;
1810 diag = kdbgetaddrarg(argc, argv, &nextarg,
1811 &addr, &offset, NULL);
1815 return KDB_ARGCOUNT;
1819 if (KDB_FLAG(CATASTROPHIC)) {
1820 kdb_printf("Catastrophic error detected\n");
1821 kdb_printf("kdb_continue_catastrophic=%d, ",
1822 kdb_continue_catastrophic);
1823 if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1824 kdb_printf("type go a second time if you really want "
1828 if (kdb_continue_catastrophic == 2) {
1829 kdb_printf("forcing reboot\n");
1830 kdb_reboot(0, NULL);
1832 kdb_printf("attempting to continue\n");
1838 * kdb_rd - This function implements the 'rd' command.
1840 static int kdb_rd(int argc, const char **argv)
1842 int len = kdb_check_regs();
1843 #if DBG_MAX_REG_NUM > 0
1855 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1856 rsize = dbg_reg_def[i].size * 2;
1859 if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
1864 len += kdb_printf(" ");
1865 switch(dbg_reg_def[i].size * 8) {
1867 rname = dbg_get_reg(i, ®8, kdb_current_regs);
1870 len += kdb_printf("%s: %02x", rname, reg8);
1873 rname = dbg_get_reg(i, ®16, kdb_current_regs);
1876 len += kdb_printf("%s: %04x", rname, reg16);
1879 rname = dbg_get_reg(i, ®32, kdb_current_regs);
1882 len += kdb_printf("%s: %08x", rname, reg32);
1885 rname = dbg_get_reg(i, ®64, kdb_current_regs);
1888 len += kdb_printf("%s: %016llx", rname, reg64);
1891 len += kdb_printf("%s: ??", dbg_reg_def[i].name);
1899 kdb_dumpregs(kdb_current_regs);
1905 * kdb_rm - This function implements the 'rm' (register modify) command.
1906 * rm register-name new-contents
1908 * Allows register modification with the same restrictions as gdb
1910 static int kdb_rm(int argc, const char **argv)
1912 #if DBG_MAX_REG_NUM > 0
1922 return KDB_ARGCOUNT;
1924 * Allow presence or absence of leading '%' symbol.
1930 diag = kdbgetu64arg(argv[2], ®64);
1934 diag = kdb_check_regs();
1939 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1940 if (strcmp(rname, dbg_reg_def[i].name) == 0) {
1946 switch(dbg_reg_def[i].size * 8) {
1949 dbg_set_reg(i, ®8, kdb_current_regs);
1953 dbg_set_reg(i, ®16, kdb_current_regs);
1957 dbg_set_reg(i, ®32, kdb_current_regs);
1960 dbg_set_reg(i, ®64, kdb_current_regs);
1966 kdb_printf("ERROR: Register set currently not implemented\n");
1971 #if defined(CONFIG_MAGIC_SYSRQ)
1973 * kdb_sr - This function implements the 'sr' (SYSRQ key) command
1974 * which interfaces to the soi-disant MAGIC SYSRQ functionality.
1975 * sr <magic-sysrq-code>
1977 static int kdb_sr(int argc, const char **argv)
1980 !kdb_check_flags(KDB_ENABLE_ALL, kdb_cmd_enabled, false);
1983 return KDB_ARGCOUNT;
1986 __handle_sysrq(*argv[1], check_mask);
1991 #endif /* CONFIG_MAGIC_SYSRQ */
1994 * kdb_ef - This function implements the 'regs' (display exception
1995 * frame) command. This command takes an address and expects to
1996 * find an exception frame at that address, formats and prints
1998 * regs address-expression
2002 static int kdb_ef(int argc, const char **argv)
2010 return KDB_ARGCOUNT;
2013 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
2016 show_regs((struct pt_regs *)addr);
2020 #if defined(CONFIG_MODULES)
2022 * kdb_lsmod - This function implements the 'lsmod' command. Lists
2023 * currently loaded kernel modules.
2024 * Mostly taken from userland lsmod.
2026 static int kdb_lsmod(int argc, const char **argv)
2031 return KDB_ARGCOUNT;
2033 kdb_printf("Module Size modstruct Used by\n");
2034 list_for_each_entry(mod, kdb_modules, list) {
2035 if (mod->state == MODULE_STATE_UNFORMED)
2038 kdb_printf("%-20s%8u 0x%p ", mod->name,
2039 mod->core_layout.size, (void *)mod);
2040 #ifdef CONFIG_MODULE_UNLOAD
2041 kdb_printf("%4d ", module_refcount(mod));
2043 if (mod->state == MODULE_STATE_GOING)
2044 kdb_printf(" (Unloading)");
2045 else if (mod->state == MODULE_STATE_COMING)
2046 kdb_printf(" (Loading)");
2048 kdb_printf(" (Live)");
2049 kdb_printf(" 0x%p", mod->core_layout.base);
2051 #ifdef CONFIG_MODULE_UNLOAD
2053 struct module_use *use;
2055 list_for_each_entry(use, &mod->source_list,
2057 kdb_printf("%s ", use->target->name);
2066 #endif /* CONFIG_MODULES */
2069 * kdb_env - This function implements the 'env' command. Display the
2070 * current environment variables.
2073 static int kdb_env(int argc, const char **argv)
2077 for (i = 0; i < __nenv; i++) {
2079 kdb_printf("%s\n", __env[i]);
2082 if (KDB_DEBUG(MASK))
2083 kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
2088 #ifdef CONFIG_PRINTK
2090 * kdb_dmesg - This function implements the 'dmesg' command to display
2091 * the contents of the syslog buffer.
2092 * dmesg [lines] [adjust]
2094 static int kdb_dmesg(int argc, const char **argv)
2102 struct kmsg_dumper dumper = { .active = 1 };
2107 return KDB_ARGCOUNT;
2110 lines = simple_strtol(argv[1], &cp, 0);
2114 adjust = simple_strtoul(argv[2], &cp, 0);
2115 if (*cp || adjust < 0)
2120 /* disable LOGGING if set */
2121 diag = kdbgetintenv("LOGGING", &logging);
2122 if (!diag && logging) {
2123 const char *setargs[] = { "set", "LOGGING", "0" };
2124 kdb_set(2, setargs);
2127 kmsg_dump_rewind_nolock(&dumper);
2128 while (kmsg_dump_get_line_nolock(&dumper, 1, NULL, 0, NULL))
2133 kdb_printf("buffer only contains %d lines, nothing "
2135 else if (adjust - lines >= n)
2136 kdb_printf("buffer only contains %d lines, last %d "
2137 "lines printed\n", n, n - adjust);
2140 } else if (lines > 0) {
2141 skip = n - lines - adjust;
2144 kdb_printf("buffer only contains %d lines, "
2145 "nothing printed\n", n);
2147 } else if (skip < 0) {
2150 kdb_printf("buffer only contains %d lines, first "
2151 "%d lines printed\n", n, lines);
2157 if (skip >= n || skip < 0)
2160 kmsg_dump_rewind_nolock(&dumper);
2161 while (kmsg_dump_get_line_nolock(&dumper, 1, buf, sizeof(buf), &len)) {
2168 if (KDB_FLAG(CMD_INTERRUPT))
2171 kdb_printf("%.*s\n", (int)len - 1, buf);
2176 #endif /* CONFIG_PRINTK */
2178 /* Make sure we balance enable/disable calls, must disable first. */
2179 static atomic_t kdb_nmi_disabled;
2181 static int kdb_disable_nmi(int argc, const char *argv[])
2183 if (atomic_read(&kdb_nmi_disabled))
2185 atomic_set(&kdb_nmi_disabled, 1);
2186 arch_kgdb_ops.enable_nmi(0);
2190 static int kdb_param_enable_nmi(const char *val, const struct kernel_param *kp)
2192 if (!atomic_add_unless(&kdb_nmi_disabled, -1, 0))
2194 arch_kgdb_ops.enable_nmi(1);
2198 static const struct kernel_param_ops kdb_param_ops_enable_nmi = {
2199 .set = kdb_param_enable_nmi,
2201 module_param_cb(enable_nmi, &kdb_param_ops_enable_nmi, NULL, 0600);
2204 * kdb_cpu - This function implements the 'cpu' command.
2207 * KDB_CMD_CPU for success, a kdb diagnostic if error
2209 static void kdb_cpu_status(void)
2211 int i, start_cpu, first_print = 1;
2212 char state, prev_state = '?';
2214 kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2215 kdb_printf("Available cpus: ");
2216 for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2217 if (!cpu_online(i)) {
2218 state = 'F'; /* cpu is offline */
2219 } else if (!kgdb_info[i].enter_kgdb) {
2220 state = 'D'; /* cpu is online but unresponsive */
2222 state = ' '; /* cpu is responding to kdb */
2223 if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2224 state = 'I'; /* idle task */
2226 if (state != prev_state) {
2227 if (prev_state != '?') {
2231 kdb_printf("%d", start_cpu);
2232 if (start_cpu < i-1)
2233 kdb_printf("-%d", i-1);
2234 if (prev_state != ' ')
2235 kdb_printf("(%c)", prev_state);
2241 /* print the trailing cpus, ignoring them if they are all offline */
2242 if (prev_state != 'F') {
2245 kdb_printf("%d", start_cpu);
2246 if (start_cpu < i-1)
2247 kdb_printf("-%d", i-1);
2248 if (prev_state != ' ')
2249 kdb_printf("(%c)", prev_state);
2254 static int kdb_cpu(int argc, const char **argv)
2256 unsigned long cpunum;
2265 return KDB_ARGCOUNT;
2267 diag = kdbgetularg(argv[1], &cpunum);
2274 if ((cpunum >= CONFIG_NR_CPUS) || !kgdb_info[cpunum].enter_kgdb)
2275 return KDB_BADCPUNUM;
2277 dbg_switch_cpu = cpunum;
2280 * Switch to other cpu
2285 /* The user may not realize that ps/bta with no parameters does not print idle
2286 * or sleeping system daemon processes, so tell them how many were suppressed.
2288 void kdb_ps_suppressed(void)
2290 int idle = 0, daemon = 0;
2291 unsigned long mask_I = kdb_task_state_string("I"),
2292 mask_M = kdb_task_state_string("M");
2294 const struct task_struct *p, *g;
2295 for_each_online_cpu(cpu) {
2296 p = kdb_curr_task(cpu);
2297 if (kdb_task_state(p, mask_I))
2300 kdb_do_each_thread(g, p) {
2301 if (kdb_task_state(p, mask_M))
2303 } kdb_while_each_thread(g, p);
2304 if (idle || daemon) {
2306 kdb_printf("%d idle process%s (state I)%s\n",
2307 idle, idle == 1 ? "" : "es",
2308 daemon ? " and " : "");
2310 kdb_printf("%d sleeping system daemon (state M) "
2311 "process%s", daemon,
2312 daemon == 1 ? "" : "es");
2313 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2318 * kdb_ps - This function implements the 'ps' command which shows a
2319 * list of the active processes.
2320 * ps [DRSTCZEUIMA] All processes, optionally filtered by state
2322 void kdb_ps1(const struct task_struct *p)
2327 if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
2330 cpu = kdb_process_cpu(p);
2331 kdb_printf("0x%p %8d %8d %d %4d %c 0x%p %c%s\n",
2332 (void *)p, p->pid, p->parent->pid,
2333 kdb_task_has_cpu(p), kdb_process_cpu(p),
2334 kdb_task_state_char(p),
2335 (void *)(&p->thread),
2336 p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2338 if (kdb_task_has_cpu(p)) {
2339 if (!KDB_TSK(cpu)) {
2340 kdb_printf(" Error: no saved data for this cpu\n");
2342 if (KDB_TSK(cpu) != p)
2343 kdb_printf(" Error: does not match running "
2344 "process table (0x%p)\n", KDB_TSK(cpu));
2349 static int kdb_ps(int argc, const char **argv)
2351 struct task_struct *g, *p;
2352 unsigned long mask, cpu;
2355 kdb_ps_suppressed();
2356 kdb_printf("%-*s Pid Parent [*] cpu State %-*s Command\n",
2357 (int)(2*sizeof(void *))+2, "Task Addr",
2358 (int)(2*sizeof(void *))+2, "Thread");
2359 mask = kdb_task_state_string(argc ? argv[1] : NULL);
2360 /* Run the active tasks first */
2361 for_each_online_cpu(cpu) {
2362 if (KDB_FLAG(CMD_INTERRUPT))
2364 p = kdb_curr_task(cpu);
2365 if (kdb_task_state(p, mask))
2369 /* Now the real tasks */
2370 kdb_do_each_thread(g, p) {
2371 if (KDB_FLAG(CMD_INTERRUPT))
2373 if (kdb_task_state(p, mask))
2375 } kdb_while_each_thread(g, p);
2381 * kdb_pid - This function implements the 'pid' command which switches
2382 * the currently active process.
2385 static int kdb_pid(int argc, const char **argv)
2387 struct task_struct *p;
2392 return KDB_ARGCOUNT;
2395 if (strcmp(argv[1], "R") == 0) {
2396 p = KDB_TSK(kdb_initial_cpu);
2398 diag = kdbgetularg(argv[1], &val);
2402 p = find_task_by_pid_ns((pid_t)val, &init_pid_ns);
2404 kdb_printf("No task with pid=%d\n", (pid_t)val);
2408 kdb_set_current_task(p);
2410 kdb_printf("KDB current process is %s(pid=%d)\n",
2411 kdb_current_task->comm,
2412 kdb_current_task->pid);
2417 static int kdb_kgdb(int argc, const char **argv)
2419 return KDB_CMD_KGDB;
2423 * kdb_help - This function implements the 'help' and '?' commands.
2425 static int kdb_help(int argc, const char **argv)
2430 kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2431 kdb_printf("-----------------------------"
2432 "-----------------------------\n");
2433 for_each_kdbcmd(kt, i) {
2435 if (KDB_FLAG(CMD_INTERRUPT))
2439 if (!kdb_check_flags(kt->cmd_flags, kdb_cmd_enabled, true))
2441 if (strlen(kt->cmd_usage) > 20)
2443 kdb_printf("%-15.15s %-20s%s%s\n", kt->cmd_name,
2444 kt->cmd_usage, space, kt->cmd_help);
2450 * kdb_kill - This function implements the 'kill' commands.
2452 static int kdb_kill(int argc, const char **argv)
2456 struct task_struct *p;
2457 struct siginfo info;
2460 return KDB_ARGCOUNT;
2462 sig = simple_strtol(argv[1], &endp, 0);
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 info.si_signo = sig;
2488 info.si_code = SI_USER;
2489 info.si_pid = pid; /* same capabilities as process being signalled */
2490 info.si_uid = 0; /* kdb has root authority */
2491 kdb_send_sig_info(p, &info);
2496 int tm_sec; /* seconds */
2497 int tm_min; /* minutes */
2498 int tm_hour; /* hours */
2499 int tm_mday; /* day of the month */
2500 int tm_mon; /* month */
2501 int tm_year; /* year */
2504 static void kdb_gmtime(struct timespec *tv, struct kdb_tm *tm)
2506 /* This will work from 1970-2099, 2100 is not a leap year */
2507 static int mon_day[] = { 31, 29, 31, 30, 31, 30, 31,
2508 31, 30, 31, 30, 31 };
2509 memset(tm, 0, sizeof(*tm));
2510 tm->tm_sec = tv->tv_sec % (24 * 60 * 60);
2511 tm->tm_mday = tv->tv_sec / (24 * 60 * 60) +
2512 (2 * 365 + 1); /* shift base from 1970 to 1968 */
2513 tm->tm_min = tm->tm_sec / 60 % 60;
2514 tm->tm_hour = tm->tm_sec / 60 / 60;
2515 tm->tm_sec = tm->tm_sec % 60;
2516 tm->tm_year = 68 + 4*(tm->tm_mday / (4*365+1));
2517 tm->tm_mday %= (4*365+1);
2519 while (tm->tm_mday >= mon_day[tm->tm_mon]) {
2520 tm->tm_mday -= mon_day[tm->tm_mon];
2521 if (++tm->tm_mon == 12) {
2531 * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2532 * I cannot call that code directly from kdb, it has an unconditional
2533 * cli()/sti() and calls routines that take locks which can stop the debugger.
2535 static void kdb_sysinfo(struct sysinfo *val)
2537 struct timespec uptime;
2538 ktime_get_ts(&uptime);
2539 memset(val, 0, sizeof(*val));
2540 val->uptime = uptime.tv_sec;
2541 val->loads[0] = avenrun[0];
2542 val->loads[1] = avenrun[1];
2543 val->loads[2] = avenrun[2];
2544 val->procs = nr_threads-1;
2551 * kdb_summary - This function implements the 'summary' command.
2553 static int kdb_summary(int argc, const char **argv)
2555 struct timespec now;
2560 return KDB_ARGCOUNT;
2562 kdb_printf("sysname %s\n", init_uts_ns.name.sysname);
2563 kdb_printf("release %s\n", init_uts_ns.name.release);
2564 kdb_printf("version %s\n", init_uts_ns.name.version);
2565 kdb_printf("machine %s\n", init_uts_ns.name.machine);
2566 kdb_printf("nodename %s\n", init_uts_ns.name.nodename);
2567 kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2568 kdb_printf("ccversion %s\n", __stringify(CCVERSION));
2570 now = __current_kernel_time();
2571 kdb_gmtime(&now, &tm);
2572 kdb_printf("date %04d-%02d-%02d %02d:%02d:%02d "
2573 "tz_minuteswest %d\n",
2574 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2575 tm.tm_hour, tm.tm_min, tm.tm_sec,
2576 sys_tz.tz_minuteswest);
2579 kdb_printf("uptime ");
2580 if (val.uptime > (24*60*60)) {
2581 int days = val.uptime / (24*60*60);
2582 val.uptime %= (24*60*60);
2583 kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2585 kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2587 /* lifted from fs/proc/proc_misc.c::loadavg_read_proc() */
2589 #define LOAD_INT(x) ((x) >> FSHIFT)
2590 #define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
2591 kdb_printf("load avg %ld.%02ld %ld.%02ld %ld.%02ld\n",
2592 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2593 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2594 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2597 /* Display in kilobytes */
2598 #define K(x) ((x) << (PAGE_SHIFT - 10))
2599 kdb_printf("\nMemTotal: %8lu kB\nMemFree: %8lu kB\n"
2600 "Buffers: %8lu kB\n",
2601 K(val.totalram), K(val.freeram), K(val.bufferram));
2606 * kdb_per_cpu - This function implements the 'per_cpu' command.
2608 static int kdb_per_cpu(int argc, const char **argv)
2611 int cpu, diag, nextarg = 1;
2612 unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2614 if (argc < 1 || argc > 3)
2615 return KDB_ARGCOUNT;
2617 diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2622 diag = kdbgetularg(argv[2], &bytesperword);
2627 bytesperword = KDB_WORD_SIZE;
2628 else if (bytesperword > KDB_WORD_SIZE)
2629 return KDB_BADWIDTH;
2630 sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2632 diag = kdbgetularg(argv[3], &whichcpu);
2635 if (whichcpu >= nr_cpu_ids || !cpu_online(whichcpu)) {
2636 kdb_printf("cpu %ld is not online\n", whichcpu);
2637 return KDB_BADCPUNUM;
2641 /* Most architectures use __per_cpu_offset[cpu], some use
2642 * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2644 #ifdef __per_cpu_offset
2645 #define KDB_PCU(cpu) __per_cpu_offset(cpu)
2648 #define KDB_PCU(cpu) __per_cpu_offset[cpu]
2650 #define KDB_PCU(cpu) 0
2653 for_each_online_cpu(cpu) {
2654 if (KDB_FLAG(CMD_INTERRUPT))
2657 if (whichcpu != ~0UL && whichcpu != cpu)
2659 addr = symaddr + KDB_PCU(cpu);
2660 diag = kdb_getword(&val, addr, bytesperword);
2662 kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2663 "read, diag=%d\n", cpu, addr, diag);
2666 kdb_printf("%5d ", cpu);
2667 kdb_md_line(fmtstr, addr,
2668 bytesperword == KDB_WORD_SIZE,
2669 1, bytesperword, 1, 1, 0);
2676 * display help for the use of cmd | grep pattern
2678 static int kdb_grep_help(int argc, const char **argv)
2680 kdb_printf("Usage of cmd args | grep pattern:\n");
2681 kdb_printf(" Any command's output may be filtered through an ");
2682 kdb_printf("emulated 'pipe'.\n");
2683 kdb_printf(" 'grep' is just a key word.\n");
2684 kdb_printf(" The pattern may include a very limited set of "
2685 "metacharacters:\n");
2686 kdb_printf(" pattern or ^pattern or pattern$ or ^pattern$\n");
2687 kdb_printf(" And if there are spaces in the pattern, you may "
2689 kdb_printf(" \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2690 " or \"^pat tern$\"\n");
2695 * kdb_register_flags - This function is used to register a kernel
2699 * func Function to execute the command
2700 * usage A simple usage string showing arguments
2701 * help A simple help string describing command
2702 * repeat Does the command auto repeat on enter?
2704 * zero for success, one if a duplicate command.
2706 #define kdb_command_extend 50 /* arbitrary */
2707 int kdb_register_flags(char *cmd,
2712 kdb_cmdflags_t flags)
2718 * Brute force method to determine duplicates
2720 for_each_kdbcmd(kp, i) {
2721 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2722 kdb_printf("Duplicate kdb command registered: "
2723 "%s, func %p help %s\n", cmd, func, help);
2729 * Insert command into first available location in table
2731 for_each_kdbcmd(kp, i) {
2732 if (kp->cmd_name == NULL)
2736 if (i >= kdb_max_commands) {
2737 kdbtab_t *new = kmalloc((kdb_max_commands - KDB_BASE_CMD_MAX +
2738 kdb_command_extend) * sizeof(*new), GFP_KDB);
2740 kdb_printf("Could not allocate new kdb_command "
2745 memcpy(new, kdb_commands,
2746 (kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new));
2747 kfree(kdb_commands);
2749 memset(new + kdb_max_commands - KDB_BASE_CMD_MAX, 0,
2750 kdb_command_extend * sizeof(*new));
2752 kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX;
2753 kdb_max_commands += kdb_command_extend;
2757 kp->cmd_func = func;
2758 kp->cmd_usage = usage;
2759 kp->cmd_help = help;
2760 kp->cmd_minlen = minlen;
2761 kp->cmd_flags = flags;
2765 EXPORT_SYMBOL_GPL(kdb_register_flags);
2769 * kdb_register - Compatibility register function for commands that do
2770 * not need to specify a repeat state. Equivalent to
2771 * kdb_register_flags with flags set to 0.
2774 * func Function to execute the command
2775 * usage A simple usage string showing arguments
2776 * help A simple help string describing command
2778 * zero for success, one if a duplicate command.
2780 int kdb_register(char *cmd,
2786 return kdb_register_flags(cmd, func, usage, help, minlen, 0);
2788 EXPORT_SYMBOL_GPL(kdb_register);
2791 * kdb_unregister - This function is used to unregister a kernel
2792 * debugger command. It is generally called when a module which
2793 * implements kdb commands is unloaded.
2797 * zero for success, one command not registered.
2799 int kdb_unregister(char *cmd)
2807 for_each_kdbcmd(kp, i) {
2808 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2809 kp->cmd_name = NULL;
2814 /* Couldn't find it. */
2817 EXPORT_SYMBOL_GPL(kdb_unregister);
2819 /* Initialize the kdb command table. */
2820 static void __init kdb_inittab(void)
2825 for_each_kdbcmd(kp, i)
2826 kp->cmd_name = NULL;
2828 kdb_register_flags("md", kdb_md, "<vaddr>",
2829 "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2830 KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2831 kdb_register_flags("mdr", kdb_md, "<vaddr> <bytes>",
2832 "Display Raw Memory", 0,
2833 KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2834 kdb_register_flags("mdp", kdb_md, "<paddr> <bytes>",
2835 "Display Physical Memory", 0,
2836 KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2837 kdb_register_flags("mds", kdb_md, "<vaddr>",
2838 "Display Memory Symbolically", 0,
2839 KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2840 kdb_register_flags("mm", kdb_mm, "<vaddr> <contents>",
2841 "Modify Memory Contents", 0,
2842 KDB_ENABLE_MEM_WRITE | KDB_REPEAT_NO_ARGS);
2843 kdb_register_flags("go", kdb_go, "[<vaddr>]",
2844 "Continue Execution", 1,
2845 KDB_ENABLE_REG_WRITE | KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
2846 kdb_register_flags("rd", kdb_rd, "",
2847 "Display Registers", 0,
2848 KDB_ENABLE_REG_READ);
2849 kdb_register_flags("rm", kdb_rm, "<reg> <contents>",
2850 "Modify Registers", 0,
2851 KDB_ENABLE_REG_WRITE);
2852 kdb_register_flags("ef", kdb_ef, "<vaddr>",
2853 "Display exception frame", 0,
2854 KDB_ENABLE_MEM_READ);
2855 kdb_register_flags("bt", kdb_bt, "[<vaddr>]",
2856 "Stack traceback", 1,
2857 KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS);
2858 kdb_register_flags("btp", kdb_bt, "<pid>",
2859 "Display stack for process <pid>", 0,
2860 KDB_ENABLE_INSPECT);
2861 kdb_register_flags("bta", kdb_bt, "[D|R|S|T|C|Z|E|U|I|M|A]",
2862 "Backtrace all processes matching state flag", 0,
2863 KDB_ENABLE_INSPECT);
2864 kdb_register_flags("btc", kdb_bt, "",
2865 "Backtrace current process on each cpu", 0,
2866 KDB_ENABLE_INSPECT);
2867 kdb_register_flags("btt", kdb_bt, "<vaddr>",
2868 "Backtrace process given its struct task address", 0,
2869 KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS);
2870 kdb_register_flags("env", kdb_env, "",
2871 "Show environment variables", 0,
2872 KDB_ENABLE_ALWAYS_SAFE);
2873 kdb_register_flags("set", kdb_set, "",
2874 "Set environment variables", 0,
2875 KDB_ENABLE_ALWAYS_SAFE);
2876 kdb_register_flags("help", kdb_help, "",
2877 "Display Help Message", 1,
2878 KDB_ENABLE_ALWAYS_SAFE);
2879 kdb_register_flags("?", kdb_help, "",
2880 "Display Help Message", 0,
2881 KDB_ENABLE_ALWAYS_SAFE);
2882 kdb_register_flags("cpu", kdb_cpu, "<cpunum>",
2883 "Switch to new cpu", 0,
2884 KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
2885 kdb_register_flags("kgdb", kdb_kgdb, "",
2886 "Enter kgdb mode", 0, 0);
2887 kdb_register_flags("ps", kdb_ps, "[<flags>|A]",
2888 "Display active task list", 0,
2889 KDB_ENABLE_INSPECT);
2890 kdb_register_flags("pid", kdb_pid, "<pidnum>",
2891 "Switch to another task", 0,
2892 KDB_ENABLE_INSPECT);
2893 kdb_register_flags("reboot", kdb_reboot, "",
2894 "Reboot the machine immediately", 0,
2896 #if defined(CONFIG_MODULES)
2897 kdb_register_flags("lsmod", kdb_lsmod, "",
2898 "List loaded kernel modules", 0,
2899 KDB_ENABLE_INSPECT);
2901 #if defined(CONFIG_MAGIC_SYSRQ)
2902 kdb_register_flags("sr", kdb_sr, "<key>",
2903 "Magic SysRq key", 0,
2904 KDB_ENABLE_ALWAYS_SAFE);
2906 #if defined(CONFIG_PRINTK)
2907 kdb_register_flags("dmesg", kdb_dmesg, "[lines]",
2908 "Display syslog buffer", 0,
2909 KDB_ENABLE_ALWAYS_SAFE);
2911 if (arch_kgdb_ops.enable_nmi) {
2912 kdb_register_flags("disable_nmi", kdb_disable_nmi, "",
2913 "Disable NMI entry to KDB", 0,
2914 KDB_ENABLE_ALWAYS_SAFE);
2916 kdb_register_flags("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
2917 "Define a set of commands, down to endefcmd", 0,
2918 KDB_ENABLE_ALWAYS_SAFE);
2919 kdb_register_flags("kill", kdb_kill, "<-signal> <pid>",
2920 "Send a signal to a process", 0,
2922 kdb_register_flags("summary", kdb_summary, "",
2923 "Summarize the system", 4,
2924 KDB_ENABLE_ALWAYS_SAFE);
2925 kdb_register_flags("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
2926 "Display per_cpu variables", 3,
2927 KDB_ENABLE_MEM_READ);
2928 kdb_register_flags("grephelp", kdb_grep_help, "",
2929 "Display help on | grep", 0,
2930 KDB_ENABLE_ALWAYS_SAFE);
2933 /* Execute any commands defined in kdb_cmds. */
2934 static void __init kdb_cmd_init(void)
2937 for (i = 0; kdb_cmds[i]; ++i) {
2938 diag = kdb_parse(kdb_cmds[i]);
2940 kdb_printf("kdb command %s failed, kdb diag %d\n",
2943 if (defcmd_in_progress) {
2944 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2945 kdb_parse("endefcmd");
2949 /* Initialize kdb_printf, breakpoint tables and kdb state */
2950 void __init kdb_init(int lvl)
2952 static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2955 if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2957 for (i = kdb_init_lvl; i < lvl; i++) {
2959 case KDB_NOT_INITIALIZED:
2960 kdb_inittab(); /* Initialize Command Table */
2961 kdb_initbptab(); /* Initialize Breakpoints */
2963 case KDB_INIT_EARLY:
2964 kdb_cmd_init(); /* Build kdb_cmds tables */