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/string.h>
16 #include <linux/kernel.h>
17 #include <linux/kmsg_dump.h>
18 #include <linux/reboot.h>
19 #include <linux/sched.h>
20 #include <linux/sysrq.h>
21 #include <linux/smp.h>
22 #include <linux/utsname.h>
23 #include <linux/vmalloc.h>
24 #include <linux/atomic.h>
25 #include <linux/module.h>
27 #include <linux/init.h>
28 #include <linux/kallsyms.h>
29 #include <linux/kgdb.h>
30 #include <linux/kdb.h>
31 #include <linux/notifier.h>
32 #include <linux/interrupt.h>
33 #include <linux/delay.h>
34 #include <linux/nmi.h>
35 #include <linux/time.h>
36 #include <linux/ptrace.h>
37 #include <linux/sysctl.h>
38 #include <linux/cpu.h>
39 #include <linux/kdebug.h>
40 #include <linux/proc_fs.h>
41 #include <linux/uaccess.h>
42 #include <linux/slab.h>
43 #include "kdb_private.h"
46 char kdb_grep_string[GREP_LEN];
47 int kdb_grepping_flag;
48 EXPORT_SYMBOL(kdb_grepping_flag);
50 int kdb_grep_trailing;
53 * Kernel debugger state flags
59 * kdb_lock protects updates to kdb_initial_cpu. Used to
60 * single thread processors through the kernel debugger.
62 int kdb_initial_cpu = -1; /* cpu number that owns kdb */
64 int kdb_state; /* General KDB state */
66 struct task_struct *kdb_current_task;
67 EXPORT_SYMBOL(kdb_current_task);
68 struct pt_regs *kdb_current_regs;
70 const char *kdb_diemsg;
71 static int kdb_go_count;
72 #ifdef CONFIG_KDB_CONTINUE_CATASTROPHIC
73 static unsigned int kdb_continue_catastrophic =
74 CONFIG_KDB_CONTINUE_CATASTROPHIC;
76 static unsigned int kdb_continue_catastrophic;
79 /* kdb_commands describes the available commands. */
80 static kdbtab_t *kdb_commands;
81 #define KDB_BASE_CMD_MAX 50
82 static int kdb_max_commands = KDB_BASE_CMD_MAX;
83 static kdbtab_t kdb_base_commands[KDB_BASE_CMD_MAX];
84 #define for_each_kdbcmd(cmd, num) \
85 for ((cmd) = kdb_base_commands, (num) = 0; \
86 num < kdb_max_commands; \
87 num++, num == KDB_BASE_CMD_MAX ? cmd = kdb_commands : cmd++)
89 typedef struct _kdbmsg {
90 int km_diag; /* kdb diagnostic */
91 char *km_msg; /* Corresponding message text */
94 #define KDBMSG(msgnum, text) \
95 { KDB_##msgnum, text }
97 static kdbmsg_t kdbmsgs[] = {
98 KDBMSG(NOTFOUND, "Command Not Found"),
99 KDBMSG(ARGCOUNT, "Improper argument count, see usage."),
100 KDBMSG(BADWIDTH, "Illegal value for BYTESPERWORD use 1, 2, 4 or 8, "
101 "8 is only allowed on 64 bit systems"),
102 KDBMSG(BADRADIX, "Illegal value for RADIX use 8, 10 or 16"),
103 KDBMSG(NOTENV, "Cannot find environment variable"),
104 KDBMSG(NOENVVALUE, "Environment variable should have value"),
105 KDBMSG(NOTIMP, "Command not implemented"),
106 KDBMSG(ENVFULL, "Environment full"),
107 KDBMSG(ENVBUFFULL, "Environment buffer full"),
108 KDBMSG(TOOMANYBPT, "Too many breakpoints defined"),
109 #ifdef CONFIG_CPU_XSCALE
110 KDBMSG(TOOMANYDBREGS, "More breakpoints than ibcr registers defined"),
112 KDBMSG(TOOMANYDBREGS, "More breakpoints than db registers defined"),
114 KDBMSG(DUPBPT, "Duplicate breakpoint address"),
115 KDBMSG(BPTNOTFOUND, "Breakpoint not found"),
116 KDBMSG(BADMODE, "Invalid IDMODE"),
117 KDBMSG(BADINT, "Illegal numeric value"),
118 KDBMSG(INVADDRFMT, "Invalid symbolic address format"),
119 KDBMSG(BADREG, "Invalid register name"),
120 KDBMSG(BADCPUNUM, "Invalid cpu number"),
121 KDBMSG(BADLENGTH, "Invalid length field"),
122 KDBMSG(NOBP, "No Breakpoint exists"),
123 KDBMSG(BADADDR, "Invalid address"),
127 static const int __nkdb_err = ARRAY_SIZE(kdbmsgs);
131 * Initial environment. This is all kept static and local to
132 * this file. We don't want to rely on the memory allocation
133 * mechanisms in the kernel, so we use a very limited allocate-only
134 * heap for new and altered environment variables. The entire
135 * environment is limited to a fixed number of entries (add more
136 * to __env[] if required) and a fixed amount of heap (add more to
137 * KDB_ENVBUFSIZE if required).
140 static char *__env[] = {
141 #if defined(CONFIG_SMP)
148 "MDCOUNT=8", /* lines of md output */
178 static const int __nenv = ARRAY_SIZE(__env);
180 struct task_struct *kdb_curr_task(int cpu)
182 struct task_struct *p = curr_task(cpu);
184 if ((task_thread_info(p)->flags & _TIF_MCA_INIT) && KDB_TSK(cpu))
191 * kdbgetenv - This function will return the character string value of
192 * an environment variable.
194 * match A character string representing an environment variable.
196 * NULL No environment variable matches 'match'
197 * char* Pointer to string value of environment variable.
199 char *kdbgetenv(const char *match)
202 int matchlen = strlen(match);
205 for (i = 0; i < __nenv; i++) {
211 if ((strncmp(match, e, matchlen) == 0)
212 && ((e[matchlen] == '\0')
213 || (e[matchlen] == '='))) {
214 char *cp = strchr(e, '=');
215 return cp ? ++cp : "";
222 * kdballocenv - This function is used to allocate bytes for
223 * environment entries.
225 * match A character string representing a numeric value
227 * *value the unsigned long representation of the env variable 'match'
229 * Zero on success, a kdb diagnostic on failure.
231 * We use a static environment buffer (envbuffer) to hold the values
232 * of dynamically generated environment variables (see kdb_set). Buffer
233 * space once allocated is never free'd, so over time, the amount of space
234 * (currently 512 bytes) will be exhausted if env variables are changed
237 static char *kdballocenv(size_t bytes)
239 #define KDB_ENVBUFSIZE 512
240 static char envbuffer[KDB_ENVBUFSIZE];
241 static int envbufsize;
244 if ((KDB_ENVBUFSIZE - envbufsize) >= bytes) {
245 ep = &envbuffer[envbufsize];
252 * kdbgetulenv - This function will return the value of an unsigned
253 * long-valued environment variable.
255 * match A character string representing a numeric value
257 * *value the unsigned long represntation of the env variable 'match'
259 * Zero on success, a kdb diagnostic on failure.
261 static int kdbgetulenv(const char *match, unsigned long *value)
265 ep = kdbgetenv(match);
269 return KDB_NOENVVALUE;
271 *value = simple_strtoul(ep, NULL, 0);
277 * kdbgetintenv - This function will return the value of an
278 * integer-valued environment variable.
280 * match A character string representing an integer-valued env variable
282 * *value the integer representation of the environment variable 'match'
284 * Zero on success, a kdb diagnostic on failure.
286 int kdbgetintenv(const char *match, int *value)
291 diag = kdbgetulenv(match, &val);
298 * kdbgetularg - This function will convert a numeric string into an
299 * unsigned long value.
301 * arg A character string representing a numeric value
303 * *value the unsigned long represntation of arg.
305 * Zero on success, a kdb diagnostic on failure.
307 int kdbgetularg(const char *arg, unsigned long *value)
312 val = simple_strtoul(arg, &endp, 0);
316 * Also try base 16, for us folks too lazy to type the
319 val = simple_strtoul(arg, &endp, 16);
329 int kdbgetu64arg(const char *arg, u64 *value)
334 val = simple_strtoull(arg, &endp, 0);
338 val = simple_strtoull(arg, &endp, 16);
349 * kdb_set - This function implements the 'set' command. Alter an
350 * existing environment variable or create a new one.
352 int kdb_set(int argc, const char **argv)
356 size_t varlen, vallen;
359 * we can be invoked two ways:
360 * set var=value argv[1]="var", argv[2]="value"
361 * set var = value argv[1]="var", argv[2]="=", argv[3]="value"
362 * - if the latter, shift 'em down.
373 * Check for internal variables
375 if (strcmp(argv[1], "KDBDEBUG") == 0) {
376 unsigned int debugflags;
379 debugflags = simple_strtoul(argv[2], &cp, 0);
380 if (cp == argv[2] || debugflags & ~KDB_DEBUG_FLAG_MASK) {
381 kdb_printf("kdb: illegal debug flags '%s'\n",
385 kdb_flags = (kdb_flags &
386 ~(KDB_DEBUG_FLAG_MASK << KDB_DEBUG_FLAG_SHIFT))
387 | (debugflags << KDB_DEBUG_FLAG_SHIFT);
393 * Tokenizer squashed the '=' sign. argv[1] is variable
394 * name, argv[2] = value.
396 varlen = strlen(argv[1]);
397 vallen = strlen(argv[2]);
398 ep = kdballocenv(varlen + vallen + 2);
400 return KDB_ENVBUFFULL;
402 sprintf(ep, "%s=%s", argv[1], argv[2]);
404 ep[varlen+vallen+1] = '\0';
406 for (i = 0; i < __nenv; i++) {
408 && ((strncmp(__env[i], argv[1], varlen) == 0)
409 && ((__env[i][varlen] == '\0')
410 || (__env[i][varlen] == '=')))) {
417 * Wasn't existing variable. Fit into slot.
419 for (i = 0; i < __nenv-1; i++) {
420 if (__env[i] == (char *)0) {
429 static int kdb_check_regs(void)
431 if (!kdb_current_regs) {
432 kdb_printf("No current kdb registers."
433 " You may need to select another task\n");
440 * kdbgetaddrarg - This function is responsible for parsing an
441 * address-expression and returning the value of the expression,
442 * symbol name, and offset to the caller.
444 * The argument may consist of a numeric value (decimal or
445 * hexidecimal), a symbol name, a register name (preceded by the
446 * percent sign), an environment variable with a numeric value
447 * (preceded by a dollar sign) or a simple arithmetic expression
448 * consisting of a symbol name, +/-, and a numeric constant value
451 * argc - count of arguments in argv
452 * argv - argument vector
453 * *nextarg - index to next unparsed argument in argv[]
454 * regs - Register state at time of KDB entry
456 * *value - receives the value of the address-expression
457 * *offset - receives the offset specified, if any
458 * *name - receives the symbol name, if any
459 * *nextarg - index to next unparsed argument in argv[]
461 * zero is returned on success, a kdb diagnostic code is
464 int kdbgetaddrarg(int argc, const char **argv, int *nextarg,
465 unsigned long *value, long *offset,
469 unsigned long off = 0;
479 * Process arguments which follow the following syntax:
481 * symbol | numeric-address [+/- numeric-offset]
483 * $environment-variable
489 symname = (char *)argv[*nextarg];
492 * If there is no whitespace between the symbol
493 * or address and the '+' or '-' symbols, we
494 * remember the character and replace it with a
495 * null so the symbol/value can be properly parsed
497 cp = strpbrk(symname, "+-");
503 if (symname[0] == '$') {
504 diag = kdbgetulenv(&symname[1], &addr);
507 } else if (symname[0] == '%') {
508 diag = kdb_check_regs();
511 /* Implement register values with % at a later time as it is
516 found = kdbgetsymval(symname, &symtab);
518 addr = symtab.sym_start;
520 diag = kdbgetularg(argv[*nextarg], &addr);
527 found = kdbnearsym(addr, &symtab);
535 if (offset && name && *name)
536 *offset = addr - symtab.sym_start;
538 if ((*nextarg > argc)
543 * check for +/- and offset
546 if (symbol == '\0') {
547 if ((argv[*nextarg][0] != '+')
548 && (argv[*nextarg][0] != '-')) {
550 * Not our argument. Return.
554 positive = (argv[*nextarg][0] == '+');
558 positive = (symbol == '+');
561 * Now there must be an offset!
563 if ((*nextarg > argc)
564 && (symbol == '\0')) {
565 return KDB_INVADDRFMT;
569 cp = (char *)argv[*nextarg];
573 diag = kdbgetularg(cp, &off);
589 static void kdb_cmderror(int diag)
594 kdb_printf("no error detected (diagnostic is %d)\n", diag);
598 for (i = 0; i < __nkdb_err; i++) {
599 if (kdbmsgs[i].km_diag == diag) {
600 kdb_printf("diag: %d: %s\n", diag, kdbmsgs[i].km_msg);
605 kdb_printf("Unknown diag %d\n", -diag);
609 * kdb_defcmd, kdb_defcmd2 - This function implements the 'defcmd'
610 * command which defines one command as a set of other commands,
611 * terminated by endefcmd. kdb_defcmd processes the initial
612 * 'defcmd' command, kdb_defcmd2 is invoked from kdb_parse for
613 * the following commands until 'endefcmd'.
615 * argc argument count
616 * argv argument vector
618 * zero for success, a kdb diagnostic if error
628 static struct defcmd_set *defcmd_set;
629 static int defcmd_set_count;
630 static int defcmd_in_progress;
632 /* Forward references */
633 static int kdb_exec_defcmd(int argc, const char **argv);
635 static int kdb_defcmd2(const char *cmdstr, const char *argv0)
637 struct defcmd_set *s = defcmd_set + defcmd_set_count - 1;
638 char **save_command = s->command;
639 if (strcmp(argv0, "endefcmd") == 0) {
640 defcmd_in_progress = 0;
644 kdb_register(s->name, kdb_exec_defcmd,
645 s->usage, s->help, 0);
650 s->command = kzalloc((s->count + 1) * sizeof(*(s->command)), GFP_KDB);
652 kdb_printf("Could not allocate new kdb_defcmd table for %s\n",
657 memcpy(s->command, save_command, s->count * sizeof(*(s->command)));
658 s->command[s->count++] = kdb_strdup(cmdstr, GFP_KDB);
663 static int kdb_defcmd(int argc, const char **argv)
665 struct defcmd_set *save_defcmd_set = defcmd_set, *s;
666 if (defcmd_in_progress) {
667 kdb_printf("kdb: nested defcmd detected, assuming missing "
669 kdb_defcmd2("endefcmd", "endefcmd");
673 for (s = defcmd_set; s < defcmd_set + defcmd_set_count; ++s) {
674 kdb_printf("defcmd %s \"%s\" \"%s\"\n", s->name,
676 for (i = 0; i < s->count; ++i)
677 kdb_printf("%s", s->command[i]);
678 kdb_printf("endefcmd\n");
684 if (in_dbg_master()) {
685 kdb_printf("Command only available during kdb_init()\n");
688 defcmd_set = kmalloc((defcmd_set_count + 1) * sizeof(*defcmd_set),
692 memcpy(defcmd_set, save_defcmd_set,
693 defcmd_set_count * sizeof(*defcmd_set));
694 s = defcmd_set + defcmd_set_count;
695 memset(s, 0, sizeof(*s));
697 s->name = kdb_strdup(argv[1], GFP_KDB);
700 s->usage = kdb_strdup(argv[2], GFP_KDB);
703 s->help = kdb_strdup(argv[3], GFP_KDB);
706 if (s->usage[0] == '"') {
707 strcpy(s->usage, argv[2]+1);
708 s->usage[strlen(s->usage)-1] = '\0';
710 if (s->help[0] == '"') {
711 strcpy(s->help, argv[3]+1);
712 s->help[strlen(s->help)-1] = '\0';
715 defcmd_in_progress = 1;
716 kfree(save_defcmd_set);
725 kdb_printf("Could not allocate new defcmd_set entry for %s\n", argv[1]);
726 defcmd_set = save_defcmd_set;
731 * kdb_exec_defcmd - Execute the set of commands associated with this
734 * argc argument count
735 * argv argument vector
737 * zero for success, a kdb diagnostic if error
739 static int kdb_exec_defcmd(int argc, const char **argv)
742 struct defcmd_set *s;
745 for (s = defcmd_set, i = 0; i < defcmd_set_count; ++i, ++s) {
746 if (strcmp(s->name, argv[0]) == 0)
749 if (i == defcmd_set_count) {
750 kdb_printf("kdb_exec_defcmd: could not find commands for %s\n",
754 for (i = 0; i < s->count; ++i) {
755 /* Recursive use of kdb_parse, do not use argv after
758 kdb_printf("[%s]kdb> %s\n", s->name, s->command[i]);
759 ret = kdb_parse(s->command[i]);
766 /* Command history */
767 #define KDB_CMD_HISTORY_COUNT 32
768 #define CMD_BUFLEN 200 /* kdb_printf: max printline
770 static unsigned int cmd_head, cmd_tail;
771 static unsigned int cmdptr;
772 static char cmd_hist[KDB_CMD_HISTORY_COUNT][CMD_BUFLEN];
773 static char cmd_cur[CMD_BUFLEN];
776 * The "str" argument may point to something like | grep xyz
778 static void parse_grep(const char *str)
781 char *cp = (char *)str, *cp2;
783 /* sanity check: we should have been called with the \ first */
789 if (strncmp(cp, "grep ", 5)) {
790 kdb_printf("invalid 'pipe', see grephelp\n");
796 cp2 = strchr(cp, '\n');
798 *cp2 = '\0'; /* remove the trailing newline */
801 kdb_printf("invalid 'pipe', see grephelp\n");
804 /* now cp points to a nonzero length search string */
806 /* allow it be "x y z" by removing the "'s - there must
809 cp2 = strchr(cp, '"');
811 kdb_printf("invalid quoted string, see grephelp\n");
814 *cp2 = '\0'; /* end the string where the 2nd " was */
816 kdb_grep_leading = 0;
818 kdb_grep_leading = 1;
822 kdb_grep_trailing = 0;
823 if (*(cp+len-1) == '$') {
824 kdb_grep_trailing = 1;
830 if (len >= GREP_LEN) {
831 kdb_printf("search string too long\n");
834 strcpy(kdb_grep_string, cp);
840 * kdb_parse - Parse the command line, search the command table for a
841 * matching command and invoke the command function. This
842 * function may be called recursively, if it is, the second call
843 * will overwrite argv and cbuf. It is the caller's
844 * responsibility to save their argv if they recursively call
847 * cmdstr The input command line to be parsed.
848 * regs The registers at the time kdb was entered.
850 * Zero for success, a kdb diagnostic if failure.
852 * Limited to 20 tokens.
854 * Real rudimentary tokenization. Basically only whitespace
855 * is considered a token delimeter (but special consideration
856 * is taken of the '=' sign as used by the 'set' command).
858 * The algorithm used to tokenize the input string relies on
859 * there being at least one whitespace (or otherwise useless)
860 * character between tokens as the character immediately following
861 * the token is altered in-place to a null-byte to terminate the
867 int kdb_parse(const char *cmdstr)
869 static char *argv[MAXARGC];
871 static char cbuf[CMD_BUFLEN+2];
875 int i, escaped, ignore_errors = 0, check_grep;
878 * First tokenize the command string.
881 kdb_grepping_flag = check_grep = 0;
883 if (KDB_FLAG(CMD_INTERRUPT)) {
884 /* Previous command was interrupted, newline must not
885 * repeat the command */
886 KDB_FLAG_CLEAR(CMD_INTERRUPT);
887 KDB_STATE_SET(PAGER);
888 argc = 0; /* no repeat */
891 if (*cp != '\n' && *cp != '\0') {
895 /* skip whitespace */
898 if ((*cp == '\0') || (*cp == '\n') ||
899 (*cp == '#' && !defcmd_in_progress))
901 /* special case: check for | grep pattern */
906 if (cpp >= cbuf + CMD_BUFLEN) {
907 kdb_printf("kdb_parse: command buffer "
908 "overflow, command ignored\n%s\n",
912 if (argc >= MAXARGC - 1) {
913 kdb_printf("kdb_parse: too many arguments, "
914 "command ignored\n%s\n", cmdstr);
920 /* Copy to next unquoted and unescaped
921 * whitespace or '=' */
922 while (*cp && *cp != '\n' &&
923 (escaped || quoted || !isspace(*cp))) {
924 if (cpp >= cbuf + CMD_BUFLEN)
938 else if (*cp == '\'' || *cp == '"')
941 if (*cpp == '=' && !quoted)
945 *cpp++ = '\0'; /* Squash a ws or '=' character */
952 if (defcmd_in_progress) {
953 int result = kdb_defcmd2(cmdstr, argv[0]);
954 if (!defcmd_in_progress) {
955 argc = 0; /* avoid repeat on endefcmd */
960 if (argv[0][0] == '-' && argv[0][1] &&
961 (argv[0][1] < '0' || argv[0][1] > '9')) {
966 for_each_kdbcmd(tp, i) {
969 * If this command is allowed to be abbreviated,
970 * check to see if this is it.
974 && (strlen(argv[0]) <= tp->cmd_minlen)) {
977 tp->cmd_minlen) == 0) {
982 if (strcmp(argv[0], tp->cmd_name) == 0)
988 * If we don't find a command by this name, see if the first
989 * few characters of this match any of the known commands.
990 * e.g., md1c20 should match md.
992 if (i == kdb_max_commands) {
993 for_each_kdbcmd(tp, i) {
997 strlen(tp->cmd_name)) == 0) {
1004 if (i < kdb_max_commands) {
1007 result = (*tp->cmd_func)(argc-1, (const char **)argv);
1008 if (result && ignore_errors && result > KDB_CMD_GO)
1010 KDB_STATE_CLEAR(CMD);
1011 switch (tp->cmd_repeat) {
1012 case KDB_REPEAT_NONE:
1017 case KDB_REPEAT_NO_ARGS:
1022 case KDB_REPEAT_WITH_ARGS:
1029 * If the input with which we were presented does not
1030 * map to an existing command, attempt to parse it as an
1031 * address argument and display the result. Useful for
1032 * obtaining the address of a variable, or the nearest symbol
1033 * to an address contained in a register.
1036 unsigned long value;
1041 if (kdbgetaddrarg(0, (const char **)argv, &nextarg,
1042 &value, &offset, &name)) {
1043 return KDB_NOTFOUND;
1046 kdb_printf("%s = ", argv[0]);
1047 kdb_symbol_print(value, NULL, KDB_SP_DEFAULT);
1054 static int handle_ctrl_cmd(char *cmd)
1059 /* initial situation */
1060 if (cmd_head == cmd_tail)
1064 if (cmdptr != cmd_tail)
1065 cmdptr = (cmdptr-1) % KDB_CMD_HISTORY_COUNT;
1066 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1069 if (cmdptr != cmd_head)
1070 cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT;
1071 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1078 * kdb_reboot - This function implements the 'reboot' command. Reboot
1079 * the system immediately, or loop for ever on failure.
1081 static int kdb_reboot(int argc, const char **argv)
1083 emergency_restart();
1084 kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
1091 static void kdb_dumpregs(struct pt_regs *regs)
1093 int old_lvl = console_loglevel;
1094 console_loglevel = 15;
1099 console_loglevel = old_lvl;
1102 void kdb_set_current_task(struct task_struct *p)
1104 kdb_current_task = p;
1106 if (kdb_task_has_cpu(p)) {
1107 kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p));
1110 kdb_current_regs = NULL;
1114 * kdb_local - The main code for kdb. This routine is invoked on a
1115 * specific processor, it is not global. The main kdb() routine
1116 * ensures that only one processor at a time is in this routine.
1117 * This code is called with the real reason code on the first
1118 * entry to a kdb session, thereafter it is called with reason
1119 * SWITCH, even if the user goes back to the original cpu.
1121 * reason The reason KDB was invoked
1122 * error The hardware-defined error code
1123 * regs The exception frame at time of fault/breakpoint.
1124 * db_result Result code from the break or debug point.
1126 * 0 KDB was invoked for an event which it wasn't responsible
1127 * 1 KDB handled the event for which it was invoked.
1128 * KDB_CMD_GO User typed 'go'.
1129 * KDB_CMD_CPU User switched to another cpu.
1130 * KDB_CMD_SS Single step.
1132 static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs,
1133 kdb_dbtrap_t db_result)
1137 struct task_struct *kdb_current =
1138 kdb_curr_task(raw_smp_processor_id());
1140 KDB_DEBUG_STATE("kdb_local 1", reason);
1142 if (reason == KDB_REASON_DEBUG) {
1143 /* special case below */
1145 kdb_printf("\nEntering kdb (current=0x%p, pid %d) ",
1146 kdb_current, kdb_current ? kdb_current->pid : 0);
1147 #if defined(CONFIG_SMP)
1148 kdb_printf("on processor %d ", raw_smp_processor_id());
1153 case KDB_REASON_DEBUG:
1156 * If re-entering kdb after a single step
1157 * command, don't print the message.
1159 switch (db_result) {
1161 kdb_printf("\nEntering kdb (0x%p, pid %d) ",
1162 kdb_current, kdb_current->pid);
1163 #if defined(CONFIG_SMP)
1164 kdb_printf("on processor %d ", raw_smp_processor_id());
1166 kdb_printf("due to Debug @ " kdb_machreg_fmt "\n",
1167 instruction_pointer(regs));
1172 KDB_DEBUG_STATE("kdb_local 4", reason);
1173 return 1; /* kdba_db_trap did the work */
1175 kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
1182 case KDB_REASON_ENTER:
1183 if (KDB_STATE(KEYBOARD))
1184 kdb_printf("due to Keyboard Entry\n");
1186 kdb_printf("due to KDB_ENTER()\n");
1188 case KDB_REASON_KEYBOARD:
1189 KDB_STATE_SET(KEYBOARD);
1190 kdb_printf("due to Keyboard Entry\n");
1192 case KDB_REASON_ENTER_SLAVE:
1193 /* drop through, slaves only get released via cpu switch */
1194 case KDB_REASON_SWITCH:
1195 kdb_printf("due to cpu switch\n");
1197 case KDB_REASON_OOPS:
1198 kdb_printf("Oops: %s\n", kdb_diemsg);
1199 kdb_printf("due to oops @ " kdb_machreg_fmt "\n",
1200 instruction_pointer(regs));
1203 case KDB_REASON_NMI:
1204 kdb_printf("due to NonMaskable Interrupt @ "
1205 kdb_machreg_fmt "\n",
1206 instruction_pointer(regs));
1209 case KDB_REASON_SSTEP:
1210 case KDB_REASON_BREAK:
1211 kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
1212 reason == KDB_REASON_BREAK ?
1213 "Breakpoint" : "SS trap", instruction_pointer(regs));
1215 * Determine if this breakpoint is one that we
1216 * are interested in.
1218 if (db_result != KDB_DB_BPT) {
1219 kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1221 KDB_DEBUG_STATE("kdb_local 6", reason);
1222 return 0; /* Not for us, dismiss it */
1225 case KDB_REASON_RECURSE:
1226 kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
1227 instruction_pointer(regs));
1230 kdb_printf("kdb: unexpected reason code: %d\n", reason);
1231 KDB_DEBUG_STATE("kdb_local 8", reason);
1232 return 0; /* Not for us, dismiss it */
1237 * Initialize pager context.
1240 KDB_STATE_CLEAR(SUPPRESS);
1244 *(cmd_hist[cmd_head]) = '\0';
1247 #if defined(CONFIG_SMP)
1248 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
1249 raw_smp_processor_id());
1251 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"));
1253 if (defcmd_in_progress)
1254 strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
1257 * Fetch command from keyboard
1259 cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
1260 if (*cmdbuf != '\n') {
1262 if (cmdptr == cmd_head) {
1263 strncpy(cmd_hist[cmd_head], cmd_cur,
1265 *(cmd_hist[cmd_head] +
1266 strlen(cmd_hist[cmd_head])-1) = '\0';
1268 if (!handle_ctrl_cmd(cmdbuf))
1269 *(cmd_cur+strlen(cmd_cur)-1) = '\0';
1271 goto do_full_getstr;
1273 strncpy(cmd_hist[cmd_head], cmd_cur,
1277 cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
1278 if (cmd_head == cmd_tail)
1279 cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
1283 diag = kdb_parse(cmdbuf);
1284 if (diag == KDB_NOTFOUND) {
1285 kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
1288 if (diag == KDB_CMD_GO
1289 || diag == KDB_CMD_CPU
1290 || diag == KDB_CMD_SS
1291 || diag == KDB_CMD_KGDB)
1297 KDB_DEBUG_STATE("kdb_local 9", diag);
1303 * kdb_print_state - Print the state data for the current processor
1306 * text Identifies the debug point
1307 * value Any integer value to be printed, e.g. reason code.
1309 void kdb_print_state(const char *text, int value)
1311 kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1312 text, raw_smp_processor_id(), value, kdb_initial_cpu,
1317 * kdb_main_loop - After initial setup and assignment of the
1318 * controlling cpu, all cpus are in this loop. One cpu is in
1319 * control and will issue the kdb prompt, the others will spin
1320 * until 'go' or cpu switch.
1322 * To get a consistent view of the kernel stacks for all
1323 * processes, this routine is invoked from the main kdb code via
1324 * an architecture specific routine. kdba_main_loop is
1325 * responsible for making the kernel stacks consistent for all
1326 * processes, there should be no difference between a blocked
1327 * process and a running process as far as kdb is concerned.
1329 * reason The reason KDB was invoked
1330 * error The hardware-defined error code
1331 * reason2 kdb's current reason code.
1332 * Initially error but can change
1333 * according to kdb state.
1334 * db_result Result code from break or debug point.
1335 * regs The exception frame at time of fault/breakpoint.
1336 * should always be valid.
1338 * 0 KDB was invoked for an event which it wasn't responsible
1339 * 1 KDB handled the event for which it was invoked.
1341 int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
1342 kdb_dbtrap_t db_result, struct pt_regs *regs)
1345 /* Stay in kdb() until 'go', 'ss[b]' or an error */
1348 * All processors except the one that is in control
1351 KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1352 while (KDB_STATE(HOLD_CPU)) {
1353 /* state KDB is turned off by kdb_cpu to see if the
1354 * other cpus are still live, each cpu in this loop
1357 if (!KDB_STATE(KDB))
1361 KDB_STATE_CLEAR(SUPPRESS);
1362 KDB_DEBUG_STATE("kdb_main_loop 2", reason);
1363 if (KDB_STATE(LEAVING))
1364 break; /* Another cpu said 'go' */
1365 /* Still using kdb, this processor is in control */
1366 result = kdb_local(reason2, error, regs, db_result);
1367 KDB_DEBUG_STATE("kdb_main_loop 3", result);
1369 if (result == KDB_CMD_CPU)
1372 if (result == KDB_CMD_SS) {
1373 KDB_STATE_SET(DOING_SS);
1377 if (result == KDB_CMD_KGDB) {
1378 if (!KDB_STATE(DOING_KGDB))
1379 kdb_printf("Entering please attach debugger "
1380 "or use $D#44+ or $3#33\n");
1383 if (result && result != 1 && result != KDB_CMD_GO)
1384 kdb_printf("\nUnexpected kdb_local return code %d\n",
1386 KDB_DEBUG_STATE("kdb_main_loop 4", reason);
1389 if (KDB_STATE(DOING_SS))
1390 KDB_STATE_CLEAR(SSBPT);
1392 /* Clean up any keyboard devices before leaving */
1393 kdb_kbd_cleanup_state();
1399 * kdb_mdr - This function implements the guts of the 'mdr', memory
1401 * mdr <addr arg>,<byte count>
1403 * addr Start address
1404 * count Number of bytes
1406 * Always 0. Any errors are detected and printed by kdb_getarea.
1408 static int kdb_mdr(unsigned long addr, unsigned int count)
1412 if (kdb_getarea(c, addr))
1414 kdb_printf("%02x", c);
1422 * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1423 * 'md8' 'mdr' and 'mds' commands.
1425 * md|mds [<addr arg> [<line count> [<radix>]]]
1426 * mdWcN [<addr arg> [<line count> [<radix>]]]
1427 * where W = is the width (1, 2, 4 or 8) and N is the count.
1428 * for eg., md1c20 reads 20 bytes, 1 at a time.
1429 * mdr <addr arg>,<byte count>
1431 static void kdb_md_line(const char *fmtstr, unsigned long addr,
1432 int symbolic, int nosect, int bytesperword,
1433 int num, int repeat, int phys)
1435 /* print just one line of data */
1436 kdb_symtab_t symtab;
1442 memset(cbuf, '\0', sizeof(cbuf));
1444 kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1446 kdb_printf(kdb_machreg_fmt0 " ", addr);
1448 for (i = 0; i < num && repeat--; i++) {
1450 if (kdb_getphysword(&word, addr, bytesperword))
1452 } else if (kdb_getword(&word, addr, bytesperword))
1454 kdb_printf(fmtstr, word);
1456 kdbnearsym(word, &symtab);
1458 memset(&symtab, 0, sizeof(symtab));
1459 if (symtab.sym_name) {
1460 kdb_symbol_print(word, &symtab, 0);
1463 kdb_printf(" %s %s "
1466 kdb_machreg_fmt, symtab.mod_name,
1467 symtab.sec_name, symtab.sec_start,
1468 symtab.sym_start, symtab.sym_end);
1470 addr += bytesperword;
1478 cp = wc.c + 8 - bytesperword;
1483 #define printable_char(c) \
1484 ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1485 switch (bytesperword) {
1487 *c++ = printable_char(*cp++);
1488 *c++ = printable_char(*cp++);
1489 *c++ = printable_char(*cp++);
1490 *c++ = printable_char(*cp++);
1493 *c++ = printable_char(*cp++);
1494 *c++ = printable_char(*cp++);
1497 *c++ = printable_char(*cp++);
1500 *c++ = printable_char(*cp++);
1504 #undef printable_char
1507 kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1511 static int kdb_md(int argc, const char **argv)
1513 static unsigned long last_addr;
1514 static int last_radix, last_bytesperword, last_repeat;
1515 int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1517 char fmtchar, fmtstr[64];
1525 kdbgetintenv("MDCOUNT", &mdcount);
1526 kdbgetintenv("RADIX", &radix);
1527 kdbgetintenv("BYTESPERWORD", &bytesperword);
1529 /* Assume 'md <addr>' and start with environment values */
1530 repeat = mdcount * 16 / bytesperword;
1532 if (strcmp(argv[0], "mdr") == 0) {
1534 return KDB_ARGCOUNT;
1536 } else if (isdigit(argv[0][2])) {
1537 bytesperword = (int)(argv[0][2] - '0');
1538 if (bytesperword == 0) {
1539 bytesperword = last_bytesperword;
1540 if (bytesperword == 0)
1543 last_bytesperword = bytesperword;
1544 repeat = mdcount * 16 / bytesperword;
1547 else if (argv[0][3] == 'c' && argv[0][4]) {
1549 repeat = simple_strtoul(argv[0] + 4, &p, 10);
1550 mdcount = ((repeat * bytesperword) + 15) / 16;
1553 last_repeat = repeat;
1554 } else if (strcmp(argv[0], "md") == 0)
1556 else if (strcmp(argv[0], "mds") == 0)
1558 else if (strcmp(argv[0], "mdp") == 0) {
1562 return KDB_NOTFOUND;
1566 return KDB_ARGCOUNT;
1569 bytesperword = last_bytesperword;
1570 repeat = last_repeat;
1571 mdcount = ((repeat * bytesperword) + 15) / 16;
1576 int diag, nextarg = 1;
1577 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1581 if (argc > nextarg+2)
1582 return KDB_ARGCOUNT;
1584 if (argc >= nextarg) {
1585 diag = kdbgetularg(argv[nextarg], &val);
1587 mdcount = (int) val;
1588 repeat = mdcount * 16 / bytesperword;
1591 if (argc >= nextarg+1) {
1592 diag = kdbgetularg(argv[nextarg+1], &val);
1598 if (strcmp(argv[0], "mdr") == 0)
1599 return kdb_mdr(addr, mdcount);
1612 return KDB_BADRADIX;
1617 if (bytesperword > KDB_WORD_SIZE)
1618 return KDB_BADWIDTH;
1620 switch (bytesperword) {
1622 sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1625 sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1628 sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1631 sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1634 return KDB_BADWIDTH;
1637 last_repeat = repeat;
1638 last_bytesperword = bytesperword;
1640 if (strcmp(argv[0], "mds") == 0) {
1642 /* Do not save these changes as last_*, they are temporary mds
1645 bytesperword = KDB_WORD_SIZE;
1647 kdbgetintenv("NOSECT", &nosect);
1650 /* Round address down modulo BYTESPERWORD */
1652 addr &= ~(bytesperword-1);
1654 while (repeat > 0) {
1656 int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1658 if (KDB_FLAG(CMD_INTERRUPT))
1660 for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1662 if (kdb_getphysword(&word, a, bytesperword)
1665 } else if (kdb_getword(&word, a, bytesperword) || word)
1668 n = min(num, repeat);
1669 kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1671 addr += bytesperword * n;
1673 z = (z + num - 1) / num;
1675 int s = num * (z-2);
1676 kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1677 " zero suppressed\n",
1678 addr, addr + bytesperword * s - 1);
1679 addr += bytesperword * s;
1689 * kdb_mm - This function implements the 'mm' command.
1690 * mm address-expression new-value
1692 * mm works on machine words, mmW works on bytes.
1694 static int kdb_mm(int argc, const char **argv)
1699 unsigned long contents;
1703 if (argv[0][2] && !isdigit(argv[0][2]))
1704 return KDB_NOTFOUND;
1707 return KDB_ARGCOUNT;
1710 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1715 return KDB_ARGCOUNT;
1716 diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1720 if (nextarg != argc + 1)
1721 return KDB_ARGCOUNT;
1723 width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1724 diag = kdb_putword(addr, contents, width);
1728 kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1734 * kdb_go - This function implements the 'go' command.
1735 * go [address-expression]
1737 static int kdb_go(int argc, const char **argv)
1744 if (raw_smp_processor_id() != kdb_initial_cpu) {
1745 kdb_printf("go must execute on the entry cpu, "
1746 "please use \"cpu %d\" and then execute go\n",
1748 return KDB_BADCPUNUM;
1752 diag = kdbgetaddrarg(argc, argv, &nextarg,
1753 &addr, &offset, NULL);
1757 return KDB_ARGCOUNT;
1761 if (KDB_FLAG(CATASTROPHIC)) {
1762 kdb_printf("Catastrophic error detected\n");
1763 kdb_printf("kdb_continue_catastrophic=%d, ",
1764 kdb_continue_catastrophic);
1765 if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1766 kdb_printf("type go a second time if you really want "
1770 if (kdb_continue_catastrophic == 2) {
1771 kdb_printf("forcing reboot\n");
1772 kdb_reboot(0, NULL);
1774 kdb_printf("attempting to continue\n");
1780 * kdb_rd - This function implements the 'rd' command.
1782 static int kdb_rd(int argc, const char **argv)
1784 int len = kdb_check_regs();
1785 #if DBG_MAX_REG_NUM > 0
1797 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1798 rsize = dbg_reg_def[i].size * 2;
1801 if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
1806 len += kdb_printf(" ");
1807 switch(dbg_reg_def[i].size * 8) {
1809 rname = dbg_get_reg(i, ®8, kdb_current_regs);
1812 len += kdb_printf("%s: %02x", rname, reg8);
1815 rname = dbg_get_reg(i, ®16, kdb_current_regs);
1818 len += kdb_printf("%s: %04x", rname, reg16);
1821 rname = dbg_get_reg(i, ®32, kdb_current_regs);
1824 len += kdb_printf("%s: %08x", rname, reg32);
1827 rname = dbg_get_reg(i, ®64, kdb_current_regs);
1830 len += kdb_printf("%s: %016llx", rname, reg64);
1833 len += kdb_printf("%s: ??", dbg_reg_def[i].name);
1841 kdb_dumpregs(kdb_current_regs);
1847 * kdb_rm - This function implements the 'rm' (register modify) command.
1848 * rm register-name new-contents
1850 * Allows register modification with the same restrictions as gdb
1852 static int kdb_rm(int argc, const char **argv)
1854 #if DBG_MAX_REG_NUM > 0
1864 return KDB_ARGCOUNT;
1866 * Allow presence or absence of leading '%' symbol.
1872 diag = kdbgetu64arg(argv[2], ®64);
1876 diag = kdb_check_regs();
1881 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1882 if (strcmp(rname, dbg_reg_def[i].name) == 0) {
1888 switch(dbg_reg_def[i].size * 8) {
1891 dbg_set_reg(i, ®8, kdb_current_regs);
1895 dbg_set_reg(i, ®16, kdb_current_regs);
1899 dbg_set_reg(i, ®32, kdb_current_regs);
1902 dbg_set_reg(i, ®64, kdb_current_regs);
1908 kdb_printf("ERROR: Register set currently not implemented\n");
1913 #if defined(CONFIG_MAGIC_SYSRQ)
1915 * kdb_sr - This function implements the 'sr' (SYSRQ key) command
1916 * which interfaces to the soi-disant MAGIC SYSRQ functionality.
1917 * sr <magic-sysrq-code>
1919 static int kdb_sr(int argc, const char **argv)
1922 return KDB_ARGCOUNT;
1924 __handle_sysrq(*argv[1], false);
1929 #endif /* CONFIG_MAGIC_SYSRQ */
1932 * kdb_ef - This function implements the 'regs' (display exception
1933 * frame) command. This command takes an address and expects to
1934 * find an exception frame at that address, formats and prints
1936 * regs address-expression
1940 static int kdb_ef(int argc, const char **argv)
1948 return KDB_ARGCOUNT;
1951 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1954 show_regs((struct pt_regs *)addr);
1958 #if defined(CONFIG_MODULES)
1960 * kdb_lsmod - This function implements the 'lsmod' command. Lists
1961 * currently loaded kernel modules.
1962 * Mostly taken from userland lsmod.
1964 static int kdb_lsmod(int argc, const char **argv)
1969 return KDB_ARGCOUNT;
1971 kdb_printf("Module Size modstruct Used by\n");
1972 list_for_each_entry(mod, kdb_modules, list) {
1973 if (mod->state == MODULE_STATE_UNFORMED)
1976 kdb_printf("%-20s%8u 0x%p ", mod->name,
1977 mod->core_size, (void *)mod);
1978 #ifdef CONFIG_MODULE_UNLOAD
1979 kdb_printf("%4ld ", module_refcount(mod));
1981 if (mod->state == MODULE_STATE_GOING)
1982 kdb_printf(" (Unloading)");
1983 else if (mod->state == MODULE_STATE_COMING)
1984 kdb_printf(" (Loading)");
1986 kdb_printf(" (Live)");
1987 kdb_printf(" 0x%p", mod->module_core);
1989 #ifdef CONFIG_MODULE_UNLOAD
1991 struct module_use *use;
1993 list_for_each_entry(use, &mod->source_list,
1995 kdb_printf("%s ", use->target->name);
2004 #endif /* CONFIG_MODULES */
2007 * kdb_env - This function implements the 'env' command. Display the
2008 * current environment variables.
2011 static int kdb_env(int argc, const char **argv)
2015 for (i = 0; i < __nenv; i++) {
2017 kdb_printf("%s\n", __env[i]);
2020 if (KDB_DEBUG(MASK))
2021 kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
2026 #ifdef CONFIG_PRINTK
2028 * kdb_dmesg - This function implements the 'dmesg' command to display
2029 * the contents of the syslog buffer.
2030 * dmesg [lines] [adjust]
2032 static int kdb_dmesg(int argc, const char **argv)
2040 struct kmsg_dumper dumper = { .active = 1 };
2045 return KDB_ARGCOUNT;
2048 lines = simple_strtol(argv[1], &cp, 0);
2052 adjust = simple_strtoul(argv[2], &cp, 0);
2053 if (*cp || adjust < 0)
2058 /* disable LOGGING if set */
2059 diag = kdbgetintenv("LOGGING", &logging);
2060 if (!diag && logging) {
2061 const char *setargs[] = { "set", "LOGGING", "0" };
2062 kdb_set(2, setargs);
2065 kmsg_dump_rewind_nolock(&dumper);
2066 while (kmsg_dump_get_line_nolock(&dumper, 1, NULL, 0, NULL))
2071 kdb_printf("buffer only contains %d lines, nothing "
2073 else if (adjust - lines >= n)
2074 kdb_printf("buffer only contains %d lines, last %d "
2075 "lines printed\n", n, n - adjust);
2078 } else if (lines > 0) {
2079 skip = n - lines - adjust;
2082 kdb_printf("buffer only contains %d lines, "
2083 "nothing printed\n", n);
2085 } else if (skip < 0) {
2088 kdb_printf("buffer only contains %d lines, first "
2089 "%d lines printed\n", n, lines);
2095 if (skip >= n || skip < 0)
2098 kmsg_dump_rewind_nolock(&dumper);
2099 while (kmsg_dump_get_line_nolock(&dumper, 1, buf, sizeof(buf), &len)) {
2106 if (KDB_FLAG(CMD_INTERRUPT))
2109 kdb_printf("%.*s\n", (int)len - 1, buf);
2114 #endif /* CONFIG_PRINTK */
2116 /* Make sure we balance enable/disable calls, must disable first. */
2117 static atomic_t kdb_nmi_disabled;
2119 static int kdb_disable_nmi(int argc, const char *argv[])
2121 if (atomic_read(&kdb_nmi_disabled))
2123 atomic_set(&kdb_nmi_disabled, 1);
2124 arch_kgdb_ops.enable_nmi(0);
2128 static int kdb_param_enable_nmi(const char *val, const struct kernel_param *kp)
2130 if (!atomic_add_unless(&kdb_nmi_disabled, -1, 0))
2132 arch_kgdb_ops.enable_nmi(1);
2136 static const struct kernel_param_ops kdb_param_ops_enable_nmi = {
2137 .set = kdb_param_enable_nmi,
2139 module_param_cb(enable_nmi, &kdb_param_ops_enable_nmi, NULL, 0600);
2142 * kdb_cpu - This function implements the 'cpu' command.
2145 * KDB_CMD_CPU for success, a kdb diagnostic if error
2147 static void kdb_cpu_status(void)
2149 int i, start_cpu, first_print = 1;
2150 char state, prev_state = '?';
2152 kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2153 kdb_printf("Available cpus: ");
2154 for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2155 if (!cpu_online(i)) {
2156 state = 'F'; /* cpu is offline */
2158 state = ' '; /* cpu is responding to kdb */
2159 if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2160 state = 'I'; /* idle task */
2162 if (state != prev_state) {
2163 if (prev_state != '?') {
2167 kdb_printf("%d", start_cpu);
2168 if (start_cpu < i-1)
2169 kdb_printf("-%d", i-1);
2170 if (prev_state != ' ')
2171 kdb_printf("(%c)", prev_state);
2177 /* print the trailing cpus, ignoring them if they are all offline */
2178 if (prev_state != 'F') {
2181 kdb_printf("%d", start_cpu);
2182 if (start_cpu < i-1)
2183 kdb_printf("-%d", i-1);
2184 if (prev_state != ' ')
2185 kdb_printf("(%c)", prev_state);
2190 static int kdb_cpu(int argc, const char **argv)
2192 unsigned long cpunum;
2201 return KDB_ARGCOUNT;
2203 diag = kdbgetularg(argv[1], &cpunum);
2210 if ((cpunum > NR_CPUS) || !cpu_online(cpunum))
2211 return KDB_BADCPUNUM;
2213 dbg_switch_cpu = cpunum;
2216 * Switch to other cpu
2221 /* The user may not realize that ps/bta with no parameters does not print idle
2222 * or sleeping system daemon processes, so tell them how many were suppressed.
2224 void kdb_ps_suppressed(void)
2226 int idle = 0, daemon = 0;
2227 unsigned long mask_I = kdb_task_state_string("I"),
2228 mask_M = kdb_task_state_string("M");
2230 const struct task_struct *p, *g;
2231 for_each_online_cpu(cpu) {
2232 p = kdb_curr_task(cpu);
2233 if (kdb_task_state(p, mask_I))
2236 kdb_do_each_thread(g, p) {
2237 if (kdb_task_state(p, mask_M))
2239 } kdb_while_each_thread(g, p);
2240 if (idle || daemon) {
2242 kdb_printf("%d idle process%s (state I)%s\n",
2243 idle, idle == 1 ? "" : "es",
2244 daemon ? " and " : "");
2246 kdb_printf("%d sleeping system daemon (state M) "
2247 "process%s", daemon,
2248 daemon == 1 ? "" : "es");
2249 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2254 * kdb_ps - This function implements the 'ps' command which shows a
2255 * list of the active processes.
2256 * ps [DRSTCZEUIMA] All processes, optionally filtered by state
2258 void kdb_ps1(const struct task_struct *p)
2263 if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
2266 cpu = kdb_process_cpu(p);
2267 kdb_printf("0x%p %8d %8d %d %4d %c 0x%p %c%s\n",
2268 (void *)p, p->pid, p->parent->pid,
2269 kdb_task_has_cpu(p), kdb_process_cpu(p),
2270 kdb_task_state_char(p),
2271 (void *)(&p->thread),
2272 p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2274 if (kdb_task_has_cpu(p)) {
2275 if (!KDB_TSK(cpu)) {
2276 kdb_printf(" Error: no saved data for this cpu\n");
2278 if (KDB_TSK(cpu) != p)
2279 kdb_printf(" Error: does not match running "
2280 "process table (0x%p)\n", KDB_TSK(cpu));
2285 static int kdb_ps(int argc, const char **argv)
2287 struct task_struct *g, *p;
2288 unsigned long mask, cpu;
2291 kdb_ps_suppressed();
2292 kdb_printf("%-*s Pid Parent [*] cpu State %-*s Command\n",
2293 (int)(2*sizeof(void *))+2, "Task Addr",
2294 (int)(2*sizeof(void *))+2, "Thread");
2295 mask = kdb_task_state_string(argc ? argv[1] : NULL);
2296 /* Run the active tasks first */
2297 for_each_online_cpu(cpu) {
2298 if (KDB_FLAG(CMD_INTERRUPT))
2300 p = kdb_curr_task(cpu);
2301 if (kdb_task_state(p, mask))
2305 /* Now the real tasks */
2306 kdb_do_each_thread(g, p) {
2307 if (KDB_FLAG(CMD_INTERRUPT))
2309 if (kdb_task_state(p, mask))
2311 } kdb_while_each_thread(g, p);
2317 * kdb_pid - This function implements the 'pid' command which switches
2318 * the currently active process.
2321 static int kdb_pid(int argc, const char **argv)
2323 struct task_struct *p;
2328 return KDB_ARGCOUNT;
2331 if (strcmp(argv[1], "R") == 0) {
2332 p = KDB_TSK(kdb_initial_cpu);
2334 diag = kdbgetularg(argv[1], &val);
2338 p = find_task_by_pid_ns((pid_t)val, &init_pid_ns);
2340 kdb_printf("No task with pid=%d\n", (pid_t)val);
2344 kdb_set_current_task(p);
2346 kdb_printf("KDB current process is %s(pid=%d)\n",
2347 kdb_current_task->comm,
2348 kdb_current_task->pid);
2353 static int kdb_kgdb(int argc, const char **argv)
2355 return KDB_CMD_KGDB;
2359 * kdb_help - This function implements the 'help' and '?' commands.
2361 static int kdb_help(int argc, const char **argv)
2366 kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2367 kdb_printf("-----------------------------"
2368 "-----------------------------\n");
2369 for_each_kdbcmd(kt, i) {
2371 if (KDB_FLAG(CMD_INTERRUPT))
2375 if (strlen(kt->cmd_usage) > 20)
2377 kdb_printf("%-15.15s %-20s%s%s\n", kt->cmd_name,
2378 kt->cmd_usage, space, kt->cmd_help);
2384 * kdb_kill - This function implements the 'kill' commands.
2386 static int kdb_kill(int argc, const char **argv)
2390 struct task_struct *p;
2391 struct siginfo info;
2394 return KDB_ARGCOUNT;
2396 sig = simple_strtol(argv[1], &endp, 0);
2400 kdb_printf("Invalid signal parameter.<-signal>\n");
2405 pid = simple_strtol(argv[2], &endp, 0);
2409 kdb_printf("Process ID must be large than 0.\n");
2413 /* Find the process. */
2414 p = find_task_by_pid_ns(pid, &init_pid_ns);
2416 kdb_printf("The specified process isn't found.\n");
2419 p = p->group_leader;
2420 info.si_signo = sig;
2422 info.si_code = SI_USER;
2423 info.si_pid = pid; /* same capabilities as process being signalled */
2424 info.si_uid = 0; /* kdb has root authority */
2425 kdb_send_sig_info(p, &info);
2430 int tm_sec; /* seconds */
2431 int tm_min; /* minutes */
2432 int tm_hour; /* hours */
2433 int tm_mday; /* day of the month */
2434 int tm_mon; /* month */
2435 int tm_year; /* year */
2438 static void kdb_gmtime(struct timespec *tv, struct kdb_tm *tm)
2440 /* This will work from 1970-2099, 2100 is not a leap year */
2441 static int mon_day[] = { 31, 29, 31, 30, 31, 30, 31,
2442 31, 30, 31, 30, 31 };
2443 memset(tm, 0, sizeof(*tm));
2444 tm->tm_sec = tv->tv_sec % (24 * 60 * 60);
2445 tm->tm_mday = tv->tv_sec / (24 * 60 * 60) +
2446 (2 * 365 + 1); /* shift base from 1970 to 1968 */
2447 tm->tm_min = tm->tm_sec / 60 % 60;
2448 tm->tm_hour = tm->tm_sec / 60 / 60;
2449 tm->tm_sec = tm->tm_sec % 60;
2450 tm->tm_year = 68 + 4*(tm->tm_mday / (4*365+1));
2451 tm->tm_mday %= (4*365+1);
2453 while (tm->tm_mday >= mon_day[tm->tm_mon]) {
2454 tm->tm_mday -= mon_day[tm->tm_mon];
2455 if (++tm->tm_mon == 12) {
2465 * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2466 * I cannot call that code directly from kdb, it has an unconditional
2467 * cli()/sti() and calls routines that take locks which can stop the debugger.
2469 static void kdb_sysinfo(struct sysinfo *val)
2471 struct timespec uptime;
2472 do_posix_clock_monotonic_gettime(&uptime);
2473 memset(val, 0, sizeof(*val));
2474 val->uptime = uptime.tv_sec;
2475 val->loads[0] = avenrun[0];
2476 val->loads[1] = avenrun[1];
2477 val->loads[2] = avenrun[2];
2478 val->procs = nr_threads-1;
2485 * kdb_summary - This function implements the 'summary' command.
2487 static int kdb_summary(int argc, const char **argv)
2489 struct timespec now;
2494 return KDB_ARGCOUNT;
2496 kdb_printf("sysname %s\n", init_uts_ns.name.sysname);
2497 kdb_printf("release %s\n", init_uts_ns.name.release);
2498 kdb_printf("version %s\n", init_uts_ns.name.version);
2499 kdb_printf("machine %s\n", init_uts_ns.name.machine);
2500 kdb_printf("nodename %s\n", init_uts_ns.name.nodename);
2501 kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2502 kdb_printf("ccversion %s\n", __stringify(CCVERSION));
2504 now = __current_kernel_time();
2505 kdb_gmtime(&now, &tm);
2506 kdb_printf("date %04d-%02d-%02d %02d:%02d:%02d "
2507 "tz_minuteswest %d\n",
2508 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2509 tm.tm_hour, tm.tm_min, tm.tm_sec,
2510 sys_tz.tz_minuteswest);
2513 kdb_printf("uptime ");
2514 if (val.uptime > (24*60*60)) {
2515 int days = val.uptime / (24*60*60);
2516 val.uptime %= (24*60*60);
2517 kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2519 kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2521 /* lifted from fs/proc/proc_misc.c::loadavg_read_proc() */
2523 #define LOAD_INT(x) ((x) >> FSHIFT)
2524 #define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
2525 kdb_printf("load avg %ld.%02ld %ld.%02ld %ld.%02ld\n",
2526 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2527 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2528 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2531 /* Display in kilobytes */
2532 #define K(x) ((x) << (PAGE_SHIFT - 10))
2533 kdb_printf("\nMemTotal: %8lu kB\nMemFree: %8lu kB\n"
2534 "Buffers: %8lu kB\n",
2535 K(val.totalram), K(val.freeram), K(val.bufferram));
2540 * kdb_per_cpu - This function implements the 'per_cpu' command.
2542 static int kdb_per_cpu(int argc, const char **argv)
2545 int cpu, diag, nextarg = 1;
2546 unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2548 if (argc < 1 || argc > 3)
2549 return KDB_ARGCOUNT;
2551 diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2556 diag = kdbgetularg(argv[2], &bytesperword);
2561 bytesperword = KDB_WORD_SIZE;
2562 else if (bytesperword > KDB_WORD_SIZE)
2563 return KDB_BADWIDTH;
2564 sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2566 diag = kdbgetularg(argv[3], &whichcpu);
2569 if (!cpu_online(whichcpu)) {
2570 kdb_printf("cpu %ld is not online\n", whichcpu);
2571 return KDB_BADCPUNUM;
2575 /* Most architectures use __per_cpu_offset[cpu], some use
2576 * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2578 #ifdef __per_cpu_offset
2579 #define KDB_PCU(cpu) __per_cpu_offset(cpu)
2582 #define KDB_PCU(cpu) __per_cpu_offset[cpu]
2584 #define KDB_PCU(cpu) 0
2587 for_each_online_cpu(cpu) {
2588 if (KDB_FLAG(CMD_INTERRUPT))
2591 if (whichcpu != ~0UL && whichcpu != cpu)
2593 addr = symaddr + KDB_PCU(cpu);
2594 diag = kdb_getword(&val, addr, bytesperword);
2596 kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2597 "read, diag=%d\n", cpu, addr, diag);
2600 kdb_printf("%5d ", cpu);
2601 kdb_md_line(fmtstr, addr,
2602 bytesperword == KDB_WORD_SIZE,
2603 1, bytesperword, 1, 1, 0);
2610 * display help for the use of cmd | grep pattern
2612 static int kdb_grep_help(int argc, const char **argv)
2614 kdb_printf("Usage of cmd args | grep pattern:\n");
2615 kdb_printf(" Any command's output may be filtered through an ");
2616 kdb_printf("emulated 'pipe'.\n");
2617 kdb_printf(" 'grep' is just a key word.\n");
2618 kdb_printf(" The pattern may include a very limited set of "
2619 "metacharacters:\n");
2620 kdb_printf(" pattern or ^pattern or pattern$ or ^pattern$\n");
2621 kdb_printf(" And if there are spaces in the pattern, you may "
2623 kdb_printf(" \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2624 " or \"^pat tern$\"\n");
2629 * kdb_register_repeat - This function is used to register a kernel
2633 * func Function to execute the command
2634 * usage A simple usage string showing arguments
2635 * help A simple help string describing command
2636 * repeat Does the command auto repeat on enter?
2638 * zero for success, one if a duplicate command.
2640 #define kdb_command_extend 50 /* arbitrary */
2641 int kdb_register_repeat(char *cmd,
2646 kdb_repeat_t repeat)
2652 * Brute force method to determine duplicates
2654 for_each_kdbcmd(kp, i) {
2655 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2656 kdb_printf("Duplicate kdb command registered: "
2657 "%s, func %p help %s\n", cmd, func, help);
2663 * Insert command into first available location in table
2665 for_each_kdbcmd(kp, i) {
2666 if (kp->cmd_name == NULL)
2670 if (i >= kdb_max_commands) {
2671 kdbtab_t *new = kmalloc((kdb_max_commands - KDB_BASE_CMD_MAX +
2672 kdb_command_extend) * sizeof(*new), GFP_KDB);
2674 kdb_printf("Could not allocate new kdb_command "
2679 memcpy(new, kdb_commands,
2680 (kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new));
2681 kfree(kdb_commands);
2683 memset(new + kdb_max_commands - KDB_BASE_CMD_MAX, 0,
2684 kdb_command_extend * sizeof(*new));
2686 kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX;
2687 kdb_max_commands += kdb_command_extend;
2691 kp->cmd_func = func;
2692 kp->cmd_usage = usage;
2693 kp->cmd_help = help;
2695 kp->cmd_minlen = minlen;
2696 kp->cmd_repeat = repeat;
2700 EXPORT_SYMBOL_GPL(kdb_register_repeat);
2704 * kdb_register - Compatibility register function for commands that do
2705 * not need to specify a repeat state. Equivalent to
2706 * kdb_register_repeat with KDB_REPEAT_NONE.
2709 * func Function to execute the command
2710 * usage A simple usage string showing arguments
2711 * help A simple help string describing command
2713 * zero for success, one if a duplicate command.
2715 int kdb_register(char *cmd,
2721 return kdb_register_repeat(cmd, func, usage, help, minlen,
2724 EXPORT_SYMBOL_GPL(kdb_register);
2727 * kdb_unregister - This function is used to unregister a kernel
2728 * debugger command. It is generally called when a module which
2729 * implements kdb commands is unloaded.
2733 * zero for success, one command not registered.
2735 int kdb_unregister(char *cmd)
2743 for_each_kdbcmd(kp, i) {
2744 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2745 kp->cmd_name = NULL;
2750 /* Couldn't find it. */
2753 EXPORT_SYMBOL_GPL(kdb_unregister);
2755 /* Initialize the kdb command table. */
2756 static void __init kdb_inittab(void)
2761 for_each_kdbcmd(kp, i)
2762 kp->cmd_name = NULL;
2764 kdb_register_repeat("md", kdb_md, "<vaddr>",
2765 "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2766 KDB_REPEAT_NO_ARGS);
2767 kdb_register_repeat("mdr", kdb_md, "<vaddr> <bytes>",
2768 "Display Raw Memory", 0, KDB_REPEAT_NO_ARGS);
2769 kdb_register_repeat("mdp", kdb_md, "<paddr> <bytes>",
2770 "Display Physical Memory", 0, KDB_REPEAT_NO_ARGS);
2771 kdb_register_repeat("mds", kdb_md, "<vaddr>",
2772 "Display Memory Symbolically", 0, KDB_REPEAT_NO_ARGS);
2773 kdb_register_repeat("mm", kdb_mm, "<vaddr> <contents>",
2774 "Modify Memory Contents", 0, KDB_REPEAT_NO_ARGS);
2775 kdb_register_repeat("go", kdb_go, "[<vaddr>]",
2776 "Continue Execution", 1, KDB_REPEAT_NONE);
2777 kdb_register_repeat("rd", kdb_rd, "",
2778 "Display Registers", 0, KDB_REPEAT_NONE);
2779 kdb_register_repeat("rm", kdb_rm, "<reg> <contents>",
2780 "Modify Registers", 0, KDB_REPEAT_NONE);
2781 kdb_register_repeat("ef", kdb_ef, "<vaddr>",
2782 "Display exception frame", 0, KDB_REPEAT_NONE);
2783 kdb_register_repeat("bt", kdb_bt, "[<vaddr>]",
2784 "Stack traceback", 1, KDB_REPEAT_NONE);
2785 kdb_register_repeat("btp", kdb_bt, "<pid>",
2786 "Display stack for process <pid>", 0, KDB_REPEAT_NONE);
2787 kdb_register_repeat("bta", kdb_bt, "[D|R|S|T|C|Z|E|U|I|M|A]",
2788 "Backtrace all processes matching state flag", 0, KDB_REPEAT_NONE);
2789 kdb_register_repeat("btc", kdb_bt, "",
2790 "Backtrace current process on each cpu", 0, KDB_REPEAT_NONE);
2791 kdb_register_repeat("btt", kdb_bt, "<vaddr>",
2792 "Backtrace process given its struct task address", 0,
2794 kdb_register_repeat("env", kdb_env, "",
2795 "Show environment variables", 0, KDB_REPEAT_NONE);
2796 kdb_register_repeat("set", kdb_set, "",
2797 "Set environment variables", 0, KDB_REPEAT_NONE);
2798 kdb_register_repeat("help", kdb_help, "",
2799 "Display Help Message", 1, KDB_REPEAT_NONE);
2800 kdb_register_repeat("?", kdb_help, "",
2801 "Display Help Message", 0, KDB_REPEAT_NONE);
2802 kdb_register_repeat("cpu", kdb_cpu, "<cpunum>",
2803 "Switch to new cpu", 0, KDB_REPEAT_NONE);
2804 kdb_register_repeat("kgdb", kdb_kgdb, "",
2805 "Enter kgdb mode", 0, KDB_REPEAT_NONE);
2806 kdb_register_repeat("ps", kdb_ps, "[<flags>|A]",
2807 "Display active task list", 0, KDB_REPEAT_NONE);
2808 kdb_register_repeat("pid", kdb_pid, "<pidnum>",
2809 "Switch to another task", 0, KDB_REPEAT_NONE);
2810 kdb_register_repeat("reboot", kdb_reboot, "",
2811 "Reboot the machine immediately", 0, KDB_REPEAT_NONE);
2812 #if defined(CONFIG_MODULES)
2813 kdb_register_repeat("lsmod", kdb_lsmod, "",
2814 "List loaded kernel modules", 0, KDB_REPEAT_NONE);
2816 #if defined(CONFIG_MAGIC_SYSRQ)
2817 kdb_register_repeat("sr", kdb_sr, "<key>",
2818 "Magic SysRq key", 0, KDB_REPEAT_NONE);
2820 #if defined(CONFIG_PRINTK)
2821 kdb_register_repeat("dmesg", kdb_dmesg, "[lines]",
2822 "Display syslog buffer", 0, KDB_REPEAT_NONE);
2824 if (arch_kgdb_ops.enable_nmi) {
2825 kdb_register_repeat("disable_nmi", kdb_disable_nmi, "",
2826 "Disable NMI entry to KDB", 0, KDB_REPEAT_NONE);
2828 kdb_register_repeat("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
2829 "Define a set of commands, down to endefcmd", 0, KDB_REPEAT_NONE);
2830 kdb_register_repeat("kill", kdb_kill, "<-signal> <pid>",
2831 "Send a signal to a process", 0, KDB_REPEAT_NONE);
2832 kdb_register_repeat("summary", kdb_summary, "",
2833 "Summarize the system", 4, KDB_REPEAT_NONE);
2834 kdb_register_repeat("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
2835 "Display per_cpu variables", 3, KDB_REPEAT_NONE);
2836 kdb_register_repeat("grephelp", kdb_grep_help, "",
2837 "Display help on | grep", 0, KDB_REPEAT_NONE);
2840 /* Execute any commands defined in kdb_cmds. */
2841 static void __init kdb_cmd_init(void)
2844 for (i = 0; kdb_cmds[i]; ++i) {
2845 diag = kdb_parse(kdb_cmds[i]);
2847 kdb_printf("kdb command %s failed, kdb diag %d\n",
2850 if (defcmd_in_progress) {
2851 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2852 kdb_parse("endefcmd");
2856 /* Initialize kdb_printf, breakpoint tables and kdb state */
2857 void __init kdb_init(int lvl)
2859 static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2862 if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2864 for (i = kdb_init_lvl; i < lvl; i++) {
2866 case KDB_NOT_INITIALIZED:
2867 kdb_inittab(); /* Initialize Command Table */
2868 kdb_initbptab(); /* Initialize Breakpoints */
2870 case KDB_INIT_EARLY:
2871 kdb_cmd_init(); /* Build kdb_cmds tables */