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);
54 char kdb_grep_string[GREP_LEN];
55 int kdb_grepping_flag;
56 EXPORT_SYMBOL(kdb_grepping_flag);
58 int kdb_grep_trailing;
61 * Kernel debugger state flags
67 * kdb_lock protects updates to kdb_initial_cpu. Used to
68 * single thread processors through the kernel debugger.
70 int kdb_initial_cpu = -1; /* cpu number that owns kdb */
72 int kdb_state; /* General KDB state */
74 struct task_struct *kdb_current_task;
75 EXPORT_SYMBOL(kdb_current_task);
76 struct pt_regs *kdb_current_regs;
78 const char *kdb_diemsg;
79 static int kdb_go_count;
80 #ifdef CONFIG_KDB_CONTINUE_CATASTROPHIC
81 static unsigned int kdb_continue_catastrophic =
82 CONFIG_KDB_CONTINUE_CATASTROPHIC;
84 static unsigned int kdb_continue_catastrophic;
87 /* kdb_commands describes the available commands. */
88 static kdbtab_t *kdb_commands;
89 #define KDB_BASE_CMD_MAX 50
90 static int kdb_max_commands = KDB_BASE_CMD_MAX;
91 static kdbtab_t kdb_base_commands[KDB_BASE_CMD_MAX];
92 #define for_each_kdbcmd(cmd, num) \
93 for ((cmd) = kdb_base_commands, (num) = 0; \
94 num < kdb_max_commands; \
95 num++, num == KDB_BASE_CMD_MAX ? cmd = kdb_commands : cmd++)
97 typedef struct _kdbmsg {
98 int km_diag; /* kdb diagnostic */
99 char *km_msg; /* Corresponding message text */
102 #define KDBMSG(msgnum, text) \
103 { KDB_##msgnum, text }
105 static kdbmsg_t kdbmsgs[] = {
106 KDBMSG(NOTFOUND, "Command Not Found"),
107 KDBMSG(ARGCOUNT, "Improper argument count, see usage."),
108 KDBMSG(BADWIDTH, "Illegal value for BYTESPERWORD use 1, 2, 4 or 8, "
109 "8 is only allowed on 64 bit systems"),
110 KDBMSG(BADRADIX, "Illegal value for RADIX use 8, 10 or 16"),
111 KDBMSG(NOTENV, "Cannot find environment variable"),
112 KDBMSG(NOENVVALUE, "Environment variable should have value"),
113 KDBMSG(NOTIMP, "Command not implemented"),
114 KDBMSG(ENVFULL, "Environment full"),
115 KDBMSG(ENVBUFFULL, "Environment buffer full"),
116 KDBMSG(TOOMANYBPT, "Too many breakpoints defined"),
117 #ifdef CONFIG_CPU_XSCALE
118 KDBMSG(TOOMANYDBREGS, "More breakpoints than ibcr registers defined"),
120 KDBMSG(TOOMANYDBREGS, "More breakpoints than db registers defined"),
122 KDBMSG(DUPBPT, "Duplicate breakpoint address"),
123 KDBMSG(BPTNOTFOUND, "Breakpoint not found"),
124 KDBMSG(BADMODE, "Invalid IDMODE"),
125 KDBMSG(BADINT, "Illegal numeric value"),
126 KDBMSG(INVADDRFMT, "Invalid symbolic address format"),
127 KDBMSG(BADREG, "Invalid register name"),
128 KDBMSG(BADCPUNUM, "Invalid cpu number"),
129 KDBMSG(BADLENGTH, "Invalid length field"),
130 KDBMSG(NOBP, "No Breakpoint exists"),
131 KDBMSG(BADADDR, "Invalid address"),
132 KDBMSG(NOPERM, "Permission denied"),
136 static const int __nkdb_err = ARRAY_SIZE(kdbmsgs);
140 * Initial environment. This is all kept static and local to
141 * this file. We don't want to rely on the memory allocation
142 * mechanisms in the kernel, so we use a very limited allocate-only
143 * heap for new and altered environment variables. The entire
144 * environment is limited to a fixed number of entries (add more
145 * to __env[] if required) and a fixed amount of heap (add more to
146 * KDB_ENVBUFSIZE if required).
149 static char *__env[] = {
150 #if defined(CONFIG_SMP)
157 "MDCOUNT=8", /* lines of md output */
187 static const int __nenv = ARRAY_SIZE(__env);
189 struct task_struct *kdb_curr_task(int cpu)
191 struct task_struct *p = curr_task(cpu);
193 if ((task_thread_info(p)->flags & _TIF_MCA_INIT) && KDB_TSK(cpu))
200 * Check whether the flags of the current command and the permissions
201 * of the kdb console has allow a command to be run.
203 static inline bool kdb_check_flags(kdb_cmdflags_t flags, int permissions,
206 /* permissions comes from userspace so needs massaging slightly */
207 permissions &= KDB_ENABLE_MASK;
208 permissions |= KDB_ENABLE_ALWAYS_SAFE;
210 /* some commands change group when launched with no arguments */
212 permissions |= permissions << KDB_ENABLE_NO_ARGS_SHIFT;
214 flags |= KDB_ENABLE_ALL;
216 return permissions & flags;
220 * kdbgetenv - This function will return the character string value of
221 * an environment variable.
223 * match A character string representing an environment variable.
225 * NULL No environment variable matches 'match'
226 * char* Pointer to string value of environment variable.
228 char *kdbgetenv(const char *match)
231 int matchlen = strlen(match);
234 for (i = 0; i < __nenv; i++) {
240 if ((strncmp(match, e, matchlen) == 0)
241 && ((e[matchlen] == '\0')
242 || (e[matchlen] == '='))) {
243 char *cp = strchr(e, '=');
244 return cp ? ++cp : "";
251 * kdballocenv - This function is used to allocate bytes for
252 * environment entries.
254 * match A character string representing a numeric value
256 * *value the unsigned long representation of the env variable 'match'
258 * Zero on success, a kdb diagnostic on failure.
260 * We use a static environment buffer (envbuffer) to hold the values
261 * of dynamically generated environment variables (see kdb_set). Buffer
262 * space once allocated is never free'd, so over time, the amount of space
263 * (currently 512 bytes) will be exhausted if env variables are changed
266 static char *kdballocenv(size_t bytes)
268 #define KDB_ENVBUFSIZE 512
269 static char envbuffer[KDB_ENVBUFSIZE];
270 static int envbufsize;
273 if ((KDB_ENVBUFSIZE - envbufsize) >= bytes) {
274 ep = &envbuffer[envbufsize];
281 * kdbgetulenv - This function will return the value of an unsigned
282 * long-valued environment variable.
284 * match A character string representing a numeric value
286 * *value the unsigned long represntation of the env variable 'match'
288 * Zero on success, a kdb diagnostic on failure.
290 static int kdbgetulenv(const char *match, unsigned long *value)
294 ep = kdbgetenv(match);
298 return KDB_NOENVVALUE;
300 *value = simple_strtoul(ep, NULL, 0);
306 * kdbgetintenv - This function will return the value of an
307 * integer-valued environment variable.
309 * match A character string representing an integer-valued env variable
311 * *value the integer representation of the environment variable 'match'
313 * Zero on success, a kdb diagnostic on failure.
315 int kdbgetintenv(const char *match, int *value)
320 diag = kdbgetulenv(match, &val);
327 * kdbgetularg - This function will convert a numeric string into an
328 * unsigned long value.
330 * arg A character string representing a numeric value
332 * *value the unsigned long represntation of arg.
334 * Zero on success, a kdb diagnostic on failure.
336 int kdbgetularg(const char *arg, unsigned long *value)
341 val = simple_strtoul(arg, &endp, 0);
345 * Also try base 16, for us folks too lazy to type the
348 val = simple_strtoul(arg, &endp, 16);
358 int kdbgetu64arg(const char *arg, u64 *value)
363 val = simple_strtoull(arg, &endp, 0);
367 val = simple_strtoull(arg, &endp, 16);
378 * kdb_set - This function implements the 'set' command. Alter an
379 * existing environment variable or create a new one.
381 int kdb_set(int argc, const char **argv)
385 size_t varlen, vallen;
388 * we can be invoked two ways:
389 * set var=value argv[1]="var", argv[2]="value"
390 * set var = value argv[1]="var", argv[2]="=", argv[3]="value"
391 * - if the latter, shift 'em down.
402 * Check for internal variables
404 if (strcmp(argv[1], "KDBDEBUG") == 0) {
405 unsigned int debugflags;
408 debugflags = simple_strtoul(argv[2], &cp, 0);
409 if (cp == argv[2] || debugflags & ~KDB_DEBUG_FLAG_MASK) {
410 kdb_printf("kdb: illegal debug flags '%s'\n",
414 kdb_flags = (kdb_flags &
415 ~(KDB_DEBUG_FLAG_MASK << KDB_DEBUG_FLAG_SHIFT))
416 | (debugflags << KDB_DEBUG_FLAG_SHIFT);
422 * Tokenizer squashed the '=' sign. argv[1] is variable
423 * name, argv[2] = value.
425 varlen = strlen(argv[1]);
426 vallen = strlen(argv[2]);
427 ep = kdballocenv(varlen + vallen + 2);
429 return KDB_ENVBUFFULL;
431 sprintf(ep, "%s=%s", argv[1], argv[2]);
433 ep[varlen+vallen+1] = '\0';
435 for (i = 0; i < __nenv; i++) {
437 && ((strncmp(__env[i], argv[1], varlen) == 0)
438 && ((__env[i][varlen] == '\0')
439 || (__env[i][varlen] == '=')))) {
446 * Wasn't existing variable. Fit into slot.
448 for (i = 0; i < __nenv-1; i++) {
449 if (__env[i] == (char *)0) {
458 static int kdb_check_regs(void)
460 if (!kdb_current_regs) {
461 kdb_printf("No current kdb registers."
462 " You may need to select another task\n");
469 * kdbgetaddrarg - This function is responsible for parsing an
470 * address-expression and returning the value of the expression,
471 * symbol name, and offset to the caller.
473 * The argument may consist of a numeric value (decimal or
474 * hexidecimal), a symbol name, a register name (preceded by the
475 * percent sign), an environment variable with a numeric value
476 * (preceded by a dollar sign) or a simple arithmetic expression
477 * consisting of a symbol name, +/-, and a numeric constant value
480 * argc - count of arguments in argv
481 * argv - argument vector
482 * *nextarg - index to next unparsed argument in argv[]
483 * regs - Register state at time of KDB entry
485 * *value - receives the value of the address-expression
486 * *offset - receives the offset specified, if any
487 * *name - receives the symbol name, if any
488 * *nextarg - index to next unparsed argument in argv[]
490 * zero is returned on success, a kdb diagnostic code is
493 int kdbgetaddrarg(int argc, const char **argv, int *nextarg,
494 unsigned long *value, long *offset,
498 unsigned long off = 0;
508 * If the enable flags prohibit both arbitrary memory access
509 * and flow control then there are no reasonable grounds to
510 * provide symbol lookup.
512 if (!kdb_check_flags(KDB_ENABLE_MEM_READ | KDB_ENABLE_FLOW_CTRL,
513 kdb_cmd_enabled, false))
517 * Process arguments which follow the following syntax:
519 * symbol | numeric-address [+/- numeric-offset]
521 * $environment-variable
527 symname = (char *)argv[*nextarg];
530 * If there is no whitespace between the symbol
531 * or address and the '+' or '-' symbols, we
532 * remember the character and replace it with a
533 * null so the symbol/value can be properly parsed
535 cp = strpbrk(symname, "+-");
541 if (symname[0] == '$') {
542 diag = kdbgetulenv(&symname[1], &addr);
545 } else if (symname[0] == '%') {
546 diag = kdb_check_regs();
549 /* Implement register values with % at a later time as it is
554 found = kdbgetsymval(symname, &symtab);
556 addr = symtab.sym_start;
558 diag = kdbgetularg(argv[*nextarg], &addr);
565 found = kdbnearsym(addr, &symtab);
573 if (offset && name && *name)
574 *offset = addr - symtab.sym_start;
576 if ((*nextarg > argc)
581 * check for +/- and offset
584 if (symbol == '\0') {
585 if ((argv[*nextarg][0] != '+')
586 && (argv[*nextarg][0] != '-')) {
588 * Not our argument. Return.
592 positive = (argv[*nextarg][0] == '+');
596 positive = (symbol == '+');
599 * Now there must be an offset!
601 if ((*nextarg > argc)
602 && (symbol == '\0')) {
603 return KDB_INVADDRFMT;
607 cp = (char *)argv[*nextarg];
611 diag = kdbgetularg(cp, &off);
627 static void kdb_cmderror(int diag)
632 kdb_printf("no error detected (diagnostic is %d)\n", diag);
636 for (i = 0; i < __nkdb_err; i++) {
637 if (kdbmsgs[i].km_diag == diag) {
638 kdb_printf("diag: %d: %s\n", diag, kdbmsgs[i].km_msg);
643 kdb_printf("Unknown diag %d\n", -diag);
647 * kdb_defcmd, kdb_defcmd2 - This function implements the 'defcmd'
648 * command which defines one command as a set of other commands,
649 * terminated by endefcmd. kdb_defcmd processes the initial
650 * 'defcmd' command, kdb_defcmd2 is invoked from kdb_parse for
651 * the following commands until 'endefcmd'.
653 * argc argument count
654 * argv argument vector
656 * zero for success, a kdb diagnostic if error
666 static struct defcmd_set *defcmd_set;
667 static int defcmd_set_count;
668 static int defcmd_in_progress;
670 /* Forward references */
671 static int kdb_exec_defcmd(int argc, const char **argv);
673 static int kdb_defcmd2(const char *cmdstr, const char *argv0)
675 struct defcmd_set *s = defcmd_set + defcmd_set_count - 1;
676 char **save_command = s->command;
677 if (strcmp(argv0, "endefcmd") == 0) {
678 defcmd_in_progress = 0;
682 /* macros are always safe because when executed each
683 * internal command re-enters kdb_parse() and is
684 * safety checked individually.
686 kdb_register_flags(s->name, kdb_exec_defcmd, s->usage,
688 KDB_ENABLE_ALWAYS_SAFE);
693 s->command = kzalloc((s->count + 1) * sizeof(*(s->command)), GFP_KDB);
695 kdb_printf("Could not allocate new kdb_defcmd table for %s\n",
700 memcpy(s->command, save_command, s->count * sizeof(*(s->command)));
701 s->command[s->count++] = kdb_strdup(cmdstr, GFP_KDB);
706 static int kdb_defcmd(int argc, const char **argv)
708 struct defcmd_set *save_defcmd_set = defcmd_set, *s;
709 if (defcmd_in_progress) {
710 kdb_printf("kdb: nested defcmd detected, assuming missing "
712 kdb_defcmd2("endefcmd", "endefcmd");
716 for (s = defcmd_set; s < defcmd_set + defcmd_set_count; ++s) {
717 kdb_printf("defcmd %s \"%s\" \"%s\"\n", s->name,
719 for (i = 0; i < s->count; ++i)
720 kdb_printf("%s", s->command[i]);
721 kdb_printf("endefcmd\n");
727 if (in_dbg_master()) {
728 kdb_printf("Command only available during kdb_init()\n");
731 defcmd_set = kmalloc((defcmd_set_count + 1) * sizeof(*defcmd_set),
735 memcpy(defcmd_set, save_defcmd_set,
736 defcmd_set_count * sizeof(*defcmd_set));
737 s = defcmd_set + defcmd_set_count;
738 memset(s, 0, sizeof(*s));
740 s->name = kdb_strdup(argv[1], GFP_KDB);
743 s->usage = kdb_strdup(argv[2], GFP_KDB);
746 s->help = kdb_strdup(argv[3], GFP_KDB);
749 if (s->usage[0] == '"') {
750 strcpy(s->usage, argv[2]+1);
751 s->usage[strlen(s->usage)-1] = '\0';
753 if (s->help[0] == '"') {
754 strcpy(s->help, argv[3]+1);
755 s->help[strlen(s->help)-1] = '\0';
758 defcmd_in_progress = 1;
759 kfree(save_defcmd_set);
768 kdb_printf("Could not allocate new defcmd_set entry for %s\n", argv[1]);
769 defcmd_set = save_defcmd_set;
774 * kdb_exec_defcmd - Execute the set of commands associated with this
777 * argc argument count
778 * argv argument vector
780 * zero for success, a kdb diagnostic if error
782 static int kdb_exec_defcmd(int argc, const char **argv)
785 struct defcmd_set *s;
788 for (s = defcmd_set, i = 0; i < defcmd_set_count; ++i, ++s) {
789 if (strcmp(s->name, argv[0]) == 0)
792 if (i == defcmd_set_count) {
793 kdb_printf("kdb_exec_defcmd: could not find commands for %s\n",
797 for (i = 0; i < s->count; ++i) {
798 /* Recursive use of kdb_parse, do not use argv after
801 kdb_printf("[%s]kdb> %s\n", s->name, s->command[i]);
802 ret = kdb_parse(s->command[i]);
809 /* Command history */
810 #define KDB_CMD_HISTORY_COUNT 32
811 #define CMD_BUFLEN 200 /* kdb_printf: max printline
813 static unsigned int cmd_head, cmd_tail;
814 static unsigned int cmdptr;
815 static char cmd_hist[KDB_CMD_HISTORY_COUNT][CMD_BUFLEN];
816 static char cmd_cur[CMD_BUFLEN];
819 * The "str" argument may point to something like | grep xyz
821 static void parse_grep(const char *str)
824 char *cp = (char *)str, *cp2;
826 /* sanity check: we should have been called with the \ first */
832 if (strncmp(cp, "grep ", 5)) {
833 kdb_printf("invalid 'pipe', see grephelp\n");
839 cp2 = strchr(cp, '\n');
841 *cp2 = '\0'; /* remove the trailing newline */
844 kdb_printf("invalid 'pipe', see grephelp\n");
847 /* now cp points to a nonzero length search string */
849 /* allow it be "x y z" by removing the "'s - there must
852 cp2 = strchr(cp, '"');
854 kdb_printf("invalid quoted string, see grephelp\n");
857 *cp2 = '\0'; /* end the string where the 2nd " was */
859 kdb_grep_leading = 0;
861 kdb_grep_leading = 1;
865 kdb_grep_trailing = 0;
866 if (*(cp+len-1) == '$') {
867 kdb_grep_trailing = 1;
873 if (len >= GREP_LEN) {
874 kdb_printf("search string too long\n");
877 strcpy(kdb_grep_string, cp);
883 * kdb_parse - Parse the command line, search the command table for a
884 * matching command and invoke the command function. This
885 * function may be called recursively, if it is, the second call
886 * will overwrite argv and cbuf. It is the caller's
887 * responsibility to save their argv if they recursively call
890 * cmdstr The input command line to be parsed.
891 * regs The registers at the time kdb was entered.
893 * Zero for success, a kdb diagnostic if failure.
895 * Limited to 20 tokens.
897 * Real rudimentary tokenization. Basically only whitespace
898 * is considered a token delimeter (but special consideration
899 * is taken of the '=' sign as used by the 'set' command).
901 * The algorithm used to tokenize the input string relies on
902 * there being at least one whitespace (or otherwise useless)
903 * character between tokens as the character immediately following
904 * the token is altered in-place to a null-byte to terminate the
910 int kdb_parse(const char *cmdstr)
912 static char *argv[MAXARGC];
914 static char cbuf[CMD_BUFLEN+2];
918 int i, escaped, ignore_errors = 0, check_grep;
921 * First tokenize the command string.
924 kdb_grepping_flag = check_grep = 0;
926 if (KDB_FLAG(CMD_INTERRUPT)) {
927 /* Previous command was interrupted, newline must not
928 * repeat the command */
929 KDB_FLAG_CLEAR(CMD_INTERRUPT);
930 KDB_STATE_SET(PAGER);
931 argc = 0; /* no repeat */
934 if (*cp != '\n' && *cp != '\0') {
938 /* skip whitespace */
941 if ((*cp == '\0') || (*cp == '\n') ||
942 (*cp == '#' && !defcmd_in_progress))
944 /* special case: check for | grep pattern */
949 if (cpp >= cbuf + CMD_BUFLEN) {
950 kdb_printf("kdb_parse: command buffer "
951 "overflow, command ignored\n%s\n",
955 if (argc >= MAXARGC - 1) {
956 kdb_printf("kdb_parse: too many arguments, "
957 "command ignored\n%s\n", cmdstr);
963 /* Copy to next unquoted and unescaped
964 * whitespace or '=' */
965 while (*cp && *cp != '\n' &&
966 (escaped || quoted || !isspace(*cp))) {
967 if (cpp >= cbuf + CMD_BUFLEN)
981 else if (*cp == '\'' || *cp == '"')
984 if (*cpp == '=' && !quoted)
988 *cpp++ = '\0'; /* Squash a ws or '=' character */
995 if (defcmd_in_progress) {
996 int result = kdb_defcmd2(cmdstr, argv[0]);
997 if (!defcmd_in_progress) {
998 argc = 0; /* avoid repeat on endefcmd */
1003 if (argv[0][0] == '-' && argv[0][1] &&
1004 (argv[0][1] < '0' || argv[0][1] > '9')) {
1009 for_each_kdbcmd(tp, i) {
1012 * If this command is allowed to be abbreviated,
1013 * check to see if this is it.
1017 && (strlen(argv[0]) <= tp->cmd_minlen)) {
1018 if (strncmp(argv[0],
1020 tp->cmd_minlen) == 0) {
1025 if (strcmp(argv[0], tp->cmd_name) == 0)
1031 * If we don't find a command by this name, see if the first
1032 * few characters of this match any of the known commands.
1033 * e.g., md1c20 should match md.
1035 if (i == kdb_max_commands) {
1036 for_each_kdbcmd(tp, i) {
1038 if (strncmp(argv[0],
1040 strlen(tp->cmd_name)) == 0) {
1047 if (i < kdb_max_commands) {
1050 if (!kdb_check_flags(tp->cmd_flags, kdb_cmd_enabled, argc <= 1))
1054 result = (*tp->cmd_func)(argc-1, (const char **)argv);
1055 if (result && ignore_errors && result > KDB_CMD_GO)
1057 KDB_STATE_CLEAR(CMD);
1059 if (tp->cmd_flags & KDB_REPEAT_WITH_ARGS)
1062 argc = tp->cmd_flags & KDB_REPEAT_NO_ARGS ? 1 : 0;
1064 *(argv[argc]) = '\0';
1069 * If the input with which we were presented does not
1070 * map to an existing command, attempt to parse it as an
1071 * address argument and display the result. Useful for
1072 * obtaining the address of a variable, or the nearest symbol
1073 * to an address contained in a register.
1076 unsigned long value;
1081 if (kdbgetaddrarg(0, (const char **)argv, &nextarg,
1082 &value, &offset, &name)) {
1083 return KDB_NOTFOUND;
1086 kdb_printf("%s = ", argv[0]);
1087 kdb_symbol_print(value, NULL, KDB_SP_DEFAULT);
1094 static int handle_ctrl_cmd(char *cmd)
1099 /* initial situation */
1100 if (cmd_head == cmd_tail)
1104 if (cmdptr != cmd_tail)
1105 cmdptr = (cmdptr-1) % KDB_CMD_HISTORY_COUNT;
1106 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1109 if (cmdptr != cmd_head)
1110 cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT;
1111 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1118 * kdb_reboot - This function implements the 'reboot' command. Reboot
1119 * the system immediately, or loop for ever on failure.
1121 static int kdb_reboot(int argc, const char **argv)
1123 emergency_restart();
1124 kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
1131 static void kdb_dumpregs(struct pt_regs *regs)
1133 int old_lvl = console_loglevel;
1134 console_loglevel = CONSOLE_LOGLEVEL_MOTORMOUTH;
1139 console_loglevel = old_lvl;
1142 void kdb_set_current_task(struct task_struct *p)
1144 kdb_current_task = p;
1146 if (kdb_task_has_cpu(p)) {
1147 kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p));
1150 kdb_current_regs = NULL;
1154 * kdb_local - The main code for kdb. This routine is invoked on a
1155 * specific processor, it is not global. The main kdb() routine
1156 * ensures that only one processor at a time is in this routine.
1157 * This code is called with the real reason code on the first
1158 * entry to a kdb session, thereafter it is called with reason
1159 * SWITCH, even if the user goes back to the original cpu.
1161 * reason The reason KDB was invoked
1162 * error The hardware-defined error code
1163 * regs The exception frame at time of fault/breakpoint.
1164 * db_result Result code from the break or debug point.
1166 * 0 KDB was invoked for an event which it wasn't responsible
1167 * 1 KDB handled the event for which it was invoked.
1168 * KDB_CMD_GO User typed 'go'.
1169 * KDB_CMD_CPU User switched to another cpu.
1170 * KDB_CMD_SS Single step.
1172 static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs,
1173 kdb_dbtrap_t db_result)
1177 struct task_struct *kdb_current =
1178 kdb_curr_task(raw_smp_processor_id());
1180 KDB_DEBUG_STATE("kdb_local 1", reason);
1182 if (reason == KDB_REASON_DEBUG) {
1183 /* special case below */
1185 kdb_printf("\nEntering kdb (current=0x%p, pid %d) ",
1186 kdb_current, kdb_current ? kdb_current->pid : 0);
1187 #if defined(CONFIG_SMP)
1188 kdb_printf("on processor %d ", raw_smp_processor_id());
1193 case KDB_REASON_DEBUG:
1196 * If re-entering kdb after a single step
1197 * command, don't print the message.
1199 switch (db_result) {
1201 kdb_printf("\nEntering kdb (0x%p, pid %d) ",
1202 kdb_current, kdb_current->pid);
1203 #if defined(CONFIG_SMP)
1204 kdb_printf("on processor %d ", raw_smp_processor_id());
1206 kdb_printf("due to Debug @ " kdb_machreg_fmt "\n",
1207 instruction_pointer(regs));
1212 KDB_DEBUG_STATE("kdb_local 4", reason);
1213 return 1; /* kdba_db_trap did the work */
1215 kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
1222 case KDB_REASON_ENTER:
1223 if (KDB_STATE(KEYBOARD))
1224 kdb_printf("due to Keyboard Entry\n");
1226 kdb_printf("due to KDB_ENTER()\n");
1228 case KDB_REASON_KEYBOARD:
1229 KDB_STATE_SET(KEYBOARD);
1230 kdb_printf("due to Keyboard Entry\n");
1232 case KDB_REASON_ENTER_SLAVE:
1233 /* drop through, slaves only get released via cpu switch */
1234 case KDB_REASON_SWITCH:
1235 kdb_printf("due to cpu switch\n");
1237 case KDB_REASON_OOPS:
1238 kdb_printf("Oops: %s\n", kdb_diemsg);
1239 kdb_printf("due to oops @ " kdb_machreg_fmt "\n",
1240 instruction_pointer(regs));
1243 case KDB_REASON_SYSTEM_NMI:
1244 kdb_printf("due to System NonMaskable Interrupt\n");
1246 case KDB_REASON_NMI:
1247 kdb_printf("due to NonMaskable Interrupt @ "
1248 kdb_machreg_fmt "\n",
1249 instruction_pointer(regs));
1252 case KDB_REASON_SSTEP:
1253 case KDB_REASON_BREAK:
1254 kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
1255 reason == KDB_REASON_BREAK ?
1256 "Breakpoint" : "SS trap", instruction_pointer(regs));
1258 * Determine if this breakpoint is one that we
1259 * are interested in.
1261 if (db_result != KDB_DB_BPT) {
1262 kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1264 KDB_DEBUG_STATE("kdb_local 6", reason);
1265 return 0; /* Not for us, dismiss it */
1268 case KDB_REASON_RECURSE:
1269 kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
1270 instruction_pointer(regs));
1273 kdb_printf("kdb: unexpected reason code: %d\n", reason);
1274 KDB_DEBUG_STATE("kdb_local 8", reason);
1275 return 0; /* Not for us, dismiss it */
1280 * Initialize pager context.
1283 KDB_STATE_CLEAR(SUPPRESS);
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];
1568 kdbgetintenv("MDCOUNT", &mdcount);
1569 kdbgetintenv("RADIX", &radix);
1570 kdbgetintenv("BYTESPERWORD", &bytesperword);
1572 /* Assume 'md <addr>' and start with environment values */
1573 repeat = mdcount * 16 / bytesperword;
1575 if (strcmp(argv[0], "mdr") == 0) {
1577 return KDB_ARGCOUNT;
1579 } else if (isdigit(argv[0][2])) {
1580 bytesperword = (int)(argv[0][2] - '0');
1581 if (bytesperword == 0) {
1582 bytesperword = last_bytesperword;
1583 if (bytesperword == 0)
1586 last_bytesperword = bytesperword;
1587 repeat = mdcount * 16 / bytesperword;
1590 else if (argv[0][3] == 'c' && argv[0][4]) {
1592 repeat = simple_strtoul(argv[0] + 4, &p, 10);
1593 mdcount = ((repeat * bytesperword) + 15) / 16;
1596 last_repeat = repeat;
1597 } else if (strcmp(argv[0], "md") == 0)
1599 else if (strcmp(argv[0], "mds") == 0)
1601 else if (strcmp(argv[0], "mdp") == 0) {
1605 return KDB_NOTFOUND;
1609 return KDB_ARGCOUNT;
1612 bytesperword = last_bytesperword;
1613 repeat = last_repeat;
1614 mdcount = ((repeat * bytesperword) + 15) / 16;
1619 int diag, nextarg = 1;
1620 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1624 if (argc > nextarg+2)
1625 return KDB_ARGCOUNT;
1627 if (argc >= nextarg) {
1628 diag = kdbgetularg(argv[nextarg], &val);
1630 mdcount = (int) val;
1631 repeat = mdcount * 16 / bytesperword;
1634 if (argc >= nextarg+1) {
1635 diag = kdbgetularg(argv[nextarg+1], &val);
1641 if (strcmp(argv[0], "mdr") == 0)
1642 return kdb_mdr(addr, mdcount);
1655 return KDB_BADRADIX;
1660 if (bytesperword > KDB_WORD_SIZE)
1661 return KDB_BADWIDTH;
1663 switch (bytesperword) {
1665 sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1668 sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1671 sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1674 sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1677 return KDB_BADWIDTH;
1680 last_repeat = repeat;
1681 last_bytesperword = bytesperword;
1683 if (strcmp(argv[0], "mds") == 0) {
1685 /* Do not save these changes as last_*, they are temporary mds
1688 bytesperword = KDB_WORD_SIZE;
1690 kdbgetintenv("NOSECT", &nosect);
1693 /* Round address down modulo BYTESPERWORD */
1695 addr &= ~(bytesperword-1);
1697 while (repeat > 0) {
1699 int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1701 if (KDB_FLAG(CMD_INTERRUPT))
1703 for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1705 if (kdb_getphysword(&word, a, bytesperword)
1708 } else if (kdb_getword(&word, a, bytesperword) || word)
1711 n = min(num, repeat);
1712 kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1714 addr += bytesperword * n;
1716 z = (z + num - 1) / num;
1718 int s = num * (z-2);
1719 kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1720 " zero suppressed\n",
1721 addr, addr + bytesperword * s - 1);
1722 addr += bytesperword * s;
1732 * kdb_mm - This function implements the 'mm' command.
1733 * mm address-expression new-value
1735 * mm works on machine words, mmW works on bytes.
1737 static int kdb_mm(int argc, const char **argv)
1742 unsigned long contents;
1746 if (argv[0][2] && !isdigit(argv[0][2]))
1747 return KDB_NOTFOUND;
1750 return KDB_ARGCOUNT;
1753 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1758 return KDB_ARGCOUNT;
1759 diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1763 if (nextarg != argc + 1)
1764 return KDB_ARGCOUNT;
1766 width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1767 diag = kdb_putword(addr, contents, width);
1771 kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1777 * kdb_go - This function implements the 'go' command.
1778 * go [address-expression]
1780 static int kdb_go(int argc, const char **argv)
1787 if (raw_smp_processor_id() != kdb_initial_cpu) {
1788 kdb_printf("go must execute on the entry cpu, "
1789 "please use \"cpu %d\" and then execute go\n",
1791 return KDB_BADCPUNUM;
1795 diag = kdbgetaddrarg(argc, argv, &nextarg,
1796 &addr, &offset, NULL);
1800 return KDB_ARGCOUNT;
1804 if (KDB_FLAG(CATASTROPHIC)) {
1805 kdb_printf("Catastrophic error detected\n");
1806 kdb_printf("kdb_continue_catastrophic=%d, ",
1807 kdb_continue_catastrophic);
1808 if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1809 kdb_printf("type go a second time if you really want "
1813 if (kdb_continue_catastrophic == 2) {
1814 kdb_printf("forcing reboot\n");
1815 kdb_reboot(0, NULL);
1817 kdb_printf("attempting to continue\n");
1823 * kdb_rd - This function implements the 'rd' command.
1825 static int kdb_rd(int argc, const char **argv)
1827 int len = kdb_check_regs();
1828 #if DBG_MAX_REG_NUM > 0
1840 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1841 rsize = dbg_reg_def[i].size * 2;
1844 if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
1849 len += kdb_printf(" ");
1850 switch(dbg_reg_def[i].size * 8) {
1852 rname = dbg_get_reg(i, ®8, kdb_current_regs);
1855 len += kdb_printf("%s: %02x", rname, reg8);
1858 rname = dbg_get_reg(i, ®16, kdb_current_regs);
1861 len += kdb_printf("%s: %04x", rname, reg16);
1864 rname = dbg_get_reg(i, ®32, kdb_current_regs);
1867 len += kdb_printf("%s: %08x", rname, reg32);
1870 rname = dbg_get_reg(i, ®64, kdb_current_regs);
1873 len += kdb_printf("%s: %016llx", rname, reg64);
1876 len += kdb_printf("%s: ??", dbg_reg_def[i].name);
1884 kdb_dumpregs(kdb_current_regs);
1890 * kdb_rm - This function implements the 'rm' (register modify) command.
1891 * rm register-name new-contents
1893 * Allows register modification with the same restrictions as gdb
1895 static int kdb_rm(int argc, const char **argv)
1897 #if DBG_MAX_REG_NUM > 0
1907 return KDB_ARGCOUNT;
1909 * Allow presence or absence of leading '%' symbol.
1915 diag = kdbgetu64arg(argv[2], ®64);
1919 diag = kdb_check_regs();
1924 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1925 if (strcmp(rname, dbg_reg_def[i].name) == 0) {
1931 switch(dbg_reg_def[i].size * 8) {
1934 dbg_set_reg(i, ®8, kdb_current_regs);
1938 dbg_set_reg(i, ®16, kdb_current_regs);
1942 dbg_set_reg(i, ®32, kdb_current_regs);
1945 dbg_set_reg(i, ®64, kdb_current_regs);
1951 kdb_printf("ERROR: Register set currently not implemented\n");
1956 #if defined(CONFIG_MAGIC_SYSRQ)
1958 * kdb_sr - This function implements the 'sr' (SYSRQ key) command
1959 * which interfaces to the soi-disant MAGIC SYSRQ functionality.
1960 * sr <magic-sysrq-code>
1962 static int kdb_sr(int argc, const char **argv)
1965 !kdb_check_flags(KDB_ENABLE_ALL, kdb_cmd_enabled, false);
1968 return KDB_ARGCOUNT;
1971 __handle_sysrq(*argv[1], check_mask);
1976 #endif /* CONFIG_MAGIC_SYSRQ */
1979 * kdb_ef - This function implements the 'regs' (display exception
1980 * frame) command. This command takes an address and expects to
1981 * find an exception frame at that address, formats and prints
1983 * regs address-expression
1987 static int kdb_ef(int argc, const char **argv)
1995 return KDB_ARGCOUNT;
1998 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
2001 show_regs((struct pt_regs *)addr);
2005 #if defined(CONFIG_MODULES)
2007 * kdb_lsmod - This function implements the 'lsmod' command. Lists
2008 * currently loaded kernel modules.
2009 * Mostly taken from userland lsmod.
2011 static int kdb_lsmod(int argc, const char **argv)
2016 return KDB_ARGCOUNT;
2018 kdb_printf("Module Size modstruct Used by\n");
2019 list_for_each_entry(mod, kdb_modules, list) {
2020 if (mod->state == MODULE_STATE_UNFORMED)
2023 kdb_printf("%-20s%8u 0x%p ", mod->name,
2024 mod->core_size, (void *)mod);
2025 #ifdef CONFIG_MODULE_UNLOAD
2026 kdb_printf("%4d ", module_refcount(mod));
2028 if (mod->state == MODULE_STATE_GOING)
2029 kdb_printf(" (Unloading)");
2030 else if (mod->state == MODULE_STATE_COMING)
2031 kdb_printf(" (Loading)");
2033 kdb_printf(" (Live)");
2034 kdb_printf(" 0x%p", mod->module_core);
2036 #ifdef CONFIG_MODULE_UNLOAD
2038 struct module_use *use;
2040 list_for_each_entry(use, &mod->source_list,
2042 kdb_printf("%s ", use->target->name);
2051 #endif /* CONFIG_MODULES */
2054 * kdb_env - This function implements the 'env' command. Display the
2055 * current environment variables.
2058 static int kdb_env(int argc, const char **argv)
2062 for (i = 0; i < __nenv; i++) {
2064 kdb_printf("%s\n", __env[i]);
2067 if (KDB_DEBUG(MASK))
2068 kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
2073 #ifdef CONFIG_PRINTK
2075 * kdb_dmesg - This function implements the 'dmesg' command to display
2076 * the contents of the syslog buffer.
2077 * dmesg [lines] [adjust]
2079 static int kdb_dmesg(int argc, const char **argv)
2087 struct kmsg_dumper dumper = { .active = 1 };
2092 return KDB_ARGCOUNT;
2095 lines = simple_strtol(argv[1], &cp, 0);
2099 adjust = simple_strtoul(argv[2], &cp, 0);
2100 if (*cp || adjust < 0)
2105 /* disable LOGGING if set */
2106 diag = kdbgetintenv("LOGGING", &logging);
2107 if (!diag && logging) {
2108 const char *setargs[] = { "set", "LOGGING", "0" };
2109 kdb_set(2, setargs);
2112 kmsg_dump_rewind_nolock(&dumper);
2113 while (kmsg_dump_get_line_nolock(&dumper, 1, NULL, 0, NULL))
2118 kdb_printf("buffer only contains %d lines, nothing "
2120 else if (adjust - lines >= n)
2121 kdb_printf("buffer only contains %d lines, last %d "
2122 "lines printed\n", n, n - adjust);
2125 } else if (lines > 0) {
2126 skip = n - lines - adjust;
2129 kdb_printf("buffer only contains %d lines, "
2130 "nothing printed\n", n);
2132 } else if (skip < 0) {
2135 kdb_printf("buffer only contains %d lines, first "
2136 "%d lines printed\n", n, lines);
2142 if (skip >= n || skip < 0)
2145 kmsg_dump_rewind_nolock(&dumper);
2146 while (kmsg_dump_get_line_nolock(&dumper, 1, buf, sizeof(buf), &len)) {
2153 if (KDB_FLAG(CMD_INTERRUPT))
2156 kdb_printf("%.*s\n", (int)len - 1, buf);
2161 #endif /* CONFIG_PRINTK */
2163 /* Make sure we balance enable/disable calls, must disable first. */
2164 static atomic_t kdb_nmi_disabled;
2166 static int kdb_disable_nmi(int argc, const char *argv[])
2168 if (atomic_read(&kdb_nmi_disabled))
2170 atomic_set(&kdb_nmi_disabled, 1);
2171 arch_kgdb_ops.enable_nmi(0);
2175 static int kdb_param_enable_nmi(const char *val, const struct kernel_param *kp)
2177 if (!atomic_add_unless(&kdb_nmi_disabled, -1, 0))
2179 arch_kgdb_ops.enable_nmi(1);
2183 static const struct kernel_param_ops kdb_param_ops_enable_nmi = {
2184 .set = kdb_param_enable_nmi,
2186 module_param_cb(enable_nmi, &kdb_param_ops_enable_nmi, NULL, 0600);
2189 * kdb_cpu - This function implements the 'cpu' command.
2192 * KDB_CMD_CPU for success, a kdb diagnostic if error
2194 static void kdb_cpu_status(void)
2196 int i, start_cpu, first_print = 1;
2197 char state, prev_state = '?';
2199 kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2200 kdb_printf("Available cpus: ");
2201 for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2202 if (!cpu_online(i)) {
2203 state = 'F'; /* cpu is offline */
2204 } else if (!kgdb_info[i].enter_kgdb) {
2205 state = 'D'; /* cpu is online but unresponsive */
2207 state = ' '; /* cpu is responding to kdb */
2208 if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2209 state = 'I'; /* idle task */
2211 if (state != prev_state) {
2212 if (prev_state != '?') {
2216 kdb_printf("%d", start_cpu);
2217 if (start_cpu < i-1)
2218 kdb_printf("-%d", i-1);
2219 if (prev_state != ' ')
2220 kdb_printf("(%c)", prev_state);
2226 /* print the trailing cpus, ignoring them if they are all offline */
2227 if (prev_state != 'F') {
2230 kdb_printf("%d", start_cpu);
2231 if (start_cpu < i-1)
2232 kdb_printf("-%d", i-1);
2233 if (prev_state != ' ')
2234 kdb_printf("(%c)", prev_state);
2239 static int kdb_cpu(int argc, const char **argv)
2241 unsigned long cpunum;
2250 return KDB_ARGCOUNT;
2252 diag = kdbgetularg(argv[1], &cpunum);
2259 if ((cpunum > NR_CPUS) || !kgdb_info[cpunum].enter_kgdb)
2260 return KDB_BADCPUNUM;
2262 dbg_switch_cpu = cpunum;
2265 * Switch to other cpu
2270 /* The user may not realize that ps/bta with no parameters does not print idle
2271 * or sleeping system daemon processes, so tell them how many were suppressed.
2273 void kdb_ps_suppressed(void)
2275 int idle = 0, daemon = 0;
2276 unsigned long mask_I = kdb_task_state_string("I"),
2277 mask_M = kdb_task_state_string("M");
2279 const struct task_struct *p, *g;
2280 for_each_online_cpu(cpu) {
2281 p = kdb_curr_task(cpu);
2282 if (kdb_task_state(p, mask_I))
2285 kdb_do_each_thread(g, p) {
2286 if (kdb_task_state(p, mask_M))
2288 } kdb_while_each_thread(g, p);
2289 if (idle || daemon) {
2291 kdb_printf("%d idle process%s (state I)%s\n",
2292 idle, idle == 1 ? "" : "es",
2293 daemon ? " and " : "");
2295 kdb_printf("%d sleeping system daemon (state M) "
2296 "process%s", daemon,
2297 daemon == 1 ? "" : "es");
2298 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2303 * kdb_ps - This function implements the 'ps' command which shows a
2304 * list of the active processes.
2305 * ps [DRSTCZEUIMA] All processes, optionally filtered by state
2307 void kdb_ps1(const struct task_struct *p)
2312 if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
2315 cpu = kdb_process_cpu(p);
2316 kdb_printf("0x%p %8d %8d %d %4d %c 0x%p %c%s\n",
2317 (void *)p, p->pid, p->parent->pid,
2318 kdb_task_has_cpu(p), kdb_process_cpu(p),
2319 kdb_task_state_char(p),
2320 (void *)(&p->thread),
2321 p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2323 if (kdb_task_has_cpu(p)) {
2324 if (!KDB_TSK(cpu)) {
2325 kdb_printf(" Error: no saved data for this cpu\n");
2327 if (KDB_TSK(cpu) != p)
2328 kdb_printf(" Error: does not match running "
2329 "process table (0x%p)\n", KDB_TSK(cpu));
2334 static int kdb_ps(int argc, const char **argv)
2336 struct task_struct *g, *p;
2337 unsigned long mask, cpu;
2340 kdb_ps_suppressed();
2341 kdb_printf("%-*s Pid Parent [*] cpu State %-*s Command\n",
2342 (int)(2*sizeof(void *))+2, "Task Addr",
2343 (int)(2*sizeof(void *))+2, "Thread");
2344 mask = kdb_task_state_string(argc ? argv[1] : NULL);
2345 /* Run the active tasks first */
2346 for_each_online_cpu(cpu) {
2347 if (KDB_FLAG(CMD_INTERRUPT))
2349 p = kdb_curr_task(cpu);
2350 if (kdb_task_state(p, mask))
2354 /* Now the real tasks */
2355 kdb_do_each_thread(g, p) {
2356 if (KDB_FLAG(CMD_INTERRUPT))
2358 if (kdb_task_state(p, mask))
2360 } kdb_while_each_thread(g, p);
2366 * kdb_pid - This function implements the 'pid' command which switches
2367 * the currently active process.
2370 static int kdb_pid(int argc, const char **argv)
2372 struct task_struct *p;
2377 return KDB_ARGCOUNT;
2380 if (strcmp(argv[1], "R") == 0) {
2381 p = KDB_TSK(kdb_initial_cpu);
2383 diag = kdbgetularg(argv[1], &val);
2387 p = find_task_by_pid_ns((pid_t)val, &init_pid_ns);
2389 kdb_printf("No task with pid=%d\n", (pid_t)val);
2393 kdb_set_current_task(p);
2395 kdb_printf("KDB current process is %s(pid=%d)\n",
2396 kdb_current_task->comm,
2397 kdb_current_task->pid);
2402 static int kdb_kgdb(int argc, const char **argv)
2404 return KDB_CMD_KGDB;
2408 * kdb_help - This function implements the 'help' and '?' commands.
2410 static int kdb_help(int argc, const char **argv)
2415 kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2416 kdb_printf("-----------------------------"
2417 "-----------------------------\n");
2418 for_each_kdbcmd(kt, i) {
2420 if (KDB_FLAG(CMD_INTERRUPT))
2424 if (!kdb_check_flags(kt->cmd_flags, kdb_cmd_enabled, true))
2426 if (strlen(kt->cmd_usage) > 20)
2428 kdb_printf("%-15.15s %-20s%s%s\n", kt->cmd_name,
2429 kt->cmd_usage, space, kt->cmd_help);
2435 * kdb_kill - This function implements the 'kill' commands.
2437 static int kdb_kill(int argc, const char **argv)
2441 struct task_struct *p;
2442 struct siginfo info;
2445 return KDB_ARGCOUNT;
2447 sig = simple_strtol(argv[1], &endp, 0);
2451 kdb_printf("Invalid signal parameter.<-signal>\n");
2456 pid = simple_strtol(argv[2], &endp, 0);
2460 kdb_printf("Process ID must be large than 0.\n");
2464 /* Find the process. */
2465 p = find_task_by_pid_ns(pid, &init_pid_ns);
2467 kdb_printf("The specified process isn't found.\n");
2470 p = p->group_leader;
2471 info.si_signo = sig;
2473 info.si_code = SI_USER;
2474 info.si_pid = pid; /* same capabilities as process being signalled */
2475 info.si_uid = 0; /* kdb has root authority */
2476 kdb_send_sig_info(p, &info);
2481 int tm_sec; /* seconds */
2482 int tm_min; /* minutes */
2483 int tm_hour; /* hours */
2484 int tm_mday; /* day of the month */
2485 int tm_mon; /* month */
2486 int tm_year; /* year */
2489 static void kdb_gmtime(struct timespec *tv, struct kdb_tm *tm)
2491 /* This will work from 1970-2099, 2100 is not a leap year */
2492 static int mon_day[] = { 31, 29, 31, 30, 31, 30, 31,
2493 31, 30, 31, 30, 31 };
2494 memset(tm, 0, sizeof(*tm));
2495 tm->tm_sec = tv->tv_sec % (24 * 60 * 60);
2496 tm->tm_mday = tv->tv_sec / (24 * 60 * 60) +
2497 (2 * 365 + 1); /* shift base from 1970 to 1968 */
2498 tm->tm_min = tm->tm_sec / 60 % 60;
2499 tm->tm_hour = tm->tm_sec / 60 / 60;
2500 tm->tm_sec = tm->tm_sec % 60;
2501 tm->tm_year = 68 + 4*(tm->tm_mday / (4*365+1));
2502 tm->tm_mday %= (4*365+1);
2504 while (tm->tm_mday >= mon_day[tm->tm_mon]) {
2505 tm->tm_mday -= mon_day[tm->tm_mon];
2506 if (++tm->tm_mon == 12) {
2516 * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2517 * I cannot call that code directly from kdb, it has an unconditional
2518 * cli()/sti() and calls routines that take locks which can stop the debugger.
2520 static void kdb_sysinfo(struct sysinfo *val)
2522 struct timespec uptime;
2523 ktime_get_ts(&uptime);
2524 memset(val, 0, sizeof(*val));
2525 val->uptime = uptime.tv_sec;
2526 val->loads[0] = avenrun[0];
2527 val->loads[1] = avenrun[1];
2528 val->loads[2] = avenrun[2];
2529 val->procs = nr_threads-1;
2536 * kdb_summary - This function implements the 'summary' command.
2538 static int kdb_summary(int argc, const char **argv)
2540 struct timespec now;
2545 return KDB_ARGCOUNT;
2547 kdb_printf("sysname %s\n", init_uts_ns.name.sysname);
2548 kdb_printf("release %s\n", init_uts_ns.name.release);
2549 kdb_printf("version %s\n", init_uts_ns.name.version);
2550 kdb_printf("machine %s\n", init_uts_ns.name.machine);
2551 kdb_printf("nodename %s\n", init_uts_ns.name.nodename);
2552 kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2553 kdb_printf("ccversion %s\n", __stringify(CCVERSION));
2555 now = __current_kernel_time();
2556 kdb_gmtime(&now, &tm);
2557 kdb_printf("date %04d-%02d-%02d %02d:%02d:%02d "
2558 "tz_minuteswest %d\n",
2559 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2560 tm.tm_hour, tm.tm_min, tm.tm_sec,
2561 sys_tz.tz_minuteswest);
2564 kdb_printf("uptime ");
2565 if (val.uptime > (24*60*60)) {
2566 int days = val.uptime / (24*60*60);
2567 val.uptime %= (24*60*60);
2568 kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2570 kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2572 /* lifted from fs/proc/proc_misc.c::loadavg_read_proc() */
2574 #define LOAD_INT(x) ((x) >> FSHIFT)
2575 #define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
2576 kdb_printf("load avg %ld.%02ld %ld.%02ld %ld.%02ld\n",
2577 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2578 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2579 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2582 /* Display in kilobytes */
2583 #define K(x) ((x) << (PAGE_SHIFT - 10))
2584 kdb_printf("\nMemTotal: %8lu kB\nMemFree: %8lu kB\n"
2585 "Buffers: %8lu kB\n",
2586 val.totalram, val.freeram, val.bufferram);
2591 * kdb_per_cpu - This function implements the 'per_cpu' command.
2593 static int kdb_per_cpu(int argc, const char **argv)
2596 int cpu, diag, nextarg = 1;
2597 unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2599 if (argc < 1 || argc > 3)
2600 return KDB_ARGCOUNT;
2602 diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2607 diag = kdbgetularg(argv[2], &bytesperword);
2612 bytesperword = KDB_WORD_SIZE;
2613 else if (bytesperword > KDB_WORD_SIZE)
2614 return KDB_BADWIDTH;
2615 sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2617 diag = kdbgetularg(argv[3], &whichcpu);
2620 if (!cpu_online(whichcpu)) {
2621 kdb_printf("cpu %ld is not online\n", whichcpu);
2622 return KDB_BADCPUNUM;
2626 /* Most architectures use __per_cpu_offset[cpu], some use
2627 * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2629 #ifdef __per_cpu_offset
2630 #define KDB_PCU(cpu) __per_cpu_offset(cpu)
2633 #define KDB_PCU(cpu) __per_cpu_offset[cpu]
2635 #define KDB_PCU(cpu) 0
2638 for_each_online_cpu(cpu) {
2639 if (KDB_FLAG(CMD_INTERRUPT))
2642 if (whichcpu != ~0UL && whichcpu != cpu)
2644 addr = symaddr + KDB_PCU(cpu);
2645 diag = kdb_getword(&val, addr, bytesperword);
2647 kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2648 "read, diag=%d\n", cpu, addr, diag);
2651 kdb_printf("%5d ", cpu);
2652 kdb_md_line(fmtstr, addr,
2653 bytesperword == KDB_WORD_SIZE,
2654 1, bytesperword, 1, 1, 0);
2661 * display help for the use of cmd | grep pattern
2663 static int kdb_grep_help(int argc, const char **argv)
2665 kdb_printf("Usage of cmd args | grep pattern:\n");
2666 kdb_printf(" Any command's output may be filtered through an ");
2667 kdb_printf("emulated 'pipe'.\n");
2668 kdb_printf(" 'grep' is just a key word.\n");
2669 kdb_printf(" The pattern may include a very limited set of "
2670 "metacharacters:\n");
2671 kdb_printf(" pattern or ^pattern or pattern$ or ^pattern$\n");
2672 kdb_printf(" And if there are spaces in the pattern, you may "
2674 kdb_printf(" \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2675 " or \"^pat tern$\"\n");
2680 * kdb_register_flags - This function is used to register a kernel
2684 * func Function to execute the command
2685 * usage A simple usage string showing arguments
2686 * help A simple help string describing command
2687 * repeat Does the command auto repeat on enter?
2689 * zero for success, one if a duplicate command.
2691 #define kdb_command_extend 50 /* arbitrary */
2692 int kdb_register_flags(char *cmd,
2697 kdb_cmdflags_t flags)
2703 * Brute force method to determine duplicates
2705 for_each_kdbcmd(kp, i) {
2706 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2707 kdb_printf("Duplicate kdb command registered: "
2708 "%s, func %p help %s\n", cmd, func, help);
2714 * Insert command into first available location in table
2716 for_each_kdbcmd(kp, i) {
2717 if (kp->cmd_name == NULL)
2721 if (i >= kdb_max_commands) {
2722 kdbtab_t *new = kmalloc((kdb_max_commands - KDB_BASE_CMD_MAX +
2723 kdb_command_extend) * sizeof(*new), GFP_KDB);
2725 kdb_printf("Could not allocate new kdb_command "
2730 memcpy(new, kdb_commands,
2731 (kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new));
2732 kfree(kdb_commands);
2734 memset(new + kdb_max_commands - KDB_BASE_CMD_MAX, 0,
2735 kdb_command_extend * sizeof(*new));
2737 kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX;
2738 kdb_max_commands += kdb_command_extend;
2742 kp->cmd_func = func;
2743 kp->cmd_usage = usage;
2744 kp->cmd_help = help;
2745 kp->cmd_minlen = minlen;
2746 kp->cmd_flags = flags;
2750 EXPORT_SYMBOL_GPL(kdb_register_flags);
2754 * kdb_register - Compatibility register function for commands that do
2755 * not need to specify a repeat state. Equivalent to
2756 * kdb_register_flags with flags set to 0.
2759 * func Function to execute the command
2760 * usage A simple usage string showing arguments
2761 * help A simple help string describing command
2763 * zero for success, one if a duplicate command.
2765 int kdb_register(char *cmd,
2771 return kdb_register_flags(cmd, func, usage, help, minlen, 0);
2773 EXPORT_SYMBOL_GPL(kdb_register);
2776 * kdb_unregister - This function is used to unregister a kernel
2777 * debugger command. It is generally called when a module which
2778 * implements kdb commands is unloaded.
2782 * zero for success, one command not registered.
2784 int kdb_unregister(char *cmd)
2792 for_each_kdbcmd(kp, i) {
2793 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2794 kp->cmd_name = NULL;
2799 /* Couldn't find it. */
2802 EXPORT_SYMBOL_GPL(kdb_unregister);
2804 /* Initialize the kdb command table. */
2805 static void __init kdb_inittab(void)
2810 for_each_kdbcmd(kp, i)
2811 kp->cmd_name = NULL;
2813 kdb_register_flags("md", kdb_md, "<vaddr>",
2814 "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2815 KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2816 kdb_register_flags("mdr", kdb_md, "<vaddr> <bytes>",
2817 "Display Raw Memory", 0,
2818 KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2819 kdb_register_flags("mdp", kdb_md, "<paddr> <bytes>",
2820 "Display Physical Memory", 0,
2821 KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2822 kdb_register_flags("mds", kdb_md, "<vaddr>",
2823 "Display Memory Symbolically", 0,
2824 KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2825 kdb_register_flags("mm", kdb_mm, "<vaddr> <contents>",
2826 "Modify Memory Contents", 0,
2827 KDB_ENABLE_MEM_WRITE | KDB_REPEAT_NO_ARGS);
2828 kdb_register_flags("go", kdb_go, "[<vaddr>]",
2829 "Continue Execution", 1,
2830 KDB_ENABLE_REG_WRITE | KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
2831 kdb_register_flags("rd", kdb_rd, "",
2832 "Display Registers", 0,
2833 KDB_ENABLE_REG_READ);
2834 kdb_register_flags("rm", kdb_rm, "<reg> <contents>",
2835 "Modify Registers", 0,
2836 KDB_ENABLE_REG_WRITE);
2837 kdb_register_flags("ef", kdb_ef, "<vaddr>",
2838 "Display exception frame", 0,
2839 KDB_ENABLE_MEM_READ);
2840 kdb_register_flags("bt", kdb_bt, "[<vaddr>]",
2841 "Stack traceback", 1,
2842 KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS);
2843 kdb_register_flags("btp", kdb_bt, "<pid>",
2844 "Display stack for process <pid>", 0,
2845 KDB_ENABLE_INSPECT);
2846 kdb_register_flags("bta", kdb_bt, "[D|R|S|T|C|Z|E|U|I|M|A]",
2847 "Backtrace all processes matching state flag", 0,
2848 KDB_ENABLE_INSPECT);
2849 kdb_register_flags("btc", kdb_bt, "",
2850 "Backtrace current process on each cpu", 0,
2851 KDB_ENABLE_INSPECT);
2852 kdb_register_flags("btt", kdb_bt, "<vaddr>",
2853 "Backtrace process given its struct task address", 0,
2854 KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS);
2855 kdb_register_flags("env", kdb_env, "",
2856 "Show environment variables", 0,
2857 KDB_ENABLE_ALWAYS_SAFE);
2858 kdb_register_flags("set", kdb_set, "",
2859 "Set environment variables", 0,
2860 KDB_ENABLE_ALWAYS_SAFE);
2861 kdb_register_flags("help", kdb_help, "",
2862 "Display Help Message", 1,
2863 KDB_ENABLE_ALWAYS_SAFE);
2864 kdb_register_flags("?", kdb_help, "",
2865 "Display Help Message", 0,
2866 KDB_ENABLE_ALWAYS_SAFE);
2867 kdb_register_flags("cpu", kdb_cpu, "<cpunum>",
2868 "Switch to new cpu", 0,
2869 KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
2870 kdb_register_flags("kgdb", kdb_kgdb, "",
2871 "Enter kgdb mode", 0, 0);
2872 kdb_register_flags("ps", kdb_ps, "[<flags>|A]",
2873 "Display active task list", 0,
2874 KDB_ENABLE_INSPECT);
2875 kdb_register_flags("pid", kdb_pid, "<pidnum>",
2876 "Switch to another task", 0,
2877 KDB_ENABLE_INSPECT);
2878 kdb_register_flags("reboot", kdb_reboot, "",
2879 "Reboot the machine immediately", 0,
2881 #if defined(CONFIG_MODULES)
2882 kdb_register_flags("lsmod", kdb_lsmod, "",
2883 "List loaded kernel modules", 0,
2884 KDB_ENABLE_INSPECT);
2886 #if defined(CONFIG_MAGIC_SYSRQ)
2887 kdb_register_flags("sr", kdb_sr, "<key>",
2888 "Magic SysRq key", 0,
2889 KDB_ENABLE_ALWAYS_SAFE);
2891 #if defined(CONFIG_PRINTK)
2892 kdb_register_flags("dmesg", kdb_dmesg, "[lines]",
2893 "Display syslog buffer", 0,
2894 KDB_ENABLE_ALWAYS_SAFE);
2896 if (arch_kgdb_ops.enable_nmi) {
2897 kdb_register_flags("disable_nmi", kdb_disable_nmi, "",
2898 "Disable NMI entry to KDB", 0,
2899 KDB_ENABLE_ALWAYS_SAFE);
2901 kdb_register_flags("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
2902 "Define a set of commands, down to endefcmd", 0,
2903 KDB_ENABLE_ALWAYS_SAFE);
2904 kdb_register_flags("kill", kdb_kill, "<-signal> <pid>",
2905 "Send a signal to a process", 0,
2907 kdb_register_flags("summary", kdb_summary, "",
2908 "Summarize the system", 4,
2909 KDB_ENABLE_ALWAYS_SAFE);
2910 kdb_register_flags("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
2911 "Display per_cpu variables", 3,
2912 KDB_ENABLE_MEM_READ);
2913 kdb_register_flags("grephelp", kdb_grep_help, "",
2914 "Display help on | grep", 0,
2915 KDB_ENABLE_ALWAYS_SAFE);
2918 /* Execute any commands defined in kdb_cmds. */
2919 static void __init kdb_cmd_init(void)
2922 for (i = 0; kdb_cmds[i]; ++i) {
2923 diag = kdb_parse(kdb_cmds[i]);
2925 kdb_printf("kdb command %s failed, kdb diag %d\n",
2928 if (defcmd_in_progress) {
2929 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2930 kdb_parse("endefcmd");
2934 /* Initialize kdb_printf, breakpoint tables and kdb state */
2935 void __init kdb_init(int lvl)
2937 static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2940 if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2942 for (i = kdb_init_lvl; i < lvl; i++) {
2944 case KDB_NOT_INITIALIZED:
2945 kdb_inittab(); /* Initialize Command Table */
2946 kdb_initbptab(); /* Initialize Breakpoints */
2948 case KDB_INIT_EARLY:
2949 kdb_cmd_init(); /* Build kdb_cmds tables */