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[KDB_BASE_CMD_MAX];
82
#define for_each_kdbcmd(cmd, num) \
83
for ((cmd) = kdb_base_commands, (num) = 0; \
84
num < kdb_max_commands; \
85
num++, num == KDB_BASE_CMD_MAX ? cmd = kdb_commands : cmd++)
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 */
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
* Also try base 16, for us folks too lazy to type the
318
val = simple_strtoul(arg, &endp, 16);
328
int kdbgetu64arg(const char *arg, u64 *value)
333
val = simple_strtoull(arg, &endp, 0);
337
val = simple_strtoull(arg, &endp, 16);
348
* kdb_set - This function implements the 'set' command. Alter an
349
* existing environment variable or create a new one.
351
int kdb_set(int argc, const char **argv)
355
size_t varlen, vallen;
358
* we can be invoked two ways:
359
* set var=value argv[1]="var", argv[2]="value"
360
* set var = value argv[1]="var", argv[2]="=", argv[3]="value"
361
* - if the latter, shift 'em down.
372
* Check for internal variables
374
if (strcmp(argv[1], "KDBDEBUG") == 0) {
375
unsigned int debugflags;
378
debugflags = simple_strtoul(argv[2], &cp, 0);
379
if (cp == argv[2] || debugflags & ~KDB_DEBUG_FLAG_MASK) {
380
kdb_printf("kdb: illegal debug flags '%s'\n",
384
kdb_flags = (kdb_flags &
385
~(KDB_DEBUG_FLAG_MASK << KDB_DEBUG_FLAG_SHIFT))
386
| (debugflags << KDB_DEBUG_FLAG_SHIFT);
392
* Tokenizer squashed the '=' sign. argv[1] is variable
393
* name, argv[2] = value.
395
varlen = strlen(argv[1]);
396
vallen = strlen(argv[2]);
397
ep = kdballocenv(varlen + vallen + 2);
399
return KDB_ENVBUFFULL;
401
sprintf(ep, "%s=%s", argv[1], argv[2]);
403
ep[varlen+vallen+1] = '\0';
405
for (i = 0; i < __nenv; i++) {
407
&& ((strncmp(__env[i], argv[1], varlen) == 0)
408
&& ((__env[i][varlen] == '\0')
409
|| (__env[i][varlen] == '=')))) {
416
* Wasn't existing variable. Fit into slot.
418
for (i = 0; i < __nenv-1; i++) {
419
if (__env[i] == (char *)0) {
428
static int kdb_check_regs(void)
430
if (!kdb_current_regs) {
431
kdb_printf("No current kdb registers."
432
" You may need to select another task\n");
439
* kdbgetaddrarg - This function is responsible for parsing an
440
* address-expression and returning the value of the expression,
441
* symbol name, and offset to the caller.
443
* The argument may consist of a numeric value (decimal or
444
* hexidecimal), a symbol name, a register name (preceded by the
445
* percent sign), an environment variable with a numeric value
446
* (preceded by a dollar sign) or a simple arithmetic expression
447
* consisting of a symbol name, +/-, and a numeric constant value
450
* argc - count of arguments in argv
451
* argv - argument vector
452
* *nextarg - index to next unparsed argument in argv[]
453
* regs - Register state at time of KDB entry
455
* *value - receives the value of the address-expression
456
* *offset - receives the offset specified, if any
457
* *name - receives the symbol name, if any
458
* *nextarg - index to next unparsed argument in argv[]
460
* zero is returned on success, a kdb diagnostic code is
463
int kdbgetaddrarg(int argc, const char **argv, int *nextarg,
464
unsigned long *value, long *offset,
468
unsigned long off = 0;
478
* Process arguments which follow the following syntax:
480
* symbol | numeric-address [+/- numeric-offset]
482
* $environment-variable
488
symname = (char *)argv[*nextarg];
491
* If there is no whitespace between the symbol
492
* or address and the '+' or '-' symbols, we
493
* remember the character and replace it with a
494
* null so the symbol/value can be properly parsed
496
cp = strpbrk(symname, "+-");
502
if (symname[0] == '$') {
503
diag = kdbgetulenv(&symname[1], &addr);
506
} else if (symname[0] == '%') {
507
diag = kdb_check_regs();
510
/* Implement register values with % at a later time as it is
515
found = kdbgetsymval(symname, &symtab);
517
addr = symtab.sym_start;
519
diag = kdbgetularg(argv[*nextarg], &addr);
526
found = kdbnearsym(addr, &symtab);
534
if (offset && name && *name)
535
*offset = addr - symtab.sym_start;
537
if ((*nextarg > argc)
542
* check for +/- and offset
545
if (symbol == '\0') {
546
if ((argv[*nextarg][0] != '+')
547
&& (argv[*nextarg][0] != '-')) {
549
* Not our argument. Return.
553
positive = (argv[*nextarg][0] == '+');
557
positive = (symbol == '+');
560
* Now there must be an offset!
562
if ((*nextarg > argc)
563
&& (symbol == '\0')) {
564
return KDB_INVADDRFMT;
568
cp = (char *)argv[*nextarg];
572
diag = kdbgetularg(cp, &off);
588
static void kdb_cmderror(int diag)
593
kdb_printf("no error detected (diagnostic is %d)\n", diag);
597
for (i = 0; i < __nkdb_err; i++) {
598
if (kdbmsgs[i].km_diag == diag) {
599
kdb_printf("diag: %d: %s\n", diag, kdbmsgs[i].km_msg);
604
kdb_printf("Unknown diag %d\n", -diag);
608
* kdb_defcmd, kdb_defcmd2 - This function implements the 'defcmd'
609
* command which defines one command as a set of other commands,
610
* terminated by endefcmd. kdb_defcmd processes the initial
611
* 'defcmd' command, kdb_defcmd2 is invoked from kdb_parse for
612
* the following commands until 'endefcmd'.
614
* argc argument count
615
* argv argument vector
617
* zero for success, a kdb diagnostic if error
627
static struct defcmd_set *defcmd_set;
628
static int defcmd_set_count;
629
static int defcmd_in_progress;
631
/* Forward references */
632
static int kdb_exec_defcmd(int argc, const char **argv);
634
static int kdb_defcmd2(const char *cmdstr, const char *argv0)
636
struct defcmd_set *s = defcmd_set + defcmd_set_count - 1;
637
char **save_command = s->command;
638
if (strcmp(argv0, "endefcmd") == 0) {
639
defcmd_in_progress = 0;
643
kdb_register(s->name, kdb_exec_defcmd,
644
s->usage, s->help, 0);
649
s->command = kzalloc((s->count + 1) * sizeof(*(s->command)), GFP_KDB);
651
kdb_printf("Could not allocate new kdb_defcmd table for %s\n",
656
memcpy(s->command, save_command, s->count * sizeof(*(s->command)));
657
s->command[s->count++] = kdb_strdup(cmdstr, GFP_KDB);
662
static int kdb_defcmd(int argc, const char **argv)
664
struct defcmd_set *save_defcmd_set = defcmd_set, *s;
665
if (defcmd_in_progress) {
666
kdb_printf("kdb: nested defcmd detected, assuming missing "
668
kdb_defcmd2("endefcmd", "endefcmd");
672
for (s = defcmd_set; s < defcmd_set + defcmd_set_count; ++s) {
673
kdb_printf("defcmd %s \"%s\" \"%s\"\n", s->name,
675
for (i = 0; i < s->count; ++i)
676
kdb_printf("%s", s->command[i]);
677
kdb_printf("endefcmd\n");
683
defcmd_set = kmalloc((defcmd_set_count + 1) * sizeof(*defcmd_set),
686
kdb_printf("Could not allocate new defcmd_set entry for %s\n",
688
defcmd_set = save_defcmd_set;
691
memcpy(defcmd_set, save_defcmd_set,
692
defcmd_set_count * sizeof(*defcmd_set));
693
kfree(save_defcmd_set);
694
s = defcmd_set + defcmd_set_count;
695
memset(s, 0, sizeof(*s));
697
s->name = kdb_strdup(argv[1], GFP_KDB);
698
s->usage = kdb_strdup(argv[2], GFP_KDB);
699
s->help = kdb_strdup(argv[3], GFP_KDB);
700
if (s->usage[0] == '"') {
701
strcpy(s->usage, s->usage+1);
702
s->usage[strlen(s->usage)-1] = '\0';
704
if (s->help[0] == '"') {
705
strcpy(s->help, s->help+1);
706
s->help[strlen(s->help)-1] = '\0';
709
defcmd_in_progress = 1;
714
* kdb_exec_defcmd - Execute the set of commands associated with this
717
* argc argument count
718
* argv argument vector
720
* zero for success, a kdb diagnostic if error
722
static int kdb_exec_defcmd(int argc, const char **argv)
725
struct defcmd_set *s;
728
for (s = defcmd_set, i = 0; i < defcmd_set_count; ++i, ++s) {
729
if (strcmp(s->name, argv[0]) == 0)
732
if (i == defcmd_set_count) {
733
kdb_printf("kdb_exec_defcmd: could not find commands for %s\n",
737
for (i = 0; i < s->count; ++i) {
738
/* Recursive use of kdb_parse, do not use argv after
741
kdb_printf("[%s]kdb> %s\n", s->name, s->command[i]);
742
ret = kdb_parse(s->command[i]);
749
/* Command history */
750
#define KDB_CMD_HISTORY_COUNT 32
751
#define CMD_BUFLEN 200 /* kdb_printf: max printline
753
static unsigned int cmd_head, cmd_tail;
754
static unsigned int cmdptr;
755
static char cmd_hist[KDB_CMD_HISTORY_COUNT][CMD_BUFLEN];
756
static char cmd_cur[CMD_BUFLEN];
759
* The "str" argument may point to something like | grep xyz
761
static void parse_grep(const char *str)
764
char *cp = (char *)str, *cp2;
766
/* sanity check: we should have been called with the \ first */
772
if (strncmp(cp, "grep ", 5)) {
773
kdb_printf("invalid 'pipe', see grephelp\n");
779
cp2 = strchr(cp, '\n');
781
*cp2 = '\0'; /* remove the trailing newline */
784
kdb_printf("invalid 'pipe', see grephelp\n");
787
/* now cp points to a nonzero length search string */
789
/* allow it be "x y z" by removing the "'s - there must
792
cp2 = strchr(cp, '"');
794
kdb_printf("invalid quoted string, see grephelp\n");
797
*cp2 = '\0'; /* end the string where the 2nd " was */
799
kdb_grep_leading = 0;
801
kdb_grep_leading = 1;
805
kdb_grep_trailing = 0;
806
if (*(cp+len-1) == '$') {
807
kdb_grep_trailing = 1;
813
if (len >= GREP_LEN) {
814
kdb_printf("search string too long\n");
817
strcpy(kdb_grep_string, cp);
823
* kdb_parse - Parse the command line, search the command table for a
824
* matching command and invoke the command function. This
825
* function may be called recursively, if it is, the second call
826
* will overwrite argv and cbuf. It is the caller's
827
* responsibility to save their argv if they recursively call
830
* cmdstr The input command line to be parsed.
831
* regs The registers at the time kdb was entered.
833
* Zero for success, a kdb diagnostic if failure.
835
* Limited to 20 tokens.
837
* Real rudimentary tokenization. Basically only whitespace
838
* is considered a token delimeter (but special consideration
839
* is taken of the '=' sign as used by the 'set' command).
841
* The algorithm used to tokenize the input string relies on
842
* there being at least one whitespace (or otherwise useless)
843
* character between tokens as the character immediately following
844
* the token is altered in-place to a null-byte to terminate the
850
int kdb_parse(const char *cmdstr)
852
static char *argv[MAXARGC];
854
static char cbuf[CMD_BUFLEN+2];
858
int i, escaped, ignore_errors = 0, check_grep;
861
* First tokenize the command string.
864
kdb_grepping_flag = check_grep = 0;
866
if (KDB_FLAG(CMD_INTERRUPT)) {
867
/* Previous command was interrupted, newline must not
868
* repeat the command */
869
KDB_FLAG_CLEAR(CMD_INTERRUPT);
870
KDB_STATE_SET(PAGER);
871
argc = 0; /* no repeat */
874
if (*cp != '\n' && *cp != '\0') {
878
/* skip whitespace */
881
if ((*cp == '\0') || (*cp == '\n') ||
882
(*cp == '#' && !defcmd_in_progress))
884
/* special case: check for | grep pattern */
889
if (cpp >= cbuf + CMD_BUFLEN) {
890
kdb_printf("kdb_parse: command buffer "
891
"overflow, command ignored\n%s\n",
895
if (argc >= MAXARGC - 1) {
896
kdb_printf("kdb_parse: too many arguments, "
897
"command ignored\n%s\n", cmdstr);
903
/* Copy to next unquoted and unescaped
904
* whitespace or '=' */
905
while (*cp && *cp != '\n' &&
906
(escaped || quoted || !isspace(*cp))) {
907
if (cpp >= cbuf + CMD_BUFLEN)
921
else if (*cp == '\'' || *cp == '"')
924
if (*cpp == '=' && !quoted)
928
*cpp++ = '\0'; /* Squash a ws or '=' character */
935
if (defcmd_in_progress) {
936
int result = kdb_defcmd2(cmdstr, argv[0]);
937
if (!defcmd_in_progress) {
938
argc = 0; /* avoid repeat on endefcmd */
943
if (argv[0][0] == '-' && argv[0][1] &&
944
(argv[0][1] < '0' || argv[0][1] > '9')) {
949
for_each_kdbcmd(tp, i) {
952
* If this command is allowed to be abbreviated,
953
* check to see if this is it.
957
&& (strlen(argv[0]) <= tp->cmd_minlen)) {
960
tp->cmd_minlen) == 0) {
965
if (strcmp(argv[0], tp->cmd_name) == 0)
971
* If we don't find a command by this name, see if the first
972
* few characters of this match any of the known commands.
973
* e.g., md1c20 should match md.
975
if (i == kdb_max_commands) {
976
for_each_kdbcmd(tp, i) {
980
strlen(tp->cmd_name)) == 0) {
987
if (i < kdb_max_commands) {
990
result = (*tp->cmd_func)(argc-1, (const char **)argv);
991
if (result && ignore_errors && result > KDB_CMD_GO)
993
KDB_STATE_CLEAR(CMD);
994
switch (tp->cmd_repeat) {
995
case KDB_REPEAT_NONE:
1000
case KDB_REPEAT_NO_ARGS:
1005
case KDB_REPEAT_WITH_ARGS:
1012
* If the input with which we were presented does not
1013
* map to an existing command, attempt to parse it as an
1014
* address argument and display the result. Useful for
1015
* obtaining the address of a variable, or the nearest symbol
1016
* to an address contained in a register.
1019
unsigned long value;
1024
if (kdbgetaddrarg(0, (const char **)argv, &nextarg,
1025
&value, &offset, &name)) {
1026
return KDB_NOTFOUND;
1029
kdb_printf("%s = ", argv[0]);
1030
kdb_symbol_print(value, NULL, KDB_SP_DEFAULT);
1037
static int handle_ctrl_cmd(char *cmd)
1042
/* initial situation */
1043
if (cmd_head == cmd_tail)
1047
if (cmdptr != cmd_tail)
1048
cmdptr = (cmdptr-1) % KDB_CMD_HISTORY_COUNT;
1049
strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1052
if (cmdptr != cmd_head)
1053
cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT;
1054
strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1061
* kdb_reboot - This function implements the 'reboot' command. Reboot
1062
* the system immediately, or loop for ever on failure.
1064
static int kdb_reboot(int argc, const char **argv)
1066
emergency_restart();
1067
kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
1074
static void kdb_dumpregs(struct pt_regs *regs)
1076
int old_lvl = console_loglevel;
1077
console_loglevel = 15;
1082
console_loglevel = old_lvl;
1085
void kdb_set_current_task(struct task_struct *p)
1087
kdb_current_task = p;
1089
if (kdb_task_has_cpu(p)) {
1090
kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p));
1093
kdb_current_regs = NULL;
1097
* kdb_local - The main code for kdb. This routine is invoked on a
1098
* specific processor, it is not global. The main kdb() routine
1099
* ensures that only one processor at a time is in this routine.
1100
* This code is called with the real reason code on the first
1101
* entry to a kdb session, thereafter it is called with reason
1102
* SWITCH, even if the user goes back to the original cpu.
1104
* reason The reason KDB was invoked
1105
* error The hardware-defined error code
1106
* regs The exception frame at time of fault/breakpoint.
1107
* db_result Result code from the break or debug point.
1109
* 0 KDB was invoked for an event which it wasn't responsible
1110
* 1 KDB handled the event for which it was invoked.
1111
* KDB_CMD_GO User typed 'go'.
1112
* KDB_CMD_CPU User switched to another cpu.
1113
* KDB_CMD_SS Single step.
1114
* KDB_CMD_SSB Single step until branch.
1116
static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs,
1117
kdb_dbtrap_t db_result)
1121
struct task_struct *kdb_current =
1122
kdb_curr_task(raw_smp_processor_id());
1124
KDB_DEBUG_STATE("kdb_local 1", reason);
1126
if (reason == KDB_REASON_DEBUG) {
1127
/* special case below */
1129
kdb_printf("\nEntering kdb (current=0x%p, pid %d) ",
1130
kdb_current, kdb_current ? kdb_current->pid : 0);
1131
#if defined(CONFIG_SMP)
1132
kdb_printf("on processor %d ", raw_smp_processor_id());
1137
case KDB_REASON_DEBUG:
1140
* If re-entering kdb after a single step
1141
* command, don't print the message.
1143
switch (db_result) {
1145
kdb_printf("\nEntering kdb (0x%p, pid %d) ",
1146
kdb_current, kdb_current->pid);
1147
#if defined(CONFIG_SMP)
1148
kdb_printf("on processor %d ", raw_smp_processor_id());
1150
kdb_printf("due to Debug @ " kdb_machreg_fmt "\n",
1151
instruction_pointer(regs));
1155
* In the midst of ssb command. Just return.
1157
KDB_DEBUG_STATE("kdb_local 3", reason);
1158
return KDB_CMD_SSB; /* Continue with SSB command */
1164
KDB_DEBUG_STATE("kdb_local 4", reason);
1165
return 1; /* kdba_db_trap did the work */
1167
kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
1174
case KDB_REASON_ENTER:
1175
if (KDB_STATE(KEYBOARD))
1176
kdb_printf("due to Keyboard Entry\n");
1178
kdb_printf("due to KDB_ENTER()\n");
1180
case KDB_REASON_KEYBOARD:
1181
KDB_STATE_SET(KEYBOARD);
1182
kdb_printf("due to Keyboard Entry\n");
1184
case KDB_REASON_ENTER_SLAVE:
1185
/* drop through, slaves only get released via cpu switch */
1186
case KDB_REASON_SWITCH:
1187
kdb_printf("due to cpu switch\n");
1189
case KDB_REASON_OOPS:
1190
kdb_printf("Oops: %s\n", kdb_diemsg);
1191
kdb_printf("due to oops @ " kdb_machreg_fmt "\n",
1192
instruction_pointer(regs));
1195
case KDB_REASON_NMI:
1196
kdb_printf("due to NonMaskable Interrupt @ "
1197
kdb_machreg_fmt "\n",
1198
instruction_pointer(regs));
1201
case KDB_REASON_SSTEP:
1202
case KDB_REASON_BREAK:
1203
kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
1204
reason == KDB_REASON_BREAK ?
1205
"Breakpoint" : "SS trap", instruction_pointer(regs));
1207
* Determine if this breakpoint is one that we
1208
* are interested in.
1210
if (db_result != KDB_DB_BPT) {
1211
kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1213
KDB_DEBUG_STATE("kdb_local 6", reason);
1214
return 0; /* Not for us, dismiss it */
1217
case KDB_REASON_RECURSE:
1218
kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
1219
instruction_pointer(regs));
1222
kdb_printf("kdb: unexpected reason code: %d\n", reason);
1223
KDB_DEBUG_STATE("kdb_local 8", reason);
1224
return 0; /* Not for us, dismiss it */
1229
* Initialize pager context.
1232
KDB_STATE_CLEAR(SUPPRESS);
1236
*(cmd_hist[cmd_head]) = '\0';
1238
if (KDB_FLAG(ONLY_DO_DUMP)) {
1239
/* kdb is off but a catastrophic error requires a dump.
1240
* Take the dump and reboot.
1241
* Turn on logging so the kdb output appears in the log
1242
* buffer in the dump.
1244
const char *setargs[] = { "set", "LOGGING", "1" };
1245
kdb_set(2, setargs);
1246
kdb_reboot(0, NULL);
1251
#if defined(CONFIG_SMP)
1252
snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
1253
raw_smp_processor_id());
1255
snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"));
1257
if (defcmd_in_progress)
1258
strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
1261
* Fetch command from keyboard
1263
cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
1264
if (*cmdbuf != '\n') {
1266
if (cmdptr == cmd_head) {
1267
strncpy(cmd_hist[cmd_head], cmd_cur,
1269
*(cmd_hist[cmd_head] +
1270
strlen(cmd_hist[cmd_head])-1) = '\0';
1272
if (!handle_ctrl_cmd(cmdbuf))
1273
*(cmd_cur+strlen(cmd_cur)-1) = '\0';
1275
goto do_full_getstr;
1277
strncpy(cmd_hist[cmd_head], cmd_cur,
1281
cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
1282
if (cmd_head == cmd_tail)
1283
cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
1287
diag = kdb_parse(cmdbuf);
1288
if (diag == KDB_NOTFOUND) {
1289
kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
1292
if (diag == KDB_CMD_GO
1293
|| diag == KDB_CMD_CPU
1294
|| diag == KDB_CMD_SS
1295
|| diag == KDB_CMD_SSB
1296
|| diag == KDB_CMD_KGDB)
1302
KDB_DEBUG_STATE("kdb_local 9", diag);
1308
* kdb_print_state - Print the state data for the current processor
1311
* text Identifies the debug point
1312
* value Any integer value to be printed, e.g. reason code.
1314
void kdb_print_state(const char *text, int value)
1316
kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1317
text, raw_smp_processor_id(), value, kdb_initial_cpu,
1322
* kdb_main_loop - After initial setup and assignment of the
1323
* controlling cpu, all cpus are in this loop. One cpu is in
1324
* control and will issue the kdb prompt, the others will spin
1325
* until 'go' or cpu switch.
1327
* To get a consistent view of the kernel stacks for all
1328
* processes, this routine is invoked from the main kdb code via
1329
* an architecture specific routine. kdba_main_loop is
1330
* responsible for making the kernel stacks consistent for all
1331
* processes, there should be no difference between a blocked
1332
* process and a running process as far as kdb is concerned.
1334
* reason The reason KDB was invoked
1335
* error The hardware-defined error code
1336
* reason2 kdb's current reason code.
1337
* Initially error but can change
1338
* according to kdb state.
1339
* db_result Result code from break or debug point.
1340
* regs The exception frame at time of fault/breakpoint.
1341
* should always be valid.
1343
* 0 KDB was invoked for an event which it wasn't responsible
1344
* 1 KDB handled the event for which it was invoked.
1346
int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
1347
kdb_dbtrap_t db_result, struct pt_regs *regs)
1350
/* Stay in kdb() until 'go', 'ss[b]' or an error */
1353
* All processors except the one that is in control
1356
KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1357
while (KDB_STATE(HOLD_CPU)) {
1358
/* state KDB is turned off by kdb_cpu to see if the
1359
* other cpus are still live, each cpu in this loop
1362
if (!KDB_STATE(KDB))
1366
KDB_STATE_CLEAR(SUPPRESS);
1367
KDB_DEBUG_STATE("kdb_main_loop 2", reason);
1368
if (KDB_STATE(LEAVING))
1369
break; /* Another cpu said 'go' */
1370
/* Still using kdb, this processor is in control */
1371
result = kdb_local(reason2, error, regs, db_result);
1372
KDB_DEBUG_STATE("kdb_main_loop 3", result);
1374
if (result == KDB_CMD_CPU)
1377
if (result == KDB_CMD_SS) {
1378
KDB_STATE_SET(DOING_SS);
1382
if (result == KDB_CMD_SSB) {
1383
KDB_STATE_SET(DOING_SS);
1384
KDB_STATE_SET(DOING_SSB);
1388
if (result == KDB_CMD_KGDB) {
1389
if (!KDB_STATE(DOING_KGDB))
1390
kdb_printf("Entering please attach debugger "
1391
"or use $D#44+ or $3#33\n");
1394
if (result && result != 1 && result != KDB_CMD_GO)
1395
kdb_printf("\nUnexpected kdb_local return code %d\n",
1397
KDB_DEBUG_STATE("kdb_main_loop 4", reason);
1400
if (KDB_STATE(DOING_SS))
1401
KDB_STATE_CLEAR(SSBPT);
1407
* kdb_mdr - This function implements the guts of the 'mdr', memory
1409
* mdr <addr arg>,<byte count>
1411
* addr Start address
1412
* count Number of bytes
1414
* Always 0. Any errors are detected and printed by kdb_getarea.
1416
static int kdb_mdr(unsigned long addr, unsigned int count)
1420
if (kdb_getarea(c, addr))
1422
kdb_printf("%02x", c);
1430
* kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1431
* 'md8' 'mdr' and 'mds' commands.
1433
* md|mds [<addr arg> [<line count> [<radix>]]]
1434
* mdWcN [<addr arg> [<line count> [<radix>]]]
1435
* where W = is the width (1, 2, 4 or 8) and N is the count.
1436
* for eg., md1c20 reads 20 bytes, 1 at a time.
1437
* mdr <addr arg>,<byte count>
1439
static void kdb_md_line(const char *fmtstr, unsigned long addr,
1440
int symbolic, int nosect, int bytesperword,
1441
int num, int repeat, int phys)
1443
/* print just one line of data */
1444
kdb_symtab_t symtab;
1450
memset(cbuf, '\0', sizeof(cbuf));
1452
kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1454
kdb_printf(kdb_machreg_fmt0 " ", addr);
1456
for (i = 0; i < num && repeat--; i++) {
1458
if (kdb_getphysword(&word, addr, bytesperword))
1460
} else if (kdb_getword(&word, addr, bytesperword))
1462
kdb_printf(fmtstr, word);
1464
kdbnearsym(word, &symtab);
1466
memset(&symtab, 0, sizeof(symtab));
1467
if (symtab.sym_name) {
1468
kdb_symbol_print(word, &symtab, 0);
1471
kdb_printf(" %s %s "
1474
kdb_machreg_fmt, symtab.mod_name,
1475
symtab.sec_name, symtab.sec_start,
1476
symtab.sym_start, symtab.sym_end);
1478
addr += bytesperword;
1486
cp = wc.c + 8 - bytesperword;
1491
#define printable_char(c) \
1492
({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1493
switch (bytesperword) {
1495
*c++ = printable_char(*cp++);
1496
*c++ = printable_char(*cp++);
1497
*c++ = printable_char(*cp++);
1498
*c++ = printable_char(*cp++);
1501
*c++ = printable_char(*cp++);
1502
*c++ = printable_char(*cp++);
1505
*c++ = printable_char(*cp++);
1508
*c++ = printable_char(*cp++);
1512
#undef printable_char
1515
kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1519
static int kdb_md(int argc, const char **argv)
1521
static unsigned long last_addr;
1522
static int last_radix, last_bytesperword, last_repeat;
1523
int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1525
char fmtchar, fmtstr[64];
1533
kdbgetintenv("MDCOUNT", &mdcount);
1534
kdbgetintenv("RADIX", &radix);
1535
kdbgetintenv("BYTESPERWORD", &bytesperword);
1537
/* Assume 'md <addr>' and start with environment values */
1538
repeat = mdcount * 16 / bytesperword;
1540
if (strcmp(argv[0], "mdr") == 0) {
1542
return KDB_ARGCOUNT;
1544
} else if (isdigit(argv[0][2])) {
1545
bytesperword = (int)(argv[0][2] - '0');
1546
if (bytesperword == 0) {
1547
bytesperword = last_bytesperword;
1548
if (bytesperword == 0)
1551
last_bytesperword = bytesperword;
1552
repeat = mdcount * 16 / bytesperword;
1555
else if (argv[0][3] == 'c' && argv[0][4]) {
1557
repeat = simple_strtoul(argv[0] + 4, &p, 10);
1558
mdcount = ((repeat * bytesperword) + 15) / 16;
1561
last_repeat = repeat;
1562
} else if (strcmp(argv[0], "md") == 0)
1564
else if (strcmp(argv[0], "mds") == 0)
1566
else if (strcmp(argv[0], "mdp") == 0) {
1570
return KDB_NOTFOUND;
1574
return KDB_ARGCOUNT;
1577
bytesperword = last_bytesperword;
1578
repeat = last_repeat;
1579
mdcount = ((repeat * bytesperword) + 15) / 16;
1584
int diag, nextarg = 1;
1585
diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1589
if (argc > nextarg+2)
1590
return KDB_ARGCOUNT;
1592
if (argc >= nextarg) {
1593
diag = kdbgetularg(argv[nextarg], &val);
1595
mdcount = (int) val;
1596
repeat = mdcount * 16 / bytesperword;
1599
if (argc >= nextarg+1) {
1600
diag = kdbgetularg(argv[nextarg+1], &val);
1606
if (strcmp(argv[0], "mdr") == 0)
1607
return kdb_mdr(addr, mdcount);
1620
return KDB_BADRADIX;
1625
if (bytesperword > KDB_WORD_SIZE)
1626
return KDB_BADWIDTH;
1628
switch (bytesperword) {
1630
sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1633
sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1636
sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1639
sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1642
return KDB_BADWIDTH;
1645
last_repeat = repeat;
1646
last_bytesperword = bytesperword;
1648
if (strcmp(argv[0], "mds") == 0) {
1650
/* Do not save these changes as last_*, they are temporary mds
1653
bytesperword = KDB_WORD_SIZE;
1655
kdbgetintenv("NOSECT", &nosect);
1658
/* Round address down modulo BYTESPERWORD */
1660
addr &= ~(bytesperword-1);
1662
while (repeat > 0) {
1664
int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1666
if (KDB_FLAG(CMD_INTERRUPT))
1668
for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1670
if (kdb_getphysword(&word, a, bytesperword)
1673
} else if (kdb_getword(&word, a, bytesperword) || word)
1676
n = min(num, repeat);
1677
kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1679
addr += bytesperword * n;
1681
z = (z + num - 1) / num;
1683
int s = num * (z-2);
1684
kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1685
" zero suppressed\n",
1686
addr, addr + bytesperword * s - 1);
1687
addr += bytesperword * s;
1697
* kdb_mm - This function implements the 'mm' command.
1698
* mm address-expression new-value
1700
* mm works on machine words, mmW works on bytes.
1702
static int kdb_mm(int argc, const char **argv)
1707
unsigned long contents;
1711
if (argv[0][2] && !isdigit(argv[0][2]))
1712
return KDB_NOTFOUND;
1715
return KDB_ARGCOUNT;
1718
diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1723
return KDB_ARGCOUNT;
1724
diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1728
if (nextarg != argc + 1)
1729
return KDB_ARGCOUNT;
1731
width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1732
diag = kdb_putword(addr, contents, width);
1736
kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1742
* kdb_go - This function implements the 'go' command.
1743
* go [address-expression]
1745
static int kdb_go(int argc, const char **argv)
1752
if (raw_smp_processor_id() != kdb_initial_cpu) {
1753
kdb_printf("go must execute on the entry cpu, "
1754
"please use \"cpu %d\" and then execute go\n",
1756
return KDB_BADCPUNUM;
1760
diag = kdbgetaddrarg(argc, argv, &nextarg,
1761
&addr, &offset, NULL);
1765
return KDB_ARGCOUNT;
1769
if (KDB_FLAG(CATASTROPHIC)) {
1770
kdb_printf("Catastrophic error detected\n");
1771
kdb_printf("kdb_continue_catastrophic=%d, ",
1772
kdb_continue_catastrophic);
1773
if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1774
kdb_printf("type go a second time if you really want "
1778
if (kdb_continue_catastrophic == 2) {
1779
kdb_printf("forcing reboot\n");
1780
kdb_reboot(0, NULL);
1782
kdb_printf("attempting to continue\n");
1788
* kdb_rd - This function implements the 'rd' command.
1790
static int kdb_rd(int argc, const char **argv)
1792
int len = kdb_check_regs();
1793
#if DBG_MAX_REG_NUM > 0
1805
for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1806
rsize = dbg_reg_def[i].size * 2;
1809
if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
1814
len += kdb_printf(" ");
1815
switch(dbg_reg_def[i].size * 8) {
1817
rname = dbg_get_reg(i, ®8, kdb_current_regs);
1820
len += kdb_printf("%s: %02x", rname, reg8);
1823
rname = dbg_get_reg(i, ®16, kdb_current_regs);
1826
len += kdb_printf("%s: %04x", rname, reg16);
1829
rname = dbg_get_reg(i, ®32, kdb_current_regs);
1832
len += kdb_printf("%s: %08x", rname, reg32);
1835
rname = dbg_get_reg(i, ®64, kdb_current_regs);
1838
len += kdb_printf("%s: %016llx", rname, reg64);
1841
len += kdb_printf("%s: ??", dbg_reg_def[i].name);
1849
kdb_dumpregs(kdb_current_regs);
1855
* kdb_rm - This function implements the 'rm' (register modify) command.
1856
* rm register-name new-contents
1858
* Allows register modification with the same restrictions as gdb
1860
static int kdb_rm(int argc, const char **argv)
1862
#if DBG_MAX_REG_NUM > 0
1872
return KDB_ARGCOUNT;
1874
* Allow presence or absence of leading '%' symbol.
1880
diag = kdbgetu64arg(argv[2], ®64);
1884
diag = kdb_check_regs();
1889
for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1890
if (strcmp(rname, dbg_reg_def[i].name) == 0) {
1896
switch(dbg_reg_def[i].size * 8) {
1899
dbg_set_reg(i, ®8, kdb_current_regs);
1903
dbg_set_reg(i, ®16, kdb_current_regs);
1907
dbg_set_reg(i, ®32, kdb_current_regs);
1910
dbg_set_reg(i, ®64, kdb_current_regs);
1916
kdb_printf("ERROR: Register set currently not implemented\n");
1921
#if defined(CONFIG_MAGIC_SYSRQ)
1923
* kdb_sr - This function implements the 'sr' (SYSRQ key) command
1924
* which interfaces to the soi-disant MAGIC SYSRQ functionality.
1925
* sr <magic-sysrq-code>
1927
static int kdb_sr(int argc, const char **argv)
1930
return KDB_ARGCOUNT;
1932
__handle_sysrq(*argv[1], false);
1937
#endif /* CONFIG_MAGIC_SYSRQ */
1940
* kdb_ef - This function implements the 'regs' (display exception
1941
* frame) command. This command takes an address and expects to
1942
* find an exception frame at that address, formats and prints
1944
* regs address-expression
1948
static int kdb_ef(int argc, const char **argv)
1956
return KDB_ARGCOUNT;
1959
diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1962
show_regs((struct pt_regs *)addr);
1966
#if defined(CONFIG_MODULES)
1968
* kdb_lsmod - This function implements the 'lsmod' command. Lists
1969
* currently loaded kernel modules.
1970
* Mostly taken from userland lsmod.
1972
static int kdb_lsmod(int argc, const char **argv)
1977
return KDB_ARGCOUNT;
1979
kdb_printf("Module Size modstruct Used by\n");
1980
list_for_each_entry(mod, kdb_modules, list) {
1982
kdb_printf("%-20s%8u 0x%p ", mod->name,
1983
mod->core_size, (void *)mod);
1984
#ifdef CONFIG_MODULE_UNLOAD
1985
kdb_printf("%4d ", module_refcount(mod));
1987
if (mod->state == MODULE_STATE_GOING)
1988
kdb_printf(" (Unloading)");
1989
else if (mod->state == MODULE_STATE_COMING)
1990
kdb_printf(" (Loading)");
1992
kdb_printf(" (Live)");
1993
kdb_printf(" 0x%p", mod->module_core);
1995
#ifdef CONFIG_MODULE_UNLOAD
1997
struct module_use *use;
1999
list_for_each_entry(use, &mod->source_list,
2001
kdb_printf("%s ", use->target->name);
2010
#endif /* CONFIG_MODULES */
2013
* kdb_env - This function implements the 'env' command. Display the
2014
* current environment variables.
2017
static int kdb_env(int argc, const char **argv)
2021
for (i = 0; i < __nenv; i++) {
2023
kdb_printf("%s\n", __env[i]);
2026
if (KDB_DEBUG(MASK))
2027
kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
2032
#ifdef CONFIG_PRINTK
2034
* kdb_dmesg - This function implements the 'dmesg' command to display
2035
* the contents of the syslog buffer.
2036
* dmesg [lines] [adjust]
2038
static int kdb_dmesg(int argc, const char **argv)
2040
char *syslog_data[4], *start, *end, c = '\0', *p;
2041
int diag, logging, logsize, lines = 0, adjust = 0, n;
2044
return KDB_ARGCOUNT;
2047
lines = simple_strtol(argv[1], &cp, 0);
2051
adjust = simple_strtoul(argv[2], &cp, 0);
2052
if (*cp || adjust < 0)
2057
/* disable LOGGING if set */
2058
diag = kdbgetintenv("LOGGING", &logging);
2059
if (!diag && logging) {
2060
const char *setargs[] = { "set", "LOGGING", "0" };
2061
kdb_set(2, setargs);
2064
/* syslog_data[0,1] physical start, end+1. syslog_data[2,3]
2065
* logical start, end+1. */
2066
kdb_syslog_data(syslog_data);
2067
if (syslog_data[2] == syslog_data[3])
2069
logsize = syslog_data[1] - syslog_data[0];
2070
start = syslog_data[2];
2071
end = syslog_data[3];
2072
#define KDB_WRAP(p) (((p - syslog_data[0]) % logsize) + syslog_data[0])
2073
for (n = 0, p = start; p < end; ++p) {
2082
kdb_printf("buffer only contains %d lines, nothing "
2084
else if (adjust - lines >= n)
2085
kdb_printf("buffer only contains %d lines, last %d "
2086
"lines printed\n", n, n - adjust);
2088
for (; start < end && adjust; ++start) {
2089
if (*KDB_WRAP(start) == '\n')
2095
for (p = start; p < end && lines; ++p) {
2096
if (*KDB_WRAP(p) == '\n')
2100
} else if (lines > 0) {
2101
int skip = n - (adjust + lines);
2103
kdb_printf("buffer only contains %d lines, "
2104
"nothing printed\n", n);
2106
} else if (skip < 0) {
2109
kdb_printf("buffer only contains %d lines, first "
2110
"%d lines printed\n", n, lines);
2112
for (; start < end && skip; ++start) {
2113
if (*KDB_WRAP(start) == '\n')
2116
for (p = start; p < end && lines; ++p) {
2117
if (*KDB_WRAP(p) == '\n')
2122
/* Do a line at a time (max 200 chars) to reduce protocol overhead */
2124
while (start != end) {
2127
if (KDB_FLAG(CMD_INTERRUPT))
2129
while (start < end && (c = *KDB_WRAP(start)) &&
2130
(p - buf) < sizeof(buf)-1) {
2137
kdb_printf("%s", buf);
2144
#endif /* CONFIG_PRINTK */
2146
* kdb_cpu - This function implements the 'cpu' command.
2149
* KDB_CMD_CPU for success, a kdb diagnostic if error
2151
static void kdb_cpu_status(void)
2153
int i, start_cpu, first_print = 1;
2154
char state, prev_state = '?';
2156
kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2157
kdb_printf("Available cpus: ");
2158
for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2159
if (!cpu_online(i)) {
2160
state = 'F'; /* cpu is offline */
2162
state = ' '; /* cpu is responding to kdb */
2163
if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2164
state = 'I'; /* idle task */
2166
if (state != prev_state) {
2167
if (prev_state != '?') {
2171
kdb_printf("%d", start_cpu);
2172
if (start_cpu < i-1)
2173
kdb_printf("-%d", i-1);
2174
if (prev_state != ' ')
2175
kdb_printf("(%c)", prev_state);
2181
/* print the trailing cpus, ignoring them if they are all offline */
2182
if (prev_state != 'F') {
2185
kdb_printf("%d", start_cpu);
2186
if (start_cpu < i-1)
2187
kdb_printf("-%d", i-1);
2188
if (prev_state != ' ')
2189
kdb_printf("(%c)", prev_state);
2194
static int kdb_cpu(int argc, const char **argv)
2196
unsigned long cpunum;
2205
return KDB_ARGCOUNT;
2207
diag = kdbgetularg(argv[1], &cpunum);
2214
if ((cpunum > NR_CPUS) || !cpu_online(cpunum))
2215
return KDB_BADCPUNUM;
2217
dbg_switch_cpu = cpunum;
2220
* Switch to other cpu
2225
/* The user may not realize that ps/bta with no parameters does not print idle
2226
* or sleeping system daemon processes, so tell them how many were suppressed.
2228
void kdb_ps_suppressed(void)
2230
int idle = 0, daemon = 0;
2231
unsigned long mask_I = kdb_task_state_string("I"),
2232
mask_M = kdb_task_state_string("M");
2234
const struct task_struct *p, *g;
2235
for_each_online_cpu(cpu) {
2236
p = kdb_curr_task(cpu);
2237
if (kdb_task_state(p, mask_I))
2240
kdb_do_each_thread(g, p) {
2241
if (kdb_task_state(p, mask_M))
2243
} kdb_while_each_thread(g, p);
2244
if (idle || daemon) {
2246
kdb_printf("%d idle process%s (state I)%s\n",
2247
idle, idle == 1 ? "" : "es",
2248
daemon ? " and " : "");
2250
kdb_printf("%d sleeping system daemon (state M) "
2251
"process%s", daemon,
2252
daemon == 1 ? "" : "es");
2253
kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2258
* kdb_ps - This function implements the 'ps' command which shows a
2259
* list of the active processes.
2260
* ps [DRSTCZEUIMA] All processes, optionally filtered by state
2262
void kdb_ps1(const struct task_struct *p)
2267
if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
2270
cpu = kdb_process_cpu(p);
2271
kdb_printf("0x%p %8d %8d %d %4d %c 0x%p %c%s\n",
2272
(void *)p, p->pid, p->parent->pid,
2273
kdb_task_has_cpu(p), kdb_process_cpu(p),
2274
kdb_task_state_char(p),
2275
(void *)(&p->thread),
2276
p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2278
if (kdb_task_has_cpu(p)) {
2279
if (!KDB_TSK(cpu)) {
2280
kdb_printf(" Error: no saved data for this cpu\n");
2282
if (KDB_TSK(cpu) != p)
2283
kdb_printf(" Error: does not match running "
2284
"process table (0x%p)\n", KDB_TSK(cpu));
2289
static int kdb_ps(int argc, const char **argv)
2291
struct task_struct *g, *p;
2292
unsigned long mask, cpu;
2295
kdb_ps_suppressed();
2296
kdb_printf("%-*s Pid Parent [*] cpu State %-*s Command\n",
2297
(int)(2*sizeof(void *))+2, "Task Addr",
2298
(int)(2*sizeof(void *))+2, "Thread");
2299
mask = kdb_task_state_string(argc ? argv[1] : NULL);
2300
/* Run the active tasks first */
2301
for_each_online_cpu(cpu) {
2302
if (KDB_FLAG(CMD_INTERRUPT))
2304
p = kdb_curr_task(cpu);
2305
if (kdb_task_state(p, mask))
2309
/* Now the real tasks */
2310
kdb_do_each_thread(g, p) {
2311
if (KDB_FLAG(CMD_INTERRUPT))
2313
if (kdb_task_state(p, mask))
2315
} kdb_while_each_thread(g, p);
2321
* kdb_pid - This function implements the 'pid' command which switches
2322
* the currently active process.
2325
static int kdb_pid(int argc, const char **argv)
2327
struct task_struct *p;
2332
return KDB_ARGCOUNT;
2335
if (strcmp(argv[1], "R") == 0) {
2336
p = KDB_TSK(kdb_initial_cpu);
2338
diag = kdbgetularg(argv[1], &val);
2342
p = find_task_by_pid_ns((pid_t)val, &init_pid_ns);
2344
kdb_printf("No task with pid=%d\n", (pid_t)val);
2348
kdb_set_current_task(p);
2350
kdb_printf("KDB current process is %s(pid=%d)\n",
2351
kdb_current_task->comm,
2352
kdb_current_task->pid);
2358
* kdb_ll - This function implements the 'll' command which follows a
2359
* linked list and executes an arbitrary command for each
2362
static int kdb_ll(int argc, const char **argv)
2368
unsigned long linkoffset;
2370
const char *command;
2373
return KDB_ARGCOUNT;
2376
diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
2380
diag = kdbgetularg(argv[2], &linkoffset);
2385
* Using the starting address as
2386
* the first element in the list, and assuming that
2387
* the list ends with a null pointer.
2391
command = kdb_strdup(argv[3], GFP_KDB);
2393
kdb_printf("%s: cannot duplicate command\n", __func__);
2396
/* Recursive use of kdb_parse, do not use argv after this point */
2402
if (KDB_FLAG(CMD_INTERRUPT))
2405
sprintf(buf, "%s " kdb_machreg_fmt "\n", command, va);
2406
diag = kdb_parse(buf);
2410
addr = va + linkoffset;
2411
if (kdb_getword(&va, addr, sizeof(va)))
2420
static int kdb_kgdb(int argc, const char **argv)
2422
return KDB_CMD_KGDB;
2426
* kdb_help - This function implements the 'help' and '?' commands.
2428
static int kdb_help(int argc, const char **argv)
2433
kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2434
kdb_printf("-----------------------------"
2435
"-----------------------------\n");
2436
for_each_kdbcmd(kt, i) {
2438
kdb_printf("%-15.15s %-20.20s %s\n", kt->cmd_name,
2439
kt->cmd_usage, kt->cmd_help);
2440
if (KDB_FLAG(CMD_INTERRUPT))
2447
* kdb_kill - This function implements the 'kill' commands.
2449
static int kdb_kill(int argc, const char **argv)
2453
struct task_struct *p;
2454
struct siginfo info;
2457
return KDB_ARGCOUNT;
2459
sig = simple_strtol(argv[1], &endp, 0);
2463
kdb_printf("Invalid signal parameter.<-signal>\n");
2468
pid = simple_strtol(argv[2], &endp, 0);
2472
kdb_printf("Process ID must be large than 0.\n");
2476
/* Find the process. */
2477
p = find_task_by_pid_ns(pid, &init_pid_ns);
2479
kdb_printf("The specified process isn't found.\n");
2482
p = p->group_leader;
2483
info.si_signo = sig;
2485
info.si_code = SI_USER;
2486
info.si_pid = pid; /* same capabilities as process being signalled */
2487
info.si_uid = 0; /* kdb has root authority */
2488
kdb_send_sig_info(p, &info);
2493
int tm_sec; /* seconds */
2494
int tm_min; /* minutes */
2495
int tm_hour; /* hours */
2496
int tm_mday; /* day of the month */
2497
int tm_mon; /* month */
2498
int tm_year; /* year */
2501
static void kdb_gmtime(struct timespec *tv, struct kdb_tm *tm)
2503
/* This will work from 1970-2099, 2100 is not a leap year */
2504
static int mon_day[] = { 31, 29, 31, 30, 31, 30, 31,
2505
31, 30, 31, 30, 31 };
2506
memset(tm, 0, sizeof(*tm));
2507
tm->tm_sec = tv->tv_sec % (24 * 60 * 60);
2508
tm->tm_mday = tv->tv_sec / (24 * 60 * 60) +
2509
(2 * 365 + 1); /* shift base from 1970 to 1968 */
2510
tm->tm_min = tm->tm_sec / 60 % 60;
2511
tm->tm_hour = tm->tm_sec / 60 / 60;
2512
tm->tm_sec = tm->tm_sec % 60;
2513
tm->tm_year = 68 + 4*(tm->tm_mday / (4*365+1));
2514
tm->tm_mday %= (4*365+1);
2516
while (tm->tm_mday >= mon_day[tm->tm_mon]) {
2517
tm->tm_mday -= mon_day[tm->tm_mon];
2518
if (++tm->tm_mon == 12) {
2528
* Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2529
* I cannot call that code directly from kdb, it has an unconditional
2530
* cli()/sti() and calls routines that take locks which can stop the debugger.
2532
static void kdb_sysinfo(struct sysinfo *val)
2534
struct timespec uptime;
2535
do_posix_clock_monotonic_gettime(&uptime);
2536
memset(val, 0, sizeof(*val));
2537
val->uptime = uptime.tv_sec;
2538
val->loads[0] = avenrun[0];
2539
val->loads[1] = avenrun[1];
2540
val->loads[2] = avenrun[2];
2541
val->procs = nr_threads-1;
2548
* kdb_summary - This function implements the 'summary' command.
2550
static int kdb_summary(int argc, const char **argv)
2552
struct timespec now;
2557
return KDB_ARGCOUNT;
2559
kdb_printf("sysname %s\n", init_uts_ns.name.sysname);
2560
kdb_printf("release %s\n", init_uts_ns.name.release);
2561
kdb_printf("version %s\n", init_uts_ns.name.version);
2562
kdb_printf("machine %s\n", init_uts_ns.name.machine);
2563
kdb_printf("nodename %s\n", init_uts_ns.name.nodename);
2564
kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2565
kdb_printf("ccversion %s\n", __stringify(CCVERSION));
2567
now = __current_kernel_time();
2568
kdb_gmtime(&now, &tm);
2569
kdb_printf("date %04d-%02d-%02d %02d:%02d:%02d "
2570
"tz_minuteswest %d\n",
2571
1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2572
tm.tm_hour, tm.tm_min, tm.tm_sec,
2573
sys_tz.tz_minuteswest);
2576
kdb_printf("uptime ");
2577
if (val.uptime > (24*60*60)) {
2578
int days = val.uptime / (24*60*60);
2579
val.uptime %= (24*60*60);
2580
kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2582
kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2584
/* lifted from fs/proc/proc_misc.c::loadavg_read_proc() */
2586
#define LOAD_INT(x) ((x) >> FSHIFT)
2587
#define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
2588
kdb_printf("load avg %ld.%02ld %ld.%02ld %ld.%02ld\n",
2589
LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2590
LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2591
LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2594
/* Display in kilobytes */
2595
#define K(x) ((x) << (PAGE_SHIFT - 10))
2596
kdb_printf("\nMemTotal: %8lu kB\nMemFree: %8lu kB\n"
2597
"Buffers: %8lu kB\n",
2598
val.totalram, val.freeram, val.bufferram);
2603
* kdb_per_cpu - This function implements the 'per_cpu' command.
2605
static int kdb_per_cpu(int argc, const char **argv)
2608
int cpu, diag, nextarg = 1;
2609
unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2611
if (argc < 1 || argc > 3)
2612
return KDB_ARGCOUNT;
2614
diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2619
diag = kdbgetularg(argv[2], &bytesperword);
2624
bytesperword = KDB_WORD_SIZE;
2625
else if (bytesperword > KDB_WORD_SIZE)
2626
return KDB_BADWIDTH;
2627
sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2629
diag = kdbgetularg(argv[3], &whichcpu);
2632
if (!cpu_online(whichcpu)) {
2633
kdb_printf("cpu %ld is not online\n", whichcpu);
2634
return KDB_BADCPUNUM;
2638
/* Most architectures use __per_cpu_offset[cpu], some use
2639
* __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2641
#ifdef __per_cpu_offset
2642
#define KDB_PCU(cpu) __per_cpu_offset(cpu)
2645
#define KDB_PCU(cpu) __per_cpu_offset[cpu]
2647
#define KDB_PCU(cpu) 0
2650
for_each_online_cpu(cpu) {
2651
if (KDB_FLAG(CMD_INTERRUPT))
2654
if (whichcpu != ~0UL && whichcpu != cpu)
2656
addr = symaddr + KDB_PCU(cpu);
2657
diag = kdb_getword(&val, addr, bytesperword);
2659
kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2660
"read, diag=%d\n", cpu, addr, diag);
2663
kdb_printf("%5d ", cpu);
2664
kdb_md_line(fmtstr, addr,
2665
bytesperword == KDB_WORD_SIZE,
2666
1, bytesperword, 1, 1, 0);
2673
* display help for the use of cmd | grep pattern
2675
static int kdb_grep_help(int argc, const char **argv)
2677
kdb_printf("Usage of cmd args | grep pattern:\n");
2678
kdb_printf(" Any command's output may be filtered through an ");
2679
kdb_printf("emulated 'pipe'.\n");
2680
kdb_printf(" 'grep' is just a key word.\n");
2681
kdb_printf(" The pattern may include a very limited set of "
2682
"metacharacters:\n");
2683
kdb_printf(" pattern or ^pattern or pattern$ or ^pattern$\n");
2684
kdb_printf(" And if there are spaces in the pattern, you may "
2686
kdb_printf(" \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2687
" or \"^pat tern$\"\n");
2692
* kdb_register_repeat - This function is used to register a kernel
2696
* func Function to execute the command
2697
* usage A simple usage string showing arguments
2698
* help A simple help string describing command
2699
* repeat Does the command auto repeat on enter?
2701
* zero for success, one if a duplicate command.
2703
#define kdb_command_extend 50 /* arbitrary */
2704
int kdb_register_repeat(char *cmd,
2709
kdb_repeat_t repeat)
2715
* Brute force method to determine duplicates
2717
for_each_kdbcmd(kp, i) {
2718
if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2719
kdb_printf("Duplicate kdb command registered: "
2720
"%s, func %p help %s\n", cmd, func, help);
2726
* Insert command into first available location in table
2728
for_each_kdbcmd(kp, i) {
2729
if (kp->cmd_name == NULL)
2733
if (i >= kdb_max_commands) {
2734
kdbtab_t *new = kmalloc((kdb_max_commands - KDB_BASE_CMD_MAX +
2735
kdb_command_extend) * sizeof(*new), GFP_KDB);
2737
kdb_printf("Could not allocate new kdb_command "
2742
memcpy(new, kdb_commands,
2743
(kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new));
2744
kfree(kdb_commands);
2746
memset(new + kdb_max_commands, 0,
2747
kdb_command_extend * sizeof(*new));
2749
kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX;
2750
kdb_max_commands += kdb_command_extend;
2754
kp->cmd_func = func;
2755
kp->cmd_usage = usage;
2756
kp->cmd_help = help;
2758
kp->cmd_minlen = minlen;
2759
kp->cmd_repeat = repeat;
2763
EXPORT_SYMBOL_GPL(kdb_register_repeat);
2767
* kdb_register - Compatibility register function for commands that do
2768
* not need to specify a repeat state. Equivalent to
2769
* kdb_register_repeat with KDB_REPEAT_NONE.
2772
* func Function to execute the command
2773
* usage A simple usage string showing arguments
2774
* help A simple help string describing command
2776
* zero for success, one if a duplicate command.
2778
int kdb_register(char *cmd,
2784
return kdb_register_repeat(cmd, func, usage, help, minlen,
2787
EXPORT_SYMBOL_GPL(kdb_register);
2790
* kdb_unregister - This function is used to unregister a kernel
2791
* debugger command. It is generally called when a module which
2792
* implements kdb commands is unloaded.
2796
* zero for success, one command not registered.
2798
int kdb_unregister(char *cmd)
2806
for_each_kdbcmd(kp, i) {
2807
if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2808
kp->cmd_name = NULL;
2813
/* Couldn't find it. */
2816
EXPORT_SYMBOL_GPL(kdb_unregister);
2818
/* Initialize the kdb command table. */
2819
static void __init kdb_inittab(void)
2824
for_each_kdbcmd(kp, i)
2825
kp->cmd_name = NULL;
2827
kdb_register_repeat("md", kdb_md, "<vaddr>",
2828
"Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2829
KDB_REPEAT_NO_ARGS);
2830
kdb_register_repeat("mdr", kdb_md, "<vaddr> <bytes>",
2831
"Display Raw Memory", 0, KDB_REPEAT_NO_ARGS);
2832
kdb_register_repeat("mdp", kdb_md, "<paddr> <bytes>",
2833
"Display Physical Memory", 0, KDB_REPEAT_NO_ARGS);
2834
kdb_register_repeat("mds", kdb_md, "<vaddr>",
2835
"Display Memory Symbolically", 0, KDB_REPEAT_NO_ARGS);
2836
kdb_register_repeat("mm", kdb_mm, "<vaddr> <contents>",
2837
"Modify Memory Contents", 0, KDB_REPEAT_NO_ARGS);
2838
kdb_register_repeat("go", kdb_go, "[<vaddr>]",
2839
"Continue Execution", 1, KDB_REPEAT_NONE);
2840
kdb_register_repeat("rd", kdb_rd, "",
2841
"Display Registers", 0, KDB_REPEAT_NONE);
2842
kdb_register_repeat("rm", kdb_rm, "<reg> <contents>",
2843
"Modify Registers", 0, KDB_REPEAT_NONE);
2844
kdb_register_repeat("ef", kdb_ef, "<vaddr>",
2845
"Display exception frame", 0, KDB_REPEAT_NONE);
2846
kdb_register_repeat("bt", kdb_bt, "[<vaddr>]",
2847
"Stack traceback", 1, KDB_REPEAT_NONE);
2848
kdb_register_repeat("btp", kdb_bt, "<pid>",
2849
"Display stack for process <pid>", 0, KDB_REPEAT_NONE);
2850
kdb_register_repeat("bta", kdb_bt, "[DRSTCZEUIMA]",
2851
"Display stack all processes", 0, KDB_REPEAT_NONE);
2852
kdb_register_repeat("btc", kdb_bt, "",
2853
"Backtrace current process on each cpu", 0, KDB_REPEAT_NONE);
2854
kdb_register_repeat("btt", kdb_bt, "<vaddr>",
2855
"Backtrace process given its struct task address", 0,
2857
kdb_register_repeat("ll", kdb_ll, "<first-element> <linkoffset> <cmd>",
2858
"Execute cmd for each element in linked list", 0, KDB_REPEAT_NONE);
2859
kdb_register_repeat("env", kdb_env, "",
2860
"Show environment variables", 0, KDB_REPEAT_NONE);
2861
kdb_register_repeat("set", kdb_set, "",
2862
"Set environment variables", 0, KDB_REPEAT_NONE);
2863
kdb_register_repeat("help", kdb_help, "",
2864
"Display Help Message", 1, KDB_REPEAT_NONE);
2865
kdb_register_repeat("?", kdb_help, "",
2866
"Display Help Message", 0, KDB_REPEAT_NONE);
2867
kdb_register_repeat("cpu", kdb_cpu, "<cpunum>",
2868
"Switch to new cpu", 0, KDB_REPEAT_NONE);
2869
kdb_register_repeat("kgdb", kdb_kgdb, "",
2870
"Enter kgdb mode", 0, KDB_REPEAT_NONE);
2871
kdb_register_repeat("ps", kdb_ps, "[<flags>|A]",
2872
"Display active task list", 0, KDB_REPEAT_NONE);
2873
kdb_register_repeat("pid", kdb_pid, "<pidnum>",
2874
"Switch to another task", 0, KDB_REPEAT_NONE);
2875
kdb_register_repeat("reboot", kdb_reboot, "",
2876
"Reboot the machine immediately", 0, KDB_REPEAT_NONE);
2877
#if defined(CONFIG_MODULES)
2878
kdb_register_repeat("lsmod", kdb_lsmod, "",
2879
"List loaded kernel modules", 0, KDB_REPEAT_NONE);
2881
#if defined(CONFIG_MAGIC_SYSRQ)
2882
kdb_register_repeat("sr", kdb_sr, "<key>",
2883
"Magic SysRq key", 0, KDB_REPEAT_NONE);
2885
#if defined(CONFIG_PRINTK)
2886
kdb_register_repeat("dmesg", kdb_dmesg, "[lines]",
2887
"Display syslog buffer", 0, KDB_REPEAT_NONE);
2889
kdb_register_repeat("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
2890
"Define a set of commands, down to endefcmd", 0, KDB_REPEAT_NONE);
2891
kdb_register_repeat("kill", kdb_kill, "<-signal> <pid>",
2892
"Send a signal to a process", 0, KDB_REPEAT_NONE);
2893
kdb_register_repeat("summary", kdb_summary, "",
2894
"Summarize the system", 4, KDB_REPEAT_NONE);
2895
kdb_register_repeat("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
2896
"Display per_cpu variables", 3, KDB_REPEAT_NONE);
2897
kdb_register_repeat("grephelp", kdb_grep_help, "",
2898
"Display help on | grep", 0, KDB_REPEAT_NONE);
2901
/* Execute any commands defined in kdb_cmds. */
2902
static void __init kdb_cmd_init(void)
2905
for (i = 0; kdb_cmds[i]; ++i) {
2906
diag = kdb_parse(kdb_cmds[i]);
2908
kdb_printf("kdb command %s failed, kdb diag %d\n",
2911
if (defcmd_in_progress) {
2912
kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2913
kdb_parse("endefcmd");
2917
/* Initialize kdb_printf, breakpoint tables and kdb state */
2918
void __init kdb_init(int lvl)
2920
static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2923
if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2925
for (i = kdb_init_lvl; i < lvl; i++) {
2927
case KDB_NOT_INITIALIZED:
2928
kdb_inittab(); /* Initialize Command Table */
2929
kdb_initbptab(); /* Initialize Breakpoints */
2931
case KDB_INIT_EARLY:
2932
kdb_cmd_init(); /* Build kdb_cmds tables */