2 * Kernel Debugger Architecture Independent Main Code
4 * This file is subject to the terms and conditions of the GNU General Public
5 * License. See the file "COPYING" in the main directory of this archive
8 * Copyright (C) 1999-2004 Silicon Graphics, Inc. All Rights Reserved.
9 * Copyright (C) 2000 Stephane Eranian <eranian@hpl.hp.com>
10 * Xscale (R) modifications copyright (C) 2003 Intel Corporation.
11 * Copyright (c) 2009 Wind River Systems, Inc. All Rights Reserved.
14 #include <linux/ctype.h>
15 #include <linux/string.h>
16 #include <linux/kernel.h>
17 #include <linux/reboot.h>
18 #include <linux/sched.h>
19 #include <linux/sysrq.h>
20 #include <linux/smp.h>
21 #include <linux/utsname.h>
22 #include <linux/vmalloc.h>
23 #include <linux/module.h>
25 #include <linux/init.h>
26 #include <linux/kallsyms.h>
27 #include <linux/kgdb.h>
28 #include <linux/kdb.h>
29 #include <linux/notifier.h>
30 #include <linux/interrupt.h>
31 #include <linux/delay.h>
32 #include <linux/nmi.h>
33 #include <linux/time.h>
34 #include <linux/ptrace.h>
35 #include <linux/sysctl.h>
36 #include <linux/cpu.h>
37 #include <linux/kdebug.h>
38 #include <linux/proc_fs.h>
39 #include <linux/uaccess.h>
40 #include <linux/slab.h>
41 #include "kdb_private.h"
44 char kdb_grep_string
[GREP_LEN
];
45 int kdb_grepping_flag
;
46 EXPORT_SYMBOL(kdb_grepping_flag
);
48 int kdb_grep_trailing
;
51 * Kernel debugger state flags
57 * kdb_lock protects updates to kdb_initial_cpu. Used to
58 * single thread processors through the kernel debugger.
60 int kdb_initial_cpu
= -1; /* cpu number that owns kdb */
62 int kdb_state
; /* General KDB state */
64 struct task_struct
*kdb_current_task
;
65 EXPORT_SYMBOL(kdb_current_task
);
66 struct pt_regs
*kdb_current_regs
;
68 const char *kdb_diemsg
;
69 static int kdb_go_count
;
70 #ifdef CONFIG_KDB_CONTINUE_CATASTROPHIC
71 static unsigned int kdb_continue_catastrophic
=
72 CONFIG_KDB_CONTINUE_CATASTROPHIC
;
74 static unsigned int kdb_continue_catastrophic
;
77 /* kdb_commands describes the available commands. */
78 static kdbtab_t
*kdb_commands
;
79 #define KDB_BASE_CMD_MAX 50
80 static int kdb_max_commands
= KDB_BASE_CMD_MAX
;
81 static kdbtab_t kdb_base_commands
[50];
82 #define for_each_kdbcmd(cmd, num) \
83 for ((cmd) = kdb_base_commands, (num) = 0; \
84 num < kdb_max_commands; \
85 num == KDB_BASE_CMD_MAX ? cmd = kdb_commands : cmd++, num++)
87 typedef struct _kdbmsg
{
88 int km_diag
; /* kdb diagnostic */
89 char *km_msg
; /* Corresponding message text */
92 #define KDBMSG(msgnum, text) \
93 { KDB_##msgnum, text }
95 static kdbmsg_t kdbmsgs
[] = {
96 KDBMSG(NOTFOUND
, "Command Not Found"),
97 KDBMSG(ARGCOUNT
, "Improper argument count, see usage."),
98 KDBMSG(BADWIDTH
, "Illegal value for BYTESPERWORD use 1, 2, 4 or 8, "
99 "8 is only allowed on 64 bit systems"),
100 KDBMSG(BADRADIX
, "Illegal value for RADIX use 8, 10 or 16"),
101 KDBMSG(NOTENV
, "Cannot find environment variable"),
102 KDBMSG(NOENVVALUE
, "Environment variable should have value"),
103 KDBMSG(NOTIMP
, "Command not implemented"),
104 KDBMSG(ENVFULL
, "Environment full"),
105 KDBMSG(ENVBUFFULL
, "Environment buffer full"),
106 KDBMSG(TOOMANYBPT
, "Too many breakpoints defined"),
107 #ifdef CONFIG_CPU_XSCALE
108 KDBMSG(TOOMANYDBREGS
, "More breakpoints than ibcr registers defined"),
110 KDBMSG(TOOMANYDBREGS
, "More breakpoints than db registers defined"),
112 KDBMSG(DUPBPT
, "Duplicate breakpoint address"),
113 KDBMSG(BPTNOTFOUND
, "Breakpoint not found"),
114 KDBMSG(BADMODE
, "Invalid IDMODE"),
115 KDBMSG(BADINT
, "Illegal numeric value"),
116 KDBMSG(INVADDRFMT
, "Invalid symbolic address format"),
117 KDBMSG(BADREG
, "Invalid register name"),
118 KDBMSG(BADCPUNUM
, "Invalid cpu number"),
119 KDBMSG(BADLENGTH
, "Invalid length field"),
120 KDBMSG(NOBP
, "No Breakpoint exists"),
121 KDBMSG(BADADDR
, "Invalid address"),
125 static const int __nkdb_err
= sizeof(kdbmsgs
) / sizeof(kdbmsg_t
);
129 * Initial environment. This is all kept static and local to
130 * this file. We don't want to rely on the memory allocation
131 * mechanisms in the kernel, so we use a very limited allocate-only
132 * heap for new and altered environment variables. The entire
133 * environment is limited to a fixed number of entries (add more
134 * to __env[] if required) and a fixed amount of heap (add more to
135 * KDB_ENVBUFSIZE if required).
138 static char *__env
[] = {
139 #if defined(CONFIG_SMP)
141 "MOREPROMPT=[%d]more> ",
147 "MDCOUNT=8", /* lines of md output */
148 "BTARGS=9", /* 9 possible args in bt */
177 static const int __nenv
= (sizeof(__env
) / sizeof(char *));
179 struct task_struct
*kdb_curr_task(int cpu
)
181 struct task_struct
*p
= curr_task(cpu
);
183 if ((task_thread_info(p
)->flags
& _TIF_MCA_INIT
) && KDB_TSK(cpu
))
190 * kdbgetenv - This function will return the character string value of
191 * an environment variable.
193 * match A character string representing an environment variable.
195 * NULL No environment variable matches 'match'
196 * char* Pointer to string value of environment variable.
198 char *kdbgetenv(const char *match
)
201 int matchlen
= strlen(match
);
204 for (i
= 0; i
< __nenv
; i
++) {
210 if ((strncmp(match
, e
, matchlen
) == 0)
211 && ((e
[matchlen
] == '\0')
212 || (e
[matchlen
] == '='))) {
213 char *cp
= strchr(e
, '=');
214 return cp
? ++cp
: "";
221 * kdballocenv - This function is used to allocate bytes for
222 * environment entries.
224 * match A character string representing a numeric value
226 * *value the unsigned long representation of the env variable 'match'
228 * Zero on success, a kdb diagnostic on failure.
230 * We use a static environment buffer (envbuffer) to hold the values
231 * of dynamically generated environment variables (see kdb_set). Buffer
232 * space once allocated is never free'd, so over time, the amount of space
233 * (currently 512 bytes) will be exhausted if env variables are changed
236 static char *kdballocenv(size_t bytes
)
238 #define KDB_ENVBUFSIZE 512
239 static char envbuffer
[KDB_ENVBUFSIZE
];
240 static int envbufsize
;
243 if ((KDB_ENVBUFSIZE
- envbufsize
) >= bytes
) {
244 ep
= &envbuffer
[envbufsize
];
251 * kdbgetulenv - This function will return the value of an unsigned
252 * long-valued environment variable.
254 * match A character string representing a numeric value
256 * *value the unsigned long represntation of the env variable 'match'
258 * Zero on success, a kdb diagnostic on failure.
260 static int kdbgetulenv(const char *match
, unsigned long *value
)
264 ep
= kdbgetenv(match
);
268 return KDB_NOENVVALUE
;
270 *value
= simple_strtoul(ep
, NULL
, 0);
276 * kdbgetintenv - This function will return the value of an
277 * integer-valued environment variable.
279 * match A character string representing an integer-valued env variable
281 * *value the integer representation of the environment variable 'match'
283 * Zero on success, a kdb diagnostic on failure.
285 int kdbgetintenv(const char *match
, int *value
)
290 diag
= kdbgetulenv(match
, &val
);
297 * kdbgetularg - This function will convert a numeric string into an
298 * unsigned long value.
300 * arg A character string representing a numeric value
302 * *value the unsigned long represntation of arg.
304 * Zero on success, a kdb diagnostic on failure.
306 int kdbgetularg(const char *arg
, unsigned long *value
)
311 val
= simple_strtoul(arg
, &endp
, 0);
315 * Try base 16, for us folks too lazy to type the
318 val
= simple_strtoul(arg
, &endp
, 16);
329 * kdb_set - This function implements the 'set' command. Alter an
330 * existing environment variable or create a new one.
332 int kdb_set(int argc
, const char **argv
)
336 size_t varlen
, vallen
;
339 * we can be invoked two ways:
340 * set var=value argv[1]="var", argv[2]="value"
341 * set var = value argv[1]="var", argv[2]="=", argv[3]="value"
342 * - if the latter, shift 'em down.
353 * Check for internal variables
355 if (strcmp(argv
[1], "KDBDEBUG") == 0) {
356 unsigned int debugflags
;
359 debugflags
= simple_strtoul(argv
[2], &cp
, 0);
360 if (cp
== argv
[2] || debugflags
& ~KDB_DEBUG_FLAG_MASK
) {
361 kdb_printf("kdb: illegal debug flags '%s'\n",
365 kdb_flags
= (kdb_flags
&
366 ~(KDB_DEBUG_FLAG_MASK
<< KDB_DEBUG_FLAG_SHIFT
))
367 | (debugflags
<< KDB_DEBUG_FLAG_SHIFT
);
373 * Tokenizer squashed the '=' sign. argv[1] is variable
374 * name, argv[2] = value.
376 varlen
= strlen(argv
[1]);
377 vallen
= strlen(argv
[2]);
378 ep
= kdballocenv(varlen
+ vallen
+ 2);
380 return KDB_ENVBUFFULL
;
382 sprintf(ep
, "%s=%s", argv
[1], argv
[2]);
384 ep
[varlen
+vallen
+1] = '\0';
386 for (i
= 0; i
< __nenv
; i
++) {
388 && ((strncmp(__env
[i
], argv
[1], varlen
) == 0)
389 && ((__env
[i
][varlen
] == '\0')
390 || (__env
[i
][varlen
] == '=')))) {
397 * Wasn't existing variable. Fit into slot.
399 for (i
= 0; i
< __nenv
-1; i
++) {
400 if (__env
[i
] == (char *)0) {
409 static int kdb_check_regs(void)
411 if (!kdb_current_regs
) {
412 kdb_printf("No current kdb registers."
413 " You may need to select another task\n");
420 * kdbgetaddrarg - This function is responsible for parsing an
421 * address-expression and returning the value of the expression,
422 * symbol name, and offset to the caller.
424 * The argument may consist of a numeric value (decimal or
425 * hexidecimal), a symbol name, a register name (preceeded by the
426 * percent sign), an environment variable with a numeric value
427 * (preceeded by a dollar sign) or a simple arithmetic expression
428 * consisting of a symbol name, +/-, and a numeric constant value
431 * argc - count of arguments in argv
432 * argv - argument vector
433 * *nextarg - index to next unparsed argument in argv[]
434 * regs - Register state at time of KDB entry
436 * *value - receives the value of the address-expression
437 * *offset - receives the offset specified, if any
438 * *name - receives the symbol name, if any
439 * *nextarg - index to next unparsed argument in argv[]
441 * zero is returned on success, a kdb diagnostic code is
444 int kdbgetaddrarg(int argc
, const char **argv
, int *nextarg
,
445 unsigned long *value
, long *offset
,
449 unsigned long off
= 0;
459 * Process arguments which follow the following syntax:
461 * symbol | numeric-address [+/- numeric-offset]
463 * $environment-variable
469 symname
= (char *)argv
[*nextarg
];
472 * If there is no whitespace between the symbol
473 * or address and the '+' or '-' symbols, we
474 * remember the character and replace it with a
475 * null so the symbol/value can be properly parsed
477 cp
= strpbrk(symname
, "+-");
483 if (symname
[0] == '$') {
484 diag
= kdbgetulenv(&symname
[1], &addr
);
487 } else if (symname
[0] == '%') {
488 diag
= kdb_check_regs();
491 /* Implement register values with % at a later time as it is
496 found
= kdbgetsymval(symname
, &symtab
);
498 addr
= symtab
.sym_start
;
500 diag
= kdbgetularg(argv
[*nextarg
], &addr
);
507 found
= kdbnearsym(addr
, &symtab
);
515 if (offset
&& name
&& *name
)
516 *offset
= addr
- symtab
.sym_start
;
518 if ((*nextarg
> argc
)
523 * check for +/- and offset
526 if (symbol
== '\0') {
527 if ((argv
[*nextarg
][0] != '+')
528 && (argv
[*nextarg
][0] != '-')) {
530 * Not our argument. Return.
534 positive
= (argv
[*nextarg
][0] == '+');
538 positive
= (symbol
== '+');
541 * Now there must be an offset!
543 if ((*nextarg
> argc
)
544 && (symbol
== '\0')) {
545 return KDB_INVADDRFMT
;
549 cp
= (char *)argv
[*nextarg
];
553 diag
= kdbgetularg(cp
, &off
);
569 static void kdb_cmderror(int diag
)
574 kdb_printf("no error detected (diagnostic is %d)\n", diag
);
578 for (i
= 0; i
< __nkdb_err
; i
++) {
579 if (kdbmsgs
[i
].km_diag
== diag
) {
580 kdb_printf("diag: %d: %s\n", diag
, kdbmsgs
[i
].km_msg
);
585 kdb_printf("Unknown diag %d\n", -diag
);
589 * kdb_defcmd, kdb_defcmd2 - This function implements the 'defcmd'
590 * command which defines one command as a set of other commands,
591 * terminated by endefcmd. kdb_defcmd processes the initial
592 * 'defcmd' command, kdb_defcmd2 is invoked from kdb_parse for
593 * the following commands until 'endefcmd'.
595 * argc argument count
596 * argv argument vector
598 * zero for success, a kdb diagnostic if error
608 static struct defcmd_set
*defcmd_set
;
609 static int defcmd_set_count
;
610 static int defcmd_in_progress
;
612 /* Forward references */
613 static int kdb_exec_defcmd(int argc
, const char **argv
);
615 static int kdb_defcmd2(const char *cmdstr
, const char *argv0
)
617 struct defcmd_set
*s
= defcmd_set
+ defcmd_set_count
- 1;
618 char **save_command
= s
->command
;
619 if (strcmp(argv0
, "endefcmd") == 0) {
620 defcmd_in_progress
= 0;
624 kdb_register(s
->name
, kdb_exec_defcmd
,
625 s
->usage
, s
->help
, 0);
630 s
->command
= kmalloc((s
->count
+ 1) * sizeof(*(s
->command
)), GFP_KDB
);
632 kdb_printf("Could not allocate new kdb_defcmd table for %s\n",
637 memcpy(s
->command
, save_command
, s
->count
* sizeof(*(s
->command
)));
638 s
->command
[s
->count
++] = kdb_strdup(cmdstr
, GFP_KDB
);
643 static int kdb_defcmd(int argc
, const char **argv
)
645 struct defcmd_set
*save_defcmd_set
= defcmd_set
, *s
;
646 if (defcmd_in_progress
) {
647 kdb_printf("kdb: nested defcmd detected, assuming missing "
649 kdb_defcmd2("endefcmd", "endefcmd");
653 for (s
= defcmd_set
; s
< defcmd_set
+ defcmd_set_count
; ++s
) {
654 kdb_printf("defcmd %s \"%s\" \"%s\"\n", s
->name
,
656 for (i
= 0; i
< s
->count
; ++i
)
657 kdb_printf("%s", s
->command
[i
]);
658 kdb_printf("endefcmd\n");
664 defcmd_set
= kmalloc((defcmd_set_count
+ 1) * sizeof(*defcmd_set
),
667 kdb_printf("Could not allocate new defcmd_set entry for %s\n",
669 defcmd_set
= save_defcmd_set
;
672 memcpy(defcmd_set
, save_defcmd_set
,
673 defcmd_set_count
* sizeof(*defcmd_set
));
674 kfree(save_defcmd_set
);
675 s
= defcmd_set
+ defcmd_set_count
;
676 memset(s
, 0, sizeof(*s
));
678 s
->name
= kdb_strdup(argv
[1], GFP_KDB
);
679 s
->usage
= kdb_strdup(argv
[2], GFP_KDB
);
680 s
->help
= kdb_strdup(argv
[3], GFP_KDB
);
681 if (s
->usage
[0] == '"') {
682 strcpy(s
->usage
, s
->usage
+1);
683 s
->usage
[strlen(s
->usage
)-1] = '\0';
685 if (s
->help
[0] == '"') {
686 strcpy(s
->help
, s
->help
+1);
687 s
->help
[strlen(s
->help
)-1] = '\0';
690 defcmd_in_progress
= 1;
695 * kdb_exec_defcmd - Execute the set of commands associated with this
698 * argc argument count
699 * argv argument vector
701 * zero for success, a kdb diagnostic if error
703 static int kdb_exec_defcmd(int argc
, const char **argv
)
706 struct defcmd_set
*s
;
709 for (s
= defcmd_set
, i
= 0; i
< defcmd_set_count
; ++i
, ++s
) {
710 if (strcmp(s
->name
, argv
[0]) == 0)
713 if (i
== defcmd_set_count
) {
714 kdb_printf("kdb_exec_defcmd: could not find commands for %s\n",
718 for (i
= 0; i
< s
->count
; ++i
) {
719 /* Recursive use of kdb_parse, do not use argv after
722 kdb_printf("[%s]kdb> %s\n", s
->name
, s
->command
[i
]);
723 ret
= kdb_parse(s
->command
[i
]);
730 /* Command history */
731 #define KDB_CMD_HISTORY_COUNT 32
732 #define CMD_BUFLEN 200 /* kdb_printf: max printline
734 static unsigned int cmd_head
, cmd_tail
;
735 static unsigned int cmdptr
;
736 static char cmd_hist
[KDB_CMD_HISTORY_COUNT
][CMD_BUFLEN
];
737 static char cmd_cur
[CMD_BUFLEN
];
740 * The "str" argument may point to something like | grep xyz
742 static void parse_grep(const char *str
)
745 char *cp
= (char *)str
, *cp2
;
747 /* sanity check: we should have been called with the \ first */
753 if (strncmp(cp
, "grep ", 5)) {
754 kdb_printf("invalid 'pipe', see grephelp\n");
760 cp2
= strchr(cp
, '\n');
762 *cp2
= '\0'; /* remove the trailing newline */
765 kdb_printf("invalid 'pipe', see grephelp\n");
768 /* now cp points to a nonzero length search string */
770 /* allow it be "x y z" by removing the "'s - there must
773 cp2
= strchr(cp
, '"');
775 kdb_printf("invalid quoted string, see grephelp\n");
778 *cp2
= '\0'; /* end the string where the 2nd " was */
780 kdb_grep_leading
= 0;
782 kdb_grep_leading
= 1;
786 kdb_grep_trailing
= 0;
787 if (*(cp
+len
-1) == '$') {
788 kdb_grep_trailing
= 1;
794 if (len
>= GREP_LEN
) {
795 kdb_printf("search string too long\n");
798 strcpy(kdb_grep_string
, cp
);
804 * kdb_parse - Parse the command line, search the command table for a
805 * matching command and invoke the command function. This
806 * function may be called recursively, if it is, the second call
807 * will overwrite argv and cbuf. It is the caller's
808 * responsibility to save their argv if they recursively call
811 * cmdstr The input command line to be parsed.
812 * regs The registers at the time kdb was entered.
814 * Zero for success, a kdb diagnostic if failure.
816 * Limited to 20 tokens.
818 * Real rudimentary tokenization. Basically only whitespace
819 * is considered a token delimeter (but special consideration
820 * is taken of the '=' sign as used by the 'set' command).
822 * The algorithm used to tokenize the input string relies on
823 * there being at least one whitespace (or otherwise useless)
824 * character between tokens as the character immediately following
825 * the token is altered in-place to a null-byte to terminate the
831 int kdb_parse(const char *cmdstr
)
833 static char *argv
[MAXARGC
];
835 static char cbuf
[CMD_BUFLEN
+2];
839 int i
, escaped
, ignore_errors
= 0, check_grep
;
842 * First tokenize the command string.
845 kdb_grepping_flag
= check_grep
= 0;
847 if (KDB_FLAG(CMD_INTERRUPT
)) {
848 /* Previous command was interrupted, newline must not
849 * repeat the command */
850 KDB_FLAG_CLEAR(CMD_INTERRUPT
);
851 KDB_STATE_SET(PAGER
);
852 argc
= 0; /* no repeat */
855 if (*cp
!= '\n' && *cp
!= '\0') {
859 /* skip whitespace */
862 if ((*cp
== '\0') || (*cp
== '\n') ||
863 (*cp
== '#' && !defcmd_in_progress
))
865 /* special case: check for | grep pattern */
870 if (cpp
>= cbuf
+ CMD_BUFLEN
) {
871 kdb_printf("kdb_parse: command buffer "
872 "overflow, command ignored\n%s\n",
876 if (argc
>= MAXARGC
- 1) {
877 kdb_printf("kdb_parse: too many arguments, "
878 "command ignored\n%s\n", cmdstr
);
884 /* Copy to next unquoted and unescaped
885 * whitespace or '=' */
886 while (*cp
&& *cp
!= '\n' &&
887 (escaped
|| quoted
|| !isspace(*cp
))) {
888 if (cpp
>= cbuf
+ CMD_BUFLEN
)
902 else if (*cp
== '\'' || *cp
== '"')
905 if (*cpp
== '=' && !quoted
)
909 *cpp
++ = '\0'; /* Squash a ws or '=' character */
916 if (defcmd_in_progress
) {
917 int result
= kdb_defcmd2(cmdstr
, argv
[0]);
918 if (!defcmd_in_progress
) {
919 argc
= 0; /* avoid repeat on endefcmd */
924 if (argv
[0][0] == '-' && argv
[0][1] &&
925 (argv
[0][1] < '0' || argv
[0][1] > '9')) {
930 for_each_kdbcmd(tp
, i
) {
933 * If this command is allowed to be abbreviated,
934 * check to see if this is it.
938 && (strlen(argv
[0]) <= tp
->cmd_minlen
)) {
941 tp
->cmd_minlen
) == 0) {
946 if (strcmp(argv
[0], tp
->cmd_name
) == 0)
952 * If we don't find a command by this name, see if the first
953 * few characters of this match any of the known commands.
954 * e.g., md1c20 should match md.
956 if (i
== kdb_max_commands
) {
957 for_each_kdbcmd(tp
, i
) {
961 strlen(tp
->cmd_name
)) == 0) {
968 if (i
< kdb_max_commands
) {
971 result
= (*tp
->cmd_func
)(argc
-1, (const char **)argv
);
972 if (result
&& ignore_errors
&& result
> KDB_CMD_GO
)
974 KDB_STATE_CLEAR(CMD
);
975 switch (tp
->cmd_repeat
) {
976 case KDB_REPEAT_NONE
:
981 case KDB_REPEAT_NO_ARGS
:
986 case KDB_REPEAT_WITH_ARGS
:
993 * If the input with which we were presented does not
994 * map to an existing command, attempt to parse it as an
995 * address argument and display the result. Useful for
996 * obtaining the address of a variable, or the nearest symbol
997 * to an address contained in a register.
1000 unsigned long value
;
1005 if (kdbgetaddrarg(0, (const char **)argv
, &nextarg
,
1006 &value
, &offset
, &name
)) {
1007 return KDB_NOTFOUND
;
1010 kdb_printf("%s = ", argv
[0]);
1011 kdb_symbol_print(value
, NULL
, KDB_SP_DEFAULT
);
1018 static int handle_ctrl_cmd(char *cmd
)
1023 /* initial situation */
1024 if (cmd_head
== cmd_tail
)
1028 if (cmdptr
!= cmd_tail
)
1029 cmdptr
= (cmdptr
-1) % KDB_CMD_HISTORY_COUNT
;
1030 strncpy(cmd_cur
, cmd_hist
[cmdptr
], CMD_BUFLEN
);
1033 if (cmdptr
!= cmd_head
)
1034 cmdptr
= (cmdptr
+1) % KDB_CMD_HISTORY_COUNT
;
1035 strncpy(cmd_cur
, cmd_hist
[cmdptr
], CMD_BUFLEN
);
1042 * kdb_reboot - This function implements the 'reboot' command. Reboot
1043 * the system immediately, or loop for ever on failure.
1045 static int kdb_reboot(int argc
, const char **argv
)
1047 emergency_restart();
1048 kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
1055 static void kdb_dumpregs(struct pt_regs
*regs
)
1057 int old_lvl
= console_loglevel
;
1058 console_loglevel
= 15;
1063 console_loglevel
= old_lvl
;
1066 void kdb_set_current_task(struct task_struct
*p
)
1068 kdb_current_task
= p
;
1070 if (kdb_task_has_cpu(p
)) {
1071 kdb_current_regs
= KDB_TSKREGS(kdb_process_cpu(p
));
1074 kdb_current_regs
= NULL
;
1078 * kdb_local - The main code for kdb. This routine is invoked on a
1079 * specific processor, it is not global. The main kdb() routine
1080 * ensures that only one processor at a time is in this routine.
1081 * This code is called with the real reason code on the first
1082 * entry to a kdb session, thereafter it is called with reason
1083 * SWITCH, even if the user goes back to the original cpu.
1085 * reason The reason KDB was invoked
1086 * error The hardware-defined error code
1087 * regs The exception frame at time of fault/breakpoint.
1088 * db_result Result code from the break or debug point.
1090 * 0 KDB was invoked for an event which it wasn't responsible
1091 * 1 KDB handled the event for which it was invoked.
1092 * KDB_CMD_GO User typed 'go'.
1093 * KDB_CMD_CPU User switched to another cpu.
1094 * KDB_CMD_SS Single step.
1095 * KDB_CMD_SSB Single step until branch.
1097 static int kdb_local(kdb_reason_t reason
, int error
, struct pt_regs
*regs
,
1098 kdb_dbtrap_t db_result
)
1102 struct task_struct
*kdb_current
=
1103 kdb_curr_task(raw_smp_processor_id());
1105 KDB_DEBUG_STATE("kdb_local 1", reason
);
1107 if (reason
== KDB_REASON_DEBUG
) {
1108 /* special case below */
1110 kdb_printf("\nEntering kdb (current=0x%p, pid %d) ",
1111 kdb_current
, kdb_current
->pid
);
1112 #if defined(CONFIG_SMP)
1113 kdb_printf("on processor %d ", raw_smp_processor_id());
1118 case KDB_REASON_DEBUG
:
1121 * If re-entering kdb after a single step
1122 * command, don't print the message.
1124 switch (db_result
) {
1126 kdb_printf("\nEntering kdb (0x%p, pid %d) ",
1127 kdb_current
, kdb_current
->pid
);
1128 #if defined(CONFIG_SMP)
1129 kdb_printf("on processor %d ", raw_smp_processor_id());
1131 kdb_printf("due to Debug @ " kdb_machreg_fmt
"\n",
1132 instruction_pointer(regs
));
1136 * In the midst of ssb command. Just return.
1138 KDB_DEBUG_STATE("kdb_local 3", reason
);
1139 return KDB_CMD_SSB
; /* Continue with SSB command */
1145 KDB_DEBUG_STATE("kdb_local 4", reason
);
1146 return 1; /* kdba_db_trap did the work */
1148 kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
1155 case KDB_REASON_ENTER
:
1156 if (KDB_STATE(KEYBOARD
))
1157 kdb_printf("due to Keyboard Entry\n");
1159 kdb_printf("due to KDB_ENTER()\n");
1161 case KDB_REASON_KEYBOARD
:
1162 KDB_STATE_SET(KEYBOARD
);
1163 kdb_printf("due to Keyboard Entry\n");
1165 case KDB_REASON_ENTER_SLAVE
:
1166 /* drop through, slaves only get released via cpu switch */
1167 case KDB_REASON_SWITCH
:
1168 kdb_printf("due to cpu switch\n");
1170 case KDB_REASON_OOPS
:
1171 kdb_printf("Oops: %s\n", kdb_diemsg
);
1172 kdb_printf("due to oops @ " kdb_machreg_fmt
"\n",
1173 instruction_pointer(regs
));
1176 case KDB_REASON_NMI
:
1177 kdb_printf("due to NonMaskable Interrupt @ "
1178 kdb_machreg_fmt
"\n",
1179 instruction_pointer(regs
));
1182 case KDB_REASON_SSTEP
:
1183 case KDB_REASON_BREAK
:
1184 kdb_printf("due to %s @ " kdb_machreg_fmt
"\n",
1185 reason
== KDB_REASON_BREAK
?
1186 "Breakpoint" : "SS trap", instruction_pointer(regs
));
1188 * Determine if this breakpoint is one that we
1189 * are interested in.
1191 if (db_result
!= KDB_DB_BPT
) {
1192 kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1194 KDB_DEBUG_STATE("kdb_local 6", reason
);
1195 return 0; /* Not for us, dismiss it */
1198 case KDB_REASON_RECURSE
:
1199 kdb_printf("due to Recursion @ " kdb_machreg_fmt
"\n",
1200 instruction_pointer(regs
));
1203 kdb_printf("kdb: unexpected reason code: %d\n", reason
);
1204 KDB_DEBUG_STATE("kdb_local 8", reason
);
1205 return 0; /* Not for us, dismiss it */
1210 * Initialize pager context.
1213 KDB_STATE_CLEAR(SUPPRESS
);
1217 *(cmd_hist
[cmd_head
]) = '\0';
1219 if (KDB_FLAG(ONLY_DO_DUMP
)) {
1220 /* kdb is off but a catastrophic error requires a dump.
1221 * Take the dump and reboot.
1222 * Turn on logging so the kdb output appears in the log
1223 * buffer in the dump.
1225 const char *setargs
[] = { "set", "LOGGING", "1" };
1226 kdb_set(2, setargs
);
1227 kdb_reboot(0, NULL
);
1232 #if defined(CONFIG_SMP)
1233 snprintf(kdb_prompt_str
, CMD_BUFLEN
, kdbgetenv("PROMPT"),
1234 raw_smp_processor_id());
1236 snprintf(kdb_prompt_str
, CMD_BUFLEN
, kdbgetenv("PROMPT"));
1238 if (defcmd_in_progress
)
1239 strncat(kdb_prompt_str
, "[defcmd]", CMD_BUFLEN
);
1242 * Fetch command from keyboard
1244 cmdbuf
= kdb_getstr(cmdbuf
, CMD_BUFLEN
, kdb_prompt_str
);
1245 if (*cmdbuf
!= '\n') {
1247 if (cmdptr
== cmd_head
) {
1248 strncpy(cmd_hist
[cmd_head
], cmd_cur
,
1250 *(cmd_hist
[cmd_head
] +
1251 strlen(cmd_hist
[cmd_head
])-1) = '\0';
1253 if (!handle_ctrl_cmd(cmdbuf
))
1254 *(cmd_cur
+strlen(cmd_cur
)-1) = '\0';
1256 goto do_full_getstr
;
1258 strncpy(cmd_hist
[cmd_head
], cmd_cur
,
1262 cmd_head
= (cmd_head
+1) % KDB_CMD_HISTORY_COUNT
;
1263 if (cmd_head
== cmd_tail
)
1264 cmd_tail
= (cmd_tail
+1) % KDB_CMD_HISTORY_COUNT
;
1268 diag
= kdb_parse(cmdbuf
);
1269 if (diag
== KDB_NOTFOUND
) {
1270 kdb_printf("Unknown kdb command: '%s'\n", cmdbuf
);
1273 if (diag
== KDB_CMD_GO
1274 || diag
== KDB_CMD_CPU
1275 || diag
== KDB_CMD_SS
1276 || diag
== KDB_CMD_SSB
1277 || diag
== KDB_CMD_KGDB
)
1283 KDB_DEBUG_STATE("kdb_local 9", diag
);
1289 * kdb_print_state - Print the state data for the current processor
1292 * text Identifies the debug point
1293 * value Any integer value to be printed, e.g. reason code.
1295 void kdb_print_state(const char *text
, int value
)
1297 kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1298 text
, raw_smp_processor_id(), value
, kdb_initial_cpu
,
1303 * kdb_main_loop - After initial setup and assignment of the
1304 * controlling cpu, all cpus are in this loop. One cpu is in
1305 * control and will issue the kdb prompt, the others will spin
1306 * until 'go' or cpu switch.
1308 * To get a consistent view of the kernel stacks for all
1309 * processes, this routine is invoked from the main kdb code via
1310 * an architecture specific routine. kdba_main_loop is
1311 * responsible for making the kernel stacks consistent for all
1312 * processes, there should be no difference between a blocked
1313 * process and a running process as far as kdb is concerned.
1315 * reason The reason KDB was invoked
1316 * error The hardware-defined error code
1317 * reason2 kdb's current reason code.
1318 * Initially error but can change
1319 * acording to kdb state.
1320 * db_result Result code from break or debug point.
1321 * regs The exception frame at time of fault/breakpoint.
1322 * should always be valid.
1324 * 0 KDB was invoked for an event which it wasn't responsible
1325 * 1 KDB handled the event for which it was invoked.
1327 int kdb_main_loop(kdb_reason_t reason
, kdb_reason_t reason2
, int error
,
1328 kdb_dbtrap_t db_result
, struct pt_regs
*regs
)
1331 /* Stay in kdb() until 'go', 'ss[b]' or an error */
1334 * All processors except the one that is in control
1337 KDB_DEBUG_STATE("kdb_main_loop 1", reason
);
1338 while (KDB_STATE(HOLD_CPU
)) {
1339 /* state KDB is turned off by kdb_cpu to see if the
1340 * other cpus are still live, each cpu in this loop
1343 if (!KDB_STATE(KDB
))
1347 KDB_STATE_CLEAR(SUPPRESS
);
1348 KDB_DEBUG_STATE("kdb_main_loop 2", reason
);
1349 if (KDB_STATE(LEAVING
))
1350 break; /* Another cpu said 'go' */
1351 /* Still using kdb, this processor is in control */
1352 result
= kdb_local(reason2
, error
, regs
, db_result
);
1353 KDB_DEBUG_STATE("kdb_main_loop 3", result
);
1355 if (result
== KDB_CMD_CPU
)
1358 if (result
== KDB_CMD_SS
) {
1359 KDB_STATE_SET(DOING_SS
);
1363 if (result
== KDB_CMD_SSB
) {
1364 KDB_STATE_SET(DOING_SS
);
1365 KDB_STATE_SET(DOING_SSB
);
1369 if (result
== KDB_CMD_KGDB
) {
1370 if (!(KDB_STATE(DOING_KGDB
) || KDB_STATE(DOING_KGDB2
)))
1371 kdb_printf("Entering please attach debugger "
1372 "or use $D#44+ or $3#33\n");
1375 if (result
&& result
!= 1 && result
!= KDB_CMD_GO
)
1376 kdb_printf("\nUnexpected kdb_local return code %d\n",
1378 KDB_DEBUG_STATE("kdb_main_loop 4", reason
);
1381 if (KDB_STATE(DOING_SS
))
1382 KDB_STATE_CLEAR(SSBPT
);
1388 * kdb_mdr - This function implements the guts of the 'mdr', memory
1390 * mdr <addr arg>,<byte count>
1392 * addr Start address
1393 * count Number of bytes
1395 * Always 0. Any errors are detected and printed by kdb_getarea.
1397 static int kdb_mdr(unsigned long addr
, unsigned int count
)
1401 if (kdb_getarea(c
, addr
))
1403 kdb_printf("%02x", c
);
1411 * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1412 * 'md8' 'mdr' and 'mds' commands.
1414 * md|mds [<addr arg> [<line count> [<radix>]]]
1415 * mdWcN [<addr arg> [<line count> [<radix>]]]
1416 * where W = is the width (1, 2, 4 or 8) and N is the count.
1417 * for eg., md1c20 reads 20 bytes, 1 at a time.
1418 * mdr <addr arg>,<byte count>
1420 static void kdb_md_line(const char *fmtstr
, unsigned long addr
,
1421 int symbolic
, int nosect
, int bytesperword
,
1422 int num
, int repeat
, int phys
)
1424 /* print just one line of data */
1425 kdb_symtab_t symtab
;
1431 memset(cbuf
, '\0', sizeof(cbuf
));
1433 kdb_printf("phys " kdb_machreg_fmt0
" ", addr
);
1435 kdb_printf(kdb_machreg_fmt0
" ", addr
);
1437 for (i
= 0; i
< num
&& repeat
--; i
++) {
1439 if (kdb_getphysword(&word
, addr
, bytesperword
))
1441 } else if (kdb_getword(&word
, addr
, bytesperword
))
1443 kdb_printf(fmtstr
, word
);
1445 kdbnearsym(word
, &symtab
);
1447 memset(&symtab
, 0, sizeof(symtab
));
1448 if (symtab
.sym_name
) {
1449 kdb_symbol_print(word
, &symtab
, 0);
1452 kdb_printf(" %s %s "
1455 kdb_machreg_fmt
, symtab
.mod_name
,
1456 symtab
.sec_name
, symtab
.sec_start
,
1457 symtab
.sym_start
, symtab
.sym_end
);
1459 addr
+= bytesperword
;
1467 cp
= wc
.c
+ 8 - bytesperword
;
1472 #define printable_char(c) \
1473 ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1474 switch (bytesperword
) {
1476 *c
++ = printable_char(*cp
++);
1477 *c
++ = printable_char(*cp
++);
1478 *c
++ = printable_char(*cp
++);
1479 *c
++ = printable_char(*cp
++);
1482 *c
++ = printable_char(*cp
++);
1483 *c
++ = printable_char(*cp
++);
1486 *c
++ = printable_char(*cp
++);
1489 *c
++ = printable_char(*cp
++);
1493 #undef printable_char
1496 kdb_printf("%*s %s\n", (int)((num
-i
)*(2*bytesperword
+ 1)+1),
1500 static int kdb_md(int argc
, const char **argv
)
1502 static unsigned long last_addr
;
1503 static int last_radix
, last_bytesperword
, last_repeat
;
1504 int radix
= 16, mdcount
= 8, bytesperword
= KDB_WORD_SIZE
, repeat
;
1506 char fmtchar
, fmtstr
[64];
1514 kdbgetintenv("MDCOUNT", &mdcount
);
1515 kdbgetintenv("RADIX", &radix
);
1516 kdbgetintenv("BYTESPERWORD", &bytesperword
);
1518 /* Assume 'md <addr>' and start with environment values */
1519 repeat
= mdcount
* 16 / bytesperword
;
1521 if (strcmp(argv
[0], "mdr") == 0) {
1523 return KDB_ARGCOUNT
;
1525 } else if (isdigit(argv
[0][2])) {
1526 bytesperword
= (int)(argv
[0][2] - '0');
1527 if (bytesperword
== 0) {
1528 bytesperword
= last_bytesperword
;
1529 if (bytesperword
== 0)
1532 last_bytesperword
= bytesperword
;
1533 repeat
= mdcount
* 16 / bytesperword
;
1536 else if (argv
[0][3] == 'c' && argv
[0][4]) {
1538 repeat
= simple_strtoul(argv
[0] + 4, &p
, 10);
1539 mdcount
= ((repeat
* bytesperword
) + 15) / 16;
1542 last_repeat
= repeat
;
1543 } else if (strcmp(argv
[0], "md") == 0)
1545 else if (strcmp(argv
[0], "mds") == 0)
1547 else if (strcmp(argv
[0], "mdp") == 0) {
1551 return KDB_NOTFOUND
;
1555 return KDB_ARGCOUNT
;
1558 bytesperword
= last_bytesperword
;
1559 repeat
= last_repeat
;
1560 mdcount
= ((repeat
* bytesperword
) + 15) / 16;
1565 int diag
, nextarg
= 1;
1566 diag
= kdbgetaddrarg(argc
, argv
, &nextarg
, &addr
,
1570 if (argc
> nextarg
+2)
1571 return KDB_ARGCOUNT
;
1573 if (argc
>= nextarg
) {
1574 diag
= kdbgetularg(argv
[nextarg
], &val
);
1576 mdcount
= (int) val
;
1577 repeat
= mdcount
* 16 / bytesperword
;
1580 if (argc
>= nextarg
+1) {
1581 diag
= kdbgetularg(argv
[nextarg
+1], &val
);
1587 if (strcmp(argv
[0], "mdr") == 0)
1588 return kdb_mdr(addr
, mdcount
);
1601 return KDB_BADRADIX
;
1606 if (bytesperword
> KDB_WORD_SIZE
)
1607 return KDB_BADWIDTH
;
1609 switch (bytesperword
) {
1611 sprintf(fmtstr
, "%%16.16l%c ", fmtchar
);
1614 sprintf(fmtstr
, "%%8.8l%c ", fmtchar
);
1617 sprintf(fmtstr
, "%%4.4l%c ", fmtchar
);
1620 sprintf(fmtstr
, "%%2.2l%c ", fmtchar
);
1623 return KDB_BADWIDTH
;
1626 last_repeat
= repeat
;
1627 last_bytesperword
= bytesperword
;
1629 if (strcmp(argv
[0], "mds") == 0) {
1631 /* Do not save these changes as last_*, they are temporary mds
1634 bytesperword
= KDB_WORD_SIZE
;
1636 kdbgetintenv("NOSECT", &nosect
);
1639 /* Round address down modulo BYTESPERWORD */
1641 addr
&= ~(bytesperword
-1);
1643 while (repeat
> 0) {
1645 int n
, z
, num
= (symbolic
? 1 : (16 / bytesperword
));
1647 if (KDB_FLAG(CMD_INTERRUPT
))
1649 for (a
= addr
, z
= 0; z
< repeat
; a
+= bytesperword
, ++z
) {
1651 if (kdb_getphysword(&word
, a
, bytesperword
)
1654 } else if (kdb_getword(&word
, a
, bytesperword
) || word
)
1657 n
= min(num
, repeat
);
1658 kdb_md_line(fmtstr
, addr
, symbolic
, nosect
, bytesperword
,
1660 addr
+= bytesperword
* n
;
1662 z
= (z
+ num
- 1) / num
;
1664 int s
= num
* (z
-2);
1665 kdb_printf(kdb_machreg_fmt0
"-" kdb_machreg_fmt0
1666 " zero suppressed\n",
1667 addr
, addr
+ bytesperword
* s
- 1);
1668 addr
+= bytesperword
* s
;
1678 * kdb_mm - This function implements the 'mm' command.
1679 * mm address-expression new-value
1681 * mm works on machine words, mmW works on bytes.
1683 static int kdb_mm(int argc
, const char **argv
)
1688 unsigned long contents
;
1692 if (argv
[0][2] && !isdigit(argv
[0][2]))
1693 return KDB_NOTFOUND
;
1696 return KDB_ARGCOUNT
;
1699 diag
= kdbgetaddrarg(argc
, argv
, &nextarg
, &addr
, &offset
, NULL
);
1704 return KDB_ARGCOUNT
;
1705 diag
= kdbgetaddrarg(argc
, argv
, &nextarg
, &contents
, NULL
, NULL
);
1709 if (nextarg
!= argc
+ 1)
1710 return KDB_ARGCOUNT
;
1712 width
= argv
[0][2] ? (argv
[0][2] - '0') : (KDB_WORD_SIZE
);
1713 diag
= kdb_putword(addr
, contents
, width
);
1717 kdb_printf(kdb_machreg_fmt
" = " kdb_machreg_fmt
"\n", addr
, contents
);
1723 * kdb_go - This function implements the 'go' command.
1724 * go [address-expression]
1726 static int kdb_go(int argc
, const char **argv
)
1734 if (raw_smp_processor_id() != kdb_initial_cpu
) {
1735 kdb_printf("go <address> must be issued from the "
1736 "initial cpu, do cpu %d first\n",
1738 return KDB_ARGCOUNT
;
1741 diag
= kdbgetaddrarg(argc
, argv
, &nextarg
,
1742 &addr
, &offset
, NULL
);
1746 return KDB_ARGCOUNT
;
1750 if (KDB_FLAG(CATASTROPHIC
)) {
1751 kdb_printf("Catastrophic error detected\n");
1752 kdb_printf("kdb_continue_catastrophic=%d, ",
1753 kdb_continue_catastrophic
);
1754 if (kdb_continue_catastrophic
== 0 && kdb_go_count
++ == 0) {
1755 kdb_printf("type go a second time if you really want "
1759 if (kdb_continue_catastrophic
== 2) {
1760 kdb_printf("forcing reboot\n");
1761 kdb_reboot(0, NULL
);
1763 kdb_printf("attempting to continue\n");
1769 * kdb_rd - This function implements the 'rd' command.
1771 static int kdb_rd(int argc
, const char **argv
)
1773 int diag
= kdb_check_regs();
1777 kdb_dumpregs(kdb_current_regs
);
1782 * kdb_rm - This function implements the 'rm' (register modify) command.
1783 * rm register-name new-contents
1785 * Currently doesn't allow modification of control or
1788 static int kdb_rm(int argc
, const char **argv
)
1792 unsigned long contents
;
1795 return KDB_ARGCOUNT
;
1797 * Allow presence or absence of leading '%' symbol.
1799 if (argv
[1][0] == '%')
1802 diag
= kdbgetularg(argv
[2], &contents
);
1806 diag
= kdb_check_regs();
1809 kdb_printf("ERROR: Register set currently not implemented\n");
1813 #if defined(CONFIG_MAGIC_SYSRQ)
1815 * kdb_sr - This function implements the 'sr' (SYSRQ key) command
1816 * which interfaces to the soi-disant MAGIC SYSRQ functionality.
1817 * sr <magic-sysrq-code>
1819 static int kdb_sr(int argc
, const char **argv
)
1822 return KDB_ARGCOUNT
;
1823 sysrq_toggle_support(1);
1825 handle_sysrq(*argv
[1], NULL
);
1830 #endif /* CONFIG_MAGIC_SYSRQ */
1833 * kdb_ef - This function implements the 'regs' (display exception
1834 * frame) command. This command takes an address and expects to
1835 * find an exception frame at that address, formats and prints
1837 * regs address-expression
1841 static int kdb_ef(int argc
, const char **argv
)
1849 return KDB_ARGCOUNT
;
1852 diag
= kdbgetaddrarg(argc
, argv
, &nextarg
, &addr
, &offset
, NULL
);
1855 show_regs((struct pt_regs
*)addr
);
1859 #if defined(CONFIG_MODULES)
1860 /* modules using other modules */
1862 struct list_head list
;
1863 struct module
*module_which_uses
;
1867 * kdb_lsmod - This function implements the 'lsmod' command. Lists
1868 * currently loaded kernel modules.
1869 * Mostly taken from userland lsmod.
1871 static int kdb_lsmod(int argc
, const char **argv
)
1876 return KDB_ARGCOUNT
;
1878 kdb_printf("Module Size modstruct Used by\n");
1879 list_for_each_entry(mod
, kdb_modules
, list
) {
1881 kdb_printf("%-20s%8u 0x%p ", mod
->name
,
1882 mod
->core_size
, (void *)mod
);
1883 #ifdef CONFIG_MODULE_UNLOAD
1884 kdb_printf("%4d ", module_refcount(mod
));
1886 if (mod
->state
== MODULE_STATE_GOING
)
1887 kdb_printf(" (Unloading)");
1888 else if (mod
->state
== MODULE_STATE_COMING
)
1889 kdb_printf(" (Loading)");
1891 kdb_printf(" (Live)");
1893 #ifdef CONFIG_MODULE_UNLOAD
1895 struct module_use
*use
;
1897 list_for_each_entry(use
, &mod
->modules_which_use_me
,
1899 kdb_printf("%s ", use
->module_which_uses
->name
);
1908 #endif /* CONFIG_MODULES */
1911 * kdb_env - This function implements the 'env' command. Display the
1912 * current environment variables.
1915 static int kdb_env(int argc
, const char **argv
)
1919 for (i
= 0; i
< __nenv
; i
++) {
1921 kdb_printf("%s\n", __env
[i
]);
1924 if (KDB_DEBUG(MASK
))
1925 kdb_printf("KDBFLAGS=0x%x\n", kdb_flags
);
1930 #ifdef CONFIG_PRINTK
1932 * kdb_dmesg - This function implements the 'dmesg' command to display
1933 * the contents of the syslog buffer.
1934 * dmesg [lines] [adjust]
1936 static int kdb_dmesg(int argc
, const char **argv
)
1938 char *syslog_data
[4], *start
, *end
, c
= '\0', *p
;
1939 int diag
, logging
, logsize
, lines
= 0, adjust
= 0, n
;
1942 return KDB_ARGCOUNT
;
1945 lines
= simple_strtol(argv
[1], &cp
, 0);
1949 adjust
= simple_strtoul(argv
[2], &cp
, 0);
1950 if (*cp
|| adjust
< 0)
1955 /* disable LOGGING if set */
1956 diag
= kdbgetintenv("LOGGING", &logging
);
1957 if (!diag
&& logging
) {
1958 const char *setargs
[] = { "set", "LOGGING", "0" };
1959 kdb_set(2, setargs
);
1962 /* syslog_data[0,1] physical start, end+1. syslog_data[2,3]
1963 * logical start, end+1. */
1964 kdb_syslog_data(syslog_data
);
1965 if (syslog_data
[2] == syslog_data
[3])
1967 logsize
= syslog_data
[1] - syslog_data
[0];
1968 start
= syslog_data
[2];
1969 end
= syslog_data
[3];
1970 #define KDB_WRAP(p) (((p - syslog_data[0]) % logsize) + syslog_data[0])
1971 for (n
= 0, p
= start
; p
< end
; ++p
) {
1980 kdb_printf("buffer only contains %d lines, nothing "
1982 else if (adjust
- lines
>= n
)
1983 kdb_printf("buffer only contains %d lines, last %d "
1984 "lines printed\n", n
, n
- adjust
);
1986 for (; start
< end
&& adjust
; ++start
) {
1987 if (*KDB_WRAP(start
) == '\n')
1993 for (p
= start
; p
< end
&& lines
; ++p
) {
1994 if (*KDB_WRAP(p
) == '\n')
1998 } else if (lines
> 0) {
1999 int skip
= n
- (adjust
+ lines
);
2001 kdb_printf("buffer only contains %d lines, "
2002 "nothing printed\n", n
);
2004 } else if (skip
< 0) {
2007 kdb_printf("buffer only contains %d lines, first "
2008 "%d lines printed\n", n
, lines
);
2010 for (; start
< end
&& skip
; ++start
) {
2011 if (*KDB_WRAP(start
) == '\n')
2014 for (p
= start
; p
< end
&& lines
; ++p
) {
2015 if (*KDB_WRAP(p
) == '\n')
2020 /* Do a line at a time (max 200 chars) to reduce protocol overhead */
2022 while (start
!= end
) {
2025 if (KDB_FLAG(CMD_INTERRUPT
))
2027 while (start
< end
&& (c
= *KDB_WRAP(start
)) &&
2028 (p
- buf
) < sizeof(buf
)-1) {
2035 kdb_printf("%s", buf
);
2042 #endif /* CONFIG_PRINTK */
2044 * kdb_cpu - This function implements the 'cpu' command.
2047 * KDB_CMD_CPU for success, a kdb diagnostic if error
2049 static void kdb_cpu_status(void)
2051 int i
, start_cpu
, first_print
= 1;
2052 char state
, prev_state
= '?';
2054 kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2055 kdb_printf("Available cpus: ");
2056 for (start_cpu
= -1, i
= 0; i
< NR_CPUS
; i
++) {
2057 if (!cpu_online(i
)) {
2058 state
= 'F'; /* cpu is offline */
2060 state
= ' '; /* cpu is responding to kdb */
2061 if (kdb_task_state_char(KDB_TSK(i
)) == 'I')
2062 state
= 'I'; /* idle task */
2064 if (state
!= prev_state
) {
2065 if (prev_state
!= '?') {
2069 kdb_printf("%d", start_cpu
);
2070 if (start_cpu
< i
-1)
2071 kdb_printf("-%d", i
-1);
2072 if (prev_state
!= ' ')
2073 kdb_printf("(%c)", prev_state
);
2079 /* print the trailing cpus, ignoring them if they are all offline */
2080 if (prev_state
!= 'F') {
2083 kdb_printf("%d", start_cpu
);
2084 if (start_cpu
< i
-1)
2085 kdb_printf("-%d", i
-1);
2086 if (prev_state
!= ' ')
2087 kdb_printf("(%c)", prev_state
);
2092 static int kdb_cpu(int argc
, const char **argv
)
2094 unsigned long cpunum
;
2103 return KDB_ARGCOUNT
;
2105 diag
= kdbgetularg(argv
[1], &cpunum
);
2112 if ((cpunum
> NR_CPUS
) || !cpu_online(cpunum
))
2113 return KDB_BADCPUNUM
;
2115 dbg_switch_cpu
= cpunum
;
2118 * Switch to other cpu
2123 /* The user may not realize that ps/bta with no parameters does not print idle
2124 * or sleeping system daemon processes, so tell them how many were suppressed.
2126 void kdb_ps_suppressed(void)
2128 int idle
= 0, daemon
= 0;
2129 unsigned long mask_I
= kdb_task_state_string("I"),
2130 mask_M
= kdb_task_state_string("M");
2132 const struct task_struct
*p
, *g
;
2133 for_each_online_cpu(cpu
) {
2134 p
= kdb_curr_task(cpu
);
2135 if (kdb_task_state(p
, mask_I
))
2138 kdb_do_each_thread(g
, p
) {
2139 if (kdb_task_state(p
, mask_M
))
2141 } kdb_while_each_thread(g
, p
);
2142 if (idle
|| daemon
) {
2144 kdb_printf("%d idle process%s (state I)%s\n",
2145 idle
, idle
== 1 ? "" : "es",
2146 daemon
? " and " : "");
2148 kdb_printf("%d sleeping system daemon (state M) "
2149 "process%s", daemon
,
2150 daemon
== 1 ? "" : "es");
2151 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2156 * kdb_ps - This function implements the 'ps' command which shows a
2157 * list of the active processes.
2158 * ps [DRSTCZEUIMA] All processes, optionally filtered by state
2160 void kdb_ps1(const struct task_struct
*p
)
2165 if (!p
|| probe_kernel_read(&tmp
, (char *)p
, sizeof(unsigned long)))
2168 cpu
= kdb_process_cpu(p
);
2169 kdb_printf("0x%p %8d %8d %d %4d %c 0x%p %c%s\n",
2170 (void *)p
, p
->pid
, p
->parent
->pid
,
2171 kdb_task_has_cpu(p
), kdb_process_cpu(p
),
2172 kdb_task_state_char(p
),
2173 (void *)(&p
->thread
),
2174 p
== kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2176 if (kdb_task_has_cpu(p
)) {
2177 if (!KDB_TSK(cpu
)) {
2178 kdb_printf(" Error: no saved data for this cpu\n");
2180 if (KDB_TSK(cpu
) != p
)
2181 kdb_printf(" Error: does not match running "
2182 "process table (0x%p)\n", KDB_TSK(cpu
));
2187 static int kdb_ps(int argc
, const char **argv
)
2189 struct task_struct
*g
, *p
;
2190 unsigned long mask
, cpu
;
2193 kdb_ps_suppressed();
2194 kdb_printf("%-*s Pid Parent [*] cpu State %-*s Command\n",
2195 (int)(2*sizeof(void *))+2, "Task Addr",
2196 (int)(2*sizeof(void *))+2, "Thread");
2197 mask
= kdb_task_state_string(argc
? argv
[1] : NULL
);
2198 /* Run the active tasks first */
2199 for_each_online_cpu(cpu
) {
2200 if (KDB_FLAG(CMD_INTERRUPT
))
2202 p
= kdb_curr_task(cpu
);
2203 if (kdb_task_state(p
, mask
))
2207 /* Now the real tasks */
2208 kdb_do_each_thread(g
, p
) {
2209 if (KDB_FLAG(CMD_INTERRUPT
))
2211 if (kdb_task_state(p
, mask
))
2213 } kdb_while_each_thread(g
, p
);
2219 * kdb_pid - This function implements the 'pid' command which switches
2220 * the currently active process.
2223 static int kdb_pid(int argc
, const char **argv
)
2225 struct task_struct
*p
;
2230 return KDB_ARGCOUNT
;
2233 if (strcmp(argv
[1], "R") == 0) {
2234 p
= KDB_TSK(kdb_initial_cpu
);
2236 diag
= kdbgetularg(argv
[1], &val
);
2240 p
= find_task_by_pid_ns((pid_t
)val
, &init_pid_ns
);
2242 kdb_printf("No task with pid=%d\n", (pid_t
)val
);
2246 kdb_set_current_task(p
);
2248 kdb_printf("KDB current process is %s(pid=%d)\n",
2249 kdb_current_task
->comm
,
2250 kdb_current_task
->pid
);
2256 * kdb_ll - This function implements the 'll' command which follows a
2257 * linked list and executes an arbitrary command for each
2260 static int kdb_ll(int argc
, const char **argv
)
2266 unsigned long linkoffset
;
2268 const char *command
;
2271 return KDB_ARGCOUNT
;
2274 diag
= kdbgetaddrarg(argc
, argv
, &nextarg
, &addr
, &offset
, NULL
);
2278 diag
= kdbgetularg(argv
[2], &linkoffset
);
2283 * Using the starting address as
2284 * the first element in the list, and assuming that
2285 * the list ends with a null pointer.
2289 command
= kdb_strdup(argv
[3], GFP_KDB
);
2291 kdb_printf("%s: cannot duplicate command\n", __func__
);
2294 /* Recursive use of kdb_parse, do not use argv after this point */
2300 sprintf(buf
, "%s " kdb_machreg_fmt
"\n", command
, va
);
2301 diag
= kdb_parse(buf
);
2305 addr
= va
+ linkoffset
;
2306 if (kdb_getword(&va
, addr
, sizeof(va
)))
2314 static int kdb_kgdb(int argc
, const char **argv
)
2316 return KDB_CMD_KGDB
;
2320 * kdb_help - This function implements the 'help' and '?' commands.
2322 static int kdb_help(int argc
, const char **argv
)
2327 kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2328 kdb_printf("-----------------------------"
2329 "-----------------------------\n");
2330 for_each_kdbcmd(kt
, i
) {
2332 kdb_printf("%-15.15s %-20.20s %s\n", kt
->cmd_name
,
2333 kt
->cmd_usage
, kt
->cmd_help
);
2334 if (KDB_FLAG(CMD_INTERRUPT
))
2341 * kdb_kill - This function implements the 'kill' commands.
2343 static int kdb_kill(int argc
, const char **argv
)
2347 struct task_struct
*p
;
2348 struct siginfo info
;
2351 return KDB_ARGCOUNT
;
2353 sig
= simple_strtol(argv
[1], &endp
, 0);
2357 kdb_printf("Invalid signal parameter.<-signal>\n");
2362 pid
= simple_strtol(argv
[2], &endp
, 0);
2366 kdb_printf("Process ID must be large than 0.\n");
2370 /* Find the process. */
2371 p
= find_task_by_pid_ns(pid
, &init_pid_ns
);
2373 kdb_printf("The specified process isn't found.\n");
2376 p
= p
->group_leader
;
2377 info
.si_signo
= sig
;
2379 info
.si_code
= SI_USER
;
2380 info
.si_pid
= pid
; /* same capabilities as process being signalled */
2381 info
.si_uid
= 0; /* kdb has root authority */
2382 kdb_send_sig_info(p
, &info
);
2387 int tm_sec
; /* seconds */
2388 int tm_min
; /* minutes */
2389 int tm_hour
; /* hours */
2390 int tm_mday
; /* day of the month */
2391 int tm_mon
; /* month */
2392 int tm_year
; /* year */
2395 static void kdb_gmtime(struct timespec
*tv
, struct kdb_tm
*tm
)
2397 /* This will work from 1970-2099, 2100 is not a leap year */
2398 static int mon_day
[] = { 31, 29, 31, 30, 31, 30, 31,
2399 31, 30, 31, 30, 31 };
2400 memset(tm
, 0, sizeof(*tm
));
2401 tm
->tm_sec
= tv
->tv_sec
% (24 * 60 * 60);
2402 tm
->tm_mday
= tv
->tv_sec
/ (24 * 60 * 60) +
2403 (2 * 365 + 1); /* shift base from 1970 to 1968 */
2404 tm
->tm_min
= tm
->tm_sec
/ 60 % 60;
2405 tm
->tm_hour
= tm
->tm_sec
/ 60 / 60;
2406 tm
->tm_sec
= tm
->tm_sec
% 60;
2407 tm
->tm_year
= 68 + 4*(tm
->tm_mday
/ (4*365+1));
2408 tm
->tm_mday
%= (4*365+1);
2410 while (tm
->tm_mday
>= mon_day
[tm
->tm_mon
]) {
2411 tm
->tm_mday
-= mon_day
[tm
->tm_mon
];
2412 if (++tm
->tm_mon
== 12) {
2422 * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2423 * I cannot call that code directly from kdb, it has an unconditional
2424 * cli()/sti() and calls routines that take locks which can stop the debugger.
2426 static void kdb_sysinfo(struct sysinfo
*val
)
2428 struct timespec uptime
;
2429 do_posix_clock_monotonic_gettime(&uptime
);
2430 memset(val
, 0, sizeof(*val
));
2431 val
->uptime
= uptime
.tv_sec
;
2432 val
->loads
[0] = avenrun
[0];
2433 val
->loads
[1] = avenrun
[1];
2434 val
->loads
[2] = avenrun
[2];
2435 val
->procs
= nr_threads
-1;
2442 * kdb_summary - This function implements the 'summary' command.
2444 static int kdb_summary(int argc
, const char **argv
)
2450 return KDB_ARGCOUNT
;
2452 kdb_printf("sysname %s\n", init_uts_ns
.name
.sysname
);
2453 kdb_printf("release %s\n", init_uts_ns
.name
.release
);
2454 kdb_printf("version %s\n", init_uts_ns
.name
.version
);
2455 kdb_printf("machine %s\n", init_uts_ns
.name
.machine
);
2456 kdb_printf("nodename %s\n", init_uts_ns
.name
.nodename
);
2457 kdb_printf("domainname %s\n", init_uts_ns
.name
.domainname
);
2458 kdb_printf("ccversion %s\n", __stringify(CCVERSION
));
2460 kdb_gmtime(&xtime
, &tm
);
2461 kdb_printf("date %04d-%02d-%02d %02d:%02d:%02d "
2462 "tz_minuteswest %d\n",
2463 1900+tm
.tm_year
, tm
.tm_mon
+1, tm
.tm_mday
,
2464 tm
.tm_hour
, tm
.tm_min
, tm
.tm_sec
,
2465 sys_tz
.tz_minuteswest
);
2468 kdb_printf("uptime ");
2469 if (val
.uptime
> (24*60*60)) {
2470 int days
= val
.uptime
/ (24*60*60);
2471 val
.uptime
%= (24*60*60);
2472 kdb_printf("%d day%s ", days
, days
== 1 ? "" : "s");
2474 kdb_printf("%02ld:%02ld\n", val
.uptime
/(60*60), (val
.uptime
/60)%60);
2476 /* lifted from fs/proc/proc_misc.c::loadavg_read_proc() */
2478 #define LOAD_INT(x) ((x) >> FSHIFT)
2479 #define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
2480 kdb_printf("load avg %ld.%02ld %ld.%02ld %ld.%02ld\n",
2481 LOAD_INT(val
.loads
[0]), LOAD_FRAC(val
.loads
[0]),
2482 LOAD_INT(val
.loads
[1]), LOAD_FRAC(val
.loads
[1]),
2483 LOAD_INT(val
.loads
[2]), LOAD_FRAC(val
.loads
[2]));
2486 /* Display in kilobytes */
2487 #define K(x) ((x) << (PAGE_SHIFT - 10))
2488 kdb_printf("\nMemTotal: %8lu kB\nMemFree: %8lu kB\n"
2489 "Buffers: %8lu kB\n",
2490 val
.totalram
, val
.freeram
, val
.bufferram
);
2495 * kdb_per_cpu - This function implements the 'per_cpu' command.
2497 static int kdb_per_cpu(int argc
, const char **argv
)
2499 char buf
[256], fmtstr
[64];
2500 kdb_symtab_t symtab
;
2501 cpumask_t suppress
= CPU_MASK_NONE
;
2503 unsigned long addr
, val
, bytesperword
= 0, whichcpu
= ~0UL;
2505 if (argc
< 1 || argc
> 3)
2506 return KDB_ARGCOUNT
;
2508 snprintf(buf
, sizeof(buf
), "per_cpu__%s", argv
[1]);
2509 if (!kdbgetsymval(buf
, &symtab
)) {
2510 kdb_printf("%s is not a per_cpu variable\n", argv
[1]);
2514 diag
= kdbgetularg(argv
[2], &bytesperword
);
2519 bytesperword
= KDB_WORD_SIZE
;
2520 else if (bytesperword
> KDB_WORD_SIZE
)
2521 return KDB_BADWIDTH
;
2522 sprintf(fmtstr
, "%%0%dlx ", (int)(2*bytesperword
));
2524 diag
= kdbgetularg(argv
[3], &whichcpu
);
2527 if (!cpu_online(whichcpu
)) {
2528 kdb_printf("cpu %ld is not online\n", whichcpu
);
2529 return KDB_BADCPUNUM
;
2533 /* Most architectures use __per_cpu_offset[cpu], some use
2534 * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2536 #ifdef __per_cpu_offset
2537 #define KDB_PCU(cpu) __per_cpu_offset(cpu)
2540 #define KDB_PCU(cpu) __per_cpu_offset[cpu]
2542 #define KDB_PCU(cpu) 0
2546 for_each_online_cpu(cpu
) {
2547 if (whichcpu
!= ~0UL && whichcpu
!= cpu
)
2549 addr
= symtab
.sym_start
+ KDB_PCU(cpu
);
2550 diag
= kdb_getword(&val
, addr
, bytesperword
);
2552 kdb_printf("%5d " kdb_bfd_vma_fmt0
" - unable to "
2553 "read, diag=%d\n", cpu
, addr
, diag
);
2558 cpu_set(cpu
, suppress
);
2561 #endif /* CONFIG_SMP */
2562 kdb_printf("%5d ", cpu
);
2563 kdb_md_line(fmtstr
, addr
,
2564 bytesperword
== KDB_WORD_SIZE
,
2565 1, bytesperword
, 1, 1, 0);
2567 if (cpus_weight(suppress
) == 0)
2569 kdb_printf("Zero suppressed cpu(s):");
2570 for (cpu
= first_cpu(suppress
); cpu
< num_possible_cpus();
2571 cpu
= next_cpu(cpu
, suppress
)) {
2572 kdb_printf(" %d", cpu
);
2573 if (cpu
== num_possible_cpus() - 1 ||
2574 next_cpu(cpu
, suppress
) != cpu
+ 1)
2576 while (cpu
< num_possible_cpus() &&
2577 next_cpu(cpu
, suppress
) == cpu
+ 1)
2579 kdb_printf("-%d", cpu
);
2589 * display help for the use of cmd | grep pattern
2591 static int kdb_grep_help(int argc
, const char **argv
)
2593 kdb_printf("Usage of cmd args | grep pattern:\n");
2594 kdb_printf(" Any command's output may be filtered through an ");
2595 kdb_printf("emulated 'pipe'.\n");
2596 kdb_printf(" 'grep' is just a key word.\n");
2597 kdb_printf(" The pattern may include a very limited set of "
2598 "metacharacters:\n");
2599 kdb_printf(" pattern or ^pattern or pattern$ or ^pattern$\n");
2600 kdb_printf(" And if there are spaces in the pattern, you may "
2602 kdb_printf(" \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2603 " or \"^pat tern$\"\n");
2608 * kdb_register_repeat - This function is used to register a kernel
2612 * func Function to execute the command
2613 * usage A simple usage string showing arguments
2614 * help A simple help string describing command
2615 * repeat Does the command auto repeat on enter?
2617 * zero for success, one if a duplicate command.
2619 #define kdb_command_extend 50 /* arbitrary */
2620 int kdb_register_repeat(char *cmd
,
2625 kdb_repeat_t repeat
)
2631 * Brute force method to determine duplicates
2633 for_each_kdbcmd(kp
, i
) {
2634 if (kp
->cmd_name
&& (strcmp(kp
->cmd_name
, cmd
) == 0)) {
2635 kdb_printf("Duplicate kdb command registered: "
2636 "%s, func %p help %s\n", cmd
, func
, help
);
2642 * Insert command into first available location in table
2644 for_each_kdbcmd(kp
, i
) {
2645 if (kp
->cmd_name
== NULL
)
2649 if (i
>= kdb_max_commands
) {
2650 kdbtab_t
*new = kmalloc((kdb_max_commands
- KDB_BASE_CMD_MAX
+
2651 kdb_command_extend
) * sizeof(*new), GFP_KDB
);
2653 kdb_printf("Could not allocate new kdb_command "
2658 memcpy(new, kdb_commands
,
2659 kdb_max_commands
* sizeof(*new));
2660 kfree(kdb_commands
);
2662 memset(new + kdb_max_commands
, 0,
2663 kdb_command_extend
* sizeof(*new));
2665 kp
= kdb_commands
+ kdb_max_commands
;
2666 kdb_max_commands
+= kdb_command_extend
;
2670 kp
->cmd_func
= func
;
2671 kp
->cmd_usage
= usage
;
2672 kp
->cmd_help
= help
;
2674 kp
->cmd_minlen
= minlen
;
2675 kp
->cmd_repeat
= repeat
;
2681 * kdb_register - Compatibility register function for commands that do
2682 * not need to specify a repeat state. Equivalent to
2683 * kdb_register_repeat with KDB_REPEAT_NONE.
2686 * func Function to execute the command
2687 * usage A simple usage string showing arguments
2688 * help A simple help string describing command
2690 * zero for success, one if a duplicate command.
2692 int kdb_register(char *cmd
,
2698 return kdb_register_repeat(cmd
, func
, usage
, help
, minlen
,
2703 * kdb_unregister - This function is used to unregister a kernel
2704 * debugger command. It is generally called when a module which
2705 * implements kdb commands is unloaded.
2709 * zero for success, one command not registered.
2711 int kdb_unregister(char *cmd
)
2719 for (i
= 0, kp
= kdb_commands
; i
< kdb_max_commands
; i
++, kp
++) {
2720 if (kp
->cmd_name
&& (strcmp(kp
->cmd_name
, cmd
) == 0)) {
2721 kp
->cmd_name
= NULL
;
2726 /* Couldn't find it. */
2730 /* Initialize the kdb command table. */
2731 static void __init
kdb_inittab(void)
2736 for_each_kdbcmd(kp
, i
)
2737 kp
->cmd_name
= NULL
;
2739 kdb_register_repeat("md", kdb_md
, "<vaddr>",
2740 "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2741 KDB_REPEAT_NO_ARGS
);
2742 kdb_register_repeat("mdr", kdb_md
, "<vaddr> <bytes>",
2743 "Display Raw Memory", 0, KDB_REPEAT_NO_ARGS
);
2744 kdb_register_repeat("mdp", kdb_md
, "<paddr> <bytes>",
2745 "Display Physical Memory", 0, KDB_REPEAT_NO_ARGS
);
2746 kdb_register_repeat("mds", kdb_md
, "<vaddr>",
2747 "Display Memory Symbolically", 0, KDB_REPEAT_NO_ARGS
);
2748 kdb_register_repeat("mm", kdb_mm
, "<vaddr> <contents>",
2749 "Modify Memory Contents", 0, KDB_REPEAT_NO_ARGS
);
2750 kdb_register_repeat("go", kdb_go
, "[<vaddr>]",
2751 "Continue Execution", 1, KDB_REPEAT_NONE
);
2752 kdb_register_repeat("rd", kdb_rd
, "",
2753 "Display Registers", 0, KDB_REPEAT_NONE
);
2754 kdb_register_repeat("rm", kdb_rm
, "<reg> <contents>",
2755 "Modify Registers", 0, KDB_REPEAT_NONE
);
2756 kdb_register_repeat("ef", kdb_ef
, "<vaddr>",
2757 "Display exception frame", 0, KDB_REPEAT_NONE
);
2758 kdb_register_repeat("bt", kdb_bt
, "[<vaddr>]",
2759 "Stack traceback", 1, KDB_REPEAT_NONE
);
2760 kdb_register_repeat("btp", kdb_bt
, "<pid>",
2761 "Display stack for process <pid>", 0, KDB_REPEAT_NONE
);
2762 kdb_register_repeat("bta", kdb_bt
, "[DRSTCZEUIMA]",
2763 "Display stack all processes", 0, KDB_REPEAT_NONE
);
2764 kdb_register_repeat("btc", kdb_bt
, "",
2765 "Backtrace current process on each cpu", 0, KDB_REPEAT_NONE
);
2766 kdb_register_repeat("btt", kdb_bt
, "<vaddr>",
2767 "Backtrace process given its struct task address", 0,
2769 kdb_register_repeat("ll", kdb_ll
, "<first-element> <linkoffset> <cmd>",
2770 "Execute cmd for each element in linked list", 0, KDB_REPEAT_NONE
);
2771 kdb_register_repeat("env", kdb_env
, "",
2772 "Show environment variables", 0, KDB_REPEAT_NONE
);
2773 kdb_register_repeat("set", kdb_set
, "",
2774 "Set environment variables", 0, KDB_REPEAT_NONE
);
2775 kdb_register_repeat("help", kdb_help
, "",
2776 "Display Help Message", 1, KDB_REPEAT_NONE
);
2777 kdb_register_repeat("?", kdb_help
, "",
2778 "Display Help Message", 0, KDB_REPEAT_NONE
);
2779 kdb_register_repeat("cpu", kdb_cpu
, "<cpunum>",
2780 "Switch to new cpu", 0, KDB_REPEAT_NONE
);
2781 kdb_register_repeat("kgdb", kdb_kgdb
, "",
2782 "Enter kgdb mode", 0, KDB_REPEAT_NONE
);
2783 kdb_register_repeat("ps", kdb_ps
, "[<flags>|A]",
2784 "Display active task list", 0, KDB_REPEAT_NONE
);
2785 kdb_register_repeat("pid", kdb_pid
, "<pidnum>",
2786 "Switch to another task", 0, KDB_REPEAT_NONE
);
2787 kdb_register_repeat("reboot", kdb_reboot
, "",
2788 "Reboot the machine immediately", 0, KDB_REPEAT_NONE
);
2789 #if defined(CONFIG_MODULES)
2790 kdb_register_repeat("lsmod", kdb_lsmod
, "",
2791 "List loaded kernel modules", 0, KDB_REPEAT_NONE
);
2793 #if defined(CONFIG_MAGIC_SYSRQ)
2794 kdb_register_repeat("sr", kdb_sr
, "<key>",
2795 "Magic SysRq key", 0, KDB_REPEAT_NONE
);
2797 #if defined(CONFIG_PRINTK)
2798 kdb_register_repeat("dmesg", kdb_dmesg
, "[lines]",
2799 "Display syslog buffer", 0, KDB_REPEAT_NONE
);
2801 kdb_register_repeat("defcmd", kdb_defcmd
, "name \"usage\" \"help\"",
2802 "Define a set of commands, down to endefcmd", 0, KDB_REPEAT_NONE
);
2803 kdb_register_repeat("kill", kdb_kill
, "<-signal> <pid>",
2804 "Send a signal to a process", 0, KDB_REPEAT_NONE
);
2805 kdb_register_repeat("summary", kdb_summary
, "",
2806 "Summarize the system", 4, KDB_REPEAT_NONE
);
2807 kdb_register_repeat("per_cpu", kdb_per_cpu
, "",
2808 "Display per_cpu variables", 3, KDB_REPEAT_NONE
);
2809 kdb_register_repeat("grephelp", kdb_grep_help
, "",
2810 "Display help on | grep", 0, KDB_REPEAT_NONE
);
2813 /* Execute any commands defined in kdb_cmds. */
2814 static void __init
kdb_cmd_init(void)
2817 for (i
= 0; kdb_cmds
[i
]; ++i
) {
2818 diag
= kdb_parse(kdb_cmds
[i
]);
2820 kdb_printf("kdb command %s failed, kdb diag %d\n",
2823 if (defcmd_in_progress
) {
2824 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2825 kdb_parse("endefcmd");
2829 /* Intialize kdb_printf, breakpoint tables and kdb state */
2830 void __init
kdb_init(int lvl
)
2832 static int kdb_init_lvl
= KDB_NOT_INITIALIZED
;
2835 if (kdb_init_lvl
== KDB_INIT_FULL
|| lvl
<= kdb_init_lvl
)
2837 for (i
= kdb_init_lvl
; i
< lvl
; i
++) {
2839 case KDB_NOT_INITIALIZED
:
2840 kdb_inittab(); /* Initialize Command Table */
2841 kdb_initbptab(); /* Initialize Breakpoints */
2843 case KDB_INIT_EARLY
:
2844 kdb_cmd_init(); /* Build kdb_cmds tables */