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/list.h>
37 #include <linux/notifier.h>
38 #include <linux/interrupt.h>
39 #include <linux/delay.h>
40 #include <linux/nmi.h>
41 #include <linux/time.h>
42 #include <linux/ptrace.h>
43 #include <linux/sysctl.h>
44 #include <linux/cpu.h>
45 #include <linux/kdebug.h>
46 #include <linux/proc_fs.h>
47 #include <linux/uaccess.h>
48 #include <linux/slab.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_cmds_head describes the available commands. */
89 static LIST_HEAD(kdb_cmds_head);
91 typedef struct _kdbmsg {
92 int km_diag; /* kdb diagnostic */
93 char *km_msg; /* Corresponding message text */
96 #define KDBMSG(msgnum, text) \
97 { KDB_##msgnum, text }
99 static kdbmsg_t kdbmsgs[] = {
100 KDBMSG(NOTFOUND, "Command Not Found"),
101 KDBMSG(ARGCOUNT, "Improper argument count, see usage."),
102 KDBMSG(BADWIDTH, "Illegal value for BYTESPERWORD use 1, 2, 4 or 8, "
103 "8 is only allowed on 64 bit systems"),
104 KDBMSG(BADRADIX, "Illegal value for RADIX use 8, 10 or 16"),
105 KDBMSG(NOTENV, "Cannot find environment variable"),
106 KDBMSG(NOENVVALUE, "Environment variable should have value"),
107 KDBMSG(NOTIMP, "Command not implemented"),
108 KDBMSG(ENVFULL, "Environment full"),
109 KDBMSG(ENVBUFFULL, "Environment buffer full"),
110 KDBMSG(TOOMANYBPT, "Too many breakpoints defined"),
111 #ifdef CONFIG_CPU_XSCALE
112 KDBMSG(TOOMANYDBREGS, "More breakpoints than ibcr registers defined"),
114 KDBMSG(TOOMANYDBREGS, "More breakpoints than db registers defined"),
116 KDBMSG(DUPBPT, "Duplicate breakpoint address"),
117 KDBMSG(BPTNOTFOUND, "Breakpoint not found"),
118 KDBMSG(BADMODE, "Invalid IDMODE"),
119 KDBMSG(BADINT, "Illegal numeric value"),
120 KDBMSG(INVADDRFMT, "Invalid symbolic address format"),
121 KDBMSG(BADREG, "Invalid register name"),
122 KDBMSG(BADCPUNUM, "Invalid cpu number"),
123 KDBMSG(BADLENGTH, "Invalid length field"),
124 KDBMSG(NOBP, "No Breakpoint exists"),
125 KDBMSG(BADADDR, "Invalid address"),
126 KDBMSG(NOPERM, "Permission denied"),
130 static const int __nkdb_err = ARRAY_SIZE(kdbmsgs);
134 * Initial environment. This is all kept static and local to
135 * this file. We don't want to rely on the memory allocation
136 * mechanisms in the kernel, so we use a very limited allocate-only
137 * heap for new and altered environment variables. The entire
138 * environment is limited to a fixed number of entries (add more
139 * to __env[] if required) and a fixed amount of heap (add more to
140 * KDB_ENVBUFSIZE if required).
143 static char *__env[31] = {
144 #if defined(CONFIG_SMP)
151 "MDCOUNT=8", /* lines of md output */
157 static const int __nenv = ARRAY_SIZE(__env);
159 struct task_struct *kdb_curr_task(int cpu)
161 struct task_struct *p = curr_task(cpu);
163 if ((task_thread_info(p)->flags & _TIF_MCA_INIT) && KDB_TSK(cpu))
170 * Check whether the flags of the current command and the permissions
171 * of the kdb console has allow a command to be run.
173 static inline bool kdb_check_flags(kdb_cmdflags_t flags, int permissions,
176 /* permissions comes from userspace so needs massaging slightly */
177 permissions &= KDB_ENABLE_MASK;
178 permissions |= KDB_ENABLE_ALWAYS_SAFE;
180 /* some commands change group when launched with no arguments */
182 permissions |= permissions << KDB_ENABLE_NO_ARGS_SHIFT;
184 flags |= KDB_ENABLE_ALL;
186 return permissions & flags;
190 * kdbgetenv - This function will return the character string value of
191 * an environment variable.
193 * match A character string representing an environment variable.
195 * NULL No environment variable matches 'match'
196 * char* Pointer to string value of environment variable.
198 char *kdbgetenv(const char *match)
201 int matchlen = strlen(match);
204 for (i = 0; i < __nenv; i++) {
210 if ((strncmp(match, e, matchlen) == 0)
211 && ((e[matchlen] == '\0')
212 || (e[matchlen] == '='))) {
213 char *cp = strchr(e, '=');
214 return cp ? ++cp : "";
221 * kdballocenv - This function is used to allocate bytes for
222 * environment entries.
224 * match A character string representing a numeric value
226 * *value the unsigned long representation of the env variable 'match'
228 * Zero on success, a kdb diagnostic on failure.
230 * We use a static environment buffer (envbuffer) to hold the values
231 * of dynamically generated environment variables (see kdb_set). Buffer
232 * space once allocated is never free'd, so over time, the amount of space
233 * (currently 512 bytes) will be exhausted if env variables are changed
236 static char *kdballocenv(size_t bytes)
238 #define KDB_ENVBUFSIZE 512
239 static char envbuffer[KDB_ENVBUFSIZE];
240 static int envbufsize;
243 if ((KDB_ENVBUFSIZE - envbufsize) >= bytes) {
244 ep = &envbuffer[envbufsize];
251 * kdbgetulenv - This function will return the value of an unsigned
252 * long-valued environment variable.
254 * match A character string representing a numeric value
256 * *value the unsigned long represntation of the env variable 'match'
258 * Zero on success, a kdb diagnostic on failure.
260 static int kdbgetulenv(const char *match, unsigned long *value)
264 ep = kdbgetenv(match);
268 return KDB_NOENVVALUE;
270 *value = simple_strtoul(ep, NULL, 0);
276 * kdbgetintenv - This function will return the value of an
277 * integer-valued environment variable.
279 * match A character string representing an integer-valued env variable
281 * *value the integer representation of the environment variable 'match'
283 * Zero on success, a kdb diagnostic on failure.
285 int kdbgetintenv(const char *match, int *value)
290 diag = kdbgetulenv(match, &val);
297 * kdb_setenv() - Alter an existing environment variable or create a new one.
298 * @var: Name of the variable
299 * @val: Value of the variable
301 * Return: Zero on success, a kdb diagnostic on failure.
303 static int kdb_setenv(const char *var, const char *val)
307 size_t varlen, vallen;
309 varlen = strlen(var);
310 vallen = strlen(val);
311 ep = kdballocenv(varlen + vallen + 2);
313 return KDB_ENVBUFFULL;
315 sprintf(ep, "%s=%s", var, val);
317 for (i = 0; i < __nenv; i++) {
319 && ((strncmp(__env[i], var, varlen) == 0)
320 && ((__env[i][varlen] == '\0')
321 || (__env[i][varlen] == '=')))) {
328 * Wasn't existing variable. Fit into slot.
330 for (i = 0; i < __nenv-1; i++) {
331 if (__env[i] == (char *)0) {
341 * kdb_printenv() - Display the current environment variables.
343 static void kdb_printenv(void)
347 for (i = 0; i < __nenv; i++) {
349 kdb_printf("%s\n", __env[i]);
354 * kdbgetularg - This function will convert a numeric string into an
355 * unsigned long value.
357 * arg A character string representing a numeric value
359 * *value the unsigned long represntation of arg.
361 * Zero on success, a kdb diagnostic on failure.
363 int kdbgetularg(const char *arg, unsigned long *value)
368 val = simple_strtoul(arg, &endp, 0);
372 * Also try base 16, for us folks too lazy to type the
375 val = simple_strtoul(arg, &endp, 16);
385 int kdbgetu64arg(const char *arg, u64 *value)
390 val = simple_strtoull(arg, &endp, 0);
394 val = simple_strtoull(arg, &endp, 16);
405 * kdb_set - This function implements the 'set' command. Alter an
406 * existing environment variable or create a new one.
408 int kdb_set(int argc, const char **argv)
411 * we can be invoked two ways:
412 * set var=value argv[1]="var", argv[2]="value"
413 * set var = value argv[1]="var", argv[2]="=", argv[3]="value"
414 * - if the latter, shift 'em down.
425 * Censor sensitive variables
427 if (strcmp(argv[1], "PROMPT") == 0 &&
428 !kdb_check_flags(KDB_ENABLE_MEM_READ, kdb_cmd_enabled, false))
432 * Check for internal variables
434 if (strcmp(argv[1], "KDBDEBUG") == 0) {
435 unsigned int debugflags;
438 debugflags = simple_strtoul(argv[2], &cp, 0);
439 if (cp == argv[2] || debugflags & ~KDB_DEBUG_FLAG_MASK) {
440 kdb_printf("kdb: illegal debug flags '%s'\n",
444 kdb_flags = (kdb_flags & ~KDB_DEBUG(MASK))
445 | (debugflags << KDB_DEBUG_FLAG_SHIFT);
451 * Tokenizer squashed the '=' sign. argv[1] is variable
452 * name, argv[2] = value.
454 return kdb_setenv(argv[1], argv[2]);
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 bool 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 = false;
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 = kcalloc(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_array(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 = true;
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 (!str_has_prefix(cp, "grep ")) {
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 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 list_for_each_entry(tp, &kdb_cmds_head, list_node) {
1009 * If this command is allowed to be abbreviated,
1010 * check to see if this is it.
1012 if (tp->cmd_minlen && (strlen(argv[0]) <= tp->cmd_minlen) &&
1013 (strncmp(argv[0], tp->cmd_name, tp->cmd_minlen) == 0))
1016 if (strcmp(argv[0], tp->cmd_name) == 0)
1021 * If we don't find a command by this name, see if the first
1022 * few characters of this match any of the known commands.
1023 * e.g., md1c20 should match md.
1025 if (list_entry_is_head(tp, &kdb_cmds_head, list_node)) {
1026 list_for_each_entry(tp, &kdb_cmds_head, list_node) {
1027 if (strncmp(argv[0], tp->cmd_name,
1028 strlen(tp->cmd_name)) == 0)
1033 if (!list_entry_is_head(tp, &kdb_cmds_head, list_node)) {
1036 if (!kdb_check_flags(tp->cmd_flags, kdb_cmd_enabled, argc <= 1))
1040 result = (*tp->cmd_func)(argc-1, (const char **)argv);
1041 if (result && ignore_errors && result > KDB_CMD_GO)
1043 KDB_STATE_CLEAR(CMD);
1045 if (tp->cmd_flags & KDB_REPEAT_WITH_ARGS)
1048 argc = tp->cmd_flags & KDB_REPEAT_NO_ARGS ? 1 : 0;
1050 *(argv[argc]) = '\0';
1055 * If the input with which we were presented does not
1056 * map to an existing command, attempt to parse it as an
1057 * address argument and display the result. Useful for
1058 * obtaining the address of a variable, or the nearest symbol
1059 * to an address contained in a register.
1062 unsigned long value;
1067 if (kdbgetaddrarg(0, (const char **)argv, &nextarg,
1068 &value, &offset, &name)) {
1069 return KDB_NOTFOUND;
1072 kdb_printf("%s = ", argv[0]);
1073 kdb_symbol_print(value, NULL, KDB_SP_DEFAULT);
1080 static int handle_ctrl_cmd(char *cmd)
1085 /* initial situation */
1086 if (cmd_head == cmd_tail)
1090 if (cmdptr != cmd_tail)
1091 cmdptr = (cmdptr + KDB_CMD_HISTORY_COUNT - 1) %
1092 KDB_CMD_HISTORY_COUNT;
1093 strscpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1096 if (cmdptr != cmd_head)
1097 cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT;
1098 strscpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1105 * kdb_reboot - This function implements the 'reboot' command. Reboot
1106 * the system immediately, or loop for ever on failure.
1108 static int kdb_reboot(int argc, const char **argv)
1110 emergency_restart();
1111 kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
1118 static void kdb_dumpregs(struct pt_regs *regs)
1120 int old_lvl = console_loglevel;
1121 console_loglevel = CONSOLE_LOGLEVEL_MOTORMOUTH;
1126 console_loglevel = old_lvl;
1129 static void kdb_set_current_task(struct task_struct *p)
1131 kdb_current_task = p;
1133 if (kdb_task_has_cpu(p)) {
1134 kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p));
1137 kdb_current_regs = NULL;
1140 static void drop_newline(char *buf)
1142 size_t len = strlen(buf);
1146 if (*(buf + len - 1) == '\n')
1147 *(buf + len - 1) = '\0';
1151 * kdb_local - The main code for kdb. This routine is invoked on a
1152 * specific processor, it is not global. The main kdb() routine
1153 * ensures that only one processor at a time is in this routine.
1154 * This code is called with the real reason code on the first
1155 * entry to a kdb session, thereafter it is called with reason
1156 * SWITCH, even if the user goes back to the original cpu.
1158 * reason The reason KDB was invoked
1159 * error The hardware-defined error code
1160 * regs The exception frame at time of fault/breakpoint.
1161 * db_result Result code from the break or debug point.
1163 * 0 KDB was invoked for an event which it wasn't responsible
1164 * 1 KDB handled the event for which it was invoked.
1165 * KDB_CMD_GO User typed 'go'.
1166 * KDB_CMD_CPU User switched to another cpu.
1167 * KDB_CMD_SS Single step.
1169 static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs,
1170 kdb_dbtrap_t db_result)
1174 struct task_struct *kdb_current =
1175 kdb_curr_task(raw_smp_processor_id());
1177 KDB_DEBUG_STATE("kdb_local 1", reason);
1179 if (reason == KDB_REASON_DEBUG) {
1180 /* special case below */
1182 kdb_printf("\nEntering kdb (current=0x%px, pid %d) ",
1183 kdb_current, kdb_current ? kdb_current->pid : 0);
1184 #if defined(CONFIG_SMP)
1185 kdb_printf("on processor %d ", raw_smp_processor_id());
1190 case KDB_REASON_DEBUG:
1193 * If re-entering kdb after a single step
1194 * command, don't print the message.
1196 switch (db_result) {
1198 kdb_printf("\nEntering kdb (0x%px, pid %d) ",
1199 kdb_current, kdb_current->pid);
1200 #if defined(CONFIG_SMP)
1201 kdb_printf("on processor %d ", raw_smp_processor_id());
1203 kdb_printf("due to Debug @ " kdb_machreg_fmt "\n",
1204 instruction_pointer(regs));
1209 KDB_DEBUG_STATE("kdb_local 4", reason);
1210 return 1; /* kdba_db_trap did the work */
1212 kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
1219 case KDB_REASON_ENTER:
1220 if (KDB_STATE(KEYBOARD))
1221 kdb_printf("due to Keyboard Entry\n");
1223 kdb_printf("due to KDB_ENTER()\n");
1225 case KDB_REASON_KEYBOARD:
1226 KDB_STATE_SET(KEYBOARD);
1227 kdb_printf("due to Keyboard Entry\n");
1229 case KDB_REASON_ENTER_SLAVE:
1230 /* drop through, slaves only get released via cpu switch */
1231 case KDB_REASON_SWITCH:
1232 kdb_printf("due to cpu switch\n");
1234 case KDB_REASON_OOPS:
1235 kdb_printf("Oops: %s\n", kdb_diemsg);
1236 kdb_printf("due to oops @ " kdb_machreg_fmt "\n",
1237 instruction_pointer(regs));
1240 case KDB_REASON_SYSTEM_NMI:
1241 kdb_printf("due to System NonMaskable Interrupt\n");
1243 case KDB_REASON_NMI:
1244 kdb_printf("due to NonMaskable Interrupt @ "
1245 kdb_machreg_fmt "\n",
1246 instruction_pointer(regs));
1248 case KDB_REASON_SSTEP:
1249 case KDB_REASON_BREAK:
1250 kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
1251 reason == KDB_REASON_BREAK ?
1252 "Breakpoint" : "SS trap", instruction_pointer(regs));
1254 * Determine if this breakpoint is one that we
1255 * are interested in.
1257 if (db_result != KDB_DB_BPT) {
1258 kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1260 KDB_DEBUG_STATE("kdb_local 6", reason);
1261 return 0; /* Not for us, dismiss it */
1264 case KDB_REASON_RECURSE:
1265 kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
1266 instruction_pointer(regs));
1269 kdb_printf("kdb: unexpected reason code: %d\n", reason);
1270 KDB_DEBUG_STATE("kdb_local 8", reason);
1271 return 0; /* Not for us, dismiss it */
1276 * Initialize pager context.
1279 KDB_STATE_CLEAR(SUPPRESS);
1280 kdb_grepping_flag = 0;
1281 /* ensure the old search does not leak into '/' commands */
1282 kdb_grep_string[0] = '\0';
1286 *(cmd_hist[cmd_head]) = '\0';
1289 /* PROMPT can only be set if we have MEM_READ permission. */
1290 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
1291 raw_smp_processor_id());
1292 if (defcmd_in_progress)
1293 strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
1296 * Fetch command from keyboard
1298 cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
1299 if (*cmdbuf != '\n') {
1301 if (cmdptr == cmd_head) {
1302 strscpy(cmd_hist[cmd_head], cmd_cur,
1304 *(cmd_hist[cmd_head] +
1305 strlen(cmd_hist[cmd_head])-1) = '\0';
1307 if (!handle_ctrl_cmd(cmdbuf))
1308 *(cmd_cur+strlen(cmd_cur)-1) = '\0';
1310 goto do_full_getstr;
1312 strscpy(cmd_hist[cmd_head], cmd_cur,
1316 cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
1317 if (cmd_head == cmd_tail)
1318 cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
1322 diag = kdb_parse(cmdbuf);
1323 if (diag == KDB_NOTFOUND) {
1324 drop_newline(cmdbuf);
1325 kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
1328 if (diag == KDB_CMD_GO
1329 || diag == KDB_CMD_CPU
1330 || diag == KDB_CMD_SS
1331 || diag == KDB_CMD_KGDB)
1337 KDB_DEBUG_STATE("kdb_local 9", diag);
1343 * kdb_print_state - Print the state data for the current processor
1346 * text Identifies the debug point
1347 * value Any integer value to be printed, e.g. reason code.
1349 void kdb_print_state(const char *text, int value)
1351 kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1352 text, raw_smp_processor_id(), value, kdb_initial_cpu,
1357 * kdb_main_loop - After initial setup and assignment of the
1358 * controlling cpu, all cpus are in this loop. One cpu is in
1359 * control and will issue the kdb prompt, the others will spin
1360 * until 'go' or cpu switch.
1362 * To get a consistent view of the kernel stacks for all
1363 * processes, this routine is invoked from the main kdb code via
1364 * an architecture specific routine. kdba_main_loop is
1365 * responsible for making the kernel stacks consistent for all
1366 * processes, there should be no difference between a blocked
1367 * process and a running process as far as kdb is concerned.
1369 * reason The reason KDB was invoked
1370 * error The hardware-defined error code
1371 * reason2 kdb's current reason code.
1372 * Initially error but can change
1373 * according to kdb state.
1374 * db_result Result code from break or debug point.
1375 * regs The exception frame at time of fault/breakpoint.
1376 * should always be valid.
1378 * 0 KDB was invoked for an event which it wasn't responsible
1379 * 1 KDB handled the event for which it was invoked.
1381 int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
1382 kdb_dbtrap_t db_result, struct pt_regs *regs)
1385 /* Stay in kdb() until 'go', 'ss[b]' or an error */
1388 * All processors except the one that is in control
1391 KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1392 while (KDB_STATE(HOLD_CPU)) {
1393 /* state KDB is turned off by kdb_cpu to see if the
1394 * other cpus are still live, each cpu in this loop
1397 if (!KDB_STATE(KDB))
1401 KDB_STATE_CLEAR(SUPPRESS);
1402 KDB_DEBUG_STATE("kdb_main_loop 2", reason);
1403 if (KDB_STATE(LEAVING))
1404 break; /* Another cpu said 'go' */
1405 /* Still using kdb, this processor is in control */
1406 result = kdb_local(reason2, error, regs, db_result);
1407 KDB_DEBUG_STATE("kdb_main_loop 3", result);
1409 if (result == KDB_CMD_CPU)
1412 if (result == KDB_CMD_SS) {
1413 KDB_STATE_SET(DOING_SS);
1417 if (result == KDB_CMD_KGDB) {
1418 if (!KDB_STATE(DOING_KGDB))
1419 kdb_printf("Entering please attach debugger "
1420 "or use $D#44+ or $3#33\n");
1423 if (result && result != 1 && result != KDB_CMD_GO)
1424 kdb_printf("\nUnexpected kdb_local return code %d\n",
1426 KDB_DEBUG_STATE("kdb_main_loop 4", reason);
1429 if (KDB_STATE(DOING_SS))
1430 KDB_STATE_CLEAR(SSBPT);
1432 /* Clean up any keyboard devices before leaving */
1433 kdb_kbd_cleanup_state();
1439 * kdb_mdr - This function implements the guts of the 'mdr', memory
1441 * mdr <addr arg>,<byte count>
1443 * addr Start address
1444 * count Number of bytes
1446 * Always 0. Any errors are detected and printed by kdb_getarea.
1448 static int kdb_mdr(unsigned long addr, unsigned int count)
1452 if (kdb_getarea(c, addr))
1454 kdb_printf("%02x", c);
1462 * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1463 * 'md8' 'mdr' and 'mds' commands.
1465 * md|mds [<addr arg> [<line count> [<radix>]]]
1466 * mdWcN [<addr arg> [<line count> [<radix>]]]
1467 * where W = is the width (1, 2, 4 or 8) and N is the count.
1468 * for eg., md1c20 reads 20 bytes, 1 at a time.
1469 * mdr <addr arg>,<byte count>
1471 static void kdb_md_line(const char *fmtstr, unsigned long addr,
1472 int symbolic, int nosect, int bytesperword,
1473 int num, int repeat, int phys)
1475 /* print just one line of data */
1476 kdb_symtab_t symtab;
1483 memset(cbuf, '\0', sizeof(cbuf));
1485 kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1487 kdb_printf(kdb_machreg_fmt0 " ", addr);
1489 for (i = 0; i < num && repeat--; i++) {
1491 if (kdb_getphysword(&word, addr, bytesperword))
1493 } else if (kdb_getword(&word, addr, bytesperword))
1495 kdb_printf(fmtstr, word);
1497 kdbnearsym(word, &symtab);
1499 memset(&symtab, 0, sizeof(symtab));
1500 if (symtab.sym_name) {
1501 kdb_symbol_print(word, &symtab, 0);
1504 kdb_printf(" %s %s "
1507 kdb_machreg_fmt, symtab.mod_name,
1508 symtab.sec_name, symtab.sec_start,
1509 symtab.sym_start, symtab.sym_end);
1511 addr += bytesperword;
1519 cp = wc.c + 8 - bytesperword;
1524 #define printable_char(c) \
1525 ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1526 for (j = 0; j < bytesperword; j++)
1527 *c++ = printable_char(*cp++);
1528 addr += bytesperword;
1529 #undef printable_char
1532 kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1536 static int kdb_md(int argc, const char **argv)
1538 static unsigned long last_addr;
1539 static int last_radix, last_bytesperword, last_repeat;
1540 int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1542 char fmtchar, fmtstr[64];
1551 kdbgetintenv("MDCOUNT", &mdcount);
1552 kdbgetintenv("RADIX", &radix);
1553 kdbgetintenv("BYTESPERWORD", &bytesperword);
1555 /* Assume 'md <addr>' and start with environment values */
1556 repeat = mdcount * 16 / bytesperword;
1558 if (strcmp(argv[0], "mdr") == 0) {
1559 if (argc == 2 || (argc == 0 && last_addr != 0))
1562 return KDB_ARGCOUNT;
1563 } else if (isdigit(argv[0][2])) {
1564 bytesperword = (int)(argv[0][2] - '0');
1565 if (bytesperword == 0) {
1566 bytesperword = last_bytesperword;
1567 if (bytesperword == 0)
1570 last_bytesperword = bytesperword;
1571 repeat = mdcount * 16 / bytesperword;
1574 else if (argv[0][3] == 'c' && argv[0][4]) {
1576 repeat = simple_strtoul(argv[0] + 4, &p, 10);
1577 mdcount = ((repeat * bytesperword) + 15) / 16;
1580 last_repeat = repeat;
1581 } else if (strcmp(argv[0], "md") == 0)
1583 else if (strcmp(argv[0], "mds") == 0)
1585 else if (strcmp(argv[0], "mdp") == 0) {
1589 return KDB_NOTFOUND;
1593 return KDB_ARGCOUNT;
1596 bytesperword = last_bytesperword;
1597 repeat = last_repeat;
1601 mdcount = ((repeat * bytesperword) + 15) / 16;
1606 int diag, nextarg = 1;
1607 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1611 if (argc > nextarg+2)
1612 return KDB_ARGCOUNT;
1614 if (argc >= nextarg) {
1615 diag = kdbgetularg(argv[nextarg], &val);
1617 mdcount = (int) val;
1621 repeat = mdcount * 16 / bytesperword;
1624 if (argc >= nextarg+1) {
1625 diag = kdbgetularg(argv[nextarg+1], &val);
1631 if (strcmp(argv[0], "mdr") == 0) {
1634 ret = kdb_mdr(addr, mdcount);
1635 last_addr += mdcount;
1636 last_repeat = mdcount;
1637 last_bytesperword = bytesperword; // to make REPEAT happy
1652 return KDB_BADRADIX;
1657 if (bytesperword > KDB_WORD_SIZE)
1658 return KDB_BADWIDTH;
1660 switch (bytesperword) {
1662 sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1665 sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1668 sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1671 sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1674 return KDB_BADWIDTH;
1677 last_repeat = repeat;
1678 last_bytesperword = bytesperword;
1680 if (strcmp(argv[0], "mds") == 0) {
1682 /* Do not save these changes as last_*, they are temporary mds
1685 bytesperword = KDB_WORD_SIZE;
1687 kdbgetintenv("NOSECT", &nosect);
1690 /* Round address down modulo BYTESPERWORD */
1692 addr &= ~(bytesperword-1);
1694 while (repeat > 0) {
1696 int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1698 if (KDB_FLAG(CMD_INTERRUPT))
1700 for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1702 if (kdb_getphysword(&word, a, bytesperword)
1705 } else if (kdb_getword(&word, a, bytesperword) || word)
1708 n = min(num, repeat);
1709 kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1711 addr += bytesperword * n;
1713 z = (z + num - 1) / num;
1715 int s = num * (z-2);
1716 kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1717 " zero suppressed\n",
1718 addr, addr + bytesperword * s - 1);
1719 addr += bytesperword * s;
1729 * kdb_mm - This function implements the 'mm' command.
1730 * mm address-expression new-value
1732 * mm works on machine words, mmW works on bytes.
1734 static int kdb_mm(int argc, const char **argv)
1739 unsigned long contents;
1743 if (argv[0][2] && !isdigit(argv[0][2]))
1744 return KDB_NOTFOUND;
1747 return KDB_ARGCOUNT;
1750 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1755 return KDB_ARGCOUNT;
1756 diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1760 if (nextarg != argc + 1)
1761 return KDB_ARGCOUNT;
1763 width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1764 diag = kdb_putword(addr, contents, width);
1768 kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1774 * kdb_go - This function implements the 'go' command.
1775 * go [address-expression]
1777 static int kdb_go(int argc, const char **argv)
1784 if (raw_smp_processor_id() != kdb_initial_cpu) {
1785 kdb_printf("go must execute on the entry cpu, "
1786 "please use \"cpu %d\" and then execute go\n",
1788 return KDB_BADCPUNUM;
1792 diag = kdbgetaddrarg(argc, argv, &nextarg,
1793 &addr, &offset, NULL);
1797 return KDB_ARGCOUNT;
1801 if (KDB_FLAG(CATASTROPHIC)) {
1802 kdb_printf("Catastrophic error detected\n");
1803 kdb_printf("kdb_continue_catastrophic=%d, ",
1804 kdb_continue_catastrophic);
1805 if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1806 kdb_printf("type go a second time if you really want "
1810 if (kdb_continue_catastrophic == 2) {
1811 kdb_printf("forcing reboot\n");
1812 kdb_reboot(0, NULL);
1814 kdb_printf("attempting to continue\n");
1820 * kdb_rd - This function implements the 'rd' command.
1822 static int kdb_rd(int argc, const char **argv)
1824 int len = kdb_check_regs();
1825 #if DBG_MAX_REG_NUM > 0
1837 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1838 rsize = dbg_reg_def[i].size * 2;
1841 if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
1846 len += kdb_printf(" ");
1847 switch(dbg_reg_def[i].size * 8) {
1849 rname = dbg_get_reg(i, ®8, kdb_current_regs);
1852 len += kdb_printf("%s: %02x", rname, reg8);
1855 rname = dbg_get_reg(i, ®16, kdb_current_regs);
1858 len += kdb_printf("%s: %04x", rname, reg16);
1861 rname = dbg_get_reg(i, ®32, kdb_current_regs);
1864 len += kdb_printf("%s: %08x", rname, reg32);
1867 rname = dbg_get_reg(i, ®64, kdb_current_regs);
1870 len += kdb_printf("%s: %016llx", rname, reg64);
1873 len += kdb_printf("%s: ??", dbg_reg_def[i].name);
1881 kdb_dumpregs(kdb_current_regs);
1887 * kdb_rm - This function implements the 'rm' (register modify) command.
1888 * rm register-name new-contents
1890 * Allows register modification with the same restrictions as gdb
1892 static int kdb_rm(int argc, const char **argv)
1894 #if DBG_MAX_REG_NUM > 0
1904 return KDB_ARGCOUNT;
1906 * Allow presence or absence of leading '%' symbol.
1912 diag = kdbgetu64arg(argv[2], ®64);
1916 diag = kdb_check_regs();
1921 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1922 if (strcmp(rname, dbg_reg_def[i].name) == 0) {
1928 switch(dbg_reg_def[i].size * 8) {
1931 dbg_set_reg(i, ®8, kdb_current_regs);
1935 dbg_set_reg(i, ®16, kdb_current_regs);
1939 dbg_set_reg(i, ®32, kdb_current_regs);
1942 dbg_set_reg(i, ®64, kdb_current_regs);
1948 kdb_printf("ERROR: Register set currently not implemented\n");
1953 #if defined(CONFIG_MAGIC_SYSRQ)
1955 * kdb_sr - This function implements the 'sr' (SYSRQ key) command
1956 * which interfaces to the soi-disant MAGIC SYSRQ functionality.
1957 * sr <magic-sysrq-code>
1959 static int kdb_sr(int argc, const char **argv)
1962 !kdb_check_flags(KDB_ENABLE_ALL, kdb_cmd_enabled, false);
1965 return KDB_ARGCOUNT;
1968 __handle_sysrq(*argv[1], check_mask);
1973 #endif /* CONFIG_MAGIC_SYSRQ */
1976 * kdb_ef - This function implements the 'regs' (display exception
1977 * frame) command. This command takes an address and expects to
1978 * find an exception frame at that address, formats and prints
1980 * regs address-expression
1984 static int kdb_ef(int argc, const char **argv)
1992 return KDB_ARGCOUNT;
1995 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1998 show_regs((struct pt_regs *)addr);
2002 #if defined(CONFIG_MODULES)
2004 * kdb_lsmod - This function implements the 'lsmod' command. Lists
2005 * currently loaded kernel modules.
2006 * Mostly taken from userland lsmod.
2008 static int kdb_lsmod(int argc, const char **argv)
2013 return KDB_ARGCOUNT;
2015 kdb_printf("Module Size modstruct Used by\n");
2016 list_for_each_entry(mod, kdb_modules, list) {
2017 if (mod->state == MODULE_STATE_UNFORMED)
2020 kdb_printf("%-20s%8u 0x%px ", mod->name,
2021 mod->core_layout.size, (void *)mod);
2022 #ifdef CONFIG_MODULE_UNLOAD
2023 kdb_printf("%4d ", module_refcount(mod));
2025 if (mod->state == MODULE_STATE_GOING)
2026 kdb_printf(" (Unloading)");
2027 else if (mod->state == MODULE_STATE_COMING)
2028 kdb_printf(" (Loading)");
2030 kdb_printf(" (Live)");
2031 kdb_printf(" 0x%px", mod->core_layout.base);
2033 #ifdef CONFIG_MODULE_UNLOAD
2035 struct module_use *use;
2037 list_for_each_entry(use, &mod->source_list,
2039 kdb_printf("%s ", use->target->name);
2048 #endif /* CONFIG_MODULES */
2051 * kdb_env - This function implements the 'env' command. Display the
2052 * current environment variables.
2055 static int kdb_env(int argc, const char **argv)
2059 if (KDB_DEBUG(MASK))
2060 kdb_printf("KDBDEBUG=0x%x\n",
2061 (kdb_flags & KDB_DEBUG(MASK)) >> KDB_DEBUG_FLAG_SHIFT);
2066 #ifdef CONFIG_PRINTK
2068 * kdb_dmesg - This function implements the 'dmesg' command to display
2069 * the contents of the syslog buffer.
2070 * dmesg [lines] [adjust]
2072 static int kdb_dmesg(int argc, const char **argv)
2080 struct kmsg_dump_iter iter;
2085 return KDB_ARGCOUNT;
2088 lines = simple_strtol(argv[1], &cp, 0);
2092 adjust = simple_strtoul(argv[2], &cp, 0);
2093 if (*cp || adjust < 0)
2098 /* disable LOGGING if set */
2099 diag = kdbgetintenv("LOGGING", &logging);
2100 if (!diag && logging) {
2101 const char *setargs[] = { "set", "LOGGING", "0" };
2102 kdb_set(2, setargs);
2105 kmsg_dump_rewind(&iter);
2106 while (kmsg_dump_get_line(&iter, 1, NULL, 0, NULL))
2111 kdb_printf("buffer only contains %d lines, nothing "
2113 else if (adjust - lines >= n)
2114 kdb_printf("buffer only contains %d lines, last %d "
2115 "lines printed\n", n, n - adjust);
2118 } else if (lines > 0) {
2119 skip = n - lines - adjust;
2122 kdb_printf("buffer only contains %d lines, "
2123 "nothing printed\n", n);
2125 } else if (skip < 0) {
2128 kdb_printf("buffer only contains %d lines, first "
2129 "%d lines printed\n", n, lines);
2135 if (skip >= n || skip < 0)
2138 kmsg_dump_rewind(&iter);
2139 while (kmsg_dump_get_line(&iter, 1, buf, sizeof(buf), &len)) {
2146 if (KDB_FLAG(CMD_INTERRUPT))
2149 kdb_printf("%.*s\n", (int)len - 1, buf);
2154 #endif /* CONFIG_PRINTK */
2156 /* Make sure we balance enable/disable calls, must disable first. */
2157 static atomic_t kdb_nmi_disabled;
2159 static int kdb_disable_nmi(int argc, const char *argv[])
2161 if (atomic_read(&kdb_nmi_disabled))
2163 atomic_set(&kdb_nmi_disabled, 1);
2164 arch_kgdb_ops.enable_nmi(0);
2168 static int kdb_param_enable_nmi(const char *val, const struct kernel_param *kp)
2170 if (!atomic_add_unless(&kdb_nmi_disabled, -1, 0))
2172 arch_kgdb_ops.enable_nmi(1);
2176 static const struct kernel_param_ops kdb_param_ops_enable_nmi = {
2177 .set = kdb_param_enable_nmi,
2179 module_param_cb(enable_nmi, &kdb_param_ops_enable_nmi, NULL, 0600);
2182 * kdb_cpu - This function implements the 'cpu' command.
2185 * KDB_CMD_CPU for success, a kdb diagnostic if error
2187 static void kdb_cpu_status(void)
2189 int i, start_cpu, first_print = 1;
2190 char state, prev_state = '?';
2192 kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2193 kdb_printf("Available cpus: ");
2194 for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2195 if (!cpu_online(i)) {
2196 state = 'F'; /* cpu is offline */
2197 } else if (!kgdb_info[i].enter_kgdb) {
2198 state = 'D'; /* cpu is online but unresponsive */
2200 state = ' '; /* cpu is responding to kdb */
2201 if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2202 state = 'I'; /* idle task */
2204 if (state != prev_state) {
2205 if (prev_state != '?') {
2209 kdb_printf("%d", start_cpu);
2210 if (start_cpu < i-1)
2211 kdb_printf("-%d", i-1);
2212 if (prev_state != ' ')
2213 kdb_printf("(%c)", prev_state);
2219 /* print the trailing cpus, ignoring them if they are all offline */
2220 if (prev_state != 'F') {
2223 kdb_printf("%d", start_cpu);
2224 if (start_cpu < i-1)
2225 kdb_printf("-%d", i-1);
2226 if (prev_state != ' ')
2227 kdb_printf("(%c)", prev_state);
2232 static int kdb_cpu(int argc, const char **argv)
2234 unsigned long cpunum;
2243 return KDB_ARGCOUNT;
2245 diag = kdbgetularg(argv[1], &cpunum);
2252 if ((cpunum >= CONFIG_NR_CPUS) || !kgdb_info[cpunum].enter_kgdb)
2253 return KDB_BADCPUNUM;
2255 dbg_switch_cpu = cpunum;
2258 * Switch to other cpu
2263 /* The user may not realize that ps/bta with no parameters does not print idle
2264 * or sleeping system daemon processes, so tell them how many were suppressed.
2266 void kdb_ps_suppressed(void)
2268 int idle = 0, daemon = 0;
2269 unsigned long mask_I = kdb_task_state_string("I"),
2270 mask_M = kdb_task_state_string("M");
2272 const struct task_struct *p, *g;
2273 for_each_online_cpu(cpu) {
2274 p = kdb_curr_task(cpu);
2275 if (kdb_task_state(p, mask_I))
2278 for_each_process_thread(g, p) {
2279 if (kdb_task_state(p, mask_M))
2282 if (idle || daemon) {
2284 kdb_printf("%d idle process%s (state I)%s\n",
2285 idle, idle == 1 ? "" : "es",
2286 daemon ? " and " : "");
2288 kdb_printf("%d sleeping system daemon (state M) "
2289 "process%s", daemon,
2290 daemon == 1 ? "" : "es");
2291 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2296 * kdb_ps - This function implements the 'ps' command which shows a
2297 * list of the active processes.
2298 * ps [DRSTCZEUIMA] All processes, optionally filtered by state
2300 void kdb_ps1(const struct task_struct *p)
2306 copy_from_kernel_nofault(&tmp, (char *)p, sizeof(unsigned long)))
2309 cpu = kdb_process_cpu(p);
2310 kdb_printf("0x%px %8d %8d %d %4d %c 0x%px %c%s\n",
2311 (void *)p, p->pid, p->parent->pid,
2312 kdb_task_has_cpu(p), kdb_process_cpu(p),
2313 kdb_task_state_char(p),
2314 (void *)(&p->thread),
2315 p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2317 if (kdb_task_has_cpu(p)) {
2318 if (!KDB_TSK(cpu)) {
2319 kdb_printf(" Error: no saved data for this cpu\n");
2321 if (KDB_TSK(cpu) != p)
2322 kdb_printf(" Error: does not match running "
2323 "process table (0x%px)\n", KDB_TSK(cpu));
2328 static int kdb_ps(int argc, const char **argv)
2330 struct task_struct *g, *p;
2331 unsigned long mask, cpu;
2334 kdb_ps_suppressed();
2335 kdb_printf("%-*s Pid Parent [*] cpu State %-*s Command\n",
2336 (int)(2*sizeof(void *))+2, "Task Addr",
2337 (int)(2*sizeof(void *))+2, "Thread");
2338 mask = kdb_task_state_string(argc ? argv[1] : NULL);
2339 /* Run the active tasks first */
2340 for_each_online_cpu(cpu) {
2341 if (KDB_FLAG(CMD_INTERRUPT))
2343 p = kdb_curr_task(cpu);
2344 if (kdb_task_state(p, mask))
2348 /* Now the real tasks */
2349 for_each_process_thread(g, p) {
2350 if (KDB_FLAG(CMD_INTERRUPT))
2352 if (kdb_task_state(p, mask))
2360 * kdb_pid - This function implements the 'pid' command which switches
2361 * the currently active process.
2364 static int kdb_pid(int argc, const char **argv)
2366 struct task_struct *p;
2371 return KDB_ARGCOUNT;
2374 if (strcmp(argv[1], "R") == 0) {
2375 p = KDB_TSK(kdb_initial_cpu);
2377 diag = kdbgetularg(argv[1], &val);
2381 p = find_task_by_pid_ns((pid_t)val, &init_pid_ns);
2383 kdb_printf("No task with pid=%d\n", (pid_t)val);
2387 kdb_set_current_task(p);
2389 kdb_printf("KDB current process is %s(pid=%d)\n",
2390 kdb_current_task->comm,
2391 kdb_current_task->pid);
2396 static int kdb_kgdb(int argc, const char **argv)
2398 return KDB_CMD_KGDB;
2402 * kdb_help - This function implements the 'help' and '?' commands.
2404 static int kdb_help(int argc, const char **argv)
2408 kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2409 kdb_printf("-----------------------------"
2410 "-----------------------------\n");
2411 list_for_each_entry(kt, &kdb_cmds_head, list_node) {
2413 if (KDB_FLAG(CMD_INTERRUPT))
2415 if (!kdb_check_flags(kt->cmd_flags, kdb_cmd_enabled, true))
2417 if (strlen(kt->cmd_usage) > 20)
2419 kdb_printf("%-15.15s %-20s%s%s\n", kt->cmd_name,
2420 kt->cmd_usage, space, kt->cmd_help);
2426 * kdb_kill - This function implements the 'kill' commands.
2428 static int kdb_kill(int argc, const char **argv)
2432 struct task_struct *p;
2435 return KDB_ARGCOUNT;
2437 sig = simple_strtol(argv[1], &endp, 0);
2440 if ((sig >= 0) || !valid_signal(-sig)) {
2441 kdb_printf("Invalid signal parameter.<-signal>\n");
2446 pid = simple_strtol(argv[2], &endp, 0);
2450 kdb_printf("Process ID must be large than 0.\n");
2454 /* Find the process. */
2455 p = find_task_by_pid_ns(pid, &init_pid_ns);
2457 kdb_printf("The specified process isn't found.\n");
2460 p = p->group_leader;
2461 kdb_send_sig(p, sig);
2466 * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2467 * I cannot call that code directly from kdb, it has an unconditional
2468 * cli()/sti() and calls routines that take locks which can stop the debugger.
2470 static void kdb_sysinfo(struct sysinfo *val)
2472 u64 uptime = ktime_get_mono_fast_ns();
2474 memset(val, 0, sizeof(*val));
2475 val->uptime = div_u64(uptime, NSEC_PER_SEC);
2476 val->loads[0] = avenrun[0];
2477 val->loads[1] = avenrun[1];
2478 val->loads[2] = avenrun[2];
2479 val->procs = nr_threads-1;
2486 * kdb_summary - This function implements the 'summary' command.
2488 static int kdb_summary(int argc, const char **argv)
2495 return KDB_ARGCOUNT;
2497 kdb_printf("sysname %s\n", init_uts_ns.name.sysname);
2498 kdb_printf("release %s\n", init_uts_ns.name.release);
2499 kdb_printf("version %s\n", init_uts_ns.name.version);
2500 kdb_printf("machine %s\n", init_uts_ns.name.machine);
2501 kdb_printf("nodename %s\n", init_uts_ns.name.nodename);
2502 kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2504 now = __ktime_get_real_seconds();
2505 time64_to_tm(now, 0, &tm);
2506 kdb_printf("date %04ld-%02d-%02d %02d:%02d:%02d "
2507 "tz_minuteswest %d\n",
2508 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2509 tm.tm_hour, tm.tm_min, tm.tm_sec,
2510 sys_tz.tz_minuteswest);
2513 kdb_printf("uptime ");
2514 if (val.uptime > (24*60*60)) {
2515 int days = val.uptime / (24*60*60);
2516 val.uptime %= (24*60*60);
2517 kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2519 kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2521 kdb_printf("load avg %ld.%02ld %ld.%02ld %ld.%02ld\n",
2522 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2523 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2524 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2526 /* Display in kilobytes */
2527 #define K(x) ((x) << (PAGE_SHIFT - 10))
2528 kdb_printf("\nMemTotal: %8lu kB\nMemFree: %8lu kB\n"
2529 "Buffers: %8lu kB\n",
2530 K(val.totalram), K(val.freeram), K(val.bufferram));
2535 * kdb_per_cpu - This function implements the 'per_cpu' command.
2537 static int kdb_per_cpu(int argc, const char **argv)
2540 int cpu, diag, nextarg = 1;
2541 unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2543 if (argc < 1 || argc > 3)
2544 return KDB_ARGCOUNT;
2546 diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2551 diag = kdbgetularg(argv[2], &bytesperword);
2556 bytesperword = KDB_WORD_SIZE;
2557 else if (bytesperword > KDB_WORD_SIZE)
2558 return KDB_BADWIDTH;
2559 sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2561 diag = kdbgetularg(argv[3], &whichcpu);
2564 if (whichcpu >= nr_cpu_ids || !cpu_online(whichcpu)) {
2565 kdb_printf("cpu %ld is not online\n", whichcpu);
2566 return KDB_BADCPUNUM;
2570 /* Most architectures use __per_cpu_offset[cpu], some use
2571 * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2573 #ifdef __per_cpu_offset
2574 #define KDB_PCU(cpu) __per_cpu_offset(cpu)
2577 #define KDB_PCU(cpu) __per_cpu_offset[cpu]
2579 #define KDB_PCU(cpu) 0
2582 for_each_online_cpu(cpu) {
2583 if (KDB_FLAG(CMD_INTERRUPT))
2586 if (whichcpu != ~0UL && whichcpu != cpu)
2588 addr = symaddr + KDB_PCU(cpu);
2589 diag = kdb_getword(&val, addr, bytesperword);
2591 kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2592 "read, diag=%d\n", cpu, addr, diag);
2595 kdb_printf("%5d ", cpu);
2596 kdb_md_line(fmtstr, addr,
2597 bytesperword == KDB_WORD_SIZE,
2598 1, bytesperword, 1, 1, 0);
2605 * display help for the use of cmd | grep pattern
2607 static int kdb_grep_help(int argc, const char **argv)
2609 kdb_printf("Usage of cmd args | grep pattern:\n");
2610 kdb_printf(" Any command's output may be filtered through an ");
2611 kdb_printf("emulated 'pipe'.\n");
2612 kdb_printf(" 'grep' is just a key word.\n");
2613 kdb_printf(" The pattern may include a very limited set of "
2614 "metacharacters:\n");
2615 kdb_printf(" pattern or ^pattern or pattern$ or ^pattern$\n");
2616 kdb_printf(" And if there are spaces in the pattern, you may "
2618 kdb_printf(" \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2619 " or \"^pat tern$\"\n");
2624 * kdb_register_flags - This function is used to register a kernel
2628 * func Function to execute the command
2629 * usage A simple usage string showing arguments
2630 * help A simple help string describing command
2631 * repeat Does the command auto repeat on enter?
2633 * zero for success, one if a duplicate command.
2635 int kdb_register_flags(char *cmd,
2640 kdb_cmdflags_t flags)
2644 list_for_each_entry(kp, &kdb_cmds_head, list_node) {
2645 if (strcmp(kp->cmd_name, cmd) == 0) {
2646 kdb_printf("Duplicate kdb command registered: "
2647 "%s, func %px help %s\n", cmd, func, help);
2652 kp = kmalloc(sizeof(*kp), GFP_KDB);
2654 kdb_printf("Could not allocate new kdb_command table\n");
2659 kp->cmd_func = func;
2660 kp->cmd_usage = usage;
2661 kp->cmd_help = help;
2662 kp->cmd_minlen = minlen;
2663 kp->cmd_flags = flags;
2664 kp->is_dynamic = true;
2666 list_add_tail(&kp->list_node, &kdb_cmds_head);
2670 EXPORT_SYMBOL_GPL(kdb_register_flags);
2673 * kdb_register_table() - This function is used to register a kdb command
2675 * @kp: pointer to kdb command table
2676 * @len: length of kdb command table
2678 void kdb_register_table(kdbtab_t *kp, size_t len)
2681 list_add_tail(&kp->list_node, &kdb_cmds_head);
2687 * kdb_register - Compatibility register function for commands that do
2688 * not need to specify a repeat state. Equivalent to
2689 * kdb_register_flags with flags set to 0.
2692 * func Function to execute the command
2693 * usage A simple usage string showing arguments
2694 * help A simple help string describing command
2696 * zero for success, one if a duplicate command.
2698 int kdb_register(char *cmd,
2704 return kdb_register_flags(cmd, func, usage, help, minlen, 0);
2706 EXPORT_SYMBOL_GPL(kdb_register);
2709 * kdb_unregister - This function is used to unregister a kernel
2710 * debugger command. It is generally called when a module which
2711 * implements kdb commands is unloaded.
2715 * zero for success, one command not registered.
2717 int kdb_unregister(char *cmd)
2724 list_for_each_entry(kp, &kdb_cmds_head, list_node) {
2725 if (strcmp(kp->cmd_name, cmd) == 0) {
2726 list_del(&kp->list_node);
2733 /* Couldn't find it. */
2736 EXPORT_SYMBOL_GPL(kdb_unregister);
2738 static kdbtab_t maintab[] = {
2741 .cmd_usage = "<vaddr>",
2742 .cmd_help = "Display Memory Contents, also mdWcN, e.g. md8c1",
2744 .cmd_flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS,
2746 { .cmd_name = "mdr",
2748 .cmd_usage = "<vaddr> <bytes>",
2749 .cmd_help = "Display Raw Memory",
2750 .cmd_flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS,
2752 { .cmd_name = "mdp",
2754 .cmd_usage = "<paddr> <bytes>",
2755 .cmd_help = "Display Physical Memory",
2756 .cmd_flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS,
2758 { .cmd_name = "mds",
2760 .cmd_usage = "<vaddr>",
2761 .cmd_help = "Display Memory Symbolically",
2762 .cmd_flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS,
2766 .cmd_usage = "<vaddr> <contents>",
2767 .cmd_help = "Modify Memory Contents",
2768 .cmd_flags = KDB_ENABLE_MEM_WRITE | KDB_REPEAT_NO_ARGS,
2772 .cmd_usage = "[<vaddr>]",
2773 .cmd_help = "Continue Execution",
2775 .cmd_flags = KDB_ENABLE_REG_WRITE |
2776 KDB_ENABLE_ALWAYS_SAFE_NO_ARGS,
2781 .cmd_help = "Display Registers",
2782 .cmd_flags = KDB_ENABLE_REG_READ,
2786 .cmd_usage = "<reg> <contents>",
2787 .cmd_help = "Modify Registers",
2788 .cmd_flags = KDB_ENABLE_REG_WRITE,
2792 .cmd_usage = "<vaddr>",
2793 .cmd_help = "Display exception frame",
2794 .cmd_flags = KDB_ENABLE_MEM_READ,
2798 .cmd_usage = "[<vaddr>]",
2799 .cmd_help = "Stack traceback",
2801 .cmd_flags = KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS,
2803 { .cmd_name = "btp",
2805 .cmd_usage = "<pid>",
2806 .cmd_help = "Display stack for process <pid>",
2807 .cmd_flags = KDB_ENABLE_INSPECT,
2809 { .cmd_name = "bta",
2811 .cmd_usage = "[D|R|S|T|C|Z|E|U|I|M|A]",
2812 .cmd_help = "Backtrace all processes matching state flag",
2813 .cmd_flags = KDB_ENABLE_INSPECT,
2815 { .cmd_name = "btc",
2818 .cmd_help = "Backtrace current process on each cpu",
2819 .cmd_flags = KDB_ENABLE_INSPECT,
2821 { .cmd_name = "btt",
2823 .cmd_usage = "<vaddr>",
2824 .cmd_help = "Backtrace process given its struct task address",
2825 .cmd_flags = KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS,
2827 { .cmd_name = "env",
2828 .cmd_func = kdb_env,
2830 .cmd_help = "Show environment variables",
2831 .cmd_flags = KDB_ENABLE_ALWAYS_SAFE,
2833 { .cmd_name = "set",
2834 .cmd_func = kdb_set,
2836 .cmd_help = "Set environment variables",
2837 .cmd_flags = KDB_ENABLE_ALWAYS_SAFE,
2839 { .cmd_name = "help",
2840 .cmd_func = kdb_help,
2842 .cmd_help = "Display Help Message",
2844 .cmd_flags = KDB_ENABLE_ALWAYS_SAFE,
2847 .cmd_func = kdb_help,
2849 .cmd_help = "Display Help Message",
2850 .cmd_flags = KDB_ENABLE_ALWAYS_SAFE,
2852 { .cmd_name = "cpu",
2853 .cmd_func = kdb_cpu,
2854 .cmd_usage = "<cpunum>",
2855 .cmd_help = "Switch to new cpu",
2856 .cmd_flags = KDB_ENABLE_ALWAYS_SAFE_NO_ARGS,
2858 { .cmd_name = "kgdb",
2859 .cmd_func = kdb_kgdb,
2861 .cmd_help = "Enter kgdb mode",
2866 .cmd_usage = "[<flags>|A]",
2867 .cmd_help = "Display active task list",
2868 .cmd_flags = KDB_ENABLE_INSPECT,
2870 { .cmd_name = "pid",
2871 .cmd_func = kdb_pid,
2872 .cmd_usage = "<pidnum>",
2873 .cmd_help = "Switch to another task",
2874 .cmd_flags = KDB_ENABLE_INSPECT,
2876 { .cmd_name = "reboot",
2877 .cmd_func = kdb_reboot,
2879 .cmd_help = "Reboot the machine immediately",
2880 .cmd_flags = KDB_ENABLE_REBOOT,
2882 #if defined(CONFIG_MODULES)
2883 { .cmd_name = "lsmod",
2884 .cmd_func = kdb_lsmod,
2886 .cmd_help = "List loaded kernel modules",
2887 .cmd_flags = KDB_ENABLE_INSPECT,
2890 #if defined(CONFIG_MAGIC_SYSRQ)
2893 .cmd_usage = "<key>",
2894 .cmd_help = "Magic SysRq key",
2895 .cmd_flags = KDB_ENABLE_ALWAYS_SAFE,
2898 #if defined(CONFIG_PRINTK)
2899 { .cmd_name = "dmesg",
2900 .cmd_func = kdb_dmesg,
2901 .cmd_usage = "[lines]",
2902 .cmd_help = "Display syslog buffer",
2903 .cmd_flags = KDB_ENABLE_ALWAYS_SAFE,
2906 { .cmd_name = "defcmd",
2907 .cmd_func = kdb_defcmd,
2908 .cmd_usage = "name \"usage\" \"help\"",
2909 .cmd_help = "Define a set of commands, down to endefcmd",
2910 .cmd_flags = KDB_ENABLE_ALWAYS_SAFE,
2912 { .cmd_name = "kill",
2913 .cmd_func = kdb_kill,
2914 .cmd_usage = "<-signal> <pid>",
2915 .cmd_help = "Send a signal to a process",
2916 .cmd_flags = KDB_ENABLE_SIGNAL,
2918 { .cmd_name = "summary",
2919 .cmd_func = kdb_summary,
2921 .cmd_help = "Summarize the system",
2923 .cmd_flags = KDB_ENABLE_ALWAYS_SAFE,
2925 { .cmd_name = "per_cpu",
2926 .cmd_func = kdb_per_cpu,
2927 .cmd_usage = "<sym> [<bytes>] [<cpu>]",
2928 .cmd_help = "Display per_cpu variables",
2930 .cmd_flags = KDB_ENABLE_MEM_READ,
2932 { .cmd_name = "grephelp",
2933 .cmd_func = kdb_grep_help,
2935 .cmd_help = "Display help on | grep",
2936 .cmd_flags = KDB_ENABLE_ALWAYS_SAFE,
2940 static kdbtab_t nmicmd = {
2941 .cmd_name = "disable_nmi",
2942 .cmd_func = kdb_disable_nmi,
2944 .cmd_help = "Disable NMI entry to KDB",
2945 .cmd_flags = KDB_ENABLE_ALWAYS_SAFE,
2948 /* Initialize the kdb command table. */
2949 static void __init kdb_inittab(void)
2951 kdb_register_table(maintab, ARRAY_SIZE(maintab));
2952 if (arch_kgdb_ops.enable_nmi)
2953 kdb_register_table(&nmicmd, 1);
2956 /* Execute any commands defined in kdb_cmds. */
2957 static void __init kdb_cmd_init(void)
2960 for (i = 0; kdb_cmds[i]; ++i) {
2961 diag = kdb_parse(kdb_cmds[i]);
2963 kdb_printf("kdb command %s failed, kdb diag %d\n",
2966 if (defcmd_in_progress) {
2967 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2968 kdb_parse("endefcmd");
2972 /* Initialize kdb_printf, breakpoint tables and kdb state */
2973 void __init kdb_init(int lvl)
2975 static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2978 if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2980 for (i = kdb_init_lvl; i < lvl; i++) {
2982 case KDB_NOT_INITIALIZED:
2983 kdb_inittab(); /* Initialize Command Table */
2984 kdb_initbptab(); /* Initialize Breakpoints */
2986 case KDB_INIT_EARLY:
2987 kdb_cmd_init(); /* Build kdb_cmds tables */