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));
1251 case KDB_REASON_SSTEP:
1252 case KDB_REASON_BREAK:
1253 kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
1254 reason == KDB_REASON_BREAK ?
1255 "Breakpoint" : "SS trap", instruction_pointer(regs));
1257 * Determine if this breakpoint is one that we
1258 * are interested in.
1260 if (db_result != KDB_DB_BPT) {
1261 kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1263 KDB_DEBUG_STATE("kdb_local 6", reason);
1264 return 0; /* Not for us, dismiss it */
1267 case KDB_REASON_RECURSE:
1268 kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
1269 instruction_pointer(regs));
1272 kdb_printf("kdb: unexpected reason code: %d\n", reason);
1273 KDB_DEBUG_STATE("kdb_local 8", reason);
1274 return 0; /* Not for us, dismiss it */
1279 * Initialize pager context.
1282 KDB_STATE_CLEAR(SUPPRESS);
1286 *(cmd_hist[cmd_head]) = '\0';
1289 #if defined(CONFIG_SMP)
1290 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
1291 raw_smp_processor_id());
1293 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"));
1295 if (defcmd_in_progress)
1296 strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
1299 * Fetch command from keyboard
1301 cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
1302 if (*cmdbuf != '\n') {
1304 if (cmdptr == cmd_head) {
1305 strncpy(cmd_hist[cmd_head], cmd_cur,
1307 *(cmd_hist[cmd_head] +
1308 strlen(cmd_hist[cmd_head])-1) = '\0';
1310 if (!handle_ctrl_cmd(cmdbuf))
1311 *(cmd_cur+strlen(cmd_cur)-1) = '\0';
1313 goto do_full_getstr;
1315 strncpy(cmd_hist[cmd_head], cmd_cur,
1319 cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
1320 if (cmd_head == cmd_tail)
1321 cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
1325 diag = kdb_parse(cmdbuf);
1326 if (diag == KDB_NOTFOUND) {
1327 kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
1330 if (diag == KDB_CMD_GO
1331 || diag == KDB_CMD_CPU
1332 || diag == KDB_CMD_SS
1333 || diag == KDB_CMD_KGDB)
1339 KDB_DEBUG_STATE("kdb_local 9", diag);
1345 * kdb_print_state - Print the state data for the current processor
1348 * text Identifies the debug point
1349 * value Any integer value to be printed, e.g. reason code.
1351 void kdb_print_state(const char *text, int value)
1353 kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1354 text, raw_smp_processor_id(), value, kdb_initial_cpu,
1359 * kdb_main_loop - After initial setup and assignment of the
1360 * controlling cpu, all cpus are in this loop. One cpu is in
1361 * control and will issue the kdb prompt, the others will spin
1362 * until 'go' or cpu switch.
1364 * To get a consistent view of the kernel stacks for all
1365 * processes, this routine is invoked from the main kdb code via
1366 * an architecture specific routine. kdba_main_loop is
1367 * responsible for making the kernel stacks consistent for all
1368 * processes, there should be no difference between a blocked
1369 * process and a running process as far as kdb is concerned.
1371 * reason The reason KDB was invoked
1372 * error The hardware-defined error code
1373 * reason2 kdb's current reason code.
1374 * Initially error but can change
1375 * according to kdb state.
1376 * db_result Result code from break or debug point.
1377 * regs The exception frame at time of fault/breakpoint.
1378 * should always be valid.
1380 * 0 KDB was invoked for an event which it wasn't responsible
1381 * 1 KDB handled the event for which it was invoked.
1383 int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
1384 kdb_dbtrap_t db_result, struct pt_regs *regs)
1387 /* Stay in kdb() until 'go', 'ss[b]' or an error */
1390 * All processors except the one that is in control
1393 KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1394 while (KDB_STATE(HOLD_CPU)) {
1395 /* state KDB is turned off by kdb_cpu to see if the
1396 * other cpus are still live, each cpu in this loop
1399 if (!KDB_STATE(KDB))
1403 KDB_STATE_CLEAR(SUPPRESS);
1404 KDB_DEBUG_STATE("kdb_main_loop 2", reason);
1405 if (KDB_STATE(LEAVING))
1406 break; /* Another cpu said 'go' */
1407 /* Still using kdb, this processor is in control */
1408 result = kdb_local(reason2, error, regs, db_result);
1409 KDB_DEBUG_STATE("kdb_main_loop 3", result);
1411 if (result == KDB_CMD_CPU)
1414 if (result == KDB_CMD_SS) {
1415 KDB_STATE_SET(DOING_SS);
1419 if (result == KDB_CMD_KGDB) {
1420 if (!KDB_STATE(DOING_KGDB))
1421 kdb_printf("Entering please attach debugger "
1422 "or use $D#44+ or $3#33\n");
1425 if (result && result != 1 && result != KDB_CMD_GO)
1426 kdb_printf("\nUnexpected kdb_local return code %d\n",
1428 KDB_DEBUG_STATE("kdb_main_loop 4", reason);
1431 if (KDB_STATE(DOING_SS))
1432 KDB_STATE_CLEAR(SSBPT);
1434 /* Clean up any keyboard devices before leaving */
1435 kdb_kbd_cleanup_state();
1441 * kdb_mdr - This function implements the guts of the 'mdr', memory
1443 * mdr <addr arg>,<byte count>
1445 * addr Start address
1446 * count Number of bytes
1448 * Always 0. Any errors are detected and printed by kdb_getarea.
1450 static int kdb_mdr(unsigned long addr, unsigned int count)
1454 if (kdb_getarea(c, addr))
1456 kdb_printf("%02x", c);
1464 * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1465 * 'md8' 'mdr' and 'mds' commands.
1467 * md|mds [<addr arg> [<line count> [<radix>]]]
1468 * mdWcN [<addr arg> [<line count> [<radix>]]]
1469 * where W = is the width (1, 2, 4 or 8) and N is the count.
1470 * for eg., md1c20 reads 20 bytes, 1 at a time.
1471 * mdr <addr arg>,<byte count>
1473 static void kdb_md_line(const char *fmtstr, unsigned long addr,
1474 int symbolic, int nosect, int bytesperword,
1475 int num, int repeat, int phys)
1477 /* print just one line of data */
1478 kdb_symtab_t symtab;
1484 memset(cbuf, '\0', sizeof(cbuf));
1486 kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1488 kdb_printf(kdb_machreg_fmt0 " ", addr);
1490 for (i = 0; i < num && repeat--; i++) {
1492 if (kdb_getphysword(&word, addr, bytesperword))
1494 } else if (kdb_getword(&word, addr, bytesperword))
1496 kdb_printf(fmtstr, word);
1498 kdbnearsym(word, &symtab);
1500 memset(&symtab, 0, sizeof(symtab));
1501 if (symtab.sym_name) {
1502 kdb_symbol_print(word, &symtab, 0);
1505 kdb_printf(" %s %s "
1508 kdb_machreg_fmt, symtab.mod_name,
1509 symtab.sec_name, symtab.sec_start,
1510 symtab.sym_start, symtab.sym_end);
1512 addr += bytesperword;
1520 cp = wc.c + 8 - bytesperword;
1525 #define printable_char(c) \
1526 ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1527 switch (bytesperword) {
1529 *c++ = printable_char(*cp++);
1530 *c++ = printable_char(*cp++);
1531 *c++ = printable_char(*cp++);
1532 *c++ = printable_char(*cp++);
1535 *c++ = printable_char(*cp++);
1536 *c++ = printable_char(*cp++);
1539 *c++ = printable_char(*cp++);
1542 *c++ = printable_char(*cp++);
1546 #undef printable_char
1549 kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1553 static int kdb_md(int argc, const char **argv)
1555 static unsigned long last_addr;
1556 static int last_radix, last_bytesperword, last_repeat;
1557 int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1559 char fmtchar, fmtstr[64];
1567 kdbgetintenv("MDCOUNT", &mdcount);
1568 kdbgetintenv("RADIX", &radix);
1569 kdbgetintenv("BYTESPERWORD", &bytesperword);
1571 /* Assume 'md <addr>' and start with environment values */
1572 repeat = mdcount * 16 / bytesperword;
1574 if (strcmp(argv[0], "mdr") == 0) {
1576 return KDB_ARGCOUNT;
1578 } else if (isdigit(argv[0][2])) {
1579 bytesperword = (int)(argv[0][2] - '0');
1580 if (bytesperword == 0) {
1581 bytesperword = last_bytesperword;
1582 if (bytesperword == 0)
1585 last_bytesperword = bytesperword;
1586 repeat = mdcount * 16 / bytesperword;
1589 else if (argv[0][3] == 'c' && argv[0][4]) {
1591 repeat = simple_strtoul(argv[0] + 4, &p, 10);
1592 mdcount = ((repeat * bytesperword) + 15) / 16;
1595 last_repeat = repeat;
1596 } else if (strcmp(argv[0], "md") == 0)
1598 else if (strcmp(argv[0], "mds") == 0)
1600 else if (strcmp(argv[0], "mdp") == 0) {
1604 return KDB_NOTFOUND;
1608 return KDB_ARGCOUNT;
1611 bytesperword = last_bytesperword;
1612 repeat = last_repeat;
1613 mdcount = ((repeat * bytesperword) + 15) / 16;
1618 int diag, nextarg = 1;
1619 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1623 if (argc > nextarg+2)
1624 return KDB_ARGCOUNT;
1626 if (argc >= nextarg) {
1627 diag = kdbgetularg(argv[nextarg], &val);
1629 mdcount = (int) val;
1630 repeat = mdcount * 16 / bytesperword;
1633 if (argc >= nextarg+1) {
1634 diag = kdbgetularg(argv[nextarg+1], &val);
1640 if (strcmp(argv[0], "mdr") == 0)
1641 return kdb_mdr(addr, mdcount);
1654 return KDB_BADRADIX;
1659 if (bytesperword > KDB_WORD_SIZE)
1660 return KDB_BADWIDTH;
1662 switch (bytesperword) {
1664 sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1667 sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1670 sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1673 sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1676 return KDB_BADWIDTH;
1679 last_repeat = repeat;
1680 last_bytesperword = bytesperword;
1682 if (strcmp(argv[0], "mds") == 0) {
1684 /* Do not save these changes as last_*, they are temporary mds
1687 bytesperword = KDB_WORD_SIZE;
1689 kdbgetintenv("NOSECT", &nosect);
1692 /* Round address down modulo BYTESPERWORD */
1694 addr &= ~(bytesperword-1);
1696 while (repeat > 0) {
1698 int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1700 if (KDB_FLAG(CMD_INTERRUPT))
1702 for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1704 if (kdb_getphysword(&word, a, bytesperword)
1707 } else if (kdb_getword(&word, a, bytesperword) || word)
1710 n = min(num, repeat);
1711 kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1713 addr += bytesperword * n;
1715 z = (z + num - 1) / num;
1717 int s = num * (z-2);
1718 kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1719 " zero suppressed\n",
1720 addr, addr + bytesperword * s - 1);
1721 addr += bytesperword * s;
1731 * kdb_mm - This function implements the 'mm' command.
1732 * mm address-expression new-value
1734 * mm works on machine words, mmW works on bytes.
1736 static int kdb_mm(int argc, const char **argv)
1741 unsigned long contents;
1745 if (argv[0][2] && !isdigit(argv[0][2]))
1746 return KDB_NOTFOUND;
1749 return KDB_ARGCOUNT;
1752 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1757 return KDB_ARGCOUNT;
1758 diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1762 if (nextarg != argc + 1)
1763 return KDB_ARGCOUNT;
1765 width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1766 diag = kdb_putword(addr, contents, width);
1770 kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1776 * kdb_go - This function implements the 'go' command.
1777 * go [address-expression]
1779 static int kdb_go(int argc, const char **argv)
1786 if (raw_smp_processor_id() != kdb_initial_cpu) {
1787 kdb_printf("go must execute on the entry cpu, "
1788 "please use \"cpu %d\" and then execute go\n",
1790 return KDB_BADCPUNUM;
1794 diag = kdbgetaddrarg(argc, argv, &nextarg,
1795 &addr, &offset, NULL);
1799 return KDB_ARGCOUNT;
1803 if (KDB_FLAG(CATASTROPHIC)) {
1804 kdb_printf("Catastrophic error detected\n");
1805 kdb_printf("kdb_continue_catastrophic=%d, ",
1806 kdb_continue_catastrophic);
1807 if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1808 kdb_printf("type go a second time if you really want "
1812 if (kdb_continue_catastrophic == 2) {
1813 kdb_printf("forcing reboot\n");
1814 kdb_reboot(0, NULL);
1816 kdb_printf("attempting to continue\n");
1822 * kdb_rd - This function implements the 'rd' command.
1824 static int kdb_rd(int argc, const char **argv)
1826 int len = kdb_check_regs();
1827 #if DBG_MAX_REG_NUM > 0
1839 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1840 rsize = dbg_reg_def[i].size * 2;
1843 if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
1848 len += kdb_printf(" ");
1849 switch(dbg_reg_def[i].size * 8) {
1851 rname = dbg_get_reg(i, ®8, kdb_current_regs);
1854 len += kdb_printf("%s: %02x", rname, reg8);
1857 rname = dbg_get_reg(i, ®16, kdb_current_regs);
1860 len += kdb_printf("%s: %04x", rname, reg16);
1863 rname = dbg_get_reg(i, ®32, kdb_current_regs);
1866 len += kdb_printf("%s: %08x", rname, reg32);
1869 rname = dbg_get_reg(i, ®64, kdb_current_regs);
1872 len += kdb_printf("%s: %016llx", rname, reg64);
1875 len += kdb_printf("%s: ??", dbg_reg_def[i].name);
1883 kdb_dumpregs(kdb_current_regs);
1889 * kdb_rm - This function implements the 'rm' (register modify) command.
1890 * rm register-name new-contents
1892 * Allows register modification with the same restrictions as gdb
1894 static int kdb_rm(int argc, const char **argv)
1896 #if DBG_MAX_REG_NUM > 0
1906 return KDB_ARGCOUNT;
1908 * Allow presence or absence of leading '%' symbol.
1914 diag = kdbgetu64arg(argv[2], ®64);
1918 diag = kdb_check_regs();
1923 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1924 if (strcmp(rname, dbg_reg_def[i].name) == 0) {
1930 switch(dbg_reg_def[i].size * 8) {
1933 dbg_set_reg(i, ®8, kdb_current_regs);
1937 dbg_set_reg(i, ®16, kdb_current_regs);
1941 dbg_set_reg(i, ®32, kdb_current_regs);
1944 dbg_set_reg(i, ®64, kdb_current_regs);
1950 kdb_printf("ERROR: Register set currently not implemented\n");
1955 #if defined(CONFIG_MAGIC_SYSRQ)
1957 * kdb_sr - This function implements the 'sr' (SYSRQ key) command
1958 * which interfaces to the soi-disant MAGIC SYSRQ functionality.
1959 * sr <magic-sysrq-code>
1961 static int kdb_sr(int argc, const char **argv)
1964 !kdb_check_flags(KDB_ENABLE_ALL, kdb_cmd_enabled, false);
1967 return KDB_ARGCOUNT;
1970 __handle_sysrq(*argv[1], check_mask);
1975 #endif /* CONFIG_MAGIC_SYSRQ */
1978 * kdb_ef - This function implements the 'regs' (display exception
1979 * frame) command. This command takes an address and expects to
1980 * find an exception frame at that address, formats and prints
1982 * regs address-expression
1986 static int kdb_ef(int argc, const char **argv)
1994 return KDB_ARGCOUNT;
1997 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
2000 show_regs((struct pt_regs *)addr);
2004 #if defined(CONFIG_MODULES)
2006 * kdb_lsmod - This function implements the 'lsmod' command. Lists
2007 * currently loaded kernel modules.
2008 * Mostly taken from userland lsmod.
2010 static int kdb_lsmod(int argc, const char **argv)
2015 return KDB_ARGCOUNT;
2017 kdb_printf("Module Size modstruct Used by\n");
2018 list_for_each_entry(mod, kdb_modules, list) {
2019 if (mod->state == MODULE_STATE_UNFORMED)
2022 kdb_printf("%-20s%8u 0x%p ", mod->name,
2023 mod->core_size, (void *)mod);
2024 #ifdef CONFIG_MODULE_UNLOAD
2025 kdb_printf("%4d ", module_refcount(mod));
2027 if (mod->state == MODULE_STATE_GOING)
2028 kdb_printf(" (Unloading)");
2029 else if (mod->state == MODULE_STATE_COMING)
2030 kdb_printf(" (Loading)");
2032 kdb_printf(" (Live)");
2033 kdb_printf(" 0x%p", mod->module_core);
2035 #ifdef CONFIG_MODULE_UNLOAD
2037 struct module_use *use;
2039 list_for_each_entry(use, &mod->source_list,
2041 kdb_printf("%s ", use->target->name);
2050 #endif /* CONFIG_MODULES */
2053 * kdb_env - This function implements the 'env' command. Display the
2054 * current environment variables.
2057 static int kdb_env(int argc, const char **argv)
2061 for (i = 0; i < __nenv; i++) {
2063 kdb_printf("%s\n", __env[i]);
2066 if (KDB_DEBUG(MASK))
2067 kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
2072 #ifdef CONFIG_PRINTK
2074 * kdb_dmesg - This function implements the 'dmesg' command to display
2075 * the contents of the syslog buffer.
2076 * dmesg [lines] [adjust]
2078 static int kdb_dmesg(int argc, const char **argv)
2086 struct kmsg_dumper dumper = { .active = 1 };
2091 return KDB_ARGCOUNT;
2094 lines = simple_strtol(argv[1], &cp, 0);
2098 adjust = simple_strtoul(argv[2], &cp, 0);
2099 if (*cp || adjust < 0)
2104 /* disable LOGGING if set */
2105 diag = kdbgetintenv("LOGGING", &logging);
2106 if (!diag && logging) {
2107 const char *setargs[] = { "set", "LOGGING", "0" };
2108 kdb_set(2, setargs);
2111 kmsg_dump_rewind_nolock(&dumper);
2112 while (kmsg_dump_get_line_nolock(&dumper, 1, NULL, 0, NULL))
2117 kdb_printf("buffer only contains %d lines, nothing "
2119 else if (adjust - lines >= n)
2120 kdb_printf("buffer only contains %d lines, last %d "
2121 "lines printed\n", n, n - adjust);
2124 } else if (lines > 0) {
2125 skip = n - lines - adjust;
2128 kdb_printf("buffer only contains %d lines, "
2129 "nothing printed\n", n);
2131 } else if (skip < 0) {
2134 kdb_printf("buffer only contains %d lines, first "
2135 "%d lines printed\n", n, lines);
2141 if (skip >= n || skip < 0)
2144 kmsg_dump_rewind_nolock(&dumper);
2145 while (kmsg_dump_get_line_nolock(&dumper, 1, buf, sizeof(buf), &len)) {
2152 if (KDB_FLAG(CMD_INTERRUPT))
2155 kdb_printf("%.*s\n", (int)len - 1, buf);
2160 #endif /* CONFIG_PRINTK */
2162 /* Make sure we balance enable/disable calls, must disable first. */
2163 static atomic_t kdb_nmi_disabled;
2165 static int kdb_disable_nmi(int argc, const char *argv[])
2167 if (atomic_read(&kdb_nmi_disabled))
2169 atomic_set(&kdb_nmi_disabled, 1);
2170 arch_kgdb_ops.enable_nmi(0);
2174 static int kdb_param_enable_nmi(const char *val, const struct kernel_param *kp)
2176 if (!atomic_add_unless(&kdb_nmi_disabled, -1, 0))
2178 arch_kgdb_ops.enable_nmi(1);
2182 static const struct kernel_param_ops kdb_param_ops_enable_nmi = {
2183 .set = kdb_param_enable_nmi,
2185 module_param_cb(enable_nmi, &kdb_param_ops_enable_nmi, NULL, 0600);
2188 * kdb_cpu - This function implements the 'cpu' command.
2191 * KDB_CMD_CPU for success, a kdb diagnostic if error
2193 static void kdb_cpu_status(void)
2195 int i, start_cpu, first_print = 1;
2196 char state, prev_state = '?';
2198 kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2199 kdb_printf("Available cpus: ");
2200 for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2201 if (!cpu_online(i)) {
2202 state = 'F'; /* cpu is offline */
2203 } else if (!kgdb_info[i].enter_kgdb) {
2204 state = 'D'; /* cpu is online but unresponsive */
2206 state = ' '; /* cpu is responding to kdb */
2207 if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2208 state = 'I'; /* idle task */
2210 if (state != prev_state) {
2211 if (prev_state != '?') {
2215 kdb_printf("%d", start_cpu);
2216 if (start_cpu < i-1)
2217 kdb_printf("-%d", i-1);
2218 if (prev_state != ' ')
2219 kdb_printf("(%c)", prev_state);
2225 /* print the trailing cpus, ignoring them if they are all offline */
2226 if (prev_state != 'F') {
2229 kdb_printf("%d", start_cpu);
2230 if (start_cpu < i-1)
2231 kdb_printf("-%d", i-1);
2232 if (prev_state != ' ')
2233 kdb_printf("(%c)", prev_state);
2238 static int kdb_cpu(int argc, const char **argv)
2240 unsigned long cpunum;
2249 return KDB_ARGCOUNT;
2251 diag = kdbgetularg(argv[1], &cpunum);
2258 if ((cpunum >= CONFIG_NR_CPUS) || !kgdb_info[cpunum].enter_kgdb)
2259 return KDB_BADCPUNUM;
2261 dbg_switch_cpu = cpunum;
2264 * Switch to other cpu
2269 /* The user may not realize that ps/bta with no parameters does not print idle
2270 * or sleeping system daemon processes, so tell them how many were suppressed.
2272 void kdb_ps_suppressed(void)
2274 int idle = 0, daemon = 0;
2275 unsigned long mask_I = kdb_task_state_string("I"),
2276 mask_M = kdb_task_state_string("M");
2278 const struct task_struct *p, *g;
2279 for_each_online_cpu(cpu) {
2280 p = kdb_curr_task(cpu);
2281 if (kdb_task_state(p, mask_I))
2284 kdb_do_each_thread(g, p) {
2285 if (kdb_task_state(p, mask_M))
2287 } kdb_while_each_thread(g, p);
2288 if (idle || daemon) {
2290 kdb_printf("%d idle process%s (state I)%s\n",
2291 idle, idle == 1 ? "" : "es",
2292 daemon ? " and " : "");
2294 kdb_printf("%d sleeping system daemon (state M) "
2295 "process%s", daemon,
2296 daemon == 1 ? "" : "es");
2297 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2302 * kdb_ps - This function implements the 'ps' command which shows a
2303 * list of the active processes.
2304 * ps [DRSTCZEUIMA] All processes, optionally filtered by state
2306 void kdb_ps1(const struct task_struct *p)
2311 if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
2314 cpu = kdb_process_cpu(p);
2315 kdb_printf("0x%p %8d %8d %d %4d %c 0x%p %c%s\n",
2316 (void *)p, p->pid, p->parent->pid,
2317 kdb_task_has_cpu(p), kdb_process_cpu(p),
2318 kdb_task_state_char(p),
2319 (void *)(&p->thread),
2320 p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2322 if (kdb_task_has_cpu(p)) {
2323 if (!KDB_TSK(cpu)) {
2324 kdb_printf(" Error: no saved data for this cpu\n");
2326 if (KDB_TSK(cpu) != p)
2327 kdb_printf(" Error: does not match running "
2328 "process table (0x%p)\n", KDB_TSK(cpu));
2333 static int kdb_ps(int argc, const char **argv)
2335 struct task_struct *g, *p;
2336 unsigned long mask, cpu;
2339 kdb_ps_suppressed();
2340 kdb_printf("%-*s Pid Parent [*] cpu State %-*s Command\n",
2341 (int)(2*sizeof(void *))+2, "Task Addr",
2342 (int)(2*sizeof(void *))+2, "Thread");
2343 mask = kdb_task_state_string(argc ? argv[1] : NULL);
2344 /* Run the active tasks first */
2345 for_each_online_cpu(cpu) {
2346 if (KDB_FLAG(CMD_INTERRUPT))
2348 p = kdb_curr_task(cpu);
2349 if (kdb_task_state(p, mask))
2353 /* Now the real tasks */
2354 kdb_do_each_thread(g, p) {
2355 if (KDB_FLAG(CMD_INTERRUPT))
2357 if (kdb_task_state(p, mask))
2359 } kdb_while_each_thread(g, p);
2365 * kdb_pid - This function implements the 'pid' command which switches
2366 * the currently active process.
2369 static int kdb_pid(int argc, const char **argv)
2371 struct task_struct *p;
2376 return KDB_ARGCOUNT;
2379 if (strcmp(argv[1], "R") == 0) {
2380 p = KDB_TSK(kdb_initial_cpu);
2382 diag = kdbgetularg(argv[1], &val);
2386 p = find_task_by_pid_ns((pid_t)val, &init_pid_ns);
2388 kdb_printf("No task with pid=%d\n", (pid_t)val);
2392 kdb_set_current_task(p);
2394 kdb_printf("KDB current process is %s(pid=%d)\n",
2395 kdb_current_task->comm,
2396 kdb_current_task->pid);
2401 static int kdb_kgdb(int argc, const char **argv)
2403 return KDB_CMD_KGDB;
2407 * kdb_help - This function implements the 'help' and '?' commands.
2409 static int kdb_help(int argc, const char **argv)
2414 kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2415 kdb_printf("-----------------------------"
2416 "-----------------------------\n");
2417 for_each_kdbcmd(kt, i) {
2419 if (KDB_FLAG(CMD_INTERRUPT))
2423 if (!kdb_check_flags(kt->cmd_flags, kdb_cmd_enabled, true))
2425 if (strlen(kt->cmd_usage) > 20)
2427 kdb_printf("%-15.15s %-20s%s%s\n", kt->cmd_name,
2428 kt->cmd_usage, space, kt->cmd_help);
2434 * kdb_kill - This function implements the 'kill' commands.
2436 static int kdb_kill(int argc, const char **argv)
2440 struct task_struct *p;
2441 struct siginfo info;
2444 return KDB_ARGCOUNT;
2446 sig = simple_strtol(argv[1], &endp, 0);
2450 kdb_printf("Invalid signal parameter.<-signal>\n");
2455 pid = simple_strtol(argv[2], &endp, 0);
2459 kdb_printf("Process ID must be large than 0.\n");
2463 /* Find the process. */
2464 p = find_task_by_pid_ns(pid, &init_pid_ns);
2466 kdb_printf("The specified process isn't found.\n");
2469 p = p->group_leader;
2470 info.si_signo = sig;
2472 info.si_code = SI_USER;
2473 info.si_pid = pid; /* same capabilities as process being signalled */
2474 info.si_uid = 0; /* kdb has root authority */
2475 kdb_send_sig_info(p, &info);
2480 int tm_sec; /* seconds */
2481 int tm_min; /* minutes */
2482 int tm_hour; /* hours */
2483 int tm_mday; /* day of the month */
2484 int tm_mon; /* month */
2485 int tm_year; /* year */
2488 static void kdb_gmtime(struct timespec *tv, struct kdb_tm *tm)
2490 /* This will work from 1970-2099, 2100 is not a leap year */
2491 static int mon_day[] = { 31, 29, 31, 30, 31, 30, 31,
2492 31, 30, 31, 30, 31 };
2493 memset(tm, 0, sizeof(*tm));
2494 tm->tm_sec = tv->tv_sec % (24 * 60 * 60);
2495 tm->tm_mday = tv->tv_sec / (24 * 60 * 60) +
2496 (2 * 365 + 1); /* shift base from 1970 to 1968 */
2497 tm->tm_min = tm->tm_sec / 60 % 60;
2498 tm->tm_hour = tm->tm_sec / 60 / 60;
2499 tm->tm_sec = tm->tm_sec % 60;
2500 tm->tm_year = 68 + 4*(tm->tm_mday / (4*365+1));
2501 tm->tm_mday %= (4*365+1);
2503 while (tm->tm_mday >= mon_day[tm->tm_mon]) {
2504 tm->tm_mday -= mon_day[tm->tm_mon];
2505 if (++tm->tm_mon == 12) {
2515 * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2516 * I cannot call that code directly from kdb, it has an unconditional
2517 * cli()/sti() and calls routines that take locks which can stop the debugger.
2519 static void kdb_sysinfo(struct sysinfo *val)
2521 struct timespec uptime;
2522 ktime_get_ts(&uptime);
2523 memset(val, 0, sizeof(*val));
2524 val->uptime = uptime.tv_sec;
2525 val->loads[0] = avenrun[0];
2526 val->loads[1] = avenrun[1];
2527 val->loads[2] = avenrun[2];
2528 val->procs = nr_threads-1;
2535 * kdb_summary - This function implements the 'summary' command.
2537 static int kdb_summary(int argc, const char **argv)
2539 struct timespec now;
2544 return KDB_ARGCOUNT;
2546 kdb_printf("sysname %s\n", init_uts_ns.name.sysname);
2547 kdb_printf("release %s\n", init_uts_ns.name.release);
2548 kdb_printf("version %s\n", init_uts_ns.name.version);
2549 kdb_printf("machine %s\n", init_uts_ns.name.machine);
2550 kdb_printf("nodename %s\n", init_uts_ns.name.nodename);
2551 kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2552 kdb_printf("ccversion %s\n", __stringify(CCVERSION));
2554 now = __current_kernel_time();
2555 kdb_gmtime(&now, &tm);
2556 kdb_printf("date %04d-%02d-%02d %02d:%02d:%02d "
2557 "tz_minuteswest %d\n",
2558 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2559 tm.tm_hour, tm.tm_min, tm.tm_sec,
2560 sys_tz.tz_minuteswest);
2563 kdb_printf("uptime ");
2564 if (val.uptime > (24*60*60)) {
2565 int days = val.uptime / (24*60*60);
2566 val.uptime %= (24*60*60);
2567 kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2569 kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2571 /* lifted from fs/proc/proc_misc.c::loadavg_read_proc() */
2573 #define LOAD_INT(x) ((x) >> FSHIFT)
2574 #define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
2575 kdb_printf("load avg %ld.%02ld %ld.%02ld %ld.%02ld\n",
2576 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2577 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2578 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2581 /* Display in kilobytes */
2582 #define K(x) ((x) << (PAGE_SHIFT - 10))
2583 kdb_printf("\nMemTotal: %8lu kB\nMemFree: %8lu kB\n"
2584 "Buffers: %8lu kB\n",
2585 K(val.totalram), K(val.freeram), K(val.bufferram));
2590 * kdb_per_cpu - This function implements the 'per_cpu' command.
2592 static int kdb_per_cpu(int argc, const char **argv)
2595 int cpu, diag, nextarg = 1;
2596 unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2598 if (argc < 1 || argc > 3)
2599 return KDB_ARGCOUNT;
2601 diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2606 diag = kdbgetularg(argv[2], &bytesperword);
2611 bytesperword = KDB_WORD_SIZE;
2612 else if (bytesperword > KDB_WORD_SIZE)
2613 return KDB_BADWIDTH;
2614 sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2616 diag = kdbgetularg(argv[3], &whichcpu);
2619 if (!cpu_online(whichcpu)) {
2620 kdb_printf("cpu %ld is not online\n", whichcpu);
2621 return KDB_BADCPUNUM;
2625 /* Most architectures use __per_cpu_offset[cpu], some use
2626 * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2628 #ifdef __per_cpu_offset
2629 #define KDB_PCU(cpu) __per_cpu_offset(cpu)
2632 #define KDB_PCU(cpu) __per_cpu_offset[cpu]
2634 #define KDB_PCU(cpu) 0
2637 for_each_online_cpu(cpu) {
2638 if (KDB_FLAG(CMD_INTERRUPT))
2641 if (whichcpu != ~0UL && whichcpu != cpu)
2643 addr = symaddr + KDB_PCU(cpu);
2644 diag = kdb_getword(&val, addr, bytesperword);
2646 kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2647 "read, diag=%d\n", cpu, addr, diag);
2650 kdb_printf("%5d ", cpu);
2651 kdb_md_line(fmtstr, addr,
2652 bytesperword == KDB_WORD_SIZE,
2653 1, bytesperword, 1, 1, 0);
2660 * display help for the use of cmd | grep pattern
2662 static int kdb_grep_help(int argc, const char **argv)
2664 kdb_printf("Usage of cmd args | grep pattern:\n");
2665 kdb_printf(" Any command's output may be filtered through an ");
2666 kdb_printf("emulated 'pipe'.\n");
2667 kdb_printf(" 'grep' is just a key word.\n");
2668 kdb_printf(" The pattern may include a very limited set of "
2669 "metacharacters:\n");
2670 kdb_printf(" pattern or ^pattern or pattern$ or ^pattern$\n");
2671 kdb_printf(" And if there are spaces in the pattern, you may "
2673 kdb_printf(" \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2674 " or \"^pat tern$\"\n");
2679 * kdb_register_flags - This function is used to register a kernel
2683 * func Function to execute the command
2684 * usage A simple usage string showing arguments
2685 * help A simple help string describing command
2686 * repeat Does the command auto repeat on enter?
2688 * zero for success, one if a duplicate command.
2690 #define kdb_command_extend 50 /* arbitrary */
2691 int kdb_register_flags(char *cmd,
2696 kdb_cmdflags_t flags)
2702 * Brute force method to determine duplicates
2704 for_each_kdbcmd(kp, i) {
2705 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2706 kdb_printf("Duplicate kdb command registered: "
2707 "%s, func %p help %s\n", cmd, func, help);
2713 * Insert command into first available location in table
2715 for_each_kdbcmd(kp, i) {
2716 if (kp->cmd_name == NULL)
2720 if (i >= kdb_max_commands) {
2721 kdbtab_t *new = kmalloc((kdb_max_commands - KDB_BASE_CMD_MAX +
2722 kdb_command_extend) * sizeof(*new), GFP_KDB);
2724 kdb_printf("Could not allocate new kdb_command "
2729 memcpy(new, kdb_commands,
2730 (kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new));
2731 kfree(kdb_commands);
2733 memset(new + kdb_max_commands - KDB_BASE_CMD_MAX, 0,
2734 kdb_command_extend * sizeof(*new));
2736 kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX;
2737 kdb_max_commands += kdb_command_extend;
2741 kp->cmd_func = func;
2742 kp->cmd_usage = usage;
2743 kp->cmd_help = help;
2744 kp->cmd_minlen = minlen;
2745 kp->cmd_flags = flags;
2749 EXPORT_SYMBOL_GPL(kdb_register_flags);
2753 * kdb_register - Compatibility register function for commands that do
2754 * not need to specify a repeat state. Equivalent to
2755 * kdb_register_flags with flags set to 0.
2758 * func Function to execute the command
2759 * usage A simple usage string showing arguments
2760 * help A simple help string describing command
2762 * zero for success, one if a duplicate command.
2764 int kdb_register(char *cmd,
2770 return kdb_register_flags(cmd, func, usage, help, minlen, 0);
2772 EXPORT_SYMBOL_GPL(kdb_register);
2775 * kdb_unregister - This function is used to unregister a kernel
2776 * debugger command. It is generally called when a module which
2777 * implements kdb commands is unloaded.
2781 * zero for success, one command not registered.
2783 int kdb_unregister(char *cmd)
2791 for_each_kdbcmd(kp, i) {
2792 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2793 kp->cmd_name = NULL;
2798 /* Couldn't find it. */
2801 EXPORT_SYMBOL_GPL(kdb_unregister);
2803 /* Initialize the kdb command table. */
2804 static void __init kdb_inittab(void)
2809 for_each_kdbcmd(kp, i)
2810 kp->cmd_name = NULL;
2812 kdb_register_flags("md", kdb_md, "<vaddr>",
2813 "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2814 KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2815 kdb_register_flags("mdr", kdb_md, "<vaddr> <bytes>",
2816 "Display Raw Memory", 0,
2817 KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2818 kdb_register_flags("mdp", kdb_md, "<paddr> <bytes>",
2819 "Display Physical Memory", 0,
2820 KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2821 kdb_register_flags("mds", kdb_md, "<vaddr>",
2822 "Display Memory Symbolically", 0,
2823 KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2824 kdb_register_flags("mm", kdb_mm, "<vaddr> <contents>",
2825 "Modify Memory Contents", 0,
2826 KDB_ENABLE_MEM_WRITE | KDB_REPEAT_NO_ARGS);
2827 kdb_register_flags("go", kdb_go, "[<vaddr>]",
2828 "Continue Execution", 1,
2829 KDB_ENABLE_REG_WRITE | KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
2830 kdb_register_flags("rd", kdb_rd, "",
2831 "Display Registers", 0,
2832 KDB_ENABLE_REG_READ);
2833 kdb_register_flags("rm", kdb_rm, "<reg> <contents>",
2834 "Modify Registers", 0,
2835 KDB_ENABLE_REG_WRITE);
2836 kdb_register_flags("ef", kdb_ef, "<vaddr>",
2837 "Display exception frame", 0,
2838 KDB_ENABLE_MEM_READ);
2839 kdb_register_flags("bt", kdb_bt, "[<vaddr>]",
2840 "Stack traceback", 1,
2841 KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS);
2842 kdb_register_flags("btp", kdb_bt, "<pid>",
2843 "Display stack for process <pid>", 0,
2844 KDB_ENABLE_INSPECT);
2845 kdb_register_flags("bta", kdb_bt, "[D|R|S|T|C|Z|E|U|I|M|A]",
2846 "Backtrace all processes matching state flag", 0,
2847 KDB_ENABLE_INSPECT);
2848 kdb_register_flags("btc", kdb_bt, "",
2849 "Backtrace current process on each cpu", 0,
2850 KDB_ENABLE_INSPECT);
2851 kdb_register_flags("btt", kdb_bt, "<vaddr>",
2852 "Backtrace process given its struct task address", 0,
2853 KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS);
2854 kdb_register_flags("env", kdb_env, "",
2855 "Show environment variables", 0,
2856 KDB_ENABLE_ALWAYS_SAFE);
2857 kdb_register_flags("set", kdb_set, "",
2858 "Set environment variables", 0,
2859 KDB_ENABLE_ALWAYS_SAFE);
2860 kdb_register_flags("help", kdb_help, "",
2861 "Display Help Message", 1,
2862 KDB_ENABLE_ALWAYS_SAFE);
2863 kdb_register_flags("?", kdb_help, "",
2864 "Display Help Message", 0,
2865 KDB_ENABLE_ALWAYS_SAFE);
2866 kdb_register_flags("cpu", kdb_cpu, "<cpunum>",
2867 "Switch to new cpu", 0,
2868 KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
2869 kdb_register_flags("kgdb", kdb_kgdb, "",
2870 "Enter kgdb mode", 0, 0);
2871 kdb_register_flags("ps", kdb_ps, "[<flags>|A]",
2872 "Display active task list", 0,
2873 KDB_ENABLE_INSPECT);
2874 kdb_register_flags("pid", kdb_pid, "<pidnum>",
2875 "Switch to another task", 0,
2876 KDB_ENABLE_INSPECT);
2877 kdb_register_flags("reboot", kdb_reboot, "",
2878 "Reboot the machine immediately", 0,
2880 #if defined(CONFIG_MODULES)
2881 kdb_register_flags("lsmod", kdb_lsmod, "",
2882 "List loaded kernel modules", 0,
2883 KDB_ENABLE_INSPECT);
2885 #if defined(CONFIG_MAGIC_SYSRQ)
2886 kdb_register_flags("sr", kdb_sr, "<key>",
2887 "Magic SysRq key", 0,
2888 KDB_ENABLE_ALWAYS_SAFE);
2890 #if defined(CONFIG_PRINTK)
2891 kdb_register_flags("dmesg", kdb_dmesg, "[lines]",
2892 "Display syslog buffer", 0,
2893 KDB_ENABLE_ALWAYS_SAFE);
2895 if (arch_kgdb_ops.enable_nmi) {
2896 kdb_register_flags("disable_nmi", kdb_disable_nmi, "",
2897 "Disable NMI entry to KDB", 0,
2898 KDB_ENABLE_ALWAYS_SAFE);
2900 kdb_register_flags("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
2901 "Define a set of commands, down to endefcmd", 0,
2902 KDB_ENABLE_ALWAYS_SAFE);
2903 kdb_register_flags("kill", kdb_kill, "<-signal> <pid>",
2904 "Send a signal to a process", 0,
2906 kdb_register_flags("summary", kdb_summary, "",
2907 "Summarize the system", 4,
2908 KDB_ENABLE_ALWAYS_SAFE);
2909 kdb_register_flags("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
2910 "Display per_cpu variables", 3,
2911 KDB_ENABLE_MEM_READ);
2912 kdb_register_flags("grephelp", kdb_grep_help, "",
2913 "Display help on | grep", 0,
2914 KDB_ENABLE_ALWAYS_SAFE);
2917 /* Execute any commands defined in kdb_cmds. */
2918 static void __init kdb_cmd_init(void)
2921 for (i = 0; kdb_cmds[i]; ++i) {
2922 diag = kdb_parse(kdb_cmds[i]);
2924 kdb_printf("kdb command %s failed, kdb diag %d\n",
2927 if (defcmd_in_progress) {
2928 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2929 kdb_parse("endefcmd");
2933 /* Initialize kdb_printf, breakpoint tables and kdb state */
2934 void __init kdb_init(int lvl)
2936 static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2939 if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2941 for (i = kdb_init_lvl; i < lvl; i++) {
2943 case KDB_NOT_INITIALIZED:
2944 kdb_inittab(); /* Initialize Command Table */
2945 kdb_initbptab(); /* Initialize Breakpoints */
2947 case KDB_INIT_EARLY:
2948 kdb_cmd_init(); /* Build kdb_cmds tables */