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 = CONSOLE_LOGLEVEL_MOTORMOUTH;
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_SYSTEM_NMI:
1204 kdb_printf("due to System NonMaskable Interrupt\n");
1206 case KDB_REASON_NMI:
1207 kdb_printf("due to NonMaskable Interrupt @ "
1208 kdb_machreg_fmt "\n",
1209 instruction_pointer(regs));
1212 case KDB_REASON_SSTEP:
1213 case KDB_REASON_BREAK:
1214 kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
1215 reason == KDB_REASON_BREAK ?
1216 "Breakpoint" : "SS trap", instruction_pointer(regs));
1218 * Determine if this breakpoint is one that we
1219 * are interested in.
1221 if (db_result != KDB_DB_BPT) {
1222 kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1224 KDB_DEBUG_STATE("kdb_local 6", reason);
1225 return 0; /* Not for us, dismiss it */
1228 case KDB_REASON_RECURSE:
1229 kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
1230 instruction_pointer(regs));
1233 kdb_printf("kdb: unexpected reason code: %d\n", reason);
1234 KDB_DEBUG_STATE("kdb_local 8", reason);
1235 return 0; /* Not for us, dismiss it */
1240 * Initialize pager context.
1243 KDB_STATE_CLEAR(SUPPRESS);
1247 *(cmd_hist[cmd_head]) = '\0';
1250 #if defined(CONFIG_SMP)
1251 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
1252 raw_smp_processor_id());
1254 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"));
1256 if (defcmd_in_progress)
1257 strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
1260 * Fetch command from keyboard
1262 cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
1263 if (*cmdbuf != '\n') {
1265 if (cmdptr == cmd_head) {
1266 strncpy(cmd_hist[cmd_head], cmd_cur,
1268 *(cmd_hist[cmd_head] +
1269 strlen(cmd_hist[cmd_head])-1) = '\0';
1271 if (!handle_ctrl_cmd(cmdbuf))
1272 *(cmd_cur+strlen(cmd_cur)-1) = '\0';
1274 goto do_full_getstr;
1276 strncpy(cmd_hist[cmd_head], cmd_cur,
1280 cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
1281 if (cmd_head == cmd_tail)
1282 cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
1286 diag = kdb_parse(cmdbuf);
1287 if (diag == KDB_NOTFOUND) {
1288 kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
1291 if (diag == KDB_CMD_GO
1292 || diag == KDB_CMD_CPU
1293 || diag == KDB_CMD_SS
1294 || diag == KDB_CMD_KGDB)
1300 KDB_DEBUG_STATE("kdb_local 9", diag);
1306 * kdb_print_state - Print the state data for the current processor
1309 * text Identifies the debug point
1310 * value Any integer value to be printed, e.g. reason code.
1312 void kdb_print_state(const char *text, int value)
1314 kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1315 text, raw_smp_processor_id(), value, kdb_initial_cpu,
1320 * kdb_main_loop - After initial setup and assignment of the
1321 * controlling cpu, all cpus are in this loop. One cpu is in
1322 * control and will issue the kdb prompt, the others will spin
1323 * until 'go' or cpu switch.
1325 * To get a consistent view of the kernel stacks for all
1326 * processes, this routine is invoked from the main kdb code via
1327 * an architecture specific routine. kdba_main_loop is
1328 * responsible for making the kernel stacks consistent for all
1329 * processes, there should be no difference between a blocked
1330 * process and a running process as far as kdb is concerned.
1332 * reason The reason KDB was invoked
1333 * error The hardware-defined error code
1334 * reason2 kdb's current reason code.
1335 * Initially error but can change
1336 * according to kdb state.
1337 * db_result Result code from break or debug point.
1338 * regs The exception frame at time of fault/breakpoint.
1339 * should always be valid.
1341 * 0 KDB was invoked for an event which it wasn't responsible
1342 * 1 KDB handled the event for which it was invoked.
1344 int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
1345 kdb_dbtrap_t db_result, struct pt_regs *regs)
1348 /* Stay in kdb() until 'go', 'ss[b]' or an error */
1351 * All processors except the one that is in control
1354 KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1355 while (KDB_STATE(HOLD_CPU)) {
1356 /* state KDB is turned off by kdb_cpu to see if the
1357 * other cpus are still live, each cpu in this loop
1360 if (!KDB_STATE(KDB))
1364 KDB_STATE_CLEAR(SUPPRESS);
1365 KDB_DEBUG_STATE("kdb_main_loop 2", reason);
1366 if (KDB_STATE(LEAVING))
1367 break; /* Another cpu said 'go' */
1368 /* Still using kdb, this processor is in control */
1369 result = kdb_local(reason2, error, regs, db_result);
1370 KDB_DEBUG_STATE("kdb_main_loop 3", result);
1372 if (result == KDB_CMD_CPU)
1375 if (result == KDB_CMD_SS) {
1376 KDB_STATE_SET(DOING_SS);
1380 if (result == KDB_CMD_KGDB) {
1381 if (!KDB_STATE(DOING_KGDB))
1382 kdb_printf("Entering please attach debugger "
1383 "or use $D#44+ or $3#33\n");
1386 if (result && result != 1 && result != KDB_CMD_GO)
1387 kdb_printf("\nUnexpected kdb_local return code %d\n",
1389 KDB_DEBUG_STATE("kdb_main_loop 4", reason);
1392 if (KDB_STATE(DOING_SS))
1393 KDB_STATE_CLEAR(SSBPT);
1395 /* Clean up any keyboard devices before leaving */
1396 kdb_kbd_cleanup_state();
1402 * kdb_mdr - This function implements the guts of the 'mdr', memory
1404 * mdr <addr arg>,<byte count>
1406 * addr Start address
1407 * count Number of bytes
1409 * Always 0. Any errors are detected and printed by kdb_getarea.
1411 static int kdb_mdr(unsigned long addr, unsigned int count)
1415 if (kdb_getarea(c, addr))
1417 kdb_printf("%02x", c);
1425 * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1426 * 'md8' 'mdr' and 'mds' commands.
1428 * md|mds [<addr arg> [<line count> [<radix>]]]
1429 * mdWcN [<addr arg> [<line count> [<radix>]]]
1430 * where W = is the width (1, 2, 4 or 8) and N is the count.
1431 * for eg., md1c20 reads 20 bytes, 1 at a time.
1432 * mdr <addr arg>,<byte count>
1434 static void kdb_md_line(const char *fmtstr, unsigned long addr,
1435 int symbolic, int nosect, int bytesperword,
1436 int num, int repeat, int phys)
1438 /* print just one line of data */
1439 kdb_symtab_t symtab;
1445 memset(cbuf, '\0', sizeof(cbuf));
1447 kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1449 kdb_printf(kdb_machreg_fmt0 " ", addr);
1451 for (i = 0; i < num && repeat--; i++) {
1453 if (kdb_getphysword(&word, addr, bytesperword))
1455 } else if (kdb_getword(&word, addr, bytesperword))
1457 kdb_printf(fmtstr, word);
1459 kdbnearsym(word, &symtab);
1461 memset(&symtab, 0, sizeof(symtab));
1462 if (symtab.sym_name) {
1463 kdb_symbol_print(word, &symtab, 0);
1466 kdb_printf(" %s %s "
1469 kdb_machreg_fmt, symtab.mod_name,
1470 symtab.sec_name, symtab.sec_start,
1471 symtab.sym_start, symtab.sym_end);
1473 addr += bytesperword;
1481 cp = wc.c + 8 - bytesperword;
1486 #define printable_char(c) \
1487 ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1488 switch (bytesperword) {
1490 *c++ = printable_char(*cp++);
1491 *c++ = printable_char(*cp++);
1492 *c++ = printable_char(*cp++);
1493 *c++ = printable_char(*cp++);
1496 *c++ = printable_char(*cp++);
1497 *c++ = printable_char(*cp++);
1500 *c++ = printable_char(*cp++);
1503 *c++ = printable_char(*cp++);
1507 #undef printable_char
1510 kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1514 static int kdb_md(int argc, const char **argv)
1516 static unsigned long last_addr;
1517 static int last_radix, last_bytesperword, last_repeat;
1518 int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1520 char fmtchar, fmtstr[64];
1528 kdbgetintenv("MDCOUNT", &mdcount);
1529 kdbgetintenv("RADIX", &radix);
1530 kdbgetintenv("BYTESPERWORD", &bytesperword);
1532 /* Assume 'md <addr>' and start with environment values */
1533 repeat = mdcount * 16 / bytesperword;
1535 if (strcmp(argv[0], "mdr") == 0) {
1537 return KDB_ARGCOUNT;
1539 } else if (isdigit(argv[0][2])) {
1540 bytesperword = (int)(argv[0][2] - '0');
1541 if (bytesperword == 0) {
1542 bytesperword = last_bytesperword;
1543 if (bytesperword == 0)
1546 last_bytesperword = bytesperword;
1547 repeat = mdcount * 16 / bytesperword;
1550 else if (argv[0][3] == 'c' && argv[0][4]) {
1552 repeat = simple_strtoul(argv[0] + 4, &p, 10);
1553 mdcount = ((repeat * bytesperword) + 15) / 16;
1556 last_repeat = repeat;
1557 } else if (strcmp(argv[0], "md") == 0)
1559 else if (strcmp(argv[0], "mds") == 0)
1561 else if (strcmp(argv[0], "mdp") == 0) {
1565 return KDB_NOTFOUND;
1569 return KDB_ARGCOUNT;
1572 bytesperword = last_bytesperword;
1573 repeat = last_repeat;
1574 mdcount = ((repeat * bytesperword) + 15) / 16;
1579 int diag, nextarg = 1;
1580 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1584 if (argc > nextarg+2)
1585 return KDB_ARGCOUNT;
1587 if (argc >= nextarg) {
1588 diag = kdbgetularg(argv[nextarg], &val);
1590 mdcount = (int) val;
1591 repeat = mdcount * 16 / bytesperword;
1594 if (argc >= nextarg+1) {
1595 diag = kdbgetularg(argv[nextarg+1], &val);
1601 if (strcmp(argv[0], "mdr") == 0)
1602 return kdb_mdr(addr, mdcount);
1615 return KDB_BADRADIX;
1620 if (bytesperword > KDB_WORD_SIZE)
1621 return KDB_BADWIDTH;
1623 switch (bytesperword) {
1625 sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1628 sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1631 sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1634 sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1637 return KDB_BADWIDTH;
1640 last_repeat = repeat;
1641 last_bytesperword = bytesperword;
1643 if (strcmp(argv[0], "mds") == 0) {
1645 /* Do not save these changes as last_*, they are temporary mds
1648 bytesperword = KDB_WORD_SIZE;
1650 kdbgetintenv("NOSECT", &nosect);
1653 /* Round address down modulo BYTESPERWORD */
1655 addr &= ~(bytesperword-1);
1657 while (repeat > 0) {
1659 int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1661 if (KDB_FLAG(CMD_INTERRUPT))
1663 for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1665 if (kdb_getphysword(&word, a, bytesperword)
1668 } else if (kdb_getword(&word, a, bytesperword) || word)
1671 n = min(num, repeat);
1672 kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1674 addr += bytesperword * n;
1676 z = (z + num - 1) / num;
1678 int s = num * (z-2);
1679 kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1680 " zero suppressed\n",
1681 addr, addr + bytesperword * s - 1);
1682 addr += bytesperword * s;
1692 * kdb_mm - This function implements the 'mm' command.
1693 * mm address-expression new-value
1695 * mm works on machine words, mmW works on bytes.
1697 static int kdb_mm(int argc, const char **argv)
1702 unsigned long contents;
1706 if (argv[0][2] && !isdigit(argv[0][2]))
1707 return KDB_NOTFOUND;
1710 return KDB_ARGCOUNT;
1713 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1718 return KDB_ARGCOUNT;
1719 diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1723 if (nextarg != argc + 1)
1724 return KDB_ARGCOUNT;
1726 width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1727 diag = kdb_putword(addr, contents, width);
1731 kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1737 * kdb_go - This function implements the 'go' command.
1738 * go [address-expression]
1740 static int kdb_go(int argc, const char **argv)
1747 if (raw_smp_processor_id() != kdb_initial_cpu) {
1748 kdb_printf("go must execute on the entry cpu, "
1749 "please use \"cpu %d\" and then execute go\n",
1751 return KDB_BADCPUNUM;
1755 diag = kdbgetaddrarg(argc, argv, &nextarg,
1756 &addr, &offset, NULL);
1760 return KDB_ARGCOUNT;
1764 if (KDB_FLAG(CATASTROPHIC)) {
1765 kdb_printf("Catastrophic error detected\n");
1766 kdb_printf("kdb_continue_catastrophic=%d, ",
1767 kdb_continue_catastrophic);
1768 if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1769 kdb_printf("type go a second time if you really want "
1773 if (kdb_continue_catastrophic == 2) {
1774 kdb_printf("forcing reboot\n");
1775 kdb_reboot(0, NULL);
1777 kdb_printf("attempting to continue\n");
1783 * kdb_rd - This function implements the 'rd' command.
1785 static int kdb_rd(int argc, const char **argv)
1787 int len = kdb_check_regs();
1788 #if DBG_MAX_REG_NUM > 0
1800 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1801 rsize = dbg_reg_def[i].size * 2;
1804 if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
1809 len += kdb_printf(" ");
1810 switch(dbg_reg_def[i].size * 8) {
1812 rname = dbg_get_reg(i, ®8, kdb_current_regs);
1815 len += kdb_printf("%s: %02x", rname, reg8);
1818 rname = dbg_get_reg(i, ®16, kdb_current_regs);
1821 len += kdb_printf("%s: %04x", rname, reg16);
1824 rname = dbg_get_reg(i, ®32, kdb_current_regs);
1827 len += kdb_printf("%s: %08x", rname, reg32);
1830 rname = dbg_get_reg(i, ®64, kdb_current_regs);
1833 len += kdb_printf("%s: %016llx", rname, reg64);
1836 len += kdb_printf("%s: ??", dbg_reg_def[i].name);
1844 kdb_dumpregs(kdb_current_regs);
1850 * kdb_rm - This function implements the 'rm' (register modify) command.
1851 * rm register-name new-contents
1853 * Allows register modification with the same restrictions as gdb
1855 static int kdb_rm(int argc, const char **argv)
1857 #if DBG_MAX_REG_NUM > 0
1867 return KDB_ARGCOUNT;
1869 * Allow presence or absence of leading '%' symbol.
1875 diag = kdbgetu64arg(argv[2], ®64);
1879 diag = kdb_check_regs();
1884 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1885 if (strcmp(rname, dbg_reg_def[i].name) == 0) {
1891 switch(dbg_reg_def[i].size * 8) {
1894 dbg_set_reg(i, ®8, kdb_current_regs);
1898 dbg_set_reg(i, ®16, kdb_current_regs);
1902 dbg_set_reg(i, ®32, kdb_current_regs);
1905 dbg_set_reg(i, ®64, kdb_current_regs);
1911 kdb_printf("ERROR: Register set currently not implemented\n");
1916 #if defined(CONFIG_MAGIC_SYSRQ)
1918 * kdb_sr - This function implements the 'sr' (SYSRQ key) command
1919 * which interfaces to the soi-disant MAGIC SYSRQ functionality.
1920 * sr <magic-sysrq-code>
1922 static int kdb_sr(int argc, const char **argv)
1925 return KDB_ARGCOUNT;
1927 __handle_sysrq(*argv[1], false);
1932 #endif /* CONFIG_MAGIC_SYSRQ */
1935 * kdb_ef - This function implements the 'regs' (display exception
1936 * frame) command. This command takes an address and expects to
1937 * find an exception frame at that address, formats and prints
1939 * regs address-expression
1943 static int kdb_ef(int argc, const char **argv)
1951 return KDB_ARGCOUNT;
1954 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1957 show_regs((struct pt_regs *)addr);
1961 #if defined(CONFIG_MODULES)
1963 * kdb_lsmod - This function implements the 'lsmod' command. Lists
1964 * currently loaded kernel modules.
1965 * Mostly taken from userland lsmod.
1967 static int kdb_lsmod(int argc, const char **argv)
1972 return KDB_ARGCOUNT;
1974 kdb_printf("Module Size modstruct Used by\n");
1975 list_for_each_entry(mod, kdb_modules, list) {
1976 if (mod->state == MODULE_STATE_UNFORMED)
1979 kdb_printf("%-20s%8u 0x%p ", mod->name,
1980 mod->core_size, (void *)mod);
1981 #ifdef CONFIG_MODULE_UNLOAD
1982 kdb_printf("%4ld ", module_refcount(mod));
1984 if (mod->state == MODULE_STATE_GOING)
1985 kdb_printf(" (Unloading)");
1986 else if (mod->state == MODULE_STATE_COMING)
1987 kdb_printf(" (Loading)");
1989 kdb_printf(" (Live)");
1990 kdb_printf(" 0x%p", mod->module_core);
1992 #ifdef CONFIG_MODULE_UNLOAD
1994 struct module_use *use;
1996 list_for_each_entry(use, &mod->source_list,
1998 kdb_printf("%s ", use->target->name);
2007 #endif /* CONFIG_MODULES */
2010 * kdb_env - This function implements the 'env' command. Display the
2011 * current environment variables.
2014 static int kdb_env(int argc, const char **argv)
2018 for (i = 0; i < __nenv; i++) {
2020 kdb_printf("%s\n", __env[i]);
2023 if (KDB_DEBUG(MASK))
2024 kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
2029 #ifdef CONFIG_PRINTK
2031 * kdb_dmesg - This function implements the 'dmesg' command to display
2032 * the contents of the syslog buffer.
2033 * dmesg [lines] [adjust]
2035 static int kdb_dmesg(int argc, const char **argv)
2043 struct kmsg_dumper dumper = { .active = 1 };
2048 return KDB_ARGCOUNT;
2051 lines = simple_strtol(argv[1], &cp, 0);
2055 adjust = simple_strtoul(argv[2], &cp, 0);
2056 if (*cp || adjust < 0)
2061 /* disable LOGGING if set */
2062 diag = kdbgetintenv("LOGGING", &logging);
2063 if (!diag && logging) {
2064 const char *setargs[] = { "set", "LOGGING", "0" };
2065 kdb_set(2, setargs);
2068 kmsg_dump_rewind_nolock(&dumper);
2069 while (kmsg_dump_get_line_nolock(&dumper, 1, NULL, 0, NULL))
2074 kdb_printf("buffer only contains %d lines, nothing "
2076 else if (adjust - lines >= n)
2077 kdb_printf("buffer only contains %d lines, last %d "
2078 "lines printed\n", n, n - adjust);
2081 } else if (lines > 0) {
2082 skip = n - lines - adjust;
2085 kdb_printf("buffer only contains %d lines, "
2086 "nothing printed\n", n);
2088 } else if (skip < 0) {
2091 kdb_printf("buffer only contains %d lines, first "
2092 "%d lines printed\n", n, lines);
2098 if (skip >= n || skip < 0)
2101 kmsg_dump_rewind_nolock(&dumper);
2102 while (kmsg_dump_get_line_nolock(&dumper, 1, buf, sizeof(buf), &len)) {
2109 if (KDB_FLAG(CMD_INTERRUPT))
2112 kdb_printf("%.*s\n", (int)len - 1, buf);
2117 #endif /* CONFIG_PRINTK */
2119 /* Make sure we balance enable/disable calls, must disable first. */
2120 static atomic_t kdb_nmi_disabled;
2122 static int kdb_disable_nmi(int argc, const char *argv[])
2124 if (atomic_read(&kdb_nmi_disabled))
2126 atomic_set(&kdb_nmi_disabled, 1);
2127 arch_kgdb_ops.enable_nmi(0);
2131 static int kdb_param_enable_nmi(const char *val, const struct kernel_param *kp)
2133 if (!atomic_add_unless(&kdb_nmi_disabled, -1, 0))
2135 arch_kgdb_ops.enable_nmi(1);
2139 static const struct kernel_param_ops kdb_param_ops_enable_nmi = {
2140 .set = kdb_param_enable_nmi,
2142 module_param_cb(enable_nmi, &kdb_param_ops_enable_nmi, NULL, 0600);
2145 * kdb_cpu - This function implements the 'cpu' command.
2148 * KDB_CMD_CPU for success, a kdb diagnostic if error
2150 static void kdb_cpu_status(void)
2152 int i, start_cpu, first_print = 1;
2153 char state, prev_state = '?';
2155 kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2156 kdb_printf("Available cpus: ");
2157 for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2158 if (!cpu_online(i)) {
2159 state = 'F'; /* cpu is offline */
2161 state = ' '; /* cpu is responding to kdb */
2162 if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2163 state = 'I'; /* idle task */
2165 if (state != prev_state) {
2166 if (prev_state != '?') {
2170 kdb_printf("%d", start_cpu);
2171 if (start_cpu < i-1)
2172 kdb_printf("-%d", i-1);
2173 if (prev_state != ' ')
2174 kdb_printf("(%c)", prev_state);
2180 /* print the trailing cpus, ignoring them if they are all offline */
2181 if (prev_state != 'F') {
2184 kdb_printf("%d", start_cpu);
2185 if (start_cpu < i-1)
2186 kdb_printf("-%d", i-1);
2187 if (prev_state != ' ')
2188 kdb_printf("(%c)", prev_state);
2193 static int kdb_cpu(int argc, const char **argv)
2195 unsigned long cpunum;
2204 return KDB_ARGCOUNT;
2206 diag = kdbgetularg(argv[1], &cpunum);
2213 if ((cpunum > NR_CPUS) || !cpu_online(cpunum))
2214 return KDB_BADCPUNUM;
2216 dbg_switch_cpu = cpunum;
2219 * Switch to other cpu
2224 /* The user may not realize that ps/bta with no parameters does not print idle
2225 * or sleeping system daemon processes, so tell them how many were suppressed.
2227 void kdb_ps_suppressed(void)
2229 int idle = 0, daemon = 0;
2230 unsigned long mask_I = kdb_task_state_string("I"),
2231 mask_M = kdb_task_state_string("M");
2233 const struct task_struct *p, *g;
2234 for_each_online_cpu(cpu) {
2235 p = kdb_curr_task(cpu);
2236 if (kdb_task_state(p, mask_I))
2239 kdb_do_each_thread(g, p) {
2240 if (kdb_task_state(p, mask_M))
2242 } kdb_while_each_thread(g, p);
2243 if (idle || daemon) {
2245 kdb_printf("%d idle process%s (state I)%s\n",
2246 idle, idle == 1 ? "" : "es",
2247 daemon ? " and " : "");
2249 kdb_printf("%d sleeping system daemon (state M) "
2250 "process%s", daemon,
2251 daemon == 1 ? "" : "es");
2252 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2257 * kdb_ps - This function implements the 'ps' command which shows a
2258 * list of the active processes.
2259 * ps [DRSTCZEUIMA] All processes, optionally filtered by state
2261 void kdb_ps1(const struct task_struct *p)
2266 if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
2269 cpu = kdb_process_cpu(p);
2270 kdb_printf("0x%p %8d %8d %d %4d %c 0x%p %c%s\n",
2271 (void *)p, p->pid, p->parent->pid,
2272 kdb_task_has_cpu(p), kdb_process_cpu(p),
2273 kdb_task_state_char(p),
2274 (void *)(&p->thread),
2275 p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2277 if (kdb_task_has_cpu(p)) {
2278 if (!KDB_TSK(cpu)) {
2279 kdb_printf(" Error: no saved data for this cpu\n");
2281 if (KDB_TSK(cpu) != p)
2282 kdb_printf(" Error: does not match running "
2283 "process table (0x%p)\n", KDB_TSK(cpu));
2288 static int kdb_ps(int argc, const char **argv)
2290 struct task_struct *g, *p;
2291 unsigned long mask, cpu;
2294 kdb_ps_suppressed();
2295 kdb_printf("%-*s Pid Parent [*] cpu State %-*s Command\n",
2296 (int)(2*sizeof(void *))+2, "Task Addr",
2297 (int)(2*sizeof(void *))+2, "Thread");
2298 mask = kdb_task_state_string(argc ? argv[1] : NULL);
2299 /* Run the active tasks first */
2300 for_each_online_cpu(cpu) {
2301 if (KDB_FLAG(CMD_INTERRUPT))
2303 p = kdb_curr_task(cpu);
2304 if (kdb_task_state(p, mask))
2308 /* Now the real tasks */
2309 kdb_do_each_thread(g, p) {
2310 if (KDB_FLAG(CMD_INTERRUPT))
2312 if (kdb_task_state(p, mask))
2314 } kdb_while_each_thread(g, p);
2320 * kdb_pid - This function implements the 'pid' command which switches
2321 * the currently active process.
2324 static int kdb_pid(int argc, const char **argv)
2326 struct task_struct *p;
2331 return KDB_ARGCOUNT;
2334 if (strcmp(argv[1], "R") == 0) {
2335 p = KDB_TSK(kdb_initial_cpu);
2337 diag = kdbgetularg(argv[1], &val);
2341 p = find_task_by_pid_ns((pid_t)val, &init_pid_ns);
2343 kdb_printf("No task with pid=%d\n", (pid_t)val);
2347 kdb_set_current_task(p);
2349 kdb_printf("KDB current process is %s(pid=%d)\n",
2350 kdb_current_task->comm,
2351 kdb_current_task->pid);
2356 static int kdb_kgdb(int argc, const char **argv)
2358 return KDB_CMD_KGDB;
2362 * kdb_help - This function implements the 'help' and '?' commands.
2364 static int kdb_help(int argc, const char **argv)
2369 kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2370 kdb_printf("-----------------------------"
2371 "-----------------------------\n");
2372 for_each_kdbcmd(kt, i) {
2374 if (KDB_FLAG(CMD_INTERRUPT))
2378 if (strlen(kt->cmd_usage) > 20)
2380 kdb_printf("%-15.15s %-20s%s%s\n", kt->cmd_name,
2381 kt->cmd_usage, space, kt->cmd_help);
2387 * kdb_kill - This function implements the 'kill' commands.
2389 static int kdb_kill(int argc, const char **argv)
2393 struct task_struct *p;
2394 struct siginfo info;
2397 return KDB_ARGCOUNT;
2399 sig = simple_strtol(argv[1], &endp, 0);
2403 kdb_printf("Invalid signal parameter.<-signal>\n");
2408 pid = simple_strtol(argv[2], &endp, 0);
2412 kdb_printf("Process ID must be large than 0.\n");
2416 /* Find the process. */
2417 p = find_task_by_pid_ns(pid, &init_pid_ns);
2419 kdb_printf("The specified process isn't found.\n");
2422 p = p->group_leader;
2423 info.si_signo = sig;
2425 info.si_code = SI_USER;
2426 info.si_pid = pid; /* same capabilities as process being signalled */
2427 info.si_uid = 0; /* kdb has root authority */
2428 kdb_send_sig_info(p, &info);
2433 int tm_sec; /* seconds */
2434 int tm_min; /* minutes */
2435 int tm_hour; /* hours */
2436 int tm_mday; /* day of the month */
2437 int tm_mon; /* month */
2438 int tm_year; /* year */
2441 static void kdb_gmtime(struct timespec *tv, struct kdb_tm *tm)
2443 /* This will work from 1970-2099, 2100 is not a leap year */
2444 static int mon_day[] = { 31, 29, 31, 30, 31, 30, 31,
2445 31, 30, 31, 30, 31 };
2446 memset(tm, 0, sizeof(*tm));
2447 tm->tm_sec = tv->tv_sec % (24 * 60 * 60);
2448 tm->tm_mday = tv->tv_sec / (24 * 60 * 60) +
2449 (2 * 365 + 1); /* shift base from 1970 to 1968 */
2450 tm->tm_min = tm->tm_sec / 60 % 60;
2451 tm->tm_hour = tm->tm_sec / 60 / 60;
2452 tm->tm_sec = tm->tm_sec % 60;
2453 tm->tm_year = 68 + 4*(tm->tm_mday / (4*365+1));
2454 tm->tm_mday %= (4*365+1);
2456 while (tm->tm_mday >= mon_day[tm->tm_mon]) {
2457 tm->tm_mday -= mon_day[tm->tm_mon];
2458 if (++tm->tm_mon == 12) {
2468 * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2469 * I cannot call that code directly from kdb, it has an unconditional
2470 * cli()/sti() and calls routines that take locks which can stop the debugger.
2472 static void kdb_sysinfo(struct sysinfo *val)
2474 struct timespec uptime;
2475 ktime_get_ts(&uptime);
2476 memset(val, 0, sizeof(*val));
2477 val->uptime = uptime.tv_sec;
2478 val->loads[0] = avenrun[0];
2479 val->loads[1] = avenrun[1];
2480 val->loads[2] = avenrun[2];
2481 val->procs = nr_threads-1;
2488 * kdb_summary - This function implements the 'summary' command.
2490 static int kdb_summary(int argc, const char **argv)
2492 struct timespec now;
2497 return KDB_ARGCOUNT;
2499 kdb_printf("sysname %s\n", init_uts_ns.name.sysname);
2500 kdb_printf("release %s\n", init_uts_ns.name.release);
2501 kdb_printf("version %s\n", init_uts_ns.name.version);
2502 kdb_printf("machine %s\n", init_uts_ns.name.machine);
2503 kdb_printf("nodename %s\n", init_uts_ns.name.nodename);
2504 kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2505 kdb_printf("ccversion %s\n", __stringify(CCVERSION));
2507 now = __current_kernel_time();
2508 kdb_gmtime(&now, &tm);
2509 kdb_printf("date %04d-%02d-%02d %02d:%02d:%02d "
2510 "tz_minuteswest %d\n",
2511 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2512 tm.tm_hour, tm.tm_min, tm.tm_sec,
2513 sys_tz.tz_minuteswest);
2516 kdb_printf("uptime ");
2517 if (val.uptime > (24*60*60)) {
2518 int days = val.uptime / (24*60*60);
2519 val.uptime %= (24*60*60);
2520 kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2522 kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2524 /* lifted from fs/proc/proc_misc.c::loadavg_read_proc() */
2526 #define LOAD_INT(x) ((x) >> FSHIFT)
2527 #define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
2528 kdb_printf("load avg %ld.%02ld %ld.%02ld %ld.%02ld\n",
2529 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2530 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2531 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2534 /* Display in kilobytes */
2535 #define K(x) ((x) << (PAGE_SHIFT - 10))
2536 kdb_printf("\nMemTotal: %8lu kB\nMemFree: %8lu kB\n"
2537 "Buffers: %8lu kB\n",
2538 val.totalram, val.freeram, val.bufferram);
2543 * kdb_per_cpu - This function implements the 'per_cpu' command.
2545 static int kdb_per_cpu(int argc, const char **argv)
2548 int cpu, diag, nextarg = 1;
2549 unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2551 if (argc < 1 || argc > 3)
2552 return KDB_ARGCOUNT;
2554 diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2559 diag = kdbgetularg(argv[2], &bytesperword);
2564 bytesperword = KDB_WORD_SIZE;
2565 else if (bytesperword > KDB_WORD_SIZE)
2566 return KDB_BADWIDTH;
2567 sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2569 diag = kdbgetularg(argv[3], &whichcpu);
2572 if (!cpu_online(whichcpu)) {
2573 kdb_printf("cpu %ld is not online\n", whichcpu);
2574 return KDB_BADCPUNUM;
2578 /* Most architectures use __per_cpu_offset[cpu], some use
2579 * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2581 #ifdef __per_cpu_offset
2582 #define KDB_PCU(cpu) __per_cpu_offset(cpu)
2585 #define KDB_PCU(cpu) __per_cpu_offset[cpu]
2587 #define KDB_PCU(cpu) 0
2590 for_each_online_cpu(cpu) {
2591 if (KDB_FLAG(CMD_INTERRUPT))
2594 if (whichcpu != ~0UL && whichcpu != cpu)
2596 addr = symaddr + KDB_PCU(cpu);
2597 diag = kdb_getword(&val, addr, bytesperword);
2599 kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2600 "read, diag=%d\n", cpu, addr, diag);
2603 kdb_printf("%5d ", cpu);
2604 kdb_md_line(fmtstr, addr,
2605 bytesperword == KDB_WORD_SIZE,
2606 1, bytesperword, 1, 1, 0);
2613 * display help for the use of cmd | grep pattern
2615 static int kdb_grep_help(int argc, const char **argv)
2617 kdb_printf("Usage of cmd args | grep pattern:\n");
2618 kdb_printf(" Any command's output may be filtered through an ");
2619 kdb_printf("emulated 'pipe'.\n");
2620 kdb_printf(" 'grep' is just a key word.\n");
2621 kdb_printf(" The pattern may include a very limited set of "
2622 "metacharacters:\n");
2623 kdb_printf(" pattern or ^pattern or pattern$ or ^pattern$\n");
2624 kdb_printf(" And if there are spaces in the pattern, you may "
2626 kdb_printf(" \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2627 " or \"^pat tern$\"\n");
2632 * kdb_register_repeat - This function is used to register a kernel
2636 * func Function to execute the command
2637 * usage A simple usage string showing arguments
2638 * help A simple help string describing command
2639 * repeat Does the command auto repeat on enter?
2641 * zero for success, one if a duplicate command.
2643 #define kdb_command_extend 50 /* arbitrary */
2644 int kdb_register_repeat(char *cmd,
2649 kdb_repeat_t repeat)
2655 * Brute force method to determine duplicates
2657 for_each_kdbcmd(kp, i) {
2658 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2659 kdb_printf("Duplicate kdb command registered: "
2660 "%s, func %p help %s\n", cmd, func, help);
2666 * Insert command into first available location in table
2668 for_each_kdbcmd(kp, i) {
2669 if (kp->cmd_name == NULL)
2673 if (i >= kdb_max_commands) {
2674 kdbtab_t *new = kmalloc((kdb_max_commands - KDB_BASE_CMD_MAX +
2675 kdb_command_extend) * sizeof(*new), GFP_KDB);
2677 kdb_printf("Could not allocate new kdb_command "
2682 memcpy(new, kdb_commands,
2683 (kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new));
2684 kfree(kdb_commands);
2686 memset(new + kdb_max_commands - KDB_BASE_CMD_MAX, 0,
2687 kdb_command_extend * sizeof(*new));
2689 kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX;
2690 kdb_max_commands += kdb_command_extend;
2694 kp->cmd_func = func;
2695 kp->cmd_usage = usage;
2696 kp->cmd_help = help;
2698 kp->cmd_minlen = minlen;
2699 kp->cmd_repeat = repeat;
2703 EXPORT_SYMBOL_GPL(kdb_register_repeat);
2707 * kdb_register - Compatibility register function for commands that do
2708 * not need to specify a repeat state. Equivalent to
2709 * kdb_register_repeat with KDB_REPEAT_NONE.
2712 * func Function to execute the command
2713 * usage A simple usage string showing arguments
2714 * help A simple help string describing command
2716 * zero for success, one if a duplicate command.
2718 int kdb_register(char *cmd,
2724 return kdb_register_repeat(cmd, func, usage, help, minlen,
2727 EXPORT_SYMBOL_GPL(kdb_register);
2730 * kdb_unregister - This function is used to unregister a kernel
2731 * debugger command. It is generally called when a module which
2732 * implements kdb commands is unloaded.
2736 * zero for success, one command not registered.
2738 int kdb_unregister(char *cmd)
2746 for_each_kdbcmd(kp, i) {
2747 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2748 kp->cmd_name = NULL;
2753 /* Couldn't find it. */
2756 EXPORT_SYMBOL_GPL(kdb_unregister);
2758 /* Initialize the kdb command table. */
2759 static void __init kdb_inittab(void)
2764 for_each_kdbcmd(kp, i)
2765 kp->cmd_name = NULL;
2767 kdb_register_repeat("md", kdb_md, "<vaddr>",
2768 "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2769 KDB_REPEAT_NO_ARGS);
2770 kdb_register_repeat("mdr", kdb_md, "<vaddr> <bytes>",
2771 "Display Raw Memory", 0, KDB_REPEAT_NO_ARGS);
2772 kdb_register_repeat("mdp", kdb_md, "<paddr> <bytes>",
2773 "Display Physical Memory", 0, KDB_REPEAT_NO_ARGS);
2774 kdb_register_repeat("mds", kdb_md, "<vaddr>",
2775 "Display Memory Symbolically", 0, KDB_REPEAT_NO_ARGS);
2776 kdb_register_repeat("mm", kdb_mm, "<vaddr> <contents>",
2777 "Modify Memory Contents", 0, KDB_REPEAT_NO_ARGS);
2778 kdb_register_repeat("go", kdb_go, "[<vaddr>]",
2779 "Continue Execution", 1, KDB_REPEAT_NONE);
2780 kdb_register_repeat("rd", kdb_rd, "",
2781 "Display Registers", 0, KDB_REPEAT_NONE);
2782 kdb_register_repeat("rm", kdb_rm, "<reg> <contents>",
2783 "Modify Registers", 0, KDB_REPEAT_NONE);
2784 kdb_register_repeat("ef", kdb_ef, "<vaddr>",
2785 "Display exception frame", 0, KDB_REPEAT_NONE);
2786 kdb_register_repeat("bt", kdb_bt, "[<vaddr>]",
2787 "Stack traceback", 1, KDB_REPEAT_NONE);
2788 kdb_register_repeat("btp", kdb_bt, "<pid>",
2789 "Display stack for process <pid>", 0, KDB_REPEAT_NONE);
2790 kdb_register_repeat("bta", kdb_bt, "[D|R|S|T|C|Z|E|U|I|M|A]",
2791 "Backtrace all processes matching state flag", 0, KDB_REPEAT_NONE);
2792 kdb_register_repeat("btc", kdb_bt, "",
2793 "Backtrace current process on each cpu", 0, KDB_REPEAT_NONE);
2794 kdb_register_repeat("btt", kdb_bt, "<vaddr>",
2795 "Backtrace process given its struct task address", 0,
2797 kdb_register_repeat("env", kdb_env, "",
2798 "Show environment variables", 0, KDB_REPEAT_NONE);
2799 kdb_register_repeat("set", kdb_set, "",
2800 "Set environment variables", 0, KDB_REPEAT_NONE);
2801 kdb_register_repeat("help", kdb_help, "",
2802 "Display Help Message", 1, KDB_REPEAT_NONE);
2803 kdb_register_repeat("?", kdb_help, "",
2804 "Display Help Message", 0, KDB_REPEAT_NONE);
2805 kdb_register_repeat("cpu", kdb_cpu, "<cpunum>",
2806 "Switch to new cpu", 0, KDB_REPEAT_NONE);
2807 kdb_register_repeat("kgdb", kdb_kgdb, "",
2808 "Enter kgdb mode", 0, KDB_REPEAT_NONE);
2809 kdb_register_repeat("ps", kdb_ps, "[<flags>|A]",
2810 "Display active task list", 0, KDB_REPEAT_NONE);
2811 kdb_register_repeat("pid", kdb_pid, "<pidnum>",
2812 "Switch to another task", 0, KDB_REPEAT_NONE);
2813 kdb_register_repeat("reboot", kdb_reboot, "",
2814 "Reboot the machine immediately", 0, KDB_REPEAT_NONE);
2815 #if defined(CONFIG_MODULES)
2816 kdb_register_repeat("lsmod", kdb_lsmod, "",
2817 "List loaded kernel modules", 0, KDB_REPEAT_NONE);
2819 #if defined(CONFIG_MAGIC_SYSRQ)
2820 kdb_register_repeat("sr", kdb_sr, "<key>",
2821 "Magic SysRq key", 0, KDB_REPEAT_NONE);
2823 #if defined(CONFIG_PRINTK)
2824 kdb_register_repeat("dmesg", kdb_dmesg, "[lines]",
2825 "Display syslog buffer", 0, KDB_REPEAT_NONE);
2827 if (arch_kgdb_ops.enable_nmi) {
2828 kdb_register_repeat("disable_nmi", kdb_disable_nmi, "",
2829 "Disable NMI entry to KDB", 0, KDB_REPEAT_NONE);
2831 kdb_register_repeat("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
2832 "Define a set of commands, down to endefcmd", 0, KDB_REPEAT_NONE);
2833 kdb_register_repeat("kill", kdb_kill, "<-signal> <pid>",
2834 "Send a signal to a process", 0, KDB_REPEAT_NONE);
2835 kdb_register_repeat("summary", kdb_summary, "",
2836 "Summarize the system", 4, KDB_REPEAT_NONE);
2837 kdb_register_repeat("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
2838 "Display per_cpu variables", 3, KDB_REPEAT_NONE);
2839 kdb_register_repeat("grephelp", kdb_grep_help, "",
2840 "Display help on | grep", 0, KDB_REPEAT_NONE);
2843 /* Execute any commands defined in kdb_cmds. */
2844 static void __init kdb_cmd_init(void)
2847 for (i = 0; kdb_cmds[i]; ++i) {
2848 diag = kdb_parse(kdb_cmds[i]);
2850 kdb_printf("kdb command %s failed, kdb diag %d\n",
2853 if (defcmd_in_progress) {
2854 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2855 kdb_parse("endefcmd");
2859 /* Initialize kdb_printf, breakpoint tables and kdb state */
2860 void __init kdb_init(int lvl)
2862 static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2865 if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2867 for (i = kdb_init_lvl; i < lvl; i++) {
2869 case KDB_NOT_INITIALIZED:
2870 kdb_inittab(); /* Initialize Command Table */
2871 kdb_initbptab(); /* Initialize Breakpoints */
2873 case KDB_INIT_EARLY:
2874 kdb_cmd_init(); /* Build kdb_cmds tables */