2 * Kernel Debugger Architecture Independent Main Code
4 * This file is subject to the terms and conditions of the GNU General Public
5 * License. See the file "COPYING" in the main directory of this archive
8 * Copyright (C) 1999-2004 Silicon Graphics, Inc. All Rights Reserved.
9 * Copyright (C) 2000 Stephane Eranian <eranian@hpl.hp.com>
10 * Xscale (R) modifications copyright (C) 2003 Intel Corporation.
11 * Copyright (c) 2009 Wind River Systems, Inc. All Rights Reserved.
14 #include <linux/ctype.h>
15 #include <linux/types.h>
16 #include <linux/string.h>
17 #include <linux/kernel.h>
18 #include <linux/kmsg_dump.h>
19 #include <linux/reboot.h>
20 #include <linux/sched.h>
21 #include <linux/sched/loadavg.h>
22 #include <linux/sched/stat.h>
23 #include <linux/sched/debug.h>
24 #include <linux/sysrq.h>
25 #include <linux/smp.h>
26 #include <linux/utsname.h>
27 #include <linux/vmalloc.h>
28 #include <linux/atomic.h>
29 #include <linux/moduleparam.h>
31 #include <linux/init.h>
32 #include <linux/kallsyms.h>
33 #include <linux/kgdb.h>
34 #include <linux/kdb.h>
35 #include <linux/notifier.h>
36 #include <linux/interrupt.h>
37 #include <linux/delay.h>
38 #include <linux/nmi.h>
39 #include <linux/time.h>
40 #include <linux/ptrace.h>
41 #include <linux/sysctl.h>
42 #include <linux/cpu.h>
43 #include <linux/kdebug.h>
44 #include <linux/proc_fs.h>
45 #include <linux/uaccess.h>
46 #include <linux/slab.h>
47 #include <linux/security.h>
48 #include "kdb_private.h"
50 #undef MODULE_PARAM_PREFIX
51 #define MODULE_PARAM_PREFIX "kdb."
53 static int kdb_cmd_enabled = CONFIG_KDB_DEFAULT_ENABLE;
54 module_param_named(cmd_enable, kdb_cmd_enabled, int, 0600);
56 char kdb_grep_string[KDB_GREP_STRLEN];
57 int kdb_grepping_flag;
58 EXPORT_SYMBOL(kdb_grepping_flag);
60 int kdb_grep_trailing;
63 * Kernel debugger state flags
65 unsigned int kdb_flags;
68 * kdb_lock protects updates to kdb_initial_cpu. Used to
69 * single thread processors through the kernel debugger.
71 int kdb_initial_cpu = -1; /* cpu number that owns kdb */
73 int kdb_state; /* General KDB state */
75 struct task_struct *kdb_current_task;
76 struct pt_regs *kdb_current_regs;
78 const char *kdb_diemsg;
79 static int kdb_go_count;
80 #ifdef CONFIG_KDB_CONTINUE_CATASTROPHIC
81 static unsigned int kdb_continue_catastrophic =
82 CONFIG_KDB_CONTINUE_CATASTROPHIC;
84 static unsigned int kdb_continue_catastrophic;
87 /* kdb_cmds_head describes the available commands. */
88 static LIST_HEAD(kdb_cmds_head);
90 typedef struct _kdbmsg {
91 int km_diag; /* kdb diagnostic */
92 char *km_msg; /* Corresponding message text */
95 #define KDBMSG(msgnum, text) \
96 { KDB_##msgnum, text }
98 static kdbmsg_t kdbmsgs[] = {
99 KDBMSG(NOTFOUND, "Command Not Found"),
100 KDBMSG(ARGCOUNT, "Improper argument count, see usage."),
101 KDBMSG(BADWIDTH, "Illegal value for BYTESPERWORD use 1, 2, 4 or 8, "
102 "8 is only allowed on 64 bit systems"),
103 KDBMSG(BADRADIX, "Illegal value for RADIX use 8, 10 or 16"),
104 KDBMSG(NOTENV, "Cannot find environment variable"),
105 KDBMSG(NOENVVALUE, "Environment variable should have value"),
106 KDBMSG(NOTIMP, "Command not implemented"),
107 KDBMSG(ENVFULL, "Environment full"),
108 KDBMSG(ENVBUFFULL, "Environment buffer full"),
109 KDBMSG(TOOMANYBPT, "Too many breakpoints defined"),
110 #ifdef CONFIG_CPU_XSCALE
111 KDBMSG(TOOMANYDBREGS, "More breakpoints than ibcr registers defined"),
113 KDBMSG(TOOMANYDBREGS, "More breakpoints than db registers defined"),
115 KDBMSG(DUPBPT, "Duplicate breakpoint address"),
116 KDBMSG(BPTNOTFOUND, "Breakpoint not found"),
117 KDBMSG(BADMODE, "Invalid IDMODE"),
118 KDBMSG(BADINT, "Illegal numeric value"),
119 KDBMSG(INVADDRFMT, "Invalid symbolic address format"),
120 KDBMSG(BADREG, "Invalid register name"),
121 KDBMSG(BADCPUNUM, "Invalid cpu number"),
122 KDBMSG(BADLENGTH, "Invalid length field"),
123 KDBMSG(NOBP, "No Breakpoint exists"),
124 KDBMSG(BADADDR, "Invalid address"),
125 KDBMSG(NOPERM, "Permission denied"),
129 static const int __nkdb_err = ARRAY_SIZE(kdbmsgs);
133 * Initial environment. This is all kept static and local to
134 * this file. We don't want to rely on the memory allocation
135 * mechanisms in the kernel, so we use a very limited allocate-only
136 * heap for new and altered environment variables. The entire
137 * environment is limited to a fixed number of entries (add more
138 * to __env[] if required) and a fixed amount of heap (add more to
139 * KDB_ENVBUFSIZE if required).
142 static char *__env[31] = {
143 #if defined(CONFIG_SMP)
150 "MDCOUNT=8", /* lines of md output */
156 static const int __nenv = ARRAY_SIZE(__env);
158 struct task_struct *kdb_curr_task(int cpu)
160 struct task_struct *p = curr_task(cpu);
162 if ((task_thread_info(p)->flags & _TIF_MCA_INIT) && KDB_TSK(cpu))
169 * Update the permissions flags (kdb_cmd_enabled) to match the
170 * current lockdown state.
172 * Within this function the calls to security_locked_down() are "lazy". We
173 * avoid calling them if the current value of kdb_cmd_enabled already excludes
174 * flags that might be subject to lockdown. Additionally we deliberately check
175 * the lockdown flags independently (even though read lockdown implies write
176 * lockdown) since that results in both simpler code and clearer messages to
177 * the user on first-time debugger entry.
179 * The permission masks during a read+write lockdown permits the following
180 * flags: INSPECT, SIGNAL, REBOOT (and ALWAYS_SAFE).
182 * The INSPECT commands are not blocked during lockdown because they are
183 * not arbitrary memory reads. INSPECT covers the backtrace family (sometimes
184 * forcing them to have no arguments) and lsmod. These commands do expose
185 * some kernel state but do not allow the developer seated at the console to
186 * choose what state is reported. SIGNAL and REBOOT should not be controversial,
187 * given these are allowed for root during lockdown already.
189 static void kdb_check_for_lockdown(void)
191 const int write_flags = KDB_ENABLE_MEM_WRITE |
192 KDB_ENABLE_REG_WRITE |
193 KDB_ENABLE_FLOW_CTRL;
194 const int read_flags = KDB_ENABLE_MEM_READ |
197 bool need_to_lockdown_write = false;
198 bool need_to_lockdown_read = false;
200 if (kdb_cmd_enabled & (KDB_ENABLE_ALL | write_flags))
201 need_to_lockdown_write =
202 security_locked_down(LOCKDOWN_DBG_WRITE_KERNEL);
204 if (kdb_cmd_enabled & (KDB_ENABLE_ALL | read_flags))
205 need_to_lockdown_read =
206 security_locked_down(LOCKDOWN_DBG_READ_KERNEL);
208 /* De-compose KDB_ENABLE_ALL if required */
209 if (need_to_lockdown_write || need_to_lockdown_read)
210 if (kdb_cmd_enabled & KDB_ENABLE_ALL)
211 kdb_cmd_enabled = KDB_ENABLE_MASK & ~KDB_ENABLE_ALL;
213 if (need_to_lockdown_write)
214 kdb_cmd_enabled &= ~write_flags;
216 if (need_to_lockdown_read)
217 kdb_cmd_enabled &= ~read_flags;
221 * Check whether the flags of the current command, the permissions of the kdb
222 * console and the lockdown state allow a command to be run.
224 static bool kdb_check_flags(kdb_cmdflags_t flags, int permissions,
227 /* permissions comes from userspace so needs massaging slightly */
228 permissions &= KDB_ENABLE_MASK;
229 permissions |= KDB_ENABLE_ALWAYS_SAFE;
231 /* some commands change group when launched with no arguments */
233 permissions |= permissions << KDB_ENABLE_NO_ARGS_SHIFT;
235 flags |= KDB_ENABLE_ALL;
237 return permissions & flags;
241 * kdbgetenv - This function will return the character string value of
242 * an environment variable.
244 * match A character string representing an environment variable.
246 * NULL No environment variable matches 'match'
247 * char* Pointer to string value of environment variable.
249 char *kdbgetenv(const char *match)
252 int matchlen = strlen(match);
255 for (i = 0; i < __nenv; i++) {
261 if ((strncmp(match, e, matchlen) == 0)
262 && ((e[matchlen] == '\0')
263 || (e[matchlen] == '='))) {
264 char *cp = strchr(e, '=');
265 return cp ? ++cp : "";
272 * kdballocenv - This function is used to allocate bytes for
273 * environment entries.
275 * match A character string representing a numeric value
277 * *value the unsigned long representation of the env variable 'match'
279 * Zero on success, a kdb diagnostic on failure.
281 * We use a static environment buffer (envbuffer) to hold the values
282 * of dynamically generated environment variables (see kdb_set). Buffer
283 * space once allocated is never free'd, so over time, the amount of space
284 * (currently 512 bytes) will be exhausted if env variables are changed
287 static char *kdballocenv(size_t bytes)
289 #define KDB_ENVBUFSIZE 512
290 static char envbuffer[KDB_ENVBUFSIZE];
291 static int envbufsize;
294 if ((KDB_ENVBUFSIZE - envbufsize) >= bytes) {
295 ep = &envbuffer[envbufsize];
302 * kdbgetulenv - This function will return the value of an unsigned
303 * long-valued environment variable.
305 * match A character string representing a numeric value
307 * *value the unsigned long representation of the env variable 'match'
309 * Zero on success, a kdb diagnostic on failure.
311 static int kdbgetulenv(const char *match, unsigned long *value)
315 ep = kdbgetenv(match);
319 return KDB_NOENVVALUE;
321 *value = simple_strtoul(ep, NULL, 0);
327 * kdbgetintenv - This function will return the value of an
328 * integer-valued environment variable.
330 * match A character string representing an integer-valued env variable
332 * *value the integer representation of the environment variable 'match'
334 * Zero on success, a kdb diagnostic on failure.
336 int kdbgetintenv(const char *match, int *value)
341 diag = kdbgetulenv(match, &val);
348 * kdb_setenv() - Alter an existing environment variable or create a new one.
349 * @var: Name of the variable
350 * @val: Value of the variable
352 * Return: Zero on success, a kdb diagnostic on failure.
354 static int kdb_setenv(const char *var, const char *val)
358 size_t varlen, vallen;
360 varlen = strlen(var);
361 vallen = strlen(val);
362 ep = kdballocenv(varlen + vallen + 2);
364 return KDB_ENVBUFFULL;
366 sprintf(ep, "%s=%s", var, val);
368 for (i = 0; i < __nenv; i++) {
370 && ((strncmp(__env[i], var, varlen) == 0)
371 && ((__env[i][varlen] == '\0')
372 || (__env[i][varlen] == '=')))) {
379 * Wasn't existing variable. Fit into slot.
381 for (i = 0; i < __nenv-1; i++) {
382 if (__env[i] == (char *)0) {
392 * kdb_printenv() - Display the current environment variables.
394 static void kdb_printenv(void)
398 for (i = 0; i < __nenv; i++) {
400 kdb_printf("%s\n", __env[i]);
405 * kdbgetularg - This function will convert a numeric string into an
406 * unsigned long value.
408 * arg A character string representing a numeric value
410 * *value the unsigned long representation of arg.
412 * Zero on success, a kdb diagnostic on failure.
414 int kdbgetularg(const char *arg, unsigned long *value)
419 val = simple_strtoul(arg, &endp, 0);
423 * Also try base 16, for us folks too lazy to type the
426 val = simple_strtoul(arg, &endp, 16);
436 int kdbgetu64arg(const char *arg, u64 *value)
441 val = simple_strtoull(arg, &endp, 0);
445 val = simple_strtoull(arg, &endp, 16);
456 * kdb_set - This function implements the 'set' command. Alter an
457 * existing environment variable or create a new one.
459 int kdb_set(int argc, const char **argv)
462 * we can be invoked two ways:
463 * set var=value argv[1]="var", argv[2]="value"
464 * set var = value argv[1]="var", argv[2]="=", argv[3]="value"
465 * - if the latter, shift 'em down.
476 * Censor sensitive variables
478 if (strcmp(argv[1], "PROMPT") == 0 &&
479 !kdb_check_flags(KDB_ENABLE_MEM_READ, kdb_cmd_enabled, false))
483 * Check for internal variables
485 if (strcmp(argv[1], "KDBDEBUG") == 0) {
486 unsigned int debugflags;
489 debugflags = simple_strtoul(argv[2], &cp, 0);
490 if (cp == argv[2] || debugflags & ~KDB_DEBUG_FLAG_MASK) {
491 kdb_printf("kdb: illegal debug flags '%s'\n",
495 kdb_flags = (kdb_flags & ~KDB_DEBUG(MASK))
496 | (debugflags << KDB_DEBUG_FLAG_SHIFT);
502 * Tokenizer squashed the '=' sign. argv[1] is variable
503 * name, argv[2] = value.
505 return kdb_setenv(argv[1], argv[2]);
508 static int kdb_check_regs(void)
510 if (!kdb_current_regs) {
511 kdb_printf("No current kdb registers."
512 " You may need to select another task\n");
519 * kdbgetaddrarg - This function is responsible for parsing an
520 * address-expression and returning the value of the expression,
521 * symbol name, and offset to the caller.
523 * The argument may consist of a numeric value (decimal or
524 * hexadecimal), a symbol name, a register name (preceded by the
525 * percent sign), an environment variable with a numeric value
526 * (preceded by a dollar sign) or a simple arithmetic expression
527 * consisting of a symbol name, +/-, and a numeric constant value
530 * argc - count of arguments in argv
531 * argv - argument vector
532 * *nextarg - index to next unparsed argument in argv[]
533 * regs - Register state at time of KDB entry
535 * *value - receives the value of the address-expression
536 * *offset - receives the offset specified, if any
537 * *name - receives the symbol name, if any
538 * *nextarg - index to next unparsed argument in argv[]
540 * zero is returned on success, a kdb diagnostic code is
543 int kdbgetaddrarg(int argc, const char **argv, int *nextarg,
544 unsigned long *value, long *offset,
548 unsigned long off = 0;
558 * If the enable flags prohibit both arbitrary memory access
559 * and flow control then there are no reasonable grounds to
560 * provide symbol lookup.
562 if (!kdb_check_flags(KDB_ENABLE_MEM_READ | KDB_ENABLE_FLOW_CTRL,
563 kdb_cmd_enabled, false))
567 * Process arguments which follow the following syntax:
569 * symbol | numeric-address [+/- numeric-offset]
571 * $environment-variable
577 symname = (char *)argv[*nextarg];
580 * If there is no whitespace between the symbol
581 * or address and the '+' or '-' symbols, we
582 * remember the character and replace it with a
583 * null so the symbol/value can be properly parsed
585 cp = strpbrk(symname, "+-");
591 if (symname[0] == '$') {
592 diag = kdbgetulenv(&symname[1], &addr);
595 } else if (symname[0] == '%') {
596 diag = kdb_check_regs();
599 /* Implement register values with % at a later time as it is
604 found = kdbgetsymval(symname, &symtab);
606 addr = symtab.sym_start;
608 diag = kdbgetularg(argv[*nextarg], &addr);
615 found = kdbnearsym(addr, &symtab);
623 if (offset && name && *name)
624 *offset = addr - symtab.sym_start;
626 if ((*nextarg > argc)
631 * check for +/- and offset
634 if (symbol == '\0') {
635 if ((argv[*nextarg][0] != '+')
636 && (argv[*nextarg][0] != '-')) {
638 * Not our argument. Return.
642 positive = (argv[*nextarg][0] == '+');
646 positive = (symbol == '+');
649 * Now there must be an offset!
651 if ((*nextarg > argc)
652 && (symbol == '\0')) {
653 return KDB_INVADDRFMT;
657 cp = (char *)argv[*nextarg];
661 diag = kdbgetularg(cp, &off);
677 static void kdb_cmderror(int diag)
682 kdb_printf("no error detected (diagnostic is %d)\n", diag);
686 for (i = 0; i < __nkdb_err; i++) {
687 if (kdbmsgs[i].km_diag == diag) {
688 kdb_printf("diag: %d: %s\n", diag, kdbmsgs[i].km_msg);
693 kdb_printf("Unknown diag %d\n", -diag);
697 * kdb_defcmd, kdb_defcmd2 - This function implements the 'defcmd'
698 * command which defines one command as a set of other commands,
699 * terminated by endefcmd. kdb_defcmd processes the initial
700 * 'defcmd' command, kdb_defcmd2 is invoked from kdb_parse for
701 * the following commands until 'endefcmd'.
703 * argc argument count
704 * argv argument vector
706 * zero for success, a kdb diagnostic if error
709 kdbtab_t cmd; /* Macro command */
710 struct list_head statements; /* Associated statement list */
713 struct kdb_macro_statement {
714 char *statement; /* Statement text */
715 struct list_head list_node; /* Statement list node */
718 static struct kdb_macro *kdb_macro;
719 static bool defcmd_in_progress;
721 /* Forward references */
722 static int kdb_exec_defcmd(int argc, const char **argv);
724 static int kdb_defcmd2(const char *cmdstr, const char *argv0)
726 struct kdb_macro_statement *kms;
731 if (strcmp(argv0, "endefcmd") == 0) {
732 defcmd_in_progress = false;
733 if (!list_empty(&kdb_macro->statements))
734 kdb_register(&kdb_macro->cmd);
738 kms = kmalloc(sizeof(*kms), GFP_KDB);
740 kdb_printf("Could not allocate new kdb macro command: %s\n",
745 kms->statement = kdb_strdup(cmdstr, GFP_KDB);
746 list_add_tail(&kms->list_node, &kdb_macro->statements);
751 static int kdb_defcmd(int argc, const char **argv)
755 if (defcmd_in_progress) {
756 kdb_printf("kdb: nested defcmd detected, assuming missing "
758 kdb_defcmd2("endefcmd", "endefcmd");
762 struct kdb_macro *kmp;
763 struct kdb_macro_statement *kms;
765 list_for_each_entry(kp, &kdb_cmds_head, list_node) {
766 if (kp->func == kdb_exec_defcmd) {
767 kdb_printf("defcmd %s \"%s\" \"%s\"\n",
768 kp->name, kp->usage, kp->help);
769 kmp = container_of(kp, struct kdb_macro, cmd);
770 list_for_each_entry(kms, &kmp->statements,
772 kdb_printf("%s", kms->statement);
773 kdb_printf("endefcmd\n");
780 if (in_dbg_master()) {
781 kdb_printf("Command only available during kdb_init()\n");
784 kdb_macro = kzalloc(sizeof(*kdb_macro), GFP_KDB);
788 mp = &kdb_macro->cmd;
789 mp->func = kdb_exec_defcmd;
791 mp->flags = KDB_ENABLE_ALWAYS_SAFE;
792 mp->name = kdb_strdup(argv[1], GFP_KDB);
795 mp->usage = kdb_strdup(argv[2], GFP_KDB);
798 mp->help = kdb_strdup(argv[3], GFP_KDB);
801 if (mp->usage[0] == '"') {
802 strcpy(mp->usage, argv[2]+1);
803 mp->usage[strlen(mp->usage)-1] = '\0';
805 if (mp->help[0] == '"') {
806 strcpy(mp->help, argv[3]+1);
807 mp->help[strlen(mp->help)-1] = '\0';
810 INIT_LIST_HEAD(&kdb_macro->statements);
811 defcmd_in_progress = true;
820 kdb_printf("Could not allocate new kdb_macro entry for %s\n", argv[1]);
825 * kdb_exec_defcmd - Execute the set of commands associated with this
828 * argc argument count
829 * argv argument vector
831 * zero for success, a kdb diagnostic if error
833 static int kdb_exec_defcmd(int argc, const char **argv)
837 struct kdb_macro *kmp;
838 struct kdb_macro_statement *kms;
843 list_for_each_entry(kp, &kdb_cmds_head, list_node) {
844 if (strcmp(kp->name, argv[0]) == 0)
847 if (list_entry_is_head(kp, &kdb_cmds_head, list_node)) {
848 kdb_printf("kdb_exec_defcmd: could not find commands for %s\n",
852 kmp = container_of(kp, struct kdb_macro, cmd);
853 list_for_each_entry(kms, &kmp->statements, list_node) {
855 * Recursive use of kdb_parse, do not use argv after this point.
858 kdb_printf("[%s]kdb> %s\n", kmp->cmd.name, kms->statement);
859 ret = kdb_parse(kms->statement);
866 /* Command history */
867 #define KDB_CMD_HISTORY_COUNT 32
868 #define CMD_BUFLEN 200 /* kdb_printf: max printline
870 static unsigned int cmd_head, cmd_tail;
871 static unsigned int cmdptr;
872 static char cmd_hist[KDB_CMD_HISTORY_COUNT][CMD_BUFLEN];
873 static char cmd_cur[CMD_BUFLEN];
876 * The "str" argument may point to something like | grep xyz
878 static void parse_grep(const char *str)
881 char *cp = (char *)str, *cp2;
883 /* sanity check: we should have been called with the \ first */
889 if (!str_has_prefix(cp, "grep ")) {
890 kdb_printf("invalid 'pipe', see grephelp\n");
896 cp2 = strchr(cp, '\n');
898 *cp2 = '\0'; /* remove the trailing newline */
901 kdb_printf("invalid 'pipe', see grephelp\n");
904 /* now cp points to a nonzero length search string */
906 /* allow it be "x y z" by removing the "'s - there must
909 cp2 = strchr(cp, '"');
911 kdb_printf("invalid quoted string, see grephelp\n");
914 *cp2 = '\0'; /* end the string where the 2nd " was */
916 kdb_grep_leading = 0;
918 kdb_grep_leading = 1;
922 kdb_grep_trailing = 0;
923 if (*(cp+len-1) == '$') {
924 kdb_grep_trailing = 1;
930 if (len >= KDB_GREP_STRLEN) {
931 kdb_printf("search string too long\n");
934 strcpy(kdb_grep_string, cp);
940 * kdb_parse - Parse the command line, search the command table for a
941 * matching command and invoke the command function. This
942 * function may be called recursively, if it is, the second call
943 * will overwrite argv and cbuf. It is the caller's
944 * responsibility to save their argv if they recursively call
947 * cmdstr The input command line to be parsed.
948 * regs The registers at the time kdb was entered.
950 * Zero for success, a kdb diagnostic if failure.
952 * Limited to 20 tokens.
954 * Real rudimentary tokenization. Basically only whitespace
955 * is considered a token delimiter (but special consideration
956 * is taken of the '=' sign as used by the 'set' command).
958 * The algorithm used to tokenize the input string relies on
959 * there being at least one whitespace (or otherwise useless)
960 * character between tokens as the character immediately following
961 * the token is altered in-place to a null-byte to terminate the
967 int kdb_parse(const char *cmdstr)
969 static char *argv[MAXARGC];
971 static char cbuf[CMD_BUFLEN+2];
975 int escaped, ignore_errors = 0, check_grep = 0;
978 * First tokenize the command string.
982 if (KDB_FLAG(CMD_INTERRUPT)) {
983 /* Previous command was interrupted, newline must not
984 * repeat the command */
985 KDB_FLAG_CLEAR(CMD_INTERRUPT);
986 KDB_STATE_SET(PAGER);
987 argc = 0; /* no repeat */
990 if (*cp != '\n' && *cp != '\0') {
994 /* skip whitespace */
997 if ((*cp == '\0') || (*cp == '\n') ||
998 (*cp == '#' && !defcmd_in_progress))
1000 /* special case: check for | grep pattern */
1005 if (cpp >= cbuf + CMD_BUFLEN) {
1006 kdb_printf("kdb_parse: command buffer "
1007 "overflow, command ignored\n%s\n",
1009 return KDB_NOTFOUND;
1011 if (argc >= MAXARGC - 1) {
1012 kdb_printf("kdb_parse: too many arguments, "
1013 "command ignored\n%s\n", cmdstr);
1014 return KDB_NOTFOUND;
1019 /* Copy to next unquoted and unescaped
1020 * whitespace or '=' */
1021 while (*cp && *cp != '\n' &&
1022 (escaped || quoted || !isspace(*cp))) {
1023 if (cpp >= cbuf + CMD_BUFLEN)
1037 else if (*cp == '\'' || *cp == '"')
1040 if (*cpp == '=' && !quoted)
1044 *cpp++ = '\0'; /* Squash a ws or '=' character */
1051 if (defcmd_in_progress) {
1052 int result = kdb_defcmd2(cmdstr, argv[0]);
1053 if (!defcmd_in_progress) {
1054 argc = 0; /* avoid repeat on endefcmd */
1059 if (argv[0][0] == '-' && argv[0][1] &&
1060 (argv[0][1] < '0' || argv[0][1] > '9')) {
1065 list_for_each_entry(tp, &kdb_cmds_head, list_node) {
1067 * If this command is allowed to be abbreviated,
1068 * check to see if this is it.
1070 if (tp->minlen && (strlen(argv[0]) <= tp->minlen) &&
1071 (strncmp(argv[0], tp->name, tp->minlen) == 0))
1074 if (strcmp(argv[0], tp->name) == 0)
1079 * If we don't find a command by this name, see if the first
1080 * few characters of this match any of the known commands.
1081 * e.g., md1c20 should match md.
1083 if (list_entry_is_head(tp, &kdb_cmds_head, list_node)) {
1084 list_for_each_entry(tp, &kdb_cmds_head, list_node) {
1085 if (strncmp(argv[0], tp->name, strlen(tp->name)) == 0)
1090 if (!list_entry_is_head(tp, &kdb_cmds_head, list_node)) {
1093 if (!kdb_check_flags(tp->flags, kdb_cmd_enabled, argc <= 1))
1097 result = (*tp->func)(argc-1, (const char **)argv);
1098 if (result && ignore_errors && result > KDB_CMD_GO)
1100 KDB_STATE_CLEAR(CMD);
1102 if (tp->flags & KDB_REPEAT_WITH_ARGS)
1105 argc = tp->flags & KDB_REPEAT_NO_ARGS ? 1 : 0;
1107 *(argv[argc]) = '\0';
1112 * If the input with which we were presented does not
1113 * map to an existing command, attempt to parse it as an
1114 * address argument and display the result. Useful for
1115 * obtaining the address of a variable, or the nearest symbol
1116 * to an address contained in a register.
1119 unsigned long value;
1124 if (kdbgetaddrarg(0, (const char **)argv, &nextarg,
1125 &value, &offset, &name)) {
1126 return KDB_NOTFOUND;
1129 kdb_printf("%s = ", argv[0]);
1130 kdb_symbol_print(value, NULL, KDB_SP_DEFAULT);
1137 static int handle_ctrl_cmd(char *cmd)
1142 /* initial situation */
1143 if (cmd_head == cmd_tail)
1147 if (cmdptr != cmd_tail)
1148 cmdptr = (cmdptr + KDB_CMD_HISTORY_COUNT - 1) %
1149 KDB_CMD_HISTORY_COUNT;
1150 strscpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1153 if (cmdptr != cmd_head)
1154 cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT;
1155 strscpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1162 * kdb_reboot - This function implements the 'reboot' command. Reboot
1163 * the system immediately, or loop for ever on failure.
1165 static int kdb_reboot(int argc, const char **argv)
1167 emergency_restart();
1168 kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
1175 static void kdb_dumpregs(struct pt_regs *regs)
1177 int old_lvl = console_loglevel;
1178 console_loglevel = CONSOLE_LOGLEVEL_MOTORMOUTH;
1183 console_loglevel = old_lvl;
1186 static void kdb_set_current_task(struct task_struct *p)
1188 kdb_current_task = p;
1190 if (kdb_task_has_cpu(p)) {
1191 kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p));
1194 kdb_current_regs = NULL;
1197 static void drop_newline(char *buf)
1199 size_t len = strlen(buf);
1203 if (*(buf + len - 1) == '\n')
1204 *(buf + len - 1) = '\0';
1208 * kdb_local - The main code for kdb. This routine is invoked on a
1209 * specific processor, it is not global. The main kdb() routine
1210 * ensures that only one processor at a time is in this routine.
1211 * This code is called with the real reason code on the first
1212 * entry to a kdb session, thereafter it is called with reason
1213 * SWITCH, even if the user goes back to the original cpu.
1215 * reason The reason KDB was invoked
1216 * error The hardware-defined error code
1217 * regs The exception frame at time of fault/breakpoint.
1218 * db_result Result code from the break or debug point.
1220 * 0 KDB was invoked for an event which it wasn't responsible
1221 * 1 KDB handled the event for which it was invoked.
1222 * KDB_CMD_GO User typed 'go'.
1223 * KDB_CMD_CPU User switched to another cpu.
1224 * KDB_CMD_SS Single step.
1226 static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs,
1227 kdb_dbtrap_t db_result)
1231 struct task_struct *kdb_current =
1232 kdb_curr_task(raw_smp_processor_id());
1234 KDB_DEBUG_STATE("kdb_local 1", reason);
1236 kdb_check_for_lockdown();
1239 if (reason == KDB_REASON_DEBUG) {
1240 /* special case below */
1242 kdb_printf("\nEntering kdb (current=0x%px, pid %d) ",
1243 kdb_current, kdb_current ? kdb_current->pid : 0);
1244 #if defined(CONFIG_SMP)
1245 kdb_printf("on processor %d ", raw_smp_processor_id());
1250 case KDB_REASON_DEBUG:
1253 * If re-entering kdb after a single step
1254 * command, don't print the message.
1256 switch (db_result) {
1258 kdb_printf("\nEntering kdb (0x%px, pid %d) ",
1259 kdb_current, kdb_current->pid);
1260 #if defined(CONFIG_SMP)
1261 kdb_printf("on processor %d ", raw_smp_processor_id());
1263 kdb_printf("due to Debug @ " kdb_machreg_fmt "\n",
1264 instruction_pointer(regs));
1269 KDB_DEBUG_STATE("kdb_local 4", reason);
1270 return 1; /* kdba_db_trap did the work */
1272 kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
1279 case KDB_REASON_ENTER:
1280 if (KDB_STATE(KEYBOARD))
1281 kdb_printf("due to Keyboard Entry\n");
1283 kdb_printf("due to KDB_ENTER()\n");
1285 case KDB_REASON_KEYBOARD:
1286 KDB_STATE_SET(KEYBOARD);
1287 kdb_printf("due to Keyboard Entry\n");
1289 case KDB_REASON_ENTER_SLAVE:
1290 /* drop through, slaves only get released via cpu switch */
1291 case KDB_REASON_SWITCH:
1292 kdb_printf("due to cpu switch\n");
1294 case KDB_REASON_OOPS:
1295 kdb_printf("Oops: %s\n", kdb_diemsg);
1296 kdb_printf("due to oops @ " kdb_machreg_fmt "\n",
1297 instruction_pointer(regs));
1300 case KDB_REASON_SYSTEM_NMI:
1301 kdb_printf("due to System NonMaskable Interrupt\n");
1303 case KDB_REASON_NMI:
1304 kdb_printf("due to NonMaskable Interrupt @ "
1305 kdb_machreg_fmt "\n",
1306 instruction_pointer(regs));
1308 case KDB_REASON_SSTEP:
1309 case KDB_REASON_BREAK:
1310 kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
1311 reason == KDB_REASON_BREAK ?
1312 "Breakpoint" : "SS trap", instruction_pointer(regs));
1314 * Determine if this breakpoint is one that we
1315 * are interested in.
1317 if (db_result != KDB_DB_BPT) {
1318 kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1320 KDB_DEBUG_STATE("kdb_local 6", reason);
1321 return 0; /* Not for us, dismiss it */
1324 case KDB_REASON_RECURSE:
1325 kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
1326 instruction_pointer(regs));
1329 kdb_printf("kdb: unexpected reason code: %d\n", reason);
1330 KDB_DEBUG_STATE("kdb_local 8", reason);
1331 return 0; /* Not for us, dismiss it */
1336 * Initialize pager context.
1339 KDB_STATE_CLEAR(SUPPRESS);
1340 kdb_grepping_flag = 0;
1341 /* ensure the old search does not leak into '/' commands */
1342 kdb_grep_string[0] = '\0';
1346 *(cmd_hist[cmd_head]) = '\0';
1349 /* PROMPT can only be set if we have MEM_READ permission. */
1350 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
1351 raw_smp_processor_id());
1352 if (defcmd_in_progress)
1353 strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
1356 * Fetch command from keyboard
1358 cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
1359 if (*cmdbuf != '\n') {
1361 if (cmdptr == cmd_head) {
1362 strscpy(cmd_hist[cmd_head], cmd_cur,
1364 *(cmd_hist[cmd_head] +
1365 strlen(cmd_hist[cmd_head])-1) = '\0';
1367 if (!handle_ctrl_cmd(cmdbuf))
1368 *(cmd_cur+strlen(cmd_cur)-1) = '\0';
1370 goto do_full_getstr;
1372 strscpy(cmd_hist[cmd_head], cmd_cur,
1376 cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
1377 if (cmd_head == cmd_tail)
1378 cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
1382 diag = kdb_parse(cmdbuf);
1383 if (diag == KDB_NOTFOUND) {
1384 drop_newline(cmdbuf);
1385 kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
1388 if (diag == KDB_CMD_GO
1389 || diag == KDB_CMD_CPU
1390 || diag == KDB_CMD_SS
1391 || diag == KDB_CMD_KGDB)
1397 KDB_DEBUG_STATE("kdb_local 9", diag);
1403 * kdb_print_state - Print the state data for the current processor
1406 * text Identifies the debug point
1407 * value Any integer value to be printed, e.g. reason code.
1409 void kdb_print_state(const char *text, int value)
1411 kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1412 text, raw_smp_processor_id(), value, kdb_initial_cpu,
1417 * kdb_main_loop - After initial setup and assignment of the
1418 * controlling cpu, all cpus are in this loop. One cpu is in
1419 * control and will issue the kdb prompt, the others will spin
1420 * until 'go' or cpu switch.
1422 * To get a consistent view of the kernel stacks for all
1423 * processes, this routine is invoked from the main kdb code via
1424 * an architecture specific routine. kdba_main_loop is
1425 * responsible for making the kernel stacks consistent for all
1426 * processes, there should be no difference between a blocked
1427 * process and a running process as far as kdb is concerned.
1429 * reason The reason KDB was invoked
1430 * error The hardware-defined error code
1431 * reason2 kdb's current reason code.
1432 * Initially error but can change
1433 * according to kdb state.
1434 * db_result Result code from break or debug point.
1435 * regs The exception frame at time of fault/breakpoint.
1436 * should always be valid.
1438 * 0 KDB was invoked for an event which it wasn't responsible
1439 * 1 KDB handled the event for which it was invoked.
1441 int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
1442 kdb_dbtrap_t db_result, struct pt_regs *regs)
1445 /* Stay in kdb() until 'go', 'ss[b]' or an error */
1448 * All processors except the one that is in control
1451 KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1452 while (KDB_STATE(HOLD_CPU)) {
1453 /* state KDB is turned off by kdb_cpu to see if the
1454 * other cpus are still live, each cpu in this loop
1457 if (!KDB_STATE(KDB))
1461 KDB_STATE_CLEAR(SUPPRESS);
1462 KDB_DEBUG_STATE("kdb_main_loop 2", reason);
1463 if (KDB_STATE(LEAVING))
1464 break; /* Another cpu said 'go' */
1465 /* Still using kdb, this processor is in control */
1466 result = kdb_local(reason2, error, regs, db_result);
1467 KDB_DEBUG_STATE("kdb_main_loop 3", result);
1469 if (result == KDB_CMD_CPU)
1472 if (result == KDB_CMD_SS) {
1473 KDB_STATE_SET(DOING_SS);
1477 if (result == KDB_CMD_KGDB) {
1478 if (!KDB_STATE(DOING_KGDB))
1479 kdb_printf("Entering please attach debugger "
1480 "or use $D#44+ or $3#33\n");
1483 if (result && result != 1 && result != KDB_CMD_GO)
1484 kdb_printf("\nUnexpected kdb_local return code %d\n",
1486 KDB_DEBUG_STATE("kdb_main_loop 4", reason);
1489 if (KDB_STATE(DOING_SS))
1490 KDB_STATE_CLEAR(SSBPT);
1492 /* Clean up any keyboard devices before leaving */
1493 kdb_kbd_cleanup_state();
1499 * kdb_mdr - This function implements the guts of the 'mdr', memory
1501 * mdr <addr arg>,<byte count>
1503 * addr Start address
1504 * count Number of bytes
1506 * Always 0. Any errors are detected and printed by kdb_getarea.
1508 static int kdb_mdr(unsigned long addr, unsigned int count)
1512 if (kdb_getarea(c, addr))
1514 kdb_printf("%02x", c);
1522 * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1523 * 'md8' 'mdr' and 'mds' commands.
1525 * md|mds [<addr arg> [<line count> [<radix>]]]
1526 * mdWcN [<addr arg> [<line count> [<radix>]]]
1527 * where W = is the width (1, 2, 4 or 8) and N is the count.
1528 * for eg., md1c20 reads 20 bytes, 1 at a time.
1529 * mdr <addr arg>,<byte count>
1531 static void kdb_md_line(const char *fmtstr, unsigned long addr,
1532 int symbolic, int nosect, int bytesperword,
1533 int num, int repeat, int phys)
1535 /* print just one line of data */
1536 kdb_symtab_t symtab;
1543 memset(cbuf, '\0', sizeof(cbuf));
1545 kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1547 kdb_printf(kdb_machreg_fmt0 " ", addr);
1549 for (i = 0; i < num && repeat--; i++) {
1551 if (kdb_getphysword(&word, addr, bytesperword))
1553 } else if (kdb_getword(&word, addr, bytesperword))
1555 kdb_printf(fmtstr, word);
1557 kdbnearsym(word, &symtab);
1559 memset(&symtab, 0, sizeof(symtab));
1560 if (symtab.sym_name) {
1561 kdb_symbol_print(word, &symtab, 0);
1564 kdb_printf(" %s %s "
1567 kdb_machreg_fmt, symtab.mod_name,
1568 symtab.sec_name, symtab.sec_start,
1569 symtab.sym_start, symtab.sym_end);
1571 addr += bytesperword;
1579 cp = wc.c + 8 - bytesperword;
1584 #define printable_char(c) \
1585 ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1586 for (j = 0; j < bytesperword; j++)
1587 *c++ = printable_char(*cp++);
1588 addr += bytesperword;
1589 #undef printable_char
1592 kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1596 static int kdb_md(int argc, const char **argv)
1598 static unsigned long last_addr;
1599 static int last_radix, last_bytesperword, last_repeat;
1600 int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1602 char fmtchar, fmtstr[64];
1611 kdbgetintenv("MDCOUNT", &mdcount);
1612 kdbgetintenv("RADIX", &radix);
1613 kdbgetintenv("BYTESPERWORD", &bytesperword);
1615 /* Assume 'md <addr>' and start with environment values */
1616 repeat = mdcount * 16 / bytesperword;
1618 if (strcmp(argv[0], "mdr") == 0) {
1619 if (argc == 2 || (argc == 0 && last_addr != 0))
1622 return KDB_ARGCOUNT;
1623 } else if (isdigit(argv[0][2])) {
1624 bytesperword = (int)(argv[0][2] - '0');
1625 if (bytesperword == 0) {
1626 bytesperword = last_bytesperword;
1627 if (bytesperword == 0)
1630 last_bytesperword = bytesperword;
1631 repeat = mdcount * 16 / bytesperword;
1634 else if (argv[0][3] == 'c' && argv[0][4]) {
1636 repeat = simple_strtoul(argv[0] + 4, &p, 10);
1637 mdcount = ((repeat * bytesperword) + 15) / 16;
1640 last_repeat = repeat;
1641 } else if (strcmp(argv[0], "md") == 0)
1643 else if (strcmp(argv[0], "mds") == 0)
1645 else if (strcmp(argv[0], "mdp") == 0) {
1649 return KDB_NOTFOUND;
1653 return KDB_ARGCOUNT;
1656 bytesperword = last_bytesperword;
1657 repeat = last_repeat;
1661 mdcount = ((repeat * bytesperword) + 15) / 16;
1666 int diag, nextarg = 1;
1667 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1671 if (argc > nextarg+2)
1672 return KDB_ARGCOUNT;
1674 if (argc >= nextarg) {
1675 diag = kdbgetularg(argv[nextarg], &val);
1677 mdcount = (int) val;
1681 repeat = mdcount * 16 / bytesperword;
1684 if (argc >= nextarg+1) {
1685 diag = kdbgetularg(argv[nextarg+1], &val);
1691 if (strcmp(argv[0], "mdr") == 0) {
1694 ret = kdb_mdr(addr, mdcount);
1695 last_addr += mdcount;
1696 last_repeat = mdcount;
1697 last_bytesperword = bytesperword; // to make REPEAT happy
1712 return KDB_BADRADIX;
1717 if (bytesperword > KDB_WORD_SIZE)
1718 return KDB_BADWIDTH;
1720 switch (bytesperword) {
1722 sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1725 sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1728 sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1731 sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1734 return KDB_BADWIDTH;
1737 last_repeat = repeat;
1738 last_bytesperword = bytesperword;
1740 if (strcmp(argv[0], "mds") == 0) {
1742 /* Do not save these changes as last_*, they are temporary mds
1745 bytesperword = KDB_WORD_SIZE;
1747 kdbgetintenv("NOSECT", &nosect);
1750 /* Round address down modulo BYTESPERWORD */
1752 addr &= ~(bytesperword-1);
1754 while (repeat > 0) {
1756 int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1758 if (KDB_FLAG(CMD_INTERRUPT))
1760 for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1762 if (kdb_getphysword(&word, a, bytesperword)
1765 } else if (kdb_getword(&word, a, bytesperword) || word)
1768 n = min(num, repeat);
1769 kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1771 addr += bytesperword * n;
1773 z = (z + num - 1) / num;
1775 int s = num * (z-2);
1776 kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1777 " zero suppressed\n",
1778 addr, addr + bytesperword * s - 1);
1779 addr += bytesperword * s;
1789 * kdb_mm - This function implements the 'mm' command.
1790 * mm address-expression new-value
1792 * mm works on machine words, mmW works on bytes.
1794 static int kdb_mm(int argc, const char **argv)
1799 unsigned long contents;
1803 if (argv[0][2] && !isdigit(argv[0][2]))
1804 return KDB_NOTFOUND;
1807 return KDB_ARGCOUNT;
1810 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1815 return KDB_ARGCOUNT;
1816 diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1820 if (nextarg != argc + 1)
1821 return KDB_ARGCOUNT;
1823 width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1824 diag = kdb_putword(addr, contents, width);
1828 kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1834 * kdb_go - This function implements the 'go' command.
1835 * go [address-expression]
1837 static int kdb_go(int argc, const char **argv)
1844 if (raw_smp_processor_id() != kdb_initial_cpu) {
1845 kdb_printf("go must execute on the entry cpu, "
1846 "please use \"cpu %d\" and then execute go\n",
1848 return KDB_BADCPUNUM;
1852 diag = kdbgetaddrarg(argc, argv, &nextarg,
1853 &addr, &offset, NULL);
1857 return KDB_ARGCOUNT;
1861 if (KDB_FLAG(CATASTROPHIC)) {
1862 kdb_printf("Catastrophic error detected\n");
1863 kdb_printf("kdb_continue_catastrophic=%d, ",
1864 kdb_continue_catastrophic);
1865 if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1866 kdb_printf("type go a second time if you really want "
1870 if (kdb_continue_catastrophic == 2) {
1871 kdb_printf("forcing reboot\n");
1872 kdb_reboot(0, NULL);
1874 kdb_printf("attempting to continue\n");
1880 * kdb_rd - This function implements the 'rd' command.
1882 static int kdb_rd(int argc, const char **argv)
1884 int len = kdb_check_regs();
1885 #if DBG_MAX_REG_NUM > 0
1897 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1898 rsize = dbg_reg_def[i].size * 2;
1901 if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
1906 len += kdb_printf(" ");
1907 switch(dbg_reg_def[i].size * 8) {
1909 rname = dbg_get_reg(i, ®8, kdb_current_regs);
1912 len += kdb_printf("%s: %02x", rname, reg8);
1915 rname = dbg_get_reg(i, ®16, kdb_current_regs);
1918 len += kdb_printf("%s: %04x", rname, reg16);
1921 rname = dbg_get_reg(i, ®32, kdb_current_regs);
1924 len += kdb_printf("%s: %08x", rname, reg32);
1927 rname = dbg_get_reg(i, ®64, kdb_current_regs);
1930 len += kdb_printf("%s: %016llx", rname, reg64);
1933 len += kdb_printf("%s: ??", dbg_reg_def[i].name);
1941 kdb_dumpregs(kdb_current_regs);
1947 * kdb_rm - This function implements the 'rm' (register modify) command.
1948 * rm register-name new-contents
1950 * Allows register modification with the same restrictions as gdb
1952 static int kdb_rm(int argc, const char **argv)
1954 #if DBG_MAX_REG_NUM > 0
1964 return KDB_ARGCOUNT;
1966 * Allow presence or absence of leading '%' symbol.
1972 diag = kdbgetu64arg(argv[2], ®64);
1976 diag = kdb_check_regs();
1981 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1982 if (strcmp(rname, dbg_reg_def[i].name) == 0) {
1988 switch(dbg_reg_def[i].size * 8) {
1991 dbg_set_reg(i, ®8, kdb_current_regs);
1995 dbg_set_reg(i, ®16, kdb_current_regs);
1999 dbg_set_reg(i, ®32, kdb_current_regs);
2002 dbg_set_reg(i, ®64, kdb_current_regs);
2008 kdb_printf("ERROR: Register set currently not implemented\n");
2013 #if defined(CONFIG_MAGIC_SYSRQ)
2015 * kdb_sr - This function implements the 'sr' (SYSRQ key) command
2016 * which interfaces to the soi-disant MAGIC SYSRQ functionality.
2017 * sr <magic-sysrq-code>
2019 static int kdb_sr(int argc, const char **argv)
2022 !kdb_check_flags(KDB_ENABLE_ALL, kdb_cmd_enabled, false);
2025 return KDB_ARGCOUNT;
2028 __handle_sysrq(*argv[1], check_mask);
2033 #endif /* CONFIG_MAGIC_SYSRQ */
2036 * kdb_ef - This function implements the 'regs' (display exception
2037 * frame) command. This command takes an address and expects to
2038 * find an exception frame at that address, formats and prints
2040 * regs address-expression
2044 static int kdb_ef(int argc, const char **argv)
2052 return KDB_ARGCOUNT;
2055 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
2058 show_regs((struct pt_regs *)addr);
2063 * kdb_env - This function implements the 'env' command. Display the
2064 * current environment variables.
2067 static int kdb_env(int argc, const char **argv)
2071 if (KDB_DEBUG(MASK))
2072 kdb_printf("KDBDEBUG=0x%x\n",
2073 (kdb_flags & KDB_DEBUG(MASK)) >> KDB_DEBUG_FLAG_SHIFT);
2078 #ifdef CONFIG_PRINTK
2080 * kdb_dmesg - This function implements the 'dmesg' command to display
2081 * the contents of the syslog buffer.
2082 * dmesg [lines] [adjust]
2084 static int kdb_dmesg(int argc, const char **argv)
2092 struct kmsg_dump_iter iter;
2097 return KDB_ARGCOUNT;
2100 lines = simple_strtol(argv[1], &cp, 0);
2104 adjust = simple_strtoul(argv[2], &cp, 0);
2105 if (*cp || adjust < 0)
2110 /* disable LOGGING if set */
2111 diag = kdbgetintenv("LOGGING", &logging);
2112 if (!diag && logging) {
2113 const char *setargs[] = { "set", "LOGGING", "0" };
2114 kdb_set(2, setargs);
2117 kmsg_dump_rewind(&iter);
2118 while (kmsg_dump_get_line(&iter, 1, NULL, 0, NULL))
2123 kdb_printf("buffer only contains %d lines, nothing "
2125 else if (adjust - lines >= n)
2126 kdb_printf("buffer only contains %d lines, last %d "
2127 "lines printed\n", n, n - adjust);
2130 } else if (lines > 0) {
2131 skip = n - lines - adjust;
2134 kdb_printf("buffer only contains %d lines, "
2135 "nothing printed\n", n);
2137 } else if (skip < 0) {
2140 kdb_printf("buffer only contains %d lines, first "
2141 "%d lines printed\n", n, lines);
2147 if (skip >= n || skip < 0)
2150 kmsg_dump_rewind(&iter);
2151 while (kmsg_dump_get_line(&iter, 1, buf, sizeof(buf), &len)) {
2158 if (KDB_FLAG(CMD_INTERRUPT))
2161 kdb_printf("%.*s\n", (int)len - 1, buf);
2166 #endif /* CONFIG_PRINTK */
2168 /* Make sure we balance enable/disable calls, must disable first. */
2169 static atomic_t kdb_nmi_disabled;
2171 static int kdb_disable_nmi(int argc, const char *argv[])
2173 if (atomic_read(&kdb_nmi_disabled))
2175 atomic_set(&kdb_nmi_disabled, 1);
2176 arch_kgdb_ops.enable_nmi(0);
2180 static int kdb_param_enable_nmi(const char *val, const struct kernel_param *kp)
2182 if (!atomic_add_unless(&kdb_nmi_disabled, -1, 0))
2184 arch_kgdb_ops.enable_nmi(1);
2188 static const struct kernel_param_ops kdb_param_ops_enable_nmi = {
2189 .set = kdb_param_enable_nmi,
2191 module_param_cb(enable_nmi, &kdb_param_ops_enable_nmi, NULL, 0600);
2194 * kdb_cpu - This function implements the 'cpu' command.
2197 * KDB_CMD_CPU for success, a kdb diagnostic if error
2199 static void kdb_cpu_status(void)
2201 int i, start_cpu, first_print = 1;
2202 char state, prev_state = '?';
2204 kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2205 kdb_printf("Available cpus: ");
2206 for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2207 if (!cpu_online(i)) {
2208 state = 'F'; /* cpu is offline */
2209 } else if (!kgdb_info[i].enter_kgdb) {
2210 state = 'D'; /* cpu is online but unresponsive */
2212 state = ' '; /* cpu is responding to kdb */
2213 if (kdb_task_state_char(KDB_TSK(i)) == '-')
2214 state = '-'; /* idle task */
2216 if (state != prev_state) {
2217 if (prev_state != '?') {
2221 kdb_printf("%d", start_cpu);
2222 if (start_cpu < i-1)
2223 kdb_printf("-%d", i-1);
2224 if (prev_state != ' ')
2225 kdb_printf("(%c)", prev_state);
2231 /* print the trailing cpus, ignoring them if they are all offline */
2232 if (prev_state != 'F') {
2235 kdb_printf("%d", start_cpu);
2236 if (start_cpu < i-1)
2237 kdb_printf("-%d", i-1);
2238 if (prev_state != ' ')
2239 kdb_printf("(%c)", prev_state);
2244 static int kdb_cpu(int argc, const char **argv)
2246 unsigned long cpunum;
2255 return KDB_ARGCOUNT;
2257 diag = kdbgetularg(argv[1], &cpunum);
2264 if ((cpunum >= CONFIG_NR_CPUS) || !kgdb_info[cpunum].enter_kgdb)
2265 return KDB_BADCPUNUM;
2267 dbg_switch_cpu = cpunum;
2270 * Switch to other cpu
2275 /* The user may not realize that ps/bta with no parameters does not print idle
2276 * or sleeping system daemon processes, so tell them how many were suppressed.
2278 void kdb_ps_suppressed(void)
2280 int idle = 0, daemon = 0;
2282 const struct task_struct *p, *g;
2283 for_each_online_cpu(cpu) {
2284 p = kdb_curr_task(cpu);
2285 if (kdb_task_state(p, "-"))
2288 for_each_process_thread(g, p) {
2289 if (kdb_task_state(p, "ims"))
2292 if (idle || daemon) {
2294 kdb_printf("%d idle process%s (state -)%s\n",
2295 idle, idle == 1 ? "" : "es",
2296 daemon ? " and " : "");
2298 kdb_printf("%d sleeping system daemon (state [ims]) "
2299 "process%s", daemon,
2300 daemon == 1 ? "" : "es");
2301 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2305 void kdb_ps1(const struct task_struct *p)
2311 copy_from_kernel_nofault(&tmp, (char *)p, sizeof(unsigned long)))
2314 cpu = kdb_process_cpu(p);
2315 kdb_printf("0x%px %8d %8d %d %4d %c 0x%px %c%s\n",
2316 (void *)p, p->pid, p->parent->pid,
2317 kdb_task_has_cpu(p), kdb_process_cpu(p),
2318 kdb_task_state_char(p),
2319 (void *)(&p->thread),
2320 p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2322 if (kdb_task_has_cpu(p)) {
2323 if (!KDB_TSK(cpu)) {
2324 kdb_printf(" Error: no saved data for this cpu\n");
2326 if (KDB_TSK(cpu) != p)
2327 kdb_printf(" Error: does not match running "
2328 "process table (0x%px)\n", KDB_TSK(cpu));
2334 * kdb_ps - This function implements the 'ps' command which shows a
2335 * list of the active processes.
2337 * ps [<state_chars>] Show processes, optionally selecting only those whose
2338 * state character is found in <state_chars>.
2340 static int kdb_ps(int argc, const char **argv)
2342 struct task_struct *g, *p;
2347 kdb_ps_suppressed();
2348 kdb_printf("%-*s Pid Parent [*] cpu State %-*s Command\n",
2349 (int)(2*sizeof(void *))+2, "Task Addr",
2350 (int)(2*sizeof(void *))+2, "Thread");
2351 mask = argc ? argv[1] : kdbgetenv("PS");
2352 /* Run the active tasks first */
2353 for_each_online_cpu(cpu) {
2354 if (KDB_FLAG(CMD_INTERRUPT))
2356 p = kdb_curr_task(cpu);
2357 if (kdb_task_state(p, mask))
2361 /* Now the real tasks */
2362 for_each_process_thread(g, p) {
2363 if (KDB_FLAG(CMD_INTERRUPT))
2365 if (kdb_task_state(p, mask))
2373 * kdb_pid - This function implements the 'pid' command which switches
2374 * the currently active process.
2377 static int kdb_pid(int argc, const char **argv)
2379 struct task_struct *p;
2384 return KDB_ARGCOUNT;
2387 if (strcmp(argv[1], "R") == 0) {
2388 p = KDB_TSK(kdb_initial_cpu);
2390 diag = kdbgetularg(argv[1], &val);
2394 p = find_task_by_pid_ns((pid_t)val, &init_pid_ns);
2396 kdb_printf("No task with pid=%d\n", (pid_t)val);
2400 kdb_set_current_task(p);
2402 kdb_printf("KDB current process is %s(pid=%d)\n",
2403 kdb_current_task->comm,
2404 kdb_current_task->pid);
2409 static int kdb_kgdb(int argc, const char **argv)
2411 return KDB_CMD_KGDB;
2415 * kdb_help - This function implements the 'help' and '?' commands.
2417 static int kdb_help(int argc, const char **argv)
2421 kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2422 kdb_printf("-----------------------------"
2423 "-----------------------------\n");
2424 list_for_each_entry(kt, &kdb_cmds_head, list_node) {
2426 if (KDB_FLAG(CMD_INTERRUPT))
2428 if (!kdb_check_flags(kt->flags, kdb_cmd_enabled, true))
2430 if (strlen(kt->usage) > 20)
2432 kdb_printf("%-15.15s %-20s%s%s\n", kt->name,
2433 kt->usage, space, kt->help);
2439 * kdb_kill - This function implements the 'kill' commands.
2441 static int kdb_kill(int argc, const char **argv)
2445 struct task_struct *p;
2448 return KDB_ARGCOUNT;
2450 sig = simple_strtol(argv[1], &endp, 0);
2453 if ((sig >= 0) || !valid_signal(-sig)) {
2454 kdb_printf("Invalid signal parameter.<-signal>\n");
2459 pid = simple_strtol(argv[2], &endp, 0);
2463 kdb_printf("Process ID must be large than 0.\n");
2467 /* Find the process. */
2468 p = find_task_by_pid_ns(pid, &init_pid_ns);
2470 kdb_printf("The specified process isn't found.\n");
2473 p = p->group_leader;
2474 kdb_send_sig(p, sig);
2479 * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2480 * I cannot call that code directly from kdb, it has an unconditional
2481 * cli()/sti() and calls routines that take locks which can stop the debugger.
2483 static void kdb_sysinfo(struct sysinfo *val)
2485 u64 uptime = ktime_get_mono_fast_ns();
2487 memset(val, 0, sizeof(*val));
2488 val->uptime = div_u64(uptime, NSEC_PER_SEC);
2489 val->loads[0] = avenrun[0];
2490 val->loads[1] = avenrun[1];
2491 val->loads[2] = avenrun[2];
2492 val->procs = nr_threads-1;
2499 * kdb_summary - This function implements the 'summary' command.
2501 static int kdb_summary(int argc, const char **argv)
2507 return KDB_ARGCOUNT;
2509 kdb_printf("sysname %s\n", init_uts_ns.name.sysname);
2510 kdb_printf("release %s\n", init_uts_ns.name.release);
2511 kdb_printf("version %s\n", init_uts_ns.name.version);
2512 kdb_printf("machine %s\n", init_uts_ns.name.machine);
2513 kdb_printf("nodename %s\n", init_uts_ns.name.nodename);
2514 kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2516 now = __ktime_get_real_seconds();
2517 kdb_printf("date %ptTs tz_minuteswest %d\n", &now, sys_tz.tz_minuteswest);
2519 kdb_printf("uptime ");
2520 if (val.uptime > (24*60*60)) {
2521 int days = val.uptime / (24*60*60);
2522 val.uptime %= (24*60*60);
2523 kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2525 kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2527 kdb_printf("load avg %ld.%02ld %ld.%02ld %ld.%02ld\n",
2528 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2529 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2530 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2532 /* Display in kilobytes */
2533 #define K(x) ((x) << (PAGE_SHIFT - 10))
2534 kdb_printf("\nMemTotal: %8lu kB\nMemFree: %8lu kB\n"
2535 "Buffers: %8lu kB\n",
2536 K(val.totalram), K(val.freeram), K(val.bufferram));
2541 * kdb_per_cpu - This function implements the 'per_cpu' command.
2543 static int kdb_per_cpu(int argc, const char **argv)
2546 int cpu, diag, nextarg = 1;
2547 unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2549 if (argc < 1 || argc > 3)
2550 return KDB_ARGCOUNT;
2552 diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2557 diag = kdbgetularg(argv[2], &bytesperword);
2562 bytesperword = KDB_WORD_SIZE;
2563 else if (bytesperword > KDB_WORD_SIZE)
2564 return KDB_BADWIDTH;
2565 sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2567 diag = kdbgetularg(argv[3], &whichcpu);
2570 if (whichcpu >= nr_cpu_ids || !cpu_online(whichcpu)) {
2571 kdb_printf("cpu %ld is not online\n", whichcpu);
2572 return KDB_BADCPUNUM;
2576 /* Most architectures use __per_cpu_offset[cpu], some use
2577 * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2579 #ifdef __per_cpu_offset
2580 #define KDB_PCU(cpu) __per_cpu_offset(cpu)
2583 #define KDB_PCU(cpu) __per_cpu_offset[cpu]
2585 #define KDB_PCU(cpu) 0
2588 for_each_online_cpu(cpu) {
2589 if (KDB_FLAG(CMD_INTERRUPT))
2592 if (whichcpu != ~0UL && whichcpu != cpu)
2594 addr = symaddr + KDB_PCU(cpu);
2595 diag = kdb_getword(&val, addr, bytesperword);
2597 kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2598 "read, diag=%d\n", cpu, addr, diag);
2601 kdb_printf("%5d ", cpu);
2602 kdb_md_line(fmtstr, addr,
2603 bytesperword == KDB_WORD_SIZE,
2604 1, bytesperword, 1, 1, 0);
2611 * display help for the use of cmd | grep pattern
2613 static int kdb_grep_help(int argc, const char **argv)
2615 kdb_printf("Usage of cmd args | grep pattern:\n");
2616 kdb_printf(" Any command's output may be filtered through an ");
2617 kdb_printf("emulated 'pipe'.\n");
2618 kdb_printf(" 'grep' is just a key word.\n");
2619 kdb_printf(" The pattern may include a very limited set of "
2620 "metacharacters:\n");
2621 kdb_printf(" pattern or ^pattern or pattern$ or ^pattern$\n");
2622 kdb_printf(" And if there are spaces in the pattern, you may "
2624 kdb_printf(" \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2625 " or \"^pat tern$\"\n");
2630 * kdb_register() - This function is used to register a kernel debugger
2632 * @cmd: pointer to kdb command
2634 * Note that it's the job of the caller to keep the memory for the cmd
2635 * allocated until unregister is called.
2637 int kdb_register(kdbtab_t *cmd)
2641 list_for_each_entry(kp, &kdb_cmds_head, list_node) {
2642 if (strcmp(kp->name, cmd->name) == 0) {
2643 kdb_printf("Duplicate kdb cmd: %s, func %p help %s\n",
2644 cmd->name, cmd->func, cmd->help);
2649 list_add_tail(&cmd->list_node, &kdb_cmds_head);
2652 EXPORT_SYMBOL_GPL(kdb_register);
2655 * kdb_register_table() - This function is used to register a kdb command
2657 * @kp: pointer to kdb command table
2658 * @len: length of kdb command table
2660 void kdb_register_table(kdbtab_t *kp, size_t len)
2663 list_add_tail(&kp->list_node, &kdb_cmds_head);
2669 * kdb_unregister() - This function is used to unregister a kernel debugger
2670 * command. It is generally called when a module which
2671 * implements kdb command is unloaded.
2672 * @cmd: pointer to kdb command
2674 void kdb_unregister(kdbtab_t *cmd)
2676 list_del(&cmd->list_node);
2678 EXPORT_SYMBOL_GPL(kdb_unregister);
2680 static kdbtab_t maintab[] = {
2684 .help = "Display Memory Contents, also mdWcN, e.g. md8c1",
2686 .flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS,
2690 .usage = "<vaddr> <bytes>",
2691 .help = "Display Raw Memory",
2692 .flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS,
2696 .usage = "<paddr> <bytes>",
2697 .help = "Display Physical Memory",
2698 .flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS,
2703 .help = "Display Memory Symbolically",
2704 .flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS,
2708 .usage = "<vaddr> <contents>",
2709 .help = "Modify Memory Contents",
2710 .flags = KDB_ENABLE_MEM_WRITE | KDB_REPEAT_NO_ARGS,
2714 .usage = "[<vaddr>]",
2715 .help = "Continue Execution",
2717 .flags = KDB_ENABLE_REG_WRITE |
2718 KDB_ENABLE_ALWAYS_SAFE_NO_ARGS,
2723 .help = "Display Registers",
2724 .flags = KDB_ENABLE_REG_READ,
2728 .usage = "<reg> <contents>",
2729 .help = "Modify Registers",
2730 .flags = KDB_ENABLE_REG_WRITE,
2735 .help = "Display exception frame",
2736 .flags = KDB_ENABLE_MEM_READ,
2740 .usage = "[<vaddr>]",
2741 .help = "Stack traceback",
2743 .flags = KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS,
2748 .help = "Display stack for process <pid>",
2749 .flags = KDB_ENABLE_INSPECT,
2753 .usage = "[<state_chars>|A]",
2754 .help = "Backtrace all processes whose state matches",
2755 .flags = KDB_ENABLE_INSPECT,
2760 .help = "Backtrace current process on each cpu",
2761 .flags = KDB_ENABLE_INSPECT,
2766 .help = "Backtrace process given its struct task address",
2767 .flags = KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS,
2772 .help = "Show environment variables",
2773 .flags = KDB_ENABLE_ALWAYS_SAFE,
2778 .help = "Set environment variables",
2779 .flags = KDB_ENABLE_ALWAYS_SAFE,
2784 .help = "Display Help Message",
2786 .flags = KDB_ENABLE_ALWAYS_SAFE,
2791 .help = "Display Help Message",
2792 .flags = KDB_ENABLE_ALWAYS_SAFE,
2796 .usage = "<cpunum>",
2797 .help = "Switch to new cpu",
2798 .flags = KDB_ENABLE_ALWAYS_SAFE_NO_ARGS,
2803 .help = "Enter kgdb mode",
2808 .usage = "[<state_chars>|A]",
2809 .help = "Display active task list",
2810 .flags = KDB_ENABLE_INSPECT,
2814 .usage = "<pidnum>",
2815 .help = "Switch to another task",
2816 .flags = KDB_ENABLE_INSPECT,
2821 .help = "Reboot the machine immediately",
2822 .flags = KDB_ENABLE_REBOOT,
2824 #if defined(CONFIG_MODULES)
2828 .help = "List loaded kernel modules",
2829 .flags = KDB_ENABLE_INSPECT,
2832 #if defined(CONFIG_MAGIC_SYSRQ)
2836 .help = "Magic SysRq key",
2837 .flags = KDB_ENABLE_ALWAYS_SAFE,
2840 #if defined(CONFIG_PRINTK)
2844 .help = "Display syslog buffer",
2845 .flags = KDB_ENABLE_ALWAYS_SAFE,
2850 .usage = "name \"usage\" \"help\"",
2851 .help = "Define a set of commands, down to endefcmd",
2853 * Macros are always safe because when executed each
2854 * internal command re-enters kdb_parse() and is safety
2855 * checked individually.
2857 .flags = KDB_ENABLE_ALWAYS_SAFE,
2861 .usage = "<-signal> <pid>",
2862 .help = "Send a signal to a process",
2863 .flags = KDB_ENABLE_SIGNAL,
2865 { .name = "summary",
2866 .func = kdb_summary,
2868 .help = "Summarize the system",
2870 .flags = KDB_ENABLE_ALWAYS_SAFE,
2872 { .name = "per_cpu",
2873 .func = kdb_per_cpu,
2874 .usage = "<sym> [<bytes>] [<cpu>]",
2875 .help = "Display per_cpu variables",
2877 .flags = KDB_ENABLE_MEM_READ,
2879 { .name = "grephelp",
2880 .func = kdb_grep_help,
2882 .help = "Display help on | grep",
2883 .flags = KDB_ENABLE_ALWAYS_SAFE,
2887 static kdbtab_t nmicmd = {
2888 .name = "disable_nmi",
2889 .func = kdb_disable_nmi,
2891 .help = "Disable NMI entry to KDB",
2892 .flags = KDB_ENABLE_ALWAYS_SAFE,
2895 /* Initialize the kdb command table. */
2896 static void __init kdb_inittab(void)
2898 kdb_register_table(maintab, ARRAY_SIZE(maintab));
2899 if (arch_kgdb_ops.enable_nmi)
2900 kdb_register_table(&nmicmd, 1);
2903 /* Execute any commands defined in kdb_cmds. */
2904 static void __init kdb_cmd_init(void)
2907 for (i = 0; kdb_cmds[i]; ++i) {
2908 diag = kdb_parse(kdb_cmds[i]);
2910 kdb_printf("kdb command %s failed, kdb diag %d\n",
2913 if (defcmd_in_progress) {
2914 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2915 kdb_parse("endefcmd");
2919 /* Initialize kdb_printf, breakpoint tables and kdb state */
2920 void __init kdb_init(int lvl)
2922 static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2925 if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2927 for (i = kdb_init_lvl; i < lvl; i++) {
2929 case KDB_NOT_INITIALIZED:
2930 kdb_inittab(); /* Initialize Command Table */
2931 kdb_initbptab(); /* Initialize Breakpoints */
2933 case KDB_INIT_EARLY:
2934 kdb_cmd_init(); /* Build kdb_cmds tables */