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/module.h>
30 #include <linux/moduleparam.h>
32 #include <linux/init.h>
33 #include <linux/kallsyms.h>
34 #include <linux/kgdb.h>
35 #include <linux/kdb.h>
36 #include <linux/notifier.h>
37 #include <linux/interrupt.h>
38 #include <linux/delay.h>
39 #include <linux/nmi.h>
40 #include <linux/time.h>
41 #include <linux/ptrace.h>
42 #include <linux/sysctl.h>
43 #include <linux/cpu.h>
44 #include <linux/kdebug.h>
45 #include <linux/proc_fs.h>
46 #include <linux/uaccess.h>
47 #include <linux/slab.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
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 EXPORT_SYMBOL(kdb_current_task
);
77 struct pt_regs
*kdb_current_regs
;
79 const char *kdb_diemsg
;
80 static int kdb_go_count
;
81 #ifdef CONFIG_KDB_CONTINUE_CATASTROPHIC
82 static unsigned int kdb_continue_catastrophic
=
83 CONFIG_KDB_CONTINUE_CATASTROPHIC
;
85 static unsigned int kdb_continue_catastrophic
;
88 /* kdb_commands describes the available commands. */
89 static kdbtab_t
*kdb_commands
;
90 #define KDB_BASE_CMD_MAX 50
91 static int kdb_max_commands
= KDB_BASE_CMD_MAX
;
92 static kdbtab_t kdb_base_commands
[KDB_BASE_CMD_MAX
];
93 #define for_each_kdbcmd(cmd, num) \
94 for ((cmd) = kdb_base_commands, (num) = 0; \
95 num < kdb_max_commands; \
96 num++, num == KDB_BASE_CMD_MAX ? cmd = kdb_commands : cmd++)
98 typedef struct _kdbmsg
{
99 int km_diag
; /* kdb diagnostic */
100 char *km_msg
; /* Corresponding message text */
103 #define KDBMSG(msgnum, text) \
104 { KDB_##msgnum, text }
106 static kdbmsg_t kdbmsgs
[] = {
107 KDBMSG(NOTFOUND
, "Command Not Found"),
108 KDBMSG(ARGCOUNT
, "Improper argument count, see usage."),
109 KDBMSG(BADWIDTH
, "Illegal value for BYTESPERWORD use 1, 2, 4 or 8, "
110 "8 is only allowed on 64 bit systems"),
111 KDBMSG(BADRADIX
, "Illegal value for RADIX use 8, 10 or 16"),
112 KDBMSG(NOTENV
, "Cannot find environment variable"),
113 KDBMSG(NOENVVALUE
, "Environment variable should have value"),
114 KDBMSG(NOTIMP
, "Command not implemented"),
115 KDBMSG(ENVFULL
, "Environment full"),
116 KDBMSG(ENVBUFFULL
, "Environment buffer full"),
117 KDBMSG(TOOMANYBPT
, "Too many breakpoints defined"),
118 #ifdef CONFIG_CPU_XSCALE
119 KDBMSG(TOOMANYDBREGS
, "More breakpoints than ibcr registers defined"),
121 KDBMSG(TOOMANYDBREGS
, "More breakpoints than db registers defined"),
123 KDBMSG(DUPBPT
, "Duplicate breakpoint address"),
124 KDBMSG(BPTNOTFOUND
, "Breakpoint not found"),
125 KDBMSG(BADMODE
, "Invalid IDMODE"),
126 KDBMSG(BADINT
, "Illegal numeric value"),
127 KDBMSG(INVADDRFMT
, "Invalid symbolic address format"),
128 KDBMSG(BADREG
, "Invalid register name"),
129 KDBMSG(BADCPUNUM
, "Invalid cpu number"),
130 KDBMSG(BADLENGTH
, "Invalid length field"),
131 KDBMSG(NOBP
, "No Breakpoint exists"),
132 KDBMSG(BADADDR
, "Invalid address"),
133 KDBMSG(NOPERM
, "Permission denied"),
137 static const int __nkdb_err
= ARRAY_SIZE(kdbmsgs
);
141 * Initial environment. This is all kept static and local to
142 * this file. We don't want to rely on the memory allocation
143 * mechanisms in the kernel, so we use a very limited allocate-only
144 * heap for new and altered environment variables. The entire
145 * environment is limited to a fixed number of entries (add more
146 * to __env[] if required) and a fixed amount of heap (add more to
147 * KDB_ENVBUFSIZE if required).
150 static char *__env
[] = {
151 #if defined(CONFIG_SMP)
158 "MDCOUNT=8", /* lines of md output */
188 static const int __nenv
= ARRAY_SIZE(__env
);
190 struct task_struct
*kdb_curr_task(int cpu
)
192 struct task_struct
*p
= curr_task(cpu
);
194 if ((task_thread_info(p
)->flags
& _TIF_MCA_INIT
) && KDB_TSK(cpu
))
201 * Check whether the flags of the current command and the permissions
202 * of the kdb console has allow a command to be run.
204 static inline bool kdb_check_flags(kdb_cmdflags_t flags
, int permissions
,
207 /* permissions comes from userspace so needs massaging slightly */
208 permissions
&= KDB_ENABLE_MASK
;
209 permissions
|= KDB_ENABLE_ALWAYS_SAFE
;
211 /* some commands change group when launched with no arguments */
213 permissions
|= permissions
<< KDB_ENABLE_NO_ARGS_SHIFT
;
215 flags
|= KDB_ENABLE_ALL
;
217 return permissions
& flags
;
221 * kdbgetenv - This function will return the character string value of
222 * an environment variable.
224 * match A character string representing an environment variable.
226 * NULL No environment variable matches 'match'
227 * char* Pointer to string value of environment variable.
229 char *kdbgetenv(const char *match
)
232 int matchlen
= strlen(match
);
235 for (i
= 0; i
< __nenv
; i
++) {
241 if ((strncmp(match
, e
, matchlen
) == 0)
242 && ((e
[matchlen
] == '\0')
243 || (e
[matchlen
] == '='))) {
244 char *cp
= strchr(e
, '=');
245 return cp
? ++cp
: "";
252 * kdballocenv - This function is used to allocate bytes for
253 * environment entries.
255 * match A character string representing a numeric value
257 * *value the unsigned long representation of the env variable 'match'
259 * Zero on success, a kdb diagnostic on failure.
261 * We use a static environment buffer (envbuffer) to hold the values
262 * of dynamically generated environment variables (see kdb_set). Buffer
263 * space once allocated is never free'd, so over time, the amount of space
264 * (currently 512 bytes) will be exhausted if env variables are changed
267 static char *kdballocenv(size_t bytes
)
269 #define KDB_ENVBUFSIZE 512
270 static char envbuffer
[KDB_ENVBUFSIZE
];
271 static int envbufsize
;
274 if ((KDB_ENVBUFSIZE
- envbufsize
) >= bytes
) {
275 ep
= &envbuffer
[envbufsize
];
282 * kdbgetulenv - This function will return the value of an unsigned
283 * long-valued environment variable.
285 * match A character string representing a numeric value
287 * *value the unsigned long represntation of the env variable 'match'
289 * Zero on success, a kdb diagnostic on failure.
291 static int kdbgetulenv(const char *match
, unsigned long *value
)
295 ep
= kdbgetenv(match
);
299 return KDB_NOENVVALUE
;
301 *value
= simple_strtoul(ep
, NULL
, 0);
307 * kdbgetintenv - This function will return the value of an
308 * integer-valued environment variable.
310 * match A character string representing an integer-valued env variable
312 * *value the integer representation of the environment variable 'match'
314 * Zero on success, a kdb diagnostic on failure.
316 int kdbgetintenv(const char *match
, int *value
)
321 diag
= kdbgetulenv(match
, &val
);
328 * kdbgetularg - This function will convert a numeric string into an
329 * unsigned long value.
331 * arg A character string representing a numeric value
333 * *value the unsigned long represntation of arg.
335 * Zero on success, a kdb diagnostic on failure.
337 int kdbgetularg(const char *arg
, unsigned long *value
)
342 val
= simple_strtoul(arg
, &endp
, 0);
346 * Also try base 16, for us folks too lazy to type the
349 val
= simple_strtoul(arg
, &endp
, 16);
359 int kdbgetu64arg(const char *arg
, u64
*value
)
364 val
= simple_strtoull(arg
, &endp
, 0);
368 val
= simple_strtoull(arg
, &endp
, 16);
379 * kdb_set - This function implements the 'set' command. Alter an
380 * existing environment variable or create a new one.
382 int kdb_set(int argc
, const char **argv
)
386 size_t varlen
, vallen
;
389 * we can be invoked two ways:
390 * set var=value argv[1]="var", argv[2]="value"
391 * set var = value argv[1]="var", argv[2]="=", argv[3]="value"
392 * - if the latter, shift 'em down.
403 * Check for internal variables
405 if (strcmp(argv
[1], "KDBDEBUG") == 0) {
406 unsigned int debugflags
;
409 debugflags
= simple_strtoul(argv
[2], &cp
, 0);
410 if (cp
== argv
[2] || debugflags
& ~KDB_DEBUG_FLAG_MASK
) {
411 kdb_printf("kdb: illegal debug flags '%s'\n",
415 kdb_flags
= (kdb_flags
&
416 ~(KDB_DEBUG_FLAG_MASK
<< KDB_DEBUG_FLAG_SHIFT
))
417 | (debugflags
<< KDB_DEBUG_FLAG_SHIFT
);
423 * Tokenizer squashed the '=' sign. argv[1] is variable
424 * name, argv[2] = value.
426 varlen
= strlen(argv
[1]);
427 vallen
= strlen(argv
[2]);
428 ep
= kdballocenv(varlen
+ vallen
+ 2);
430 return KDB_ENVBUFFULL
;
432 sprintf(ep
, "%s=%s", argv
[1], argv
[2]);
434 ep
[varlen
+vallen
+1] = '\0';
436 for (i
= 0; i
< __nenv
; i
++) {
438 && ((strncmp(__env
[i
], argv
[1], varlen
) == 0)
439 && ((__env
[i
][varlen
] == '\0')
440 || (__env
[i
][varlen
] == '=')))) {
447 * Wasn't existing variable. Fit into slot.
449 for (i
= 0; i
< __nenv
-1; i
++) {
450 if (__env
[i
] == (char *)0) {
459 static int kdb_check_regs(void)
461 if (!kdb_current_regs
) {
462 kdb_printf("No current kdb registers."
463 " You may need to select another task\n");
470 * kdbgetaddrarg - This function is responsible for parsing an
471 * address-expression and returning the value of the expression,
472 * symbol name, and offset to the caller.
474 * The argument may consist of a numeric value (decimal or
475 * hexidecimal), a symbol name, a register name (preceded by the
476 * percent sign), an environment variable with a numeric value
477 * (preceded by a dollar sign) or a simple arithmetic expression
478 * consisting of a symbol name, +/-, and a numeric constant value
481 * argc - count of arguments in argv
482 * argv - argument vector
483 * *nextarg - index to next unparsed argument in argv[]
484 * regs - Register state at time of KDB entry
486 * *value - receives the value of the address-expression
487 * *offset - receives the offset specified, if any
488 * *name - receives the symbol name, if any
489 * *nextarg - index to next unparsed argument in argv[]
491 * zero is returned on success, a kdb diagnostic code is
494 int kdbgetaddrarg(int argc
, const char **argv
, int *nextarg
,
495 unsigned long *value
, long *offset
,
499 unsigned long off
= 0;
509 * If the enable flags prohibit both arbitrary memory access
510 * and flow control then there are no reasonable grounds to
511 * provide symbol lookup.
513 if (!kdb_check_flags(KDB_ENABLE_MEM_READ
| KDB_ENABLE_FLOW_CTRL
,
514 kdb_cmd_enabled
, false))
518 * Process arguments which follow the following syntax:
520 * symbol | numeric-address [+/- numeric-offset]
522 * $environment-variable
528 symname
= (char *)argv
[*nextarg
];
531 * If there is no whitespace between the symbol
532 * or address and the '+' or '-' symbols, we
533 * remember the character and replace it with a
534 * null so the symbol/value can be properly parsed
536 cp
= strpbrk(symname
, "+-");
542 if (symname
[0] == '$') {
543 diag
= kdbgetulenv(&symname
[1], &addr
);
546 } else if (symname
[0] == '%') {
547 diag
= kdb_check_regs();
550 /* Implement register values with % at a later time as it is
555 found
= kdbgetsymval(symname
, &symtab
);
557 addr
= symtab
.sym_start
;
559 diag
= kdbgetularg(argv
[*nextarg
], &addr
);
566 found
= kdbnearsym(addr
, &symtab
);
574 if (offset
&& name
&& *name
)
575 *offset
= addr
- symtab
.sym_start
;
577 if ((*nextarg
> argc
)
582 * check for +/- and offset
585 if (symbol
== '\0') {
586 if ((argv
[*nextarg
][0] != '+')
587 && (argv
[*nextarg
][0] != '-')) {
589 * Not our argument. Return.
593 positive
= (argv
[*nextarg
][0] == '+');
597 positive
= (symbol
== '+');
600 * Now there must be an offset!
602 if ((*nextarg
> argc
)
603 && (symbol
== '\0')) {
604 return KDB_INVADDRFMT
;
608 cp
= (char *)argv
[*nextarg
];
612 diag
= kdbgetularg(cp
, &off
);
628 static void kdb_cmderror(int diag
)
633 kdb_printf("no error detected (diagnostic is %d)\n", diag
);
637 for (i
= 0; i
< __nkdb_err
; i
++) {
638 if (kdbmsgs
[i
].km_diag
== diag
) {
639 kdb_printf("diag: %d: %s\n", diag
, kdbmsgs
[i
].km_msg
);
644 kdb_printf("Unknown diag %d\n", -diag
);
648 * kdb_defcmd, kdb_defcmd2 - This function implements the 'defcmd'
649 * command which defines one command as a set of other commands,
650 * terminated by endefcmd. kdb_defcmd processes the initial
651 * 'defcmd' command, kdb_defcmd2 is invoked from kdb_parse for
652 * the following commands until 'endefcmd'.
654 * argc argument count
655 * argv argument vector
657 * zero for success, a kdb diagnostic if error
667 static struct defcmd_set
*defcmd_set
;
668 static int defcmd_set_count
;
669 static int defcmd_in_progress
;
671 /* Forward references */
672 static int kdb_exec_defcmd(int argc
, const char **argv
);
674 static int kdb_defcmd2(const char *cmdstr
, const char *argv0
)
676 struct defcmd_set
*s
= defcmd_set
+ defcmd_set_count
- 1;
677 char **save_command
= s
->command
;
678 if (strcmp(argv0
, "endefcmd") == 0) {
679 defcmd_in_progress
= 0;
683 /* macros are always safe because when executed each
684 * internal command re-enters kdb_parse() and is
685 * safety checked individually.
687 kdb_register_flags(s
->name
, kdb_exec_defcmd
, s
->usage
,
689 KDB_ENABLE_ALWAYS_SAFE
);
694 s
->command
= kzalloc((s
->count
+ 1) * sizeof(*(s
->command
)), GFP_KDB
);
696 kdb_printf("Could not allocate new kdb_defcmd table for %s\n",
701 memcpy(s
->command
, save_command
, s
->count
* sizeof(*(s
->command
)));
702 s
->command
[s
->count
++] = kdb_strdup(cmdstr
, GFP_KDB
);
707 static int kdb_defcmd(int argc
, const char **argv
)
709 struct defcmd_set
*save_defcmd_set
= defcmd_set
, *s
;
710 if (defcmd_in_progress
) {
711 kdb_printf("kdb: nested defcmd detected, assuming missing "
713 kdb_defcmd2("endefcmd", "endefcmd");
717 for (s
= defcmd_set
; s
< defcmd_set
+ defcmd_set_count
; ++s
) {
718 kdb_printf("defcmd %s \"%s\" \"%s\"\n", s
->name
,
720 for (i
= 0; i
< s
->count
; ++i
)
721 kdb_printf("%s", s
->command
[i
]);
722 kdb_printf("endefcmd\n");
728 if (in_dbg_master()) {
729 kdb_printf("Command only available during kdb_init()\n");
732 defcmd_set
= kmalloc((defcmd_set_count
+ 1) * sizeof(*defcmd_set
),
736 memcpy(defcmd_set
, save_defcmd_set
,
737 defcmd_set_count
* sizeof(*defcmd_set
));
738 s
= defcmd_set
+ defcmd_set_count
;
739 memset(s
, 0, sizeof(*s
));
741 s
->name
= kdb_strdup(argv
[1], GFP_KDB
);
744 s
->usage
= kdb_strdup(argv
[2], GFP_KDB
);
747 s
->help
= kdb_strdup(argv
[3], GFP_KDB
);
750 if (s
->usage
[0] == '"') {
751 strcpy(s
->usage
, argv
[2]+1);
752 s
->usage
[strlen(s
->usage
)-1] = '\0';
754 if (s
->help
[0] == '"') {
755 strcpy(s
->help
, argv
[3]+1);
756 s
->help
[strlen(s
->help
)-1] = '\0';
759 defcmd_in_progress
= 1;
760 kfree(save_defcmd_set
);
769 kdb_printf("Could not allocate new defcmd_set entry for %s\n", argv
[1]);
770 defcmd_set
= save_defcmd_set
;
775 * kdb_exec_defcmd - Execute the set of commands associated with this
778 * argc argument count
779 * argv argument vector
781 * zero for success, a kdb diagnostic if error
783 static int kdb_exec_defcmd(int argc
, const char **argv
)
786 struct defcmd_set
*s
;
789 for (s
= defcmd_set
, i
= 0; i
< defcmd_set_count
; ++i
, ++s
) {
790 if (strcmp(s
->name
, argv
[0]) == 0)
793 if (i
== defcmd_set_count
) {
794 kdb_printf("kdb_exec_defcmd: could not find commands for %s\n",
798 for (i
= 0; i
< s
->count
; ++i
) {
799 /* Recursive use of kdb_parse, do not use argv after
802 kdb_printf("[%s]kdb> %s\n", s
->name
, s
->command
[i
]);
803 ret
= kdb_parse(s
->command
[i
]);
810 /* Command history */
811 #define KDB_CMD_HISTORY_COUNT 32
812 #define CMD_BUFLEN 200 /* kdb_printf: max printline
814 static unsigned int cmd_head
, cmd_tail
;
815 static unsigned int cmdptr
;
816 static char cmd_hist
[KDB_CMD_HISTORY_COUNT
][CMD_BUFLEN
];
817 static char cmd_cur
[CMD_BUFLEN
];
820 * The "str" argument may point to something like | grep xyz
822 static void parse_grep(const char *str
)
825 char *cp
= (char *)str
, *cp2
;
827 /* sanity check: we should have been called with the \ first */
833 if (strncmp(cp
, "grep ", 5)) {
834 kdb_printf("invalid 'pipe', see grephelp\n");
840 cp2
= strchr(cp
, '\n');
842 *cp2
= '\0'; /* remove the trailing newline */
845 kdb_printf("invalid 'pipe', see grephelp\n");
848 /* now cp points to a nonzero length search string */
850 /* allow it be "x y z" by removing the "'s - there must
853 cp2
= strchr(cp
, '"');
855 kdb_printf("invalid quoted string, see grephelp\n");
858 *cp2
= '\0'; /* end the string where the 2nd " was */
860 kdb_grep_leading
= 0;
862 kdb_grep_leading
= 1;
866 kdb_grep_trailing
= 0;
867 if (*(cp
+len
-1) == '$') {
868 kdb_grep_trailing
= 1;
874 if (len
>= KDB_GREP_STRLEN
) {
875 kdb_printf("search string too long\n");
878 strcpy(kdb_grep_string
, cp
);
884 * kdb_parse - Parse the command line, search the command table for a
885 * matching command and invoke the command function. This
886 * function may be called recursively, if it is, the second call
887 * will overwrite argv and cbuf. It is the caller's
888 * responsibility to save their argv if they recursively call
891 * cmdstr The input command line to be parsed.
892 * regs The registers at the time kdb was entered.
894 * Zero for success, a kdb diagnostic if failure.
896 * Limited to 20 tokens.
898 * Real rudimentary tokenization. Basically only whitespace
899 * is considered a token delimeter (but special consideration
900 * is taken of the '=' sign as used by the 'set' command).
902 * The algorithm used to tokenize the input string relies on
903 * there being at least one whitespace (or otherwise useless)
904 * character between tokens as the character immediately following
905 * the token is altered in-place to a null-byte to terminate the
911 int kdb_parse(const char *cmdstr
)
913 static char *argv
[MAXARGC
];
915 static char cbuf
[CMD_BUFLEN
+2];
919 int i
, escaped
, ignore_errors
= 0, check_grep
= 0;
922 * First tokenize the command string.
926 if (KDB_FLAG(CMD_INTERRUPT
)) {
927 /* Previous command was interrupted, newline must not
928 * repeat the command */
929 KDB_FLAG_CLEAR(CMD_INTERRUPT
);
930 KDB_STATE_SET(PAGER
);
931 argc
= 0; /* no repeat */
934 if (*cp
!= '\n' && *cp
!= '\0') {
938 /* skip whitespace */
941 if ((*cp
== '\0') || (*cp
== '\n') ||
942 (*cp
== '#' && !defcmd_in_progress
))
944 /* special case: check for | grep pattern */
949 if (cpp
>= cbuf
+ CMD_BUFLEN
) {
950 kdb_printf("kdb_parse: command buffer "
951 "overflow, command ignored\n%s\n",
955 if (argc
>= MAXARGC
- 1) {
956 kdb_printf("kdb_parse: too many arguments, "
957 "command ignored\n%s\n", cmdstr
);
963 /* Copy to next unquoted and unescaped
964 * whitespace or '=' */
965 while (*cp
&& *cp
!= '\n' &&
966 (escaped
|| quoted
|| !isspace(*cp
))) {
967 if (cpp
>= cbuf
+ CMD_BUFLEN
)
981 else if (*cp
== '\'' || *cp
== '"')
984 if (*cpp
== '=' && !quoted
)
988 *cpp
++ = '\0'; /* Squash a ws or '=' character */
995 if (defcmd_in_progress
) {
996 int result
= kdb_defcmd2(cmdstr
, argv
[0]);
997 if (!defcmd_in_progress
) {
998 argc
= 0; /* avoid repeat on endefcmd */
1003 if (argv
[0][0] == '-' && argv
[0][1] &&
1004 (argv
[0][1] < '0' || argv
[0][1] > '9')) {
1009 for_each_kdbcmd(tp
, i
) {
1012 * If this command is allowed to be abbreviated,
1013 * check to see if this is it.
1017 && (strlen(argv
[0]) <= tp
->cmd_minlen
)) {
1018 if (strncmp(argv
[0],
1020 tp
->cmd_minlen
) == 0) {
1025 if (strcmp(argv
[0], tp
->cmd_name
) == 0)
1031 * If we don't find a command by this name, see if the first
1032 * few characters of this match any of the known commands.
1033 * e.g., md1c20 should match md.
1035 if (i
== kdb_max_commands
) {
1036 for_each_kdbcmd(tp
, i
) {
1038 if (strncmp(argv
[0],
1040 strlen(tp
->cmd_name
)) == 0) {
1047 if (i
< kdb_max_commands
) {
1050 if (!kdb_check_flags(tp
->cmd_flags
, kdb_cmd_enabled
, argc
<= 1))
1054 result
= (*tp
->cmd_func
)(argc
-1, (const char **)argv
);
1055 if (result
&& ignore_errors
&& result
> KDB_CMD_GO
)
1057 KDB_STATE_CLEAR(CMD
);
1059 if (tp
->cmd_flags
& KDB_REPEAT_WITH_ARGS
)
1062 argc
= tp
->cmd_flags
& KDB_REPEAT_NO_ARGS
? 1 : 0;
1064 *(argv
[argc
]) = '\0';
1069 * If the input with which we were presented does not
1070 * map to an existing command, attempt to parse it as an
1071 * address argument and display the result. Useful for
1072 * obtaining the address of a variable, or the nearest symbol
1073 * to an address contained in a register.
1076 unsigned long value
;
1081 if (kdbgetaddrarg(0, (const char **)argv
, &nextarg
,
1082 &value
, &offset
, &name
)) {
1083 return KDB_NOTFOUND
;
1086 kdb_printf("%s = ", argv
[0]);
1087 kdb_symbol_print(value
, NULL
, KDB_SP_DEFAULT
);
1094 static int handle_ctrl_cmd(char *cmd
)
1099 /* initial situation */
1100 if (cmd_head
== cmd_tail
)
1104 if (cmdptr
!= cmd_tail
)
1105 cmdptr
= (cmdptr
-1) % KDB_CMD_HISTORY_COUNT
;
1106 strncpy(cmd_cur
, cmd_hist
[cmdptr
], CMD_BUFLEN
);
1109 if (cmdptr
!= cmd_head
)
1110 cmdptr
= (cmdptr
+1) % KDB_CMD_HISTORY_COUNT
;
1111 strncpy(cmd_cur
, cmd_hist
[cmdptr
], CMD_BUFLEN
);
1118 * kdb_reboot - This function implements the 'reboot' command. Reboot
1119 * the system immediately, or loop for ever on failure.
1121 static int kdb_reboot(int argc
, const char **argv
)
1123 emergency_restart();
1124 kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
1131 static void kdb_dumpregs(struct pt_regs
*regs
)
1133 int old_lvl
= console_loglevel
;
1134 console_loglevel
= CONSOLE_LOGLEVEL_MOTORMOUTH
;
1139 console_loglevel
= old_lvl
;
1142 void kdb_set_current_task(struct task_struct
*p
)
1144 kdb_current_task
= p
;
1146 if (kdb_task_has_cpu(p
)) {
1147 kdb_current_regs
= KDB_TSKREGS(kdb_process_cpu(p
));
1150 kdb_current_regs
= NULL
;
1154 * kdb_local - The main code for kdb. This routine is invoked on a
1155 * specific processor, it is not global. The main kdb() routine
1156 * ensures that only one processor at a time is in this routine.
1157 * This code is called with the real reason code on the first
1158 * entry to a kdb session, thereafter it is called with reason
1159 * SWITCH, even if the user goes back to the original cpu.
1161 * reason The reason KDB was invoked
1162 * error The hardware-defined error code
1163 * regs The exception frame at time of fault/breakpoint.
1164 * db_result Result code from the break or debug point.
1166 * 0 KDB was invoked for an event which it wasn't responsible
1167 * 1 KDB handled the event for which it was invoked.
1168 * KDB_CMD_GO User typed 'go'.
1169 * KDB_CMD_CPU User switched to another cpu.
1170 * KDB_CMD_SS Single step.
1172 static int kdb_local(kdb_reason_t reason
, int error
, struct pt_regs
*regs
,
1173 kdb_dbtrap_t db_result
)
1177 struct task_struct
*kdb_current
=
1178 kdb_curr_task(raw_smp_processor_id());
1180 KDB_DEBUG_STATE("kdb_local 1", reason
);
1182 if (reason
== KDB_REASON_DEBUG
) {
1183 /* special case below */
1185 kdb_printf("\nEntering kdb (current=0x%p, pid %d) ",
1186 kdb_current
, kdb_current
? kdb_current
->pid
: 0);
1187 #if defined(CONFIG_SMP)
1188 kdb_printf("on processor %d ", raw_smp_processor_id());
1193 case KDB_REASON_DEBUG
:
1196 * If re-entering kdb after a single step
1197 * command, don't print the message.
1199 switch (db_result
) {
1201 kdb_printf("\nEntering kdb (0x%p, pid %d) ",
1202 kdb_current
, kdb_current
->pid
);
1203 #if defined(CONFIG_SMP)
1204 kdb_printf("on processor %d ", raw_smp_processor_id());
1206 kdb_printf("due to Debug @ " kdb_machreg_fmt
"\n",
1207 instruction_pointer(regs
));
1212 KDB_DEBUG_STATE("kdb_local 4", reason
);
1213 return 1; /* kdba_db_trap did the work */
1215 kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
1222 case KDB_REASON_ENTER
:
1223 if (KDB_STATE(KEYBOARD
))
1224 kdb_printf("due to Keyboard Entry\n");
1226 kdb_printf("due to KDB_ENTER()\n");
1228 case KDB_REASON_KEYBOARD
:
1229 KDB_STATE_SET(KEYBOARD
);
1230 kdb_printf("due to Keyboard Entry\n");
1232 case KDB_REASON_ENTER_SLAVE
:
1233 /* drop through, slaves only get released via cpu switch */
1234 case KDB_REASON_SWITCH
:
1235 kdb_printf("due to cpu switch\n");
1237 case KDB_REASON_OOPS
:
1238 kdb_printf("Oops: %s\n", kdb_diemsg
);
1239 kdb_printf("due to oops @ " kdb_machreg_fmt
"\n",
1240 instruction_pointer(regs
));
1243 case KDB_REASON_SYSTEM_NMI
:
1244 kdb_printf("due to System NonMaskable Interrupt\n");
1246 case KDB_REASON_NMI
:
1247 kdb_printf("due to NonMaskable Interrupt @ "
1248 kdb_machreg_fmt
"\n",
1249 instruction_pointer(regs
));
1251 case KDB_REASON_SSTEP
:
1252 case KDB_REASON_BREAK
:
1253 kdb_printf("due to %s @ " kdb_machreg_fmt
"\n",
1254 reason
== KDB_REASON_BREAK
?
1255 "Breakpoint" : "SS trap", instruction_pointer(regs
));
1257 * Determine if this breakpoint is one that we
1258 * are interested in.
1260 if (db_result
!= KDB_DB_BPT
) {
1261 kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1263 KDB_DEBUG_STATE("kdb_local 6", reason
);
1264 return 0; /* Not for us, dismiss it */
1267 case KDB_REASON_RECURSE
:
1268 kdb_printf("due to Recursion @ " kdb_machreg_fmt
"\n",
1269 instruction_pointer(regs
));
1272 kdb_printf("kdb: unexpected reason code: %d\n", reason
);
1273 KDB_DEBUG_STATE("kdb_local 8", reason
);
1274 return 0; /* Not for us, dismiss it */
1279 * Initialize pager context.
1282 KDB_STATE_CLEAR(SUPPRESS
);
1283 kdb_grepping_flag
= 0;
1284 /* ensure the old search does not leak into '/' commands */
1285 kdb_grep_string
[0] = '\0';
1289 *(cmd_hist
[cmd_head
]) = '\0';
1292 #if defined(CONFIG_SMP)
1293 snprintf(kdb_prompt_str
, CMD_BUFLEN
, kdbgetenv("PROMPT"),
1294 raw_smp_processor_id());
1296 snprintf(kdb_prompt_str
, CMD_BUFLEN
, kdbgetenv("PROMPT"));
1298 if (defcmd_in_progress
)
1299 strncat(kdb_prompt_str
, "[defcmd]", CMD_BUFLEN
);
1302 * Fetch command from keyboard
1304 cmdbuf
= kdb_getstr(cmdbuf
, CMD_BUFLEN
, kdb_prompt_str
);
1305 if (*cmdbuf
!= '\n') {
1307 if (cmdptr
== cmd_head
) {
1308 strncpy(cmd_hist
[cmd_head
], cmd_cur
,
1310 *(cmd_hist
[cmd_head
] +
1311 strlen(cmd_hist
[cmd_head
])-1) = '\0';
1313 if (!handle_ctrl_cmd(cmdbuf
))
1314 *(cmd_cur
+strlen(cmd_cur
)-1) = '\0';
1316 goto do_full_getstr
;
1318 strncpy(cmd_hist
[cmd_head
], cmd_cur
,
1322 cmd_head
= (cmd_head
+1) % KDB_CMD_HISTORY_COUNT
;
1323 if (cmd_head
== cmd_tail
)
1324 cmd_tail
= (cmd_tail
+1) % KDB_CMD_HISTORY_COUNT
;
1328 diag
= kdb_parse(cmdbuf
);
1329 if (diag
== KDB_NOTFOUND
) {
1330 kdb_printf("Unknown kdb command: '%s'\n", cmdbuf
);
1333 if (diag
== KDB_CMD_GO
1334 || diag
== KDB_CMD_CPU
1335 || diag
== KDB_CMD_SS
1336 || diag
== KDB_CMD_KGDB
)
1342 KDB_DEBUG_STATE("kdb_local 9", diag
);
1348 * kdb_print_state - Print the state data for the current processor
1351 * text Identifies the debug point
1352 * value Any integer value to be printed, e.g. reason code.
1354 void kdb_print_state(const char *text
, int value
)
1356 kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1357 text
, raw_smp_processor_id(), value
, kdb_initial_cpu
,
1362 * kdb_main_loop - After initial setup and assignment of the
1363 * controlling cpu, all cpus are in this loop. One cpu is in
1364 * control and will issue the kdb prompt, the others will spin
1365 * until 'go' or cpu switch.
1367 * To get a consistent view of the kernel stacks for all
1368 * processes, this routine is invoked from the main kdb code via
1369 * an architecture specific routine. kdba_main_loop is
1370 * responsible for making the kernel stacks consistent for all
1371 * processes, there should be no difference between a blocked
1372 * process and a running process as far as kdb is concerned.
1374 * reason The reason KDB was invoked
1375 * error The hardware-defined error code
1376 * reason2 kdb's current reason code.
1377 * Initially error but can change
1378 * according to kdb state.
1379 * db_result Result code from break or debug point.
1380 * regs The exception frame at time of fault/breakpoint.
1381 * should always be valid.
1383 * 0 KDB was invoked for an event which it wasn't responsible
1384 * 1 KDB handled the event for which it was invoked.
1386 int kdb_main_loop(kdb_reason_t reason
, kdb_reason_t reason2
, int error
,
1387 kdb_dbtrap_t db_result
, struct pt_regs
*regs
)
1390 /* Stay in kdb() until 'go', 'ss[b]' or an error */
1393 * All processors except the one that is in control
1396 KDB_DEBUG_STATE("kdb_main_loop 1", reason
);
1397 while (KDB_STATE(HOLD_CPU
)) {
1398 /* state KDB is turned off by kdb_cpu to see if the
1399 * other cpus are still live, each cpu in this loop
1402 if (!KDB_STATE(KDB
))
1406 KDB_STATE_CLEAR(SUPPRESS
);
1407 KDB_DEBUG_STATE("kdb_main_loop 2", reason
);
1408 if (KDB_STATE(LEAVING
))
1409 break; /* Another cpu said 'go' */
1410 /* Still using kdb, this processor is in control */
1411 result
= kdb_local(reason2
, error
, regs
, db_result
);
1412 KDB_DEBUG_STATE("kdb_main_loop 3", result
);
1414 if (result
== KDB_CMD_CPU
)
1417 if (result
== KDB_CMD_SS
) {
1418 KDB_STATE_SET(DOING_SS
);
1422 if (result
== KDB_CMD_KGDB
) {
1423 if (!KDB_STATE(DOING_KGDB
))
1424 kdb_printf("Entering please attach debugger "
1425 "or use $D#44+ or $3#33\n");
1428 if (result
&& result
!= 1 && result
!= KDB_CMD_GO
)
1429 kdb_printf("\nUnexpected kdb_local return code %d\n",
1431 KDB_DEBUG_STATE("kdb_main_loop 4", reason
);
1434 if (KDB_STATE(DOING_SS
))
1435 KDB_STATE_CLEAR(SSBPT
);
1437 /* Clean up any keyboard devices before leaving */
1438 kdb_kbd_cleanup_state();
1444 * kdb_mdr - This function implements the guts of the 'mdr', memory
1446 * mdr <addr arg>,<byte count>
1448 * addr Start address
1449 * count Number of bytes
1451 * Always 0. Any errors are detected and printed by kdb_getarea.
1453 static int kdb_mdr(unsigned long addr
, unsigned int count
)
1457 if (kdb_getarea(c
, addr
))
1459 kdb_printf("%02x", c
);
1467 * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1468 * 'md8' 'mdr' and 'mds' commands.
1470 * md|mds [<addr arg> [<line count> [<radix>]]]
1471 * mdWcN [<addr arg> [<line count> [<radix>]]]
1472 * where W = is the width (1, 2, 4 or 8) and N is the count.
1473 * for eg., md1c20 reads 20 bytes, 1 at a time.
1474 * mdr <addr arg>,<byte count>
1476 static void kdb_md_line(const char *fmtstr
, unsigned long addr
,
1477 int symbolic
, int nosect
, int bytesperword
,
1478 int num
, int repeat
, int phys
)
1480 /* print just one line of data */
1481 kdb_symtab_t symtab
;
1487 memset(cbuf
, '\0', sizeof(cbuf
));
1489 kdb_printf("phys " kdb_machreg_fmt0
" ", addr
);
1491 kdb_printf(kdb_machreg_fmt0
" ", addr
);
1493 for (i
= 0; i
< num
&& repeat
--; i
++) {
1495 if (kdb_getphysword(&word
, addr
, bytesperword
))
1497 } else if (kdb_getword(&word
, addr
, bytesperword
))
1499 kdb_printf(fmtstr
, word
);
1501 kdbnearsym(word
, &symtab
);
1503 memset(&symtab
, 0, sizeof(symtab
));
1504 if (symtab
.sym_name
) {
1505 kdb_symbol_print(word
, &symtab
, 0);
1508 kdb_printf(" %s %s "
1511 kdb_machreg_fmt
, symtab
.mod_name
,
1512 symtab
.sec_name
, symtab
.sec_start
,
1513 symtab
.sym_start
, symtab
.sym_end
);
1515 addr
+= bytesperword
;
1523 cp
= wc
.c
+ 8 - bytesperword
;
1528 #define printable_char(c) \
1529 ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1530 switch (bytesperword
) {
1532 *c
++ = printable_char(*cp
++);
1533 *c
++ = printable_char(*cp
++);
1534 *c
++ = printable_char(*cp
++);
1535 *c
++ = printable_char(*cp
++);
1538 *c
++ = printable_char(*cp
++);
1539 *c
++ = printable_char(*cp
++);
1542 *c
++ = printable_char(*cp
++);
1545 *c
++ = printable_char(*cp
++);
1549 #undef printable_char
1552 kdb_printf("%*s %s\n", (int)((num
-i
)*(2*bytesperword
+ 1)+1),
1556 static int kdb_md(int argc
, const char **argv
)
1558 static unsigned long last_addr
;
1559 static int last_radix
, last_bytesperword
, last_repeat
;
1560 int radix
= 16, mdcount
= 8, bytesperword
= KDB_WORD_SIZE
, repeat
;
1562 char fmtchar
, fmtstr
[64];
1571 kdbgetintenv("MDCOUNT", &mdcount
);
1572 kdbgetintenv("RADIX", &radix
);
1573 kdbgetintenv("BYTESPERWORD", &bytesperword
);
1575 /* Assume 'md <addr>' and start with environment values */
1576 repeat
= mdcount
* 16 / bytesperword
;
1578 if (strcmp(argv
[0], "mdr") == 0) {
1579 if (argc
== 2 || (argc
== 0 && last_addr
!= 0))
1582 return KDB_ARGCOUNT
;
1583 } else if (isdigit(argv
[0][2])) {
1584 bytesperword
= (int)(argv
[0][2] - '0');
1585 if (bytesperword
== 0) {
1586 bytesperword
= last_bytesperword
;
1587 if (bytesperword
== 0)
1590 last_bytesperword
= bytesperword
;
1591 repeat
= mdcount
* 16 / bytesperword
;
1594 else if (argv
[0][3] == 'c' && argv
[0][4]) {
1596 repeat
= simple_strtoul(argv
[0] + 4, &p
, 10);
1597 mdcount
= ((repeat
* bytesperword
) + 15) / 16;
1600 last_repeat
= repeat
;
1601 } else if (strcmp(argv
[0], "md") == 0)
1603 else if (strcmp(argv
[0], "mds") == 0)
1605 else if (strcmp(argv
[0], "mdp") == 0) {
1609 return KDB_NOTFOUND
;
1613 return KDB_ARGCOUNT
;
1616 bytesperword
= last_bytesperword
;
1617 repeat
= last_repeat
;
1621 mdcount
= ((repeat
* bytesperword
) + 15) / 16;
1626 int diag
, nextarg
= 1;
1627 diag
= kdbgetaddrarg(argc
, argv
, &nextarg
, &addr
,
1631 if (argc
> nextarg
+2)
1632 return KDB_ARGCOUNT
;
1634 if (argc
>= nextarg
) {
1635 diag
= kdbgetularg(argv
[nextarg
], &val
);
1637 mdcount
= (int) val
;
1641 repeat
= mdcount
* 16 / bytesperword
;
1644 if (argc
>= nextarg
+1) {
1645 diag
= kdbgetularg(argv
[nextarg
+1], &val
);
1651 if (strcmp(argv
[0], "mdr") == 0) {
1654 ret
= kdb_mdr(addr
, mdcount
);
1655 last_addr
+= mdcount
;
1656 last_repeat
= mdcount
;
1657 last_bytesperword
= bytesperword
; // to make REPEAT happy
1672 return KDB_BADRADIX
;
1677 if (bytesperword
> KDB_WORD_SIZE
)
1678 return KDB_BADWIDTH
;
1680 switch (bytesperword
) {
1682 sprintf(fmtstr
, "%%16.16l%c ", fmtchar
);
1685 sprintf(fmtstr
, "%%8.8l%c ", fmtchar
);
1688 sprintf(fmtstr
, "%%4.4l%c ", fmtchar
);
1691 sprintf(fmtstr
, "%%2.2l%c ", fmtchar
);
1694 return KDB_BADWIDTH
;
1697 last_repeat
= repeat
;
1698 last_bytesperword
= bytesperword
;
1700 if (strcmp(argv
[0], "mds") == 0) {
1702 /* Do not save these changes as last_*, they are temporary mds
1705 bytesperword
= KDB_WORD_SIZE
;
1707 kdbgetintenv("NOSECT", &nosect
);
1710 /* Round address down modulo BYTESPERWORD */
1712 addr
&= ~(bytesperword
-1);
1714 while (repeat
> 0) {
1716 int n
, z
, num
= (symbolic
? 1 : (16 / bytesperword
));
1718 if (KDB_FLAG(CMD_INTERRUPT
))
1720 for (a
= addr
, z
= 0; z
< repeat
; a
+= bytesperword
, ++z
) {
1722 if (kdb_getphysword(&word
, a
, bytesperword
)
1725 } else if (kdb_getword(&word
, a
, bytesperword
) || word
)
1728 n
= min(num
, repeat
);
1729 kdb_md_line(fmtstr
, addr
, symbolic
, nosect
, bytesperword
,
1731 addr
+= bytesperword
* n
;
1733 z
= (z
+ num
- 1) / num
;
1735 int s
= num
* (z
-2);
1736 kdb_printf(kdb_machreg_fmt0
"-" kdb_machreg_fmt0
1737 " zero suppressed\n",
1738 addr
, addr
+ bytesperword
* s
- 1);
1739 addr
+= bytesperword
* s
;
1749 * kdb_mm - This function implements the 'mm' command.
1750 * mm address-expression new-value
1752 * mm works on machine words, mmW works on bytes.
1754 static int kdb_mm(int argc
, const char **argv
)
1759 unsigned long contents
;
1763 if (argv
[0][2] && !isdigit(argv
[0][2]))
1764 return KDB_NOTFOUND
;
1767 return KDB_ARGCOUNT
;
1770 diag
= kdbgetaddrarg(argc
, argv
, &nextarg
, &addr
, &offset
, NULL
);
1775 return KDB_ARGCOUNT
;
1776 diag
= kdbgetaddrarg(argc
, argv
, &nextarg
, &contents
, NULL
, NULL
);
1780 if (nextarg
!= argc
+ 1)
1781 return KDB_ARGCOUNT
;
1783 width
= argv
[0][2] ? (argv
[0][2] - '0') : (KDB_WORD_SIZE
);
1784 diag
= kdb_putword(addr
, contents
, width
);
1788 kdb_printf(kdb_machreg_fmt
" = " kdb_machreg_fmt
"\n", addr
, contents
);
1794 * kdb_go - This function implements the 'go' command.
1795 * go [address-expression]
1797 static int kdb_go(int argc
, const char **argv
)
1804 if (raw_smp_processor_id() != kdb_initial_cpu
) {
1805 kdb_printf("go must execute on the entry cpu, "
1806 "please use \"cpu %d\" and then execute go\n",
1808 return KDB_BADCPUNUM
;
1812 diag
= kdbgetaddrarg(argc
, argv
, &nextarg
,
1813 &addr
, &offset
, NULL
);
1817 return KDB_ARGCOUNT
;
1821 if (KDB_FLAG(CATASTROPHIC
)) {
1822 kdb_printf("Catastrophic error detected\n");
1823 kdb_printf("kdb_continue_catastrophic=%d, ",
1824 kdb_continue_catastrophic
);
1825 if (kdb_continue_catastrophic
== 0 && kdb_go_count
++ == 0) {
1826 kdb_printf("type go a second time if you really want "
1830 if (kdb_continue_catastrophic
== 2) {
1831 kdb_printf("forcing reboot\n");
1832 kdb_reboot(0, NULL
);
1834 kdb_printf("attempting to continue\n");
1840 * kdb_rd - This function implements the 'rd' command.
1842 static int kdb_rd(int argc
, const char **argv
)
1844 int len
= kdb_check_regs();
1845 #if DBG_MAX_REG_NUM > 0
1857 for (i
= 0; i
< DBG_MAX_REG_NUM
; i
++) {
1858 rsize
= dbg_reg_def
[i
].size
* 2;
1861 if (len
+ strlen(dbg_reg_def
[i
].name
) + 4 + rsize
> 80) {
1866 len
+= kdb_printf(" ");
1867 switch(dbg_reg_def
[i
].size
* 8) {
1869 rname
= dbg_get_reg(i
, ®8
, kdb_current_regs
);
1872 len
+= kdb_printf("%s: %02x", rname
, reg8
);
1875 rname
= dbg_get_reg(i
, ®16
, kdb_current_regs
);
1878 len
+= kdb_printf("%s: %04x", rname
, reg16
);
1881 rname
= dbg_get_reg(i
, ®32
, kdb_current_regs
);
1884 len
+= kdb_printf("%s: %08x", rname
, reg32
);
1887 rname
= dbg_get_reg(i
, ®64
, kdb_current_regs
);
1890 len
+= kdb_printf("%s: %016llx", rname
, reg64
);
1893 len
+= kdb_printf("%s: ??", dbg_reg_def
[i
].name
);
1901 kdb_dumpregs(kdb_current_regs
);
1907 * kdb_rm - This function implements the 'rm' (register modify) command.
1908 * rm register-name new-contents
1910 * Allows register modification with the same restrictions as gdb
1912 static int kdb_rm(int argc
, const char **argv
)
1914 #if DBG_MAX_REG_NUM > 0
1924 return KDB_ARGCOUNT
;
1926 * Allow presence or absence of leading '%' symbol.
1932 diag
= kdbgetu64arg(argv
[2], ®64
);
1936 diag
= kdb_check_regs();
1941 for (i
= 0; i
< DBG_MAX_REG_NUM
; i
++) {
1942 if (strcmp(rname
, dbg_reg_def
[i
].name
) == 0) {
1948 switch(dbg_reg_def
[i
].size
* 8) {
1951 dbg_set_reg(i
, ®8
, kdb_current_regs
);
1955 dbg_set_reg(i
, ®16
, kdb_current_regs
);
1959 dbg_set_reg(i
, ®32
, kdb_current_regs
);
1962 dbg_set_reg(i
, ®64
, kdb_current_regs
);
1968 kdb_printf("ERROR: Register set currently not implemented\n");
1973 #if defined(CONFIG_MAGIC_SYSRQ)
1975 * kdb_sr - This function implements the 'sr' (SYSRQ key) command
1976 * which interfaces to the soi-disant MAGIC SYSRQ functionality.
1977 * sr <magic-sysrq-code>
1979 static int kdb_sr(int argc
, const char **argv
)
1982 !kdb_check_flags(KDB_ENABLE_ALL
, kdb_cmd_enabled
, false);
1985 return KDB_ARGCOUNT
;
1988 __handle_sysrq(*argv
[1], check_mask
? SYSRQ_FROM_KERNEL
: 0);
1993 #endif /* CONFIG_MAGIC_SYSRQ */
1996 * kdb_ef - This function implements the 'regs' (display exception
1997 * frame) command. This command takes an address and expects to
1998 * find an exception frame at that address, formats and prints
2000 * regs address-expression
2004 static int kdb_ef(int argc
, const char **argv
)
2012 return KDB_ARGCOUNT
;
2015 diag
= kdbgetaddrarg(argc
, argv
, &nextarg
, &addr
, &offset
, NULL
);
2018 show_regs((struct pt_regs
*)addr
);
2022 #if defined(CONFIG_MODULES)
2024 * kdb_lsmod - This function implements the 'lsmod' command. Lists
2025 * currently loaded kernel modules.
2026 * Mostly taken from userland lsmod.
2028 static int kdb_lsmod(int argc
, const char **argv
)
2033 return KDB_ARGCOUNT
;
2035 kdb_printf("Module Size modstruct Used by\n");
2036 list_for_each_entry(mod
, kdb_modules
, list
) {
2037 if (mod
->state
== MODULE_STATE_UNFORMED
)
2040 kdb_printf("%-20s%8u 0x%p ", mod
->name
,
2041 mod
->core_layout
.size
, (void *)mod
);
2042 #ifdef CONFIG_MODULE_UNLOAD
2043 kdb_printf("%4d ", module_refcount(mod
));
2045 if (mod
->state
== MODULE_STATE_GOING
)
2046 kdb_printf(" (Unloading)");
2047 else if (mod
->state
== MODULE_STATE_COMING
)
2048 kdb_printf(" (Loading)");
2050 kdb_printf(" (Live)");
2051 kdb_printf(" 0x%p", mod
->core_layout
.base
);
2053 #ifdef CONFIG_MODULE_UNLOAD
2055 struct module_use
*use
;
2057 list_for_each_entry(use
, &mod
->source_list
,
2059 kdb_printf("%s ", use
->target
->name
);
2068 #endif /* CONFIG_MODULES */
2071 * kdb_env - This function implements the 'env' command. Display the
2072 * current environment variables.
2075 static int kdb_env(int argc
, const char **argv
)
2079 for (i
= 0; i
< __nenv
; i
++) {
2081 kdb_printf("%s\n", __env
[i
]);
2084 if (KDB_DEBUG(MASK
))
2085 kdb_printf("KDBFLAGS=0x%x\n", kdb_flags
);
2090 #ifdef CONFIG_PRINTK
2092 * kdb_dmesg - This function implements the 'dmesg' command to display
2093 * the contents of the syslog buffer.
2094 * dmesg [lines] [adjust]
2096 static int kdb_dmesg(int argc
, const char **argv
)
2104 struct kmsg_dumper dumper
= { .active
= 1 };
2109 return KDB_ARGCOUNT
;
2112 lines
= simple_strtol(argv
[1], &cp
, 0);
2116 adjust
= simple_strtoul(argv
[2], &cp
, 0);
2117 if (*cp
|| adjust
< 0)
2122 /* disable LOGGING if set */
2123 diag
= kdbgetintenv("LOGGING", &logging
);
2124 if (!diag
&& logging
) {
2125 const char *setargs
[] = { "set", "LOGGING", "0" };
2126 kdb_set(2, setargs
);
2129 kmsg_dump_rewind_nolock(&dumper
);
2130 while (kmsg_dump_get_line_nolock(&dumper
, 1, NULL
, 0, NULL
))
2135 kdb_printf("buffer only contains %d lines, nothing "
2137 else if (adjust
- lines
>= n
)
2138 kdb_printf("buffer only contains %d lines, last %d "
2139 "lines printed\n", n
, n
- adjust
);
2142 } else if (lines
> 0) {
2143 skip
= n
- lines
- adjust
;
2146 kdb_printf("buffer only contains %d lines, "
2147 "nothing printed\n", n
);
2149 } else if (skip
< 0) {
2152 kdb_printf("buffer only contains %d lines, first "
2153 "%d lines printed\n", n
, lines
);
2159 if (skip
>= n
|| skip
< 0)
2162 kmsg_dump_rewind_nolock(&dumper
);
2163 while (kmsg_dump_get_line_nolock(&dumper
, 1, buf
, sizeof(buf
), &len
)) {
2170 if (KDB_FLAG(CMD_INTERRUPT
))
2173 kdb_printf("%.*s\n", (int)len
- 1, buf
);
2178 #endif /* CONFIG_PRINTK */
2180 /* Make sure we balance enable/disable calls, must disable first. */
2181 static atomic_t kdb_nmi_disabled
;
2183 static int kdb_disable_nmi(int argc
, const char *argv
[])
2185 if (atomic_read(&kdb_nmi_disabled
))
2187 atomic_set(&kdb_nmi_disabled
, 1);
2188 arch_kgdb_ops
.enable_nmi(0);
2192 static int kdb_param_enable_nmi(const char *val
, const struct kernel_param
*kp
)
2194 if (!atomic_add_unless(&kdb_nmi_disabled
, -1, 0))
2196 arch_kgdb_ops
.enable_nmi(1);
2200 static const struct kernel_param_ops kdb_param_ops_enable_nmi
= {
2201 .set
= kdb_param_enable_nmi
,
2203 module_param_cb(enable_nmi
, &kdb_param_ops_enable_nmi
, NULL
, 0600);
2206 * kdb_cpu - This function implements the 'cpu' command.
2209 * KDB_CMD_CPU for success, a kdb diagnostic if error
2211 static void kdb_cpu_status(void)
2213 int i
, start_cpu
, first_print
= 1;
2214 char state
, prev_state
= '?';
2216 kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2217 kdb_printf("Available cpus: ");
2218 for (start_cpu
= -1, i
= 0; i
< NR_CPUS
; i
++) {
2219 if (!cpu_online(i
)) {
2220 state
= 'F'; /* cpu is offline */
2221 } else if (!kgdb_info
[i
].enter_kgdb
) {
2222 state
= 'D'; /* cpu is online but unresponsive */
2224 state
= ' '; /* cpu is responding to kdb */
2225 if (kdb_task_state_char(KDB_TSK(i
)) == 'I')
2226 state
= 'I'; /* idle task */
2228 if (state
!= prev_state
) {
2229 if (prev_state
!= '?') {
2233 kdb_printf("%d", start_cpu
);
2234 if (start_cpu
< i
-1)
2235 kdb_printf("-%d", i
-1);
2236 if (prev_state
!= ' ')
2237 kdb_printf("(%c)", prev_state
);
2243 /* print the trailing cpus, ignoring them if they are all offline */
2244 if (prev_state
!= 'F') {
2247 kdb_printf("%d", start_cpu
);
2248 if (start_cpu
< i
-1)
2249 kdb_printf("-%d", i
-1);
2250 if (prev_state
!= ' ')
2251 kdb_printf("(%c)", prev_state
);
2256 static int kdb_cpu(int argc
, const char **argv
)
2258 unsigned long cpunum
;
2267 return KDB_ARGCOUNT
;
2269 diag
= kdbgetularg(argv
[1], &cpunum
);
2276 if ((cpunum
>= CONFIG_NR_CPUS
) || !kgdb_info
[cpunum
].enter_kgdb
)
2277 return KDB_BADCPUNUM
;
2279 dbg_switch_cpu
= cpunum
;
2282 * Switch to other cpu
2287 /* The user may not realize that ps/bta with no parameters does not print idle
2288 * or sleeping system daemon processes, so tell them how many were suppressed.
2290 void kdb_ps_suppressed(void)
2292 int idle
= 0, daemon
= 0;
2293 unsigned long mask_I
= kdb_task_state_string("I"),
2294 mask_M
= kdb_task_state_string("M");
2296 const struct task_struct
*p
, *g
;
2297 for_each_online_cpu(cpu
) {
2298 p
= kdb_curr_task(cpu
);
2299 if (kdb_task_state(p
, mask_I
))
2302 kdb_do_each_thread(g
, p
) {
2303 if (kdb_task_state(p
, mask_M
))
2305 } kdb_while_each_thread(g
, p
);
2306 if (idle
|| daemon
) {
2308 kdb_printf("%d idle process%s (state I)%s\n",
2309 idle
, idle
== 1 ? "" : "es",
2310 daemon
? " and " : "");
2312 kdb_printf("%d sleeping system daemon (state M) "
2313 "process%s", daemon
,
2314 daemon
== 1 ? "" : "es");
2315 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2320 * kdb_ps - This function implements the 'ps' command which shows a
2321 * list of the active processes.
2322 * ps [DRSTCZEUIMA] All processes, optionally filtered by state
2324 void kdb_ps1(const struct task_struct
*p
)
2329 if (!p
|| probe_kernel_read(&tmp
, (char *)p
, sizeof(unsigned long)))
2332 cpu
= kdb_process_cpu(p
);
2333 kdb_printf("0x%p %8d %8d %d %4d %c 0x%p %c%s\n",
2334 (void *)p
, p
->pid
, p
->parent
->pid
,
2335 kdb_task_has_cpu(p
), kdb_process_cpu(p
),
2336 kdb_task_state_char(p
),
2337 (void *)(&p
->thread
),
2338 p
== kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2340 if (kdb_task_has_cpu(p
)) {
2341 if (!KDB_TSK(cpu
)) {
2342 kdb_printf(" Error: no saved data for this cpu\n");
2344 if (KDB_TSK(cpu
) != p
)
2345 kdb_printf(" Error: does not match running "
2346 "process table (0x%p)\n", KDB_TSK(cpu
));
2351 static int kdb_ps(int argc
, const char **argv
)
2353 struct task_struct
*g
, *p
;
2354 unsigned long mask
, cpu
;
2357 kdb_ps_suppressed();
2358 kdb_printf("%-*s Pid Parent [*] cpu State %-*s Command\n",
2359 (int)(2*sizeof(void *))+2, "Task Addr",
2360 (int)(2*sizeof(void *))+2, "Thread");
2361 mask
= kdb_task_state_string(argc
? argv
[1] : NULL
);
2362 /* Run the active tasks first */
2363 for_each_online_cpu(cpu
) {
2364 if (KDB_FLAG(CMD_INTERRUPT
))
2366 p
= kdb_curr_task(cpu
);
2367 if (kdb_task_state(p
, mask
))
2371 /* Now the real tasks */
2372 kdb_do_each_thread(g
, p
) {
2373 if (KDB_FLAG(CMD_INTERRUPT
))
2375 if (kdb_task_state(p
, mask
))
2377 } kdb_while_each_thread(g
, p
);
2383 * kdb_pid - This function implements the 'pid' command which switches
2384 * the currently active process.
2387 static int kdb_pid(int argc
, const char **argv
)
2389 struct task_struct
*p
;
2394 return KDB_ARGCOUNT
;
2397 if (strcmp(argv
[1], "R") == 0) {
2398 p
= KDB_TSK(kdb_initial_cpu
);
2400 diag
= kdbgetularg(argv
[1], &val
);
2404 p
= find_task_by_pid_ns((pid_t
)val
, &init_pid_ns
);
2406 kdb_printf("No task with pid=%d\n", (pid_t
)val
);
2410 kdb_set_current_task(p
);
2412 kdb_printf("KDB current process is %s(pid=%d)\n",
2413 kdb_current_task
->comm
,
2414 kdb_current_task
->pid
);
2419 static int kdb_kgdb(int argc
, const char **argv
)
2421 return KDB_CMD_KGDB
;
2425 * kdb_help - This function implements the 'help' and '?' commands.
2427 static int kdb_help(int argc
, const char **argv
)
2432 kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2433 kdb_printf("-----------------------------"
2434 "-----------------------------\n");
2435 for_each_kdbcmd(kt
, i
) {
2437 if (KDB_FLAG(CMD_INTERRUPT
))
2441 if (!kdb_check_flags(kt
->cmd_flags
, kdb_cmd_enabled
, true))
2443 if (strlen(kt
->cmd_usage
) > 20)
2445 kdb_printf("%-15.15s %-20s%s%s\n", kt
->cmd_name
,
2446 kt
->cmd_usage
, space
, kt
->cmd_help
);
2452 * kdb_kill - This function implements the 'kill' commands.
2454 static int kdb_kill(int argc
, const char **argv
)
2458 struct task_struct
*p
;
2459 struct siginfo info
;
2462 return KDB_ARGCOUNT
;
2464 sig
= simple_strtol(argv
[1], &endp
, 0);
2468 kdb_printf("Invalid signal parameter.<-signal>\n");
2473 pid
= simple_strtol(argv
[2], &endp
, 0);
2477 kdb_printf("Process ID must be large than 0.\n");
2481 /* Find the process. */
2482 p
= find_task_by_pid_ns(pid
, &init_pid_ns
);
2484 kdb_printf("The specified process isn't found.\n");
2487 p
= p
->group_leader
;
2488 info
.si_signo
= sig
;
2490 info
.si_code
= SI_USER
;
2491 info
.si_pid
= pid
; /* same capabilities as process being signalled */
2492 info
.si_uid
= 0; /* kdb has root authority */
2493 kdb_send_sig_info(p
, &info
);
2498 int tm_sec
; /* seconds */
2499 int tm_min
; /* minutes */
2500 int tm_hour
; /* hours */
2501 int tm_mday
; /* day of the month */
2502 int tm_mon
; /* month */
2503 int tm_year
; /* year */
2506 static void kdb_gmtime(struct timespec
*tv
, struct kdb_tm
*tm
)
2508 /* This will work from 1970-2099, 2100 is not a leap year */
2509 static int mon_day
[] = { 31, 29, 31, 30, 31, 30, 31,
2510 31, 30, 31, 30, 31 };
2511 memset(tm
, 0, sizeof(*tm
));
2512 tm
->tm_sec
= tv
->tv_sec
% (24 * 60 * 60);
2513 tm
->tm_mday
= tv
->tv_sec
/ (24 * 60 * 60) +
2514 (2 * 365 + 1); /* shift base from 1970 to 1968 */
2515 tm
->tm_min
= tm
->tm_sec
/ 60 % 60;
2516 tm
->tm_hour
= tm
->tm_sec
/ 60 / 60;
2517 tm
->tm_sec
= tm
->tm_sec
% 60;
2518 tm
->tm_year
= 68 + 4*(tm
->tm_mday
/ (4*365+1));
2519 tm
->tm_mday
%= (4*365+1);
2521 while (tm
->tm_mday
>= mon_day
[tm
->tm_mon
]) {
2522 tm
->tm_mday
-= mon_day
[tm
->tm_mon
];
2523 if (++tm
->tm_mon
== 12) {
2533 * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2534 * I cannot call that code directly from kdb, it has an unconditional
2535 * cli()/sti() and calls routines that take locks which can stop the debugger.
2537 static void kdb_sysinfo(struct sysinfo
*val
)
2539 struct timespec uptime
;
2540 ktime_get_ts(&uptime
);
2541 memset(val
, 0, sizeof(*val
));
2542 val
->uptime
= uptime
.tv_sec
;
2543 val
->loads
[0] = avenrun
[0];
2544 val
->loads
[1] = avenrun
[1];
2545 val
->loads
[2] = avenrun
[2];
2546 val
->procs
= nr_threads
-1;
2553 * kdb_summary - This function implements the 'summary' command.
2555 static int kdb_summary(int argc
, const char **argv
)
2557 struct timespec now
;
2562 return KDB_ARGCOUNT
;
2564 kdb_printf("sysname %s\n", init_uts_ns
.name
.sysname
);
2565 kdb_printf("release %s\n", init_uts_ns
.name
.release
);
2566 kdb_printf("version %s\n", init_uts_ns
.name
.version
);
2567 kdb_printf("machine %s\n", init_uts_ns
.name
.machine
);
2568 kdb_printf("nodename %s\n", init_uts_ns
.name
.nodename
);
2569 kdb_printf("domainname %s\n", init_uts_ns
.name
.domainname
);
2570 kdb_printf("ccversion %s\n", __stringify(CCVERSION
));
2572 now
= __current_kernel_time();
2573 kdb_gmtime(&now
, &tm
);
2574 kdb_printf("date %04d-%02d-%02d %02d:%02d:%02d "
2575 "tz_minuteswest %d\n",
2576 1900+tm
.tm_year
, tm
.tm_mon
+1, tm
.tm_mday
,
2577 tm
.tm_hour
, tm
.tm_min
, tm
.tm_sec
,
2578 sys_tz
.tz_minuteswest
);
2581 kdb_printf("uptime ");
2582 if (val
.uptime
> (24*60*60)) {
2583 int days
= val
.uptime
/ (24*60*60);
2584 val
.uptime
%= (24*60*60);
2585 kdb_printf("%d day%s ", days
, days
== 1 ? "" : "s");
2587 kdb_printf("%02ld:%02ld\n", val
.uptime
/(60*60), (val
.uptime
/60)%60);
2589 /* lifted from fs/proc/proc_misc.c::loadavg_read_proc() */
2591 #define LOAD_INT(x) ((x) >> FSHIFT)
2592 #define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
2593 kdb_printf("load avg %ld.%02ld %ld.%02ld %ld.%02ld\n",
2594 LOAD_INT(val
.loads
[0]), LOAD_FRAC(val
.loads
[0]),
2595 LOAD_INT(val
.loads
[1]), LOAD_FRAC(val
.loads
[1]),
2596 LOAD_INT(val
.loads
[2]), LOAD_FRAC(val
.loads
[2]));
2599 /* Display in kilobytes */
2600 #define K(x) ((x) << (PAGE_SHIFT - 10))
2601 kdb_printf("\nMemTotal: %8lu kB\nMemFree: %8lu kB\n"
2602 "Buffers: %8lu kB\n",
2603 K(val
.totalram
), K(val
.freeram
), K(val
.bufferram
));
2608 * kdb_per_cpu - This function implements the 'per_cpu' command.
2610 static int kdb_per_cpu(int argc
, const char **argv
)
2613 int cpu
, diag
, nextarg
= 1;
2614 unsigned long addr
, symaddr
, val
, bytesperword
= 0, whichcpu
= ~0UL;
2616 if (argc
< 1 || argc
> 3)
2617 return KDB_ARGCOUNT
;
2619 diag
= kdbgetaddrarg(argc
, argv
, &nextarg
, &symaddr
, NULL
, NULL
);
2624 diag
= kdbgetularg(argv
[2], &bytesperword
);
2629 bytesperword
= KDB_WORD_SIZE
;
2630 else if (bytesperword
> KDB_WORD_SIZE
)
2631 return KDB_BADWIDTH
;
2632 sprintf(fmtstr
, "%%0%dlx ", (int)(2*bytesperword
));
2634 diag
= kdbgetularg(argv
[3], &whichcpu
);
2637 if (!cpu_online(whichcpu
)) {
2638 kdb_printf("cpu %ld is not online\n", whichcpu
);
2639 return KDB_BADCPUNUM
;
2643 /* Most architectures use __per_cpu_offset[cpu], some use
2644 * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2646 #ifdef __per_cpu_offset
2647 #define KDB_PCU(cpu) __per_cpu_offset(cpu)
2650 #define KDB_PCU(cpu) __per_cpu_offset[cpu]
2652 #define KDB_PCU(cpu) 0
2655 for_each_online_cpu(cpu
) {
2656 if (KDB_FLAG(CMD_INTERRUPT
))
2659 if (whichcpu
!= ~0UL && whichcpu
!= cpu
)
2661 addr
= symaddr
+ KDB_PCU(cpu
);
2662 diag
= kdb_getword(&val
, addr
, bytesperword
);
2664 kdb_printf("%5d " kdb_bfd_vma_fmt0
" - unable to "
2665 "read, diag=%d\n", cpu
, addr
, diag
);
2668 kdb_printf("%5d ", cpu
);
2669 kdb_md_line(fmtstr
, addr
,
2670 bytesperword
== KDB_WORD_SIZE
,
2671 1, bytesperword
, 1, 1, 0);
2678 * display help for the use of cmd | grep pattern
2680 static int kdb_grep_help(int argc
, const char **argv
)
2682 kdb_printf("Usage of cmd args | grep pattern:\n");
2683 kdb_printf(" Any command's output may be filtered through an ");
2684 kdb_printf("emulated 'pipe'.\n");
2685 kdb_printf(" 'grep' is just a key word.\n");
2686 kdb_printf(" The pattern may include a very limited set of "
2687 "metacharacters:\n");
2688 kdb_printf(" pattern or ^pattern or pattern$ or ^pattern$\n");
2689 kdb_printf(" And if there are spaces in the pattern, you may "
2691 kdb_printf(" \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2692 " or \"^pat tern$\"\n");
2697 * kdb_register_flags - This function is used to register a kernel
2701 * func Function to execute the command
2702 * usage A simple usage string showing arguments
2703 * help A simple help string describing command
2704 * repeat Does the command auto repeat on enter?
2706 * zero for success, one if a duplicate command.
2708 #define kdb_command_extend 50 /* arbitrary */
2709 int kdb_register_flags(char *cmd
,
2714 kdb_cmdflags_t flags
)
2720 * Brute force method to determine duplicates
2722 for_each_kdbcmd(kp
, i
) {
2723 if (kp
->cmd_name
&& (strcmp(kp
->cmd_name
, cmd
) == 0)) {
2724 kdb_printf("Duplicate kdb command registered: "
2725 "%s, func %p help %s\n", cmd
, func
, help
);
2731 * Insert command into first available location in table
2733 for_each_kdbcmd(kp
, i
) {
2734 if (kp
->cmd_name
== NULL
)
2738 if (i
>= kdb_max_commands
) {
2739 kdbtab_t
*new = kmalloc((kdb_max_commands
- KDB_BASE_CMD_MAX
+
2740 kdb_command_extend
) * sizeof(*new), GFP_KDB
);
2742 kdb_printf("Could not allocate new kdb_command "
2747 memcpy(new, kdb_commands
,
2748 (kdb_max_commands
- KDB_BASE_CMD_MAX
) * sizeof(*new));
2749 kfree(kdb_commands
);
2751 memset(new + kdb_max_commands
- KDB_BASE_CMD_MAX
, 0,
2752 kdb_command_extend
* sizeof(*new));
2754 kp
= kdb_commands
+ kdb_max_commands
- KDB_BASE_CMD_MAX
;
2755 kdb_max_commands
+= kdb_command_extend
;
2759 kp
->cmd_func
= func
;
2760 kp
->cmd_usage
= usage
;
2761 kp
->cmd_help
= help
;
2762 kp
->cmd_minlen
= minlen
;
2763 kp
->cmd_flags
= flags
;
2767 EXPORT_SYMBOL_GPL(kdb_register_flags
);
2771 * kdb_register - Compatibility register function for commands that do
2772 * not need to specify a repeat state. Equivalent to
2773 * kdb_register_flags with flags set to 0.
2776 * func Function to execute the command
2777 * usage A simple usage string showing arguments
2778 * help A simple help string describing command
2780 * zero for success, one if a duplicate command.
2782 int kdb_register(char *cmd
,
2788 return kdb_register_flags(cmd
, func
, usage
, help
, minlen
, 0);
2790 EXPORT_SYMBOL_GPL(kdb_register
);
2793 * kdb_unregister - This function is used to unregister a kernel
2794 * debugger command. It is generally called when a module which
2795 * implements kdb commands is unloaded.
2799 * zero for success, one command not registered.
2801 int kdb_unregister(char *cmd
)
2809 for_each_kdbcmd(kp
, i
) {
2810 if (kp
->cmd_name
&& (strcmp(kp
->cmd_name
, cmd
) == 0)) {
2811 kp
->cmd_name
= NULL
;
2816 /* Couldn't find it. */
2819 EXPORT_SYMBOL_GPL(kdb_unregister
);
2821 /* Initialize the kdb command table. */
2822 static void __init
kdb_inittab(void)
2827 for_each_kdbcmd(kp
, i
)
2828 kp
->cmd_name
= NULL
;
2830 kdb_register_flags("md", kdb_md
, "<vaddr>",
2831 "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2832 KDB_ENABLE_MEM_READ
| KDB_REPEAT_NO_ARGS
);
2833 kdb_register_flags("mdr", kdb_md
, "<vaddr> <bytes>",
2834 "Display Raw Memory", 0,
2835 KDB_ENABLE_MEM_READ
| KDB_REPEAT_NO_ARGS
);
2836 kdb_register_flags("mdp", kdb_md
, "<paddr> <bytes>",
2837 "Display Physical Memory", 0,
2838 KDB_ENABLE_MEM_READ
| KDB_REPEAT_NO_ARGS
);
2839 kdb_register_flags("mds", kdb_md
, "<vaddr>",
2840 "Display Memory Symbolically", 0,
2841 KDB_ENABLE_MEM_READ
| KDB_REPEAT_NO_ARGS
);
2842 kdb_register_flags("mm", kdb_mm
, "<vaddr> <contents>",
2843 "Modify Memory Contents", 0,
2844 KDB_ENABLE_MEM_WRITE
| KDB_REPEAT_NO_ARGS
);
2845 kdb_register_flags("go", kdb_go
, "[<vaddr>]",
2846 "Continue Execution", 1,
2847 KDB_ENABLE_REG_WRITE
| KDB_ENABLE_ALWAYS_SAFE_NO_ARGS
);
2848 kdb_register_flags("rd", kdb_rd
, "",
2849 "Display Registers", 0,
2850 KDB_ENABLE_REG_READ
);
2851 kdb_register_flags("rm", kdb_rm
, "<reg> <contents>",
2852 "Modify Registers", 0,
2853 KDB_ENABLE_REG_WRITE
);
2854 kdb_register_flags("ef", kdb_ef
, "<vaddr>",
2855 "Display exception frame", 0,
2856 KDB_ENABLE_MEM_READ
);
2857 kdb_register_flags("bt", kdb_bt
, "[<vaddr>]",
2858 "Stack traceback", 1,
2859 KDB_ENABLE_MEM_READ
| KDB_ENABLE_INSPECT_NO_ARGS
);
2860 kdb_register_flags("btp", kdb_bt
, "<pid>",
2861 "Display stack for process <pid>", 0,
2862 KDB_ENABLE_INSPECT
);
2863 kdb_register_flags("bta", kdb_bt
, "[D|R|S|T|C|Z|E|U|I|M|A]",
2864 "Backtrace all processes matching state flag", 0,
2865 KDB_ENABLE_INSPECT
);
2866 kdb_register_flags("btc", kdb_bt
, "",
2867 "Backtrace current process on each cpu", 0,
2868 KDB_ENABLE_INSPECT
);
2869 kdb_register_flags("btt", kdb_bt
, "<vaddr>",
2870 "Backtrace process given its struct task address", 0,
2871 KDB_ENABLE_MEM_READ
| KDB_ENABLE_INSPECT_NO_ARGS
);
2872 kdb_register_flags("env", kdb_env
, "",
2873 "Show environment variables", 0,
2874 KDB_ENABLE_ALWAYS_SAFE
);
2875 kdb_register_flags("set", kdb_set
, "",
2876 "Set environment variables", 0,
2877 KDB_ENABLE_ALWAYS_SAFE
);
2878 kdb_register_flags("help", kdb_help
, "",
2879 "Display Help Message", 1,
2880 KDB_ENABLE_ALWAYS_SAFE
);
2881 kdb_register_flags("?", kdb_help
, "",
2882 "Display Help Message", 0,
2883 KDB_ENABLE_ALWAYS_SAFE
);
2884 kdb_register_flags("cpu", kdb_cpu
, "<cpunum>",
2885 "Switch to new cpu", 0,
2886 KDB_ENABLE_ALWAYS_SAFE_NO_ARGS
);
2887 kdb_register_flags("kgdb", kdb_kgdb
, "",
2888 "Enter kgdb mode", 0, 0);
2889 kdb_register_flags("ps", kdb_ps
, "[<flags>|A]",
2890 "Display active task list", 0,
2891 KDB_ENABLE_INSPECT
);
2892 kdb_register_flags("pid", kdb_pid
, "<pidnum>",
2893 "Switch to another task", 0,
2894 KDB_ENABLE_INSPECT
);
2895 kdb_register_flags("reboot", kdb_reboot
, "",
2896 "Reboot the machine immediately", 0,
2898 #if defined(CONFIG_MODULES)
2899 kdb_register_flags("lsmod", kdb_lsmod
, "",
2900 "List loaded kernel modules", 0,
2901 KDB_ENABLE_INSPECT
);
2903 #if defined(CONFIG_MAGIC_SYSRQ)
2904 kdb_register_flags("sr", kdb_sr
, "<key>",
2905 "Magic SysRq key", 0,
2906 KDB_ENABLE_ALWAYS_SAFE
);
2908 #if defined(CONFIG_PRINTK)
2909 kdb_register_flags("dmesg", kdb_dmesg
, "[lines]",
2910 "Display syslog buffer", 0,
2911 KDB_ENABLE_ALWAYS_SAFE
);
2913 if (arch_kgdb_ops
.enable_nmi
) {
2914 kdb_register_flags("disable_nmi", kdb_disable_nmi
, "",
2915 "Disable NMI entry to KDB", 0,
2916 KDB_ENABLE_ALWAYS_SAFE
);
2918 kdb_register_flags("defcmd", kdb_defcmd
, "name \"usage\" \"help\"",
2919 "Define a set of commands, down to endefcmd", 0,
2920 KDB_ENABLE_ALWAYS_SAFE
);
2921 kdb_register_flags("kill", kdb_kill
, "<-signal> <pid>",
2922 "Send a signal to a process", 0,
2924 kdb_register_flags("summary", kdb_summary
, "",
2925 "Summarize the system", 4,
2926 KDB_ENABLE_ALWAYS_SAFE
);
2927 kdb_register_flags("per_cpu", kdb_per_cpu
, "<sym> [<bytes>] [<cpu>]",
2928 "Display per_cpu variables", 3,
2929 KDB_ENABLE_MEM_READ
);
2930 kdb_register_flags("grephelp", kdb_grep_help
, "",
2931 "Display help on | grep", 0,
2932 KDB_ENABLE_ALWAYS_SAFE
);
2935 /* Execute any commands defined in kdb_cmds. */
2936 static void __init
kdb_cmd_init(void)
2939 for (i
= 0; kdb_cmds
[i
]; ++i
) {
2940 diag
= kdb_parse(kdb_cmds
[i
]);
2942 kdb_printf("kdb command %s failed, kdb diag %d\n",
2945 if (defcmd_in_progress
) {
2946 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2947 kdb_parse("endefcmd");
2951 /* Initialize kdb_printf, breakpoint tables and kdb state */
2952 void __init
kdb_init(int lvl
)
2954 static int kdb_init_lvl
= KDB_NOT_INITIALIZED
;
2957 if (kdb_init_lvl
== KDB_INIT_FULL
|| lvl
<= kdb_init_lvl
)
2959 for (i
= kdb_init_lvl
; i
< lvl
; i
++) {
2961 case KDB_NOT_INITIALIZED
:
2962 kdb_inittab(); /* Initialize Command Table */
2963 kdb_initbptab(); /* Initialize Breakpoints */
2965 case KDB_INIT_EARLY
:
2966 kdb_cmd_init(); /* Build kdb_cmds tables */