2 * Kernel Debugger Architecture Independent Main Code
4 * This file is subject to the terms and conditions of the GNU General Public
5 * License. See the file "COPYING" in the main directory of this archive
8 * Copyright (C) 1999-2004 Silicon Graphics, Inc. All Rights Reserved.
9 * Copyright (C) 2000 Stephane Eranian <eranian@hpl.hp.com>
10 * Xscale (R) modifications copyright (C) 2003 Intel Corporation.
11 * Copyright (c) 2009 Wind River Systems, Inc. All Rights Reserved.
14 #include <linux/ctype.h>
15 #include <linux/string.h>
16 #include <linux/kernel.h>
17 #include <linux/kmsg_dump.h>
18 #include <linux/reboot.h>
19 #include <linux/sched.h>
20 #include <linux/sysrq.h>
21 #include <linux/smp.h>
22 #include <linux/utsname.h>
23 #include <linux/vmalloc.h>
24 #include <linux/atomic.h>
25 #include <linux/module.h>
27 #include <linux/init.h>
28 #include <linux/kallsyms.h>
29 #include <linux/kgdb.h>
30 #include <linux/kdb.h>
31 #include <linux/notifier.h>
32 #include <linux/interrupt.h>
33 #include <linux/delay.h>
34 #include <linux/nmi.h>
35 #include <linux/time.h>
36 #include <linux/ptrace.h>
37 #include <linux/sysctl.h>
38 #include <linux/cpu.h>
39 #include <linux/kdebug.h>
40 #include <linux/proc_fs.h>
41 #include <linux/uaccess.h>
42 #include <linux/slab.h>
43 #include "kdb_private.h"
46 char kdb_grep_string[GREP_LEN];
47 int kdb_grepping_flag;
48 EXPORT_SYMBOL(kdb_grepping_flag);
50 int kdb_grep_trailing;
53 * Kernel debugger state flags
59 * kdb_lock protects updates to kdb_initial_cpu. Used to
60 * single thread processors through the kernel debugger.
62 int kdb_initial_cpu = -1; /* cpu number that owns kdb */
64 int kdb_state; /* General KDB state */
66 struct task_struct *kdb_current_task;
67 EXPORT_SYMBOL(kdb_current_task);
68 struct pt_regs *kdb_current_regs;
70 const char *kdb_diemsg;
71 static int kdb_go_count;
72 #ifdef CONFIG_KDB_CONTINUE_CATASTROPHIC
73 static unsigned int kdb_continue_catastrophic =
74 CONFIG_KDB_CONTINUE_CATASTROPHIC;
76 static unsigned int kdb_continue_catastrophic;
79 /* kdb_commands describes the available commands. */
80 static kdbtab_t *kdb_commands;
81 #define KDB_BASE_CMD_MAX 50
82 static int kdb_max_commands = KDB_BASE_CMD_MAX;
83 static kdbtab_t kdb_base_commands[KDB_BASE_CMD_MAX];
84 #define for_each_kdbcmd(cmd, num) \
85 for ((cmd) = kdb_base_commands, (num) = 0; \
86 num < kdb_max_commands; \
87 num++, num == KDB_BASE_CMD_MAX ? cmd = kdb_commands : cmd++)
89 typedef struct _kdbmsg {
90 int km_diag; /* kdb diagnostic */
91 char *km_msg; /* Corresponding message text */
94 #define KDBMSG(msgnum, text) \
95 { KDB_##msgnum, text }
97 static kdbmsg_t kdbmsgs[] = {
98 KDBMSG(NOTFOUND, "Command Not Found"),
99 KDBMSG(ARGCOUNT, "Improper argument count, see usage."),
100 KDBMSG(BADWIDTH, "Illegal value for BYTESPERWORD use 1, 2, 4 or 8, "
101 "8 is only allowed on 64 bit systems"),
102 KDBMSG(BADRADIX, "Illegal value for RADIX use 8, 10 or 16"),
103 KDBMSG(NOTENV, "Cannot find environment variable"),
104 KDBMSG(NOENVVALUE, "Environment variable should have value"),
105 KDBMSG(NOTIMP, "Command not implemented"),
106 KDBMSG(ENVFULL, "Environment full"),
107 KDBMSG(ENVBUFFULL, "Environment buffer full"),
108 KDBMSG(TOOMANYBPT, "Too many breakpoints defined"),
109 #ifdef CONFIG_CPU_XSCALE
110 KDBMSG(TOOMANYDBREGS, "More breakpoints than ibcr registers defined"),
112 KDBMSG(TOOMANYDBREGS, "More breakpoints than db registers defined"),
114 KDBMSG(DUPBPT, "Duplicate breakpoint address"),
115 KDBMSG(BPTNOTFOUND, "Breakpoint not found"),
116 KDBMSG(BADMODE, "Invalid IDMODE"),
117 KDBMSG(BADINT, "Illegal numeric value"),
118 KDBMSG(INVADDRFMT, "Invalid symbolic address format"),
119 KDBMSG(BADREG, "Invalid register name"),
120 KDBMSG(BADCPUNUM, "Invalid cpu number"),
121 KDBMSG(BADLENGTH, "Invalid length field"),
122 KDBMSG(NOBP, "No Breakpoint exists"),
123 KDBMSG(BADADDR, "Invalid address"),
127 static const int __nkdb_err = sizeof(kdbmsgs) / sizeof(kdbmsg_t);
131 * Initial environment. This is all kept static and local to
132 * this file. We don't want to rely on the memory allocation
133 * mechanisms in the kernel, so we use a very limited allocate-only
134 * heap for new and altered environment variables. The entire
135 * environment is limited to a fixed number of entries (add more
136 * to __env[] if required) and a fixed amount of heap (add more to
137 * KDB_ENVBUFSIZE if required).
140 static char *__env[] = {
141 #if defined(CONFIG_SMP)
148 "MDCOUNT=8", /* lines of md output */
178 static const int __nenv = (sizeof(__env) / sizeof(char *));
180 struct task_struct *kdb_curr_task(int cpu)
182 struct task_struct *p = curr_task(cpu);
184 if ((task_thread_info(p)->flags & _TIF_MCA_INIT) && KDB_TSK(cpu))
191 * kdbgetenv - This function will return the character string value of
192 * an environment variable.
194 * match A character string representing an environment variable.
196 * NULL No environment variable matches 'match'
197 * char* Pointer to string value of environment variable.
199 char *kdbgetenv(const char *match)
202 int matchlen = strlen(match);
205 for (i = 0; i < __nenv; i++) {
211 if ((strncmp(match, e, matchlen) == 0)
212 && ((e[matchlen] == '\0')
213 || (e[matchlen] == '='))) {
214 char *cp = strchr(e, '=');
215 return cp ? ++cp : "";
222 * kdballocenv - This function is used to allocate bytes for
223 * environment entries.
225 * match A character string representing a numeric value
227 * *value the unsigned long representation of the env variable 'match'
229 * Zero on success, a kdb diagnostic on failure.
231 * We use a static environment buffer (envbuffer) to hold the values
232 * of dynamically generated environment variables (see kdb_set). Buffer
233 * space once allocated is never free'd, so over time, the amount of space
234 * (currently 512 bytes) will be exhausted if env variables are changed
237 static char *kdballocenv(size_t bytes)
239 #define KDB_ENVBUFSIZE 512
240 static char envbuffer[KDB_ENVBUFSIZE];
241 static int envbufsize;
244 if ((KDB_ENVBUFSIZE - envbufsize) >= bytes) {
245 ep = &envbuffer[envbufsize];
252 * kdbgetulenv - This function will return the value of an unsigned
253 * long-valued environment variable.
255 * match A character string representing a numeric value
257 * *value the unsigned long represntation of the env variable 'match'
259 * Zero on success, a kdb diagnostic on failure.
261 static int kdbgetulenv(const char *match, unsigned long *value)
265 ep = kdbgetenv(match);
269 return KDB_NOENVVALUE;
271 *value = simple_strtoul(ep, NULL, 0);
277 * kdbgetintenv - This function will return the value of an
278 * integer-valued environment variable.
280 * match A character string representing an integer-valued env variable
282 * *value the integer representation of the environment variable 'match'
284 * Zero on success, a kdb diagnostic on failure.
286 int kdbgetintenv(const char *match, int *value)
291 diag = kdbgetulenv(match, &val);
298 * kdbgetularg - This function will convert a numeric string into an
299 * unsigned long value.
301 * arg A character string representing a numeric value
303 * *value the unsigned long represntation of arg.
305 * Zero on success, a kdb diagnostic on failure.
307 int kdbgetularg(const char *arg, unsigned long *value)
312 val = simple_strtoul(arg, &endp, 0);
316 * Also try base 16, for us folks too lazy to type the
319 val = simple_strtoul(arg, &endp, 16);
329 int kdbgetu64arg(const char *arg, u64 *value)
334 val = simple_strtoull(arg, &endp, 0);
338 val = simple_strtoull(arg, &endp, 16);
349 * kdb_set - This function implements the 'set' command. Alter an
350 * existing environment variable or create a new one.
352 int kdb_set(int argc, const char **argv)
356 size_t varlen, vallen;
359 * we can be invoked two ways:
360 * set var=value argv[1]="var", argv[2]="value"
361 * set var = value argv[1]="var", argv[2]="=", argv[3]="value"
362 * - if the latter, shift 'em down.
373 * Check for internal variables
375 if (strcmp(argv[1], "KDBDEBUG") == 0) {
376 unsigned int debugflags;
379 debugflags = simple_strtoul(argv[2], &cp, 0);
380 if (cp == argv[2] || debugflags & ~KDB_DEBUG_FLAG_MASK) {
381 kdb_printf("kdb: illegal debug flags '%s'\n",
385 kdb_flags = (kdb_flags &
386 ~(KDB_DEBUG_FLAG_MASK << KDB_DEBUG_FLAG_SHIFT))
387 | (debugflags << KDB_DEBUG_FLAG_SHIFT);
393 * Tokenizer squashed the '=' sign. argv[1] is variable
394 * name, argv[2] = value.
396 varlen = strlen(argv[1]);
397 vallen = strlen(argv[2]);
398 ep = kdballocenv(varlen + vallen + 2);
400 return KDB_ENVBUFFULL;
402 sprintf(ep, "%s=%s", argv[1], argv[2]);
404 ep[varlen+vallen+1] = '\0';
406 for (i = 0; i < __nenv; i++) {
408 && ((strncmp(__env[i], argv[1], varlen) == 0)
409 && ((__env[i][varlen] == '\0')
410 || (__env[i][varlen] == '=')))) {
417 * Wasn't existing variable. Fit into slot.
419 for (i = 0; i < __nenv-1; i++) {
420 if (__env[i] == (char *)0) {
429 static int kdb_check_regs(void)
431 if (!kdb_current_regs) {
432 kdb_printf("No current kdb registers."
433 " You may need to select another task\n");
440 * kdbgetaddrarg - This function is responsible for parsing an
441 * address-expression and returning the value of the expression,
442 * symbol name, and offset to the caller.
444 * The argument may consist of a numeric value (decimal or
445 * hexidecimal), a symbol name, a register name (preceded by the
446 * percent sign), an environment variable with a numeric value
447 * (preceded by a dollar sign) or a simple arithmetic expression
448 * consisting of a symbol name, +/-, and a numeric constant value
451 * argc - count of arguments in argv
452 * argv - argument vector
453 * *nextarg - index to next unparsed argument in argv[]
454 * regs - Register state at time of KDB entry
456 * *value - receives the value of the address-expression
457 * *offset - receives the offset specified, if any
458 * *name - receives the symbol name, if any
459 * *nextarg - index to next unparsed argument in argv[]
461 * zero is returned on success, a kdb diagnostic code is
464 int kdbgetaddrarg(int argc, const char **argv, int *nextarg,
465 unsigned long *value, long *offset,
469 unsigned long off = 0;
479 * Process arguments which follow the following syntax:
481 * symbol | numeric-address [+/- numeric-offset]
483 * $environment-variable
489 symname = (char *)argv[*nextarg];
492 * If there is no whitespace between the symbol
493 * or address and the '+' or '-' symbols, we
494 * remember the character and replace it with a
495 * null so the symbol/value can be properly parsed
497 cp = strpbrk(symname, "+-");
503 if (symname[0] == '$') {
504 diag = kdbgetulenv(&symname[1], &addr);
507 } else if (symname[0] == '%') {
508 diag = kdb_check_regs();
511 /* Implement register values with % at a later time as it is
516 found = kdbgetsymval(symname, &symtab);
518 addr = symtab.sym_start;
520 diag = kdbgetularg(argv[*nextarg], &addr);
527 found = kdbnearsym(addr, &symtab);
535 if (offset && name && *name)
536 *offset = addr - symtab.sym_start;
538 if ((*nextarg > argc)
543 * check for +/- and offset
546 if (symbol == '\0') {
547 if ((argv[*nextarg][0] != '+')
548 && (argv[*nextarg][0] != '-')) {
550 * Not our argument. Return.
554 positive = (argv[*nextarg][0] == '+');
558 positive = (symbol == '+');
561 * Now there must be an offset!
563 if ((*nextarg > argc)
564 && (symbol == '\0')) {
565 return KDB_INVADDRFMT;
569 cp = (char *)argv[*nextarg];
573 diag = kdbgetularg(cp, &off);
589 static void kdb_cmderror(int diag)
594 kdb_printf("no error detected (diagnostic is %d)\n", diag);
598 for (i = 0; i < __nkdb_err; i++) {
599 if (kdbmsgs[i].km_diag == diag) {
600 kdb_printf("diag: %d: %s\n", diag, kdbmsgs[i].km_msg);
605 kdb_printf("Unknown diag %d\n", -diag);
609 * kdb_defcmd, kdb_defcmd2 - This function implements the 'defcmd'
610 * command which defines one command as a set of other commands,
611 * terminated by endefcmd. kdb_defcmd processes the initial
612 * 'defcmd' command, kdb_defcmd2 is invoked from kdb_parse for
613 * the following commands until 'endefcmd'.
615 * argc argument count
616 * argv argument vector
618 * zero for success, a kdb diagnostic if error
628 static struct defcmd_set *defcmd_set;
629 static int defcmd_set_count;
630 static int defcmd_in_progress;
632 /* Forward references */
633 static int kdb_exec_defcmd(int argc, const char **argv);
635 static int kdb_defcmd2(const char *cmdstr, const char *argv0)
637 struct defcmd_set *s = defcmd_set + defcmd_set_count - 1;
638 char **save_command = s->command;
639 if (strcmp(argv0, "endefcmd") == 0) {
640 defcmd_in_progress = 0;
644 kdb_register(s->name, kdb_exec_defcmd,
645 s->usage, s->help, 0);
650 s->command = kzalloc((s->count + 1) * sizeof(*(s->command)), GFP_KDB);
652 kdb_printf("Could not allocate new kdb_defcmd table for %s\n",
657 memcpy(s->command, save_command, s->count * sizeof(*(s->command)));
658 s->command[s->count++] = kdb_strdup(cmdstr, GFP_KDB);
663 static int kdb_defcmd(int argc, const char **argv)
665 struct defcmd_set *save_defcmd_set = defcmd_set, *s;
666 if (defcmd_in_progress) {
667 kdb_printf("kdb: nested defcmd detected, assuming missing "
669 kdb_defcmd2("endefcmd", "endefcmd");
673 for (s = defcmd_set; s < defcmd_set + defcmd_set_count; ++s) {
674 kdb_printf("defcmd %s \"%s\" \"%s\"\n", s->name,
676 for (i = 0; i < s->count; ++i)
677 kdb_printf("%s", s->command[i]);
678 kdb_printf("endefcmd\n");
684 defcmd_set = kmalloc((defcmd_set_count + 1) * sizeof(*defcmd_set),
687 kdb_printf("Could not allocate new defcmd_set entry for %s\n",
689 defcmd_set = save_defcmd_set;
692 memcpy(defcmd_set, save_defcmd_set,
693 defcmd_set_count * sizeof(*defcmd_set));
694 kfree(save_defcmd_set);
695 s = defcmd_set + defcmd_set_count;
696 memset(s, 0, sizeof(*s));
698 s->name = kdb_strdup(argv[1], GFP_KDB);
699 s->usage = kdb_strdup(argv[2], GFP_KDB);
700 s->help = kdb_strdup(argv[3], GFP_KDB);
701 if (s->usage[0] == '"') {
702 strcpy(s->usage, s->usage+1);
703 s->usage[strlen(s->usage)-1] = '\0';
705 if (s->help[0] == '"') {
706 strcpy(s->help, s->help+1);
707 s->help[strlen(s->help)-1] = '\0';
710 defcmd_in_progress = 1;
715 * kdb_exec_defcmd - Execute the set of commands associated with this
718 * argc argument count
719 * argv argument vector
721 * zero for success, a kdb diagnostic if error
723 static int kdb_exec_defcmd(int argc, const char **argv)
726 struct defcmd_set *s;
729 for (s = defcmd_set, i = 0; i < defcmd_set_count; ++i, ++s) {
730 if (strcmp(s->name, argv[0]) == 0)
733 if (i == defcmd_set_count) {
734 kdb_printf("kdb_exec_defcmd: could not find commands for %s\n",
738 for (i = 0; i < s->count; ++i) {
739 /* Recursive use of kdb_parse, do not use argv after
742 kdb_printf("[%s]kdb> %s\n", s->name, s->command[i]);
743 ret = kdb_parse(s->command[i]);
750 /* Command history */
751 #define KDB_CMD_HISTORY_COUNT 32
752 #define CMD_BUFLEN 200 /* kdb_printf: max printline
754 static unsigned int cmd_head, cmd_tail;
755 static unsigned int cmdptr;
756 static char cmd_hist[KDB_CMD_HISTORY_COUNT][CMD_BUFLEN];
757 static char cmd_cur[CMD_BUFLEN];
760 * The "str" argument may point to something like | grep xyz
762 static void parse_grep(const char *str)
765 char *cp = (char *)str, *cp2;
767 /* sanity check: we should have been called with the \ first */
773 if (strncmp(cp, "grep ", 5)) {
774 kdb_printf("invalid 'pipe', see grephelp\n");
780 cp2 = strchr(cp, '\n');
782 *cp2 = '\0'; /* remove the trailing newline */
785 kdb_printf("invalid 'pipe', see grephelp\n");
788 /* now cp points to a nonzero length search string */
790 /* allow it be "x y z" by removing the "'s - there must
793 cp2 = strchr(cp, '"');
795 kdb_printf("invalid quoted string, see grephelp\n");
798 *cp2 = '\0'; /* end the string where the 2nd " was */
800 kdb_grep_leading = 0;
802 kdb_grep_leading = 1;
806 kdb_grep_trailing = 0;
807 if (*(cp+len-1) == '$') {
808 kdb_grep_trailing = 1;
814 if (len >= GREP_LEN) {
815 kdb_printf("search string too long\n");
818 strcpy(kdb_grep_string, cp);
824 * kdb_parse - Parse the command line, search the command table for a
825 * matching command and invoke the command function. This
826 * function may be called recursively, if it is, the second call
827 * will overwrite argv and cbuf. It is the caller's
828 * responsibility to save their argv if they recursively call
831 * cmdstr The input command line to be parsed.
832 * regs The registers at the time kdb was entered.
834 * Zero for success, a kdb diagnostic if failure.
836 * Limited to 20 tokens.
838 * Real rudimentary tokenization. Basically only whitespace
839 * is considered a token delimeter (but special consideration
840 * is taken of the '=' sign as used by the 'set' command).
842 * The algorithm used to tokenize the input string relies on
843 * there being at least one whitespace (or otherwise useless)
844 * character between tokens as the character immediately following
845 * the token is altered in-place to a null-byte to terminate the
851 int kdb_parse(const char *cmdstr)
853 static char *argv[MAXARGC];
855 static char cbuf[CMD_BUFLEN+2];
859 int i, escaped, ignore_errors = 0, check_grep;
862 * First tokenize the command string.
865 kdb_grepping_flag = check_grep = 0;
867 if (KDB_FLAG(CMD_INTERRUPT)) {
868 /* Previous command was interrupted, newline must not
869 * repeat the command */
870 KDB_FLAG_CLEAR(CMD_INTERRUPT);
871 KDB_STATE_SET(PAGER);
872 argc = 0; /* no repeat */
875 if (*cp != '\n' && *cp != '\0') {
879 /* skip whitespace */
882 if ((*cp == '\0') || (*cp == '\n') ||
883 (*cp == '#' && !defcmd_in_progress))
885 /* special case: check for | grep pattern */
890 if (cpp >= cbuf + CMD_BUFLEN) {
891 kdb_printf("kdb_parse: command buffer "
892 "overflow, command ignored\n%s\n",
896 if (argc >= MAXARGC - 1) {
897 kdb_printf("kdb_parse: too many arguments, "
898 "command ignored\n%s\n", cmdstr);
904 /* Copy to next unquoted and unescaped
905 * whitespace or '=' */
906 while (*cp && *cp != '\n' &&
907 (escaped || quoted || !isspace(*cp))) {
908 if (cpp >= cbuf + CMD_BUFLEN)
922 else if (*cp == '\'' || *cp == '"')
925 if (*cpp == '=' && !quoted)
929 *cpp++ = '\0'; /* Squash a ws or '=' character */
936 if (defcmd_in_progress) {
937 int result = kdb_defcmd2(cmdstr, argv[0]);
938 if (!defcmd_in_progress) {
939 argc = 0; /* avoid repeat on endefcmd */
944 if (argv[0][0] == '-' && argv[0][1] &&
945 (argv[0][1] < '0' || argv[0][1] > '9')) {
950 for_each_kdbcmd(tp, i) {
953 * If this command is allowed to be abbreviated,
954 * check to see if this is it.
958 && (strlen(argv[0]) <= tp->cmd_minlen)) {
961 tp->cmd_minlen) == 0) {
966 if (strcmp(argv[0], tp->cmd_name) == 0)
972 * If we don't find a command by this name, see if the first
973 * few characters of this match any of the known commands.
974 * e.g., md1c20 should match md.
976 if (i == kdb_max_commands) {
977 for_each_kdbcmd(tp, i) {
981 strlen(tp->cmd_name)) == 0) {
988 if (i < kdb_max_commands) {
991 result = (*tp->cmd_func)(argc-1, (const char **)argv);
992 if (result && ignore_errors && result > KDB_CMD_GO)
994 KDB_STATE_CLEAR(CMD);
995 switch (tp->cmd_repeat) {
996 case KDB_REPEAT_NONE:
1001 case KDB_REPEAT_NO_ARGS:
1006 case KDB_REPEAT_WITH_ARGS:
1013 * If the input with which we were presented does not
1014 * map to an existing command, attempt to parse it as an
1015 * address argument and display the result. Useful for
1016 * obtaining the address of a variable, or the nearest symbol
1017 * to an address contained in a register.
1020 unsigned long value;
1025 if (kdbgetaddrarg(0, (const char **)argv, &nextarg,
1026 &value, &offset, &name)) {
1027 return KDB_NOTFOUND;
1030 kdb_printf("%s = ", argv[0]);
1031 kdb_symbol_print(value, NULL, KDB_SP_DEFAULT);
1038 static int handle_ctrl_cmd(char *cmd)
1043 /* initial situation */
1044 if (cmd_head == cmd_tail)
1048 if (cmdptr != cmd_tail)
1049 cmdptr = (cmdptr-1) % KDB_CMD_HISTORY_COUNT;
1050 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1053 if (cmdptr != cmd_head)
1054 cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT;
1055 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1062 * kdb_reboot - This function implements the 'reboot' command. Reboot
1063 * the system immediately, or loop for ever on failure.
1065 static int kdb_reboot(int argc, const char **argv)
1067 emergency_restart();
1068 kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
1075 static void kdb_dumpregs(struct pt_regs *regs)
1077 int old_lvl = console_loglevel;
1078 console_loglevel = 15;
1083 console_loglevel = old_lvl;
1086 void kdb_set_current_task(struct task_struct *p)
1088 kdb_current_task = p;
1090 if (kdb_task_has_cpu(p)) {
1091 kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p));
1094 kdb_current_regs = NULL;
1098 * kdb_local - The main code for kdb. This routine is invoked on a
1099 * specific processor, it is not global. The main kdb() routine
1100 * ensures that only one processor at a time is in this routine.
1101 * This code is called with the real reason code on the first
1102 * entry to a kdb session, thereafter it is called with reason
1103 * SWITCH, even if the user goes back to the original cpu.
1105 * reason The reason KDB was invoked
1106 * error The hardware-defined error code
1107 * regs The exception frame at time of fault/breakpoint.
1108 * db_result Result code from the break or debug point.
1110 * 0 KDB was invoked for an event which it wasn't responsible
1111 * 1 KDB handled the event for which it was invoked.
1112 * KDB_CMD_GO User typed 'go'.
1113 * KDB_CMD_CPU User switched to another cpu.
1114 * KDB_CMD_SS Single step.
1115 * KDB_CMD_SSB Single step until branch.
1117 static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs,
1118 kdb_dbtrap_t db_result)
1122 struct task_struct *kdb_current =
1123 kdb_curr_task(raw_smp_processor_id());
1125 KDB_DEBUG_STATE("kdb_local 1", reason);
1127 if (reason == KDB_REASON_DEBUG) {
1128 /* special case below */
1130 kdb_printf("\nEntering kdb (current=0x%p, pid %d) ",
1131 kdb_current, kdb_current ? kdb_current->pid : 0);
1132 #if defined(CONFIG_SMP)
1133 kdb_printf("on processor %d ", raw_smp_processor_id());
1138 case KDB_REASON_DEBUG:
1141 * If re-entering kdb after a single step
1142 * command, don't print the message.
1144 switch (db_result) {
1146 kdb_printf("\nEntering kdb (0x%p, pid %d) ",
1147 kdb_current, kdb_current->pid);
1148 #if defined(CONFIG_SMP)
1149 kdb_printf("on processor %d ", raw_smp_processor_id());
1151 kdb_printf("due to Debug @ " kdb_machreg_fmt "\n",
1152 instruction_pointer(regs));
1156 * In the midst of ssb command. Just return.
1158 KDB_DEBUG_STATE("kdb_local 3", reason);
1159 return KDB_CMD_SSB; /* Continue with SSB command */
1165 KDB_DEBUG_STATE("kdb_local 4", reason);
1166 return 1; /* kdba_db_trap did the work */
1168 kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
1175 case KDB_REASON_ENTER:
1176 if (KDB_STATE(KEYBOARD))
1177 kdb_printf("due to Keyboard Entry\n");
1179 kdb_printf("due to KDB_ENTER()\n");
1181 case KDB_REASON_KEYBOARD:
1182 KDB_STATE_SET(KEYBOARD);
1183 kdb_printf("due to Keyboard Entry\n");
1185 case KDB_REASON_ENTER_SLAVE:
1186 /* drop through, slaves only get released via cpu switch */
1187 case KDB_REASON_SWITCH:
1188 kdb_printf("due to cpu switch\n");
1190 case KDB_REASON_OOPS:
1191 kdb_printf("Oops: %s\n", kdb_diemsg);
1192 kdb_printf("due to oops @ " kdb_machreg_fmt "\n",
1193 instruction_pointer(regs));
1196 case KDB_REASON_NMI:
1197 kdb_printf("due to NonMaskable Interrupt @ "
1198 kdb_machreg_fmt "\n",
1199 instruction_pointer(regs));
1202 case KDB_REASON_SSTEP:
1203 case KDB_REASON_BREAK:
1204 kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
1205 reason == KDB_REASON_BREAK ?
1206 "Breakpoint" : "SS trap", instruction_pointer(regs));
1208 * Determine if this breakpoint is one that we
1209 * are interested in.
1211 if (db_result != KDB_DB_BPT) {
1212 kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1214 KDB_DEBUG_STATE("kdb_local 6", reason);
1215 return 0; /* Not for us, dismiss it */
1218 case KDB_REASON_RECURSE:
1219 kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
1220 instruction_pointer(regs));
1223 kdb_printf("kdb: unexpected reason code: %d\n", reason);
1224 KDB_DEBUG_STATE("kdb_local 8", reason);
1225 return 0; /* Not for us, dismiss it */
1230 * Initialize pager context.
1233 KDB_STATE_CLEAR(SUPPRESS);
1237 *(cmd_hist[cmd_head]) = '\0';
1240 #if defined(CONFIG_SMP)
1241 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
1242 raw_smp_processor_id());
1244 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"));
1246 if (defcmd_in_progress)
1247 strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
1250 * Fetch command from keyboard
1252 cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
1253 if (*cmdbuf != '\n') {
1255 if (cmdptr == cmd_head) {
1256 strncpy(cmd_hist[cmd_head], cmd_cur,
1258 *(cmd_hist[cmd_head] +
1259 strlen(cmd_hist[cmd_head])-1) = '\0';
1261 if (!handle_ctrl_cmd(cmdbuf))
1262 *(cmd_cur+strlen(cmd_cur)-1) = '\0';
1264 goto do_full_getstr;
1266 strncpy(cmd_hist[cmd_head], cmd_cur,
1270 cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
1271 if (cmd_head == cmd_tail)
1272 cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
1276 diag = kdb_parse(cmdbuf);
1277 if (diag == KDB_NOTFOUND) {
1278 kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
1281 if (diag == KDB_CMD_GO
1282 || diag == KDB_CMD_CPU
1283 || diag == KDB_CMD_SS
1284 || diag == KDB_CMD_SSB
1285 || diag == KDB_CMD_KGDB)
1291 KDB_DEBUG_STATE("kdb_local 9", diag);
1297 * kdb_print_state - Print the state data for the current processor
1300 * text Identifies the debug point
1301 * value Any integer value to be printed, e.g. reason code.
1303 void kdb_print_state(const char *text, int value)
1305 kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1306 text, raw_smp_processor_id(), value, kdb_initial_cpu,
1311 * kdb_main_loop - After initial setup and assignment of the
1312 * controlling cpu, all cpus are in this loop. One cpu is in
1313 * control and will issue the kdb prompt, the others will spin
1314 * until 'go' or cpu switch.
1316 * To get a consistent view of the kernel stacks for all
1317 * processes, this routine is invoked from the main kdb code via
1318 * an architecture specific routine. kdba_main_loop is
1319 * responsible for making the kernel stacks consistent for all
1320 * processes, there should be no difference between a blocked
1321 * process and a running process as far as kdb is concerned.
1323 * reason The reason KDB was invoked
1324 * error The hardware-defined error code
1325 * reason2 kdb's current reason code.
1326 * Initially error but can change
1327 * according to kdb state.
1328 * db_result Result code from break or debug point.
1329 * regs The exception frame at time of fault/breakpoint.
1330 * should always be valid.
1332 * 0 KDB was invoked for an event which it wasn't responsible
1333 * 1 KDB handled the event for which it was invoked.
1335 int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
1336 kdb_dbtrap_t db_result, struct pt_regs *regs)
1339 /* Stay in kdb() until 'go', 'ss[b]' or an error */
1342 * All processors except the one that is in control
1345 KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1346 while (KDB_STATE(HOLD_CPU)) {
1347 /* state KDB is turned off by kdb_cpu to see if the
1348 * other cpus are still live, each cpu in this loop
1351 if (!KDB_STATE(KDB))
1355 KDB_STATE_CLEAR(SUPPRESS);
1356 KDB_DEBUG_STATE("kdb_main_loop 2", reason);
1357 if (KDB_STATE(LEAVING))
1358 break; /* Another cpu said 'go' */
1359 /* Still using kdb, this processor is in control */
1360 result = kdb_local(reason2, error, regs, db_result);
1361 KDB_DEBUG_STATE("kdb_main_loop 3", result);
1363 if (result == KDB_CMD_CPU)
1366 if (result == KDB_CMD_SS) {
1367 KDB_STATE_SET(DOING_SS);
1371 if (result == KDB_CMD_SSB) {
1372 KDB_STATE_SET(DOING_SS);
1373 KDB_STATE_SET(DOING_SSB);
1377 if (result == KDB_CMD_KGDB) {
1378 if (!KDB_STATE(DOING_KGDB))
1379 kdb_printf("Entering please attach debugger "
1380 "or use $D#44+ or $3#33\n");
1383 if (result && result != 1 && result != KDB_CMD_GO)
1384 kdb_printf("\nUnexpected kdb_local return code %d\n",
1386 KDB_DEBUG_STATE("kdb_main_loop 4", reason);
1389 if (KDB_STATE(DOING_SS))
1390 KDB_STATE_CLEAR(SSBPT);
1392 /* Clean up any keyboard devices before leaving */
1393 kdb_kbd_cleanup_state();
1399 * kdb_mdr - This function implements the guts of the 'mdr', memory
1401 * mdr <addr arg>,<byte count>
1403 * addr Start address
1404 * count Number of bytes
1406 * Always 0. Any errors are detected and printed by kdb_getarea.
1408 static int kdb_mdr(unsigned long addr, unsigned int count)
1412 if (kdb_getarea(c, addr))
1414 kdb_printf("%02x", c);
1422 * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1423 * 'md8' 'mdr' and 'mds' commands.
1425 * md|mds [<addr arg> [<line count> [<radix>]]]
1426 * mdWcN [<addr arg> [<line count> [<radix>]]]
1427 * where W = is the width (1, 2, 4 or 8) and N is the count.
1428 * for eg., md1c20 reads 20 bytes, 1 at a time.
1429 * mdr <addr arg>,<byte count>
1431 static void kdb_md_line(const char *fmtstr, unsigned long addr,
1432 int symbolic, int nosect, int bytesperword,
1433 int num, int repeat, int phys)
1435 /* print just one line of data */
1436 kdb_symtab_t symtab;
1442 memset(cbuf, '\0', sizeof(cbuf));
1444 kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1446 kdb_printf(kdb_machreg_fmt0 " ", addr);
1448 for (i = 0; i < num && repeat--; i++) {
1450 if (kdb_getphysword(&word, addr, bytesperword))
1452 } else if (kdb_getword(&word, addr, bytesperword))
1454 kdb_printf(fmtstr, word);
1456 kdbnearsym(word, &symtab);
1458 memset(&symtab, 0, sizeof(symtab));
1459 if (symtab.sym_name) {
1460 kdb_symbol_print(word, &symtab, 0);
1463 kdb_printf(" %s %s "
1466 kdb_machreg_fmt, symtab.mod_name,
1467 symtab.sec_name, symtab.sec_start,
1468 symtab.sym_start, symtab.sym_end);
1470 addr += bytesperword;
1478 cp = wc.c + 8 - bytesperword;
1483 #define printable_char(c) \
1484 ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1485 switch (bytesperword) {
1487 *c++ = printable_char(*cp++);
1488 *c++ = printable_char(*cp++);
1489 *c++ = printable_char(*cp++);
1490 *c++ = printable_char(*cp++);
1493 *c++ = printable_char(*cp++);
1494 *c++ = printable_char(*cp++);
1497 *c++ = printable_char(*cp++);
1500 *c++ = printable_char(*cp++);
1504 #undef printable_char
1507 kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1511 static int kdb_md(int argc, const char **argv)
1513 static unsigned long last_addr;
1514 static int last_radix, last_bytesperword, last_repeat;
1515 int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1517 char fmtchar, fmtstr[64];
1525 kdbgetintenv("MDCOUNT", &mdcount);
1526 kdbgetintenv("RADIX", &radix);
1527 kdbgetintenv("BYTESPERWORD", &bytesperword);
1529 /* Assume 'md <addr>' and start with environment values */
1530 repeat = mdcount * 16 / bytesperword;
1532 if (strcmp(argv[0], "mdr") == 0) {
1534 return KDB_ARGCOUNT;
1536 } else if (isdigit(argv[0][2])) {
1537 bytesperword = (int)(argv[0][2] - '0');
1538 if (bytesperword == 0) {
1539 bytesperword = last_bytesperword;
1540 if (bytesperword == 0)
1543 last_bytesperword = bytesperword;
1544 repeat = mdcount * 16 / bytesperword;
1547 else if (argv[0][3] == 'c' && argv[0][4]) {
1549 repeat = simple_strtoul(argv[0] + 4, &p, 10);
1550 mdcount = ((repeat * bytesperword) + 15) / 16;
1553 last_repeat = repeat;
1554 } else if (strcmp(argv[0], "md") == 0)
1556 else if (strcmp(argv[0], "mds") == 0)
1558 else if (strcmp(argv[0], "mdp") == 0) {
1562 return KDB_NOTFOUND;
1566 return KDB_ARGCOUNT;
1569 bytesperword = last_bytesperword;
1570 repeat = last_repeat;
1571 mdcount = ((repeat * bytesperword) + 15) / 16;
1576 int diag, nextarg = 1;
1577 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1581 if (argc > nextarg+2)
1582 return KDB_ARGCOUNT;
1584 if (argc >= nextarg) {
1585 diag = kdbgetularg(argv[nextarg], &val);
1587 mdcount = (int) val;
1588 repeat = mdcount * 16 / bytesperword;
1591 if (argc >= nextarg+1) {
1592 diag = kdbgetularg(argv[nextarg+1], &val);
1598 if (strcmp(argv[0], "mdr") == 0)
1599 return kdb_mdr(addr, mdcount);
1612 return KDB_BADRADIX;
1617 if (bytesperword > KDB_WORD_SIZE)
1618 return KDB_BADWIDTH;
1620 switch (bytesperword) {
1622 sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1625 sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1628 sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1631 sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1634 return KDB_BADWIDTH;
1637 last_repeat = repeat;
1638 last_bytesperword = bytesperword;
1640 if (strcmp(argv[0], "mds") == 0) {
1642 /* Do not save these changes as last_*, they are temporary mds
1645 bytesperword = KDB_WORD_SIZE;
1647 kdbgetintenv("NOSECT", &nosect);
1650 /* Round address down modulo BYTESPERWORD */
1652 addr &= ~(bytesperword-1);
1654 while (repeat > 0) {
1656 int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1658 if (KDB_FLAG(CMD_INTERRUPT))
1660 for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1662 if (kdb_getphysword(&word, a, bytesperword)
1665 } else if (kdb_getword(&word, a, bytesperword) || word)
1668 n = min(num, repeat);
1669 kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1671 addr += bytesperword * n;
1673 z = (z + num - 1) / num;
1675 int s = num * (z-2);
1676 kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1677 " zero suppressed\n",
1678 addr, addr + bytesperword * s - 1);
1679 addr += bytesperword * s;
1689 * kdb_mm - This function implements the 'mm' command.
1690 * mm address-expression new-value
1692 * mm works on machine words, mmW works on bytes.
1694 static int kdb_mm(int argc, const char **argv)
1699 unsigned long contents;
1703 if (argv[0][2] && !isdigit(argv[0][2]))
1704 return KDB_NOTFOUND;
1707 return KDB_ARGCOUNT;
1710 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1715 return KDB_ARGCOUNT;
1716 diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1720 if (nextarg != argc + 1)
1721 return KDB_ARGCOUNT;
1723 width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1724 diag = kdb_putword(addr, contents, width);
1728 kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1734 * kdb_go - This function implements the 'go' command.
1735 * go [address-expression]
1737 static int kdb_go(int argc, const char **argv)
1744 if (raw_smp_processor_id() != kdb_initial_cpu) {
1745 kdb_printf("go must execute on the entry cpu, "
1746 "please use \"cpu %d\" and then execute go\n",
1748 return KDB_BADCPUNUM;
1752 diag = kdbgetaddrarg(argc, argv, &nextarg,
1753 &addr, &offset, NULL);
1757 return KDB_ARGCOUNT;
1761 if (KDB_FLAG(CATASTROPHIC)) {
1762 kdb_printf("Catastrophic error detected\n");
1763 kdb_printf("kdb_continue_catastrophic=%d, ",
1764 kdb_continue_catastrophic);
1765 if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1766 kdb_printf("type go a second time if you really want "
1770 if (kdb_continue_catastrophic == 2) {
1771 kdb_printf("forcing reboot\n");
1772 kdb_reboot(0, NULL);
1774 kdb_printf("attempting to continue\n");
1780 * kdb_rd - This function implements the 'rd' command.
1782 static int kdb_rd(int argc, const char **argv)
1784 int len = kdb_check_regs();
1785 #if DBG_MAX_REG_NUM > 0
1797 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1798 rsize = dbg_reg_def[i].size * 2;
1801 if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
1806 len += kdb_printf(" ");
1807 switch(dbg_reg_def[i].size * 8) {
1809 rname = dbg_get_reg(i, ®8, kdb_current_regs);
1812 len += kdb_printf("%s: %02x", rname, reg8);
1815 rname = dbg_get_reg(i, ®16, kdb_current_regs);
1818 len += kdb_printf("%s: %04x", rname, reg16);
1821 rname = dbg_get_reg(i, ®32, kdb_current_regs);
1824 len += kdb_printf("%s: %08x", rname, reg32);
1827 rname = dbg_get_reg(i, ®64, kdb_current_regs);
1830 len += kdb_printf("%s: %016llx", rname, reg64);
1833 len += kdb_printf("%s: ??", dbg_reg_def[i].name);
1841 kdb_dumpregs(kdb_current_regs);
1847 * kdb_rm - This function implements the 'rm' (register modify) command.
1848 * rm register-name new-contents
1850 * Allows register modification with the same restrictions as gdb
1852 static int kdb_rm(int argc, const char **argv)
1854 #if DBG_MAX_REG_NUM > 0
1864 return KDB_ARGCOUNT;
1866 * Allow presence or absence of leading '%' symbol.
1872 diag = kdbgetu64arg(argv[2], ®64);
1876 diag = kdb_check_regs();
1881 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1882 if (strcmp(rname, dbg_reg_def[i].name) == 0) {
1888 switch(dbg_reg_def[i].size * 8) {
1891 dbg_set_reg(i, ®8, kdb_current_regs);
1895 dbg_set_reg(i, ®16, kdb_current_regs);
1899 dbg_set_reg(i, ®32, kdb_current_regs);
1902 dbg_set_reg(i, ®64, kdb_current_regs);
1908 kdb_printf("ERROR: Register set currently not implemented\n");
1913 #if defined(CONFIG_MAGIC_SYSRQ)
1915 * kdb_sr - This function implements the 'sr' (SYSRQ key) command
1916 * which interfaces to the soi-disant MAGIC SYSRQ functionality.
1917 * sr <magic-sysrq-code>
1919 static int kdb_sr(int argc, const char **argv)
1922 return KDB_ARGCOUNT;
1924 __handle_sysrq(*argv[1], false);
1929 #endif /* CONFIG_MAGIC_SYSRQ */
1932 * kdb_ef - This function implements the 'regs' (display exception
1933 * frame) command. This command takes an address and expects to
1934 * find an exception frame at that address, formats and prints
1936 * regs address-expression
1940 static int kdb_ef(int argc, const char **argv)
1948 return KDB_ARGCOUNT;
1951 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1954 show_regs((struct pt_regs *)addr);
1958 #if defined(CONFIG_MODULES)
1960 * kdb_lsmod - This function implements the 'lsmod' command. Lists
1961 * currently loaded kernel modules.
1962 * Mostly taken from userland lsmod.
1964 static int kdb_lsmod(int argc, const char **argv)
1969 return KDB_ARGCOUNT;
1971 kdb_printf("Module Size modstruct Used by\n");
1972 list_for_each_entry(mod, kdb_modules, list) {
1973 if (mod->state == MODULE_STATE_UNFORMED)
1976 kdb_printf("%-20s%8u 0x%p ", mod->name,
1977 mod->core_size, (void *)mod);
1978 #ifdef CONFIG_MODULE_UNLOAD
1979 kdb_printf("%4ld ", module_refcount(mod));
1981 if (mod->state == MODULE_STATE_GOING)
1982 kdb_printf(" (Unloading)");
1983 else if (mod->state == MODULE_STATE_COMING)
1984 kdb_printf(" (Loading)");
1986 kdb_printf(" (Live)");
1987 kdb_printf(" 0x%p", mod->module_core);
1989 #ifdef CONFIG_MODULE_UNLOAD
1991 struct module_use *use;
1993 list_for_each_entry(use, &mod->source_list,
1995 kdb_printf("%s ", use->target->name);
2004 #endif /* CONFIG_MODULES */
2007 * kdb_env - This function implements the 'env' command. Display the
2008 * current environment variables.
2011 static int kdb_env(int argc, const char **argv)
2015 for (i = 0; i < __nenv; i++) {
2017 kdb_printf("%s\n", __env[i]);
2020 if (KDB_DEBUG(MASK))
2021 kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
2026 #ifdef CONFIG_PRINTK
2028 * kdb_dmesg - This function implements the 'dmesg' command to display
2029 * the contents of the syslog buffer.
2030 * dmesg [lines] [adjust]
2032 static int kdb_dmesg(int argc, const char **argv)
2040 struct kmsg_dumper dumper = { .active = 1 };
2045 return KDB_ARGCOUNT;
2048 lines = simple_strtol(argv[1], &cp, 0);
2052 adjust = simple_strtoul(argv[2], &cp, 0);
2053 if (*cp || adjust < 0)
2058 /* disable LOGGING if set */
2059 diag = kdbgetintenv("LOGGING", &logging);
2060 if (!diag && logging) {
2061 const char *setargs[] = { "set", "LOGGING", "0" };
2062 kdb_set(2, setargs);
2065 kmsg_dump_rewind_nolock(&dumper);
2066 while (kmsg_dump_get_line_nolock(&dumper, 1, NULL, 0, NULL))
2071 kdb_printf("buffer only contains %d lines, nothing "
2073 else if (adjust - lines >= n)
2074 kdb_printf("buffer only contains %d lines, last %d "
2075 "lines printed\n", n, n - adjust);
2078 } else if (lines > 0) {
2079 skip = n - lines - adjust;
2082 kdb_printf("buffer only contains %d lines, "
2083 "nothing printed\n", n);
2085 } else if (skip < 0) {
2088 kdb_printf("buffer only contains %d lines, first "
2089 "%d lines printed\n", n, lines);
2095 if (skip >= n || skip < 0)
2098 kmsg_dump_rewind_nolock(&dumper);
2099 while (kmsg_dump_get_line_nolock(&dumper, 1, buf, sizeof(buf), &len)) {
2106 if (KDB_FLAG(CMD_INTERRUPT))
2109 kdb_printf("%.*s\n", (int)len - 1, buf);
2114 #endif /* CONFIG_PRINTK */
2116 /* Make sure we balance enable/disable calls, must disable first. */
2117 static atomic_t kdb_nmi_disabled;
2119 static int kdb_disable_nmi(int argc, const char *argv[])
2121 if (atomic_read(&kdb_nmi_disabled))
2123 atomic_set(&kdb_nmi_disabled, 1);
2124 arch_kgdb_ops.enable_nmi(0);
2128 static int kdb_param_enable_nmi(const char *val, const struct kernel_param *kp)
2130 if (!atomic_add_unless(&kdb_nmi_disabled, -1, 0))
2132 arch_kgdb_ops.enable_nmi(1);
2136 static const struct kernel_param_ops kdb_param_ops_enable_nmi = {
2137 .set = kdb_param_enable_nmi,
2139 module_param_cb(enable_nmi, &kdb_param_ops_enable_nmi, NULL, 0600);
2142 * kdb_cpu - This function implements the 'cpu' command.
2145 * KDB_CMD_CPU for success, a kdb diagnostic if error
2147 static void kdb_cpu_status(void)
2149 int i, start_cpu, first_print = 1;
2150 char state, prev_state = '?';
2152 kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2153 kdb_printf("Available cpus: ");
2154 for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2155 if (!cpu_online(i)) {
2156 state = 'F'; /* cpu is offline */
2158 state = ' '; /* cpu is responding to kdb */
2159 if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2160 state = 'I'; /* idle task */
2162 if (state != prev_state) {
2163 if (prev_state != '?') {
2167 kdb_printf("%d", start_cpu);
2168 if (start_cpu < i-1)
2169 kdb_printf("-%d", i-1);
2170 if (prev_state != ' ')
2171 kdb_printf("(%c)", prev_state);
2177 /* print the trailing cpus, ignoring them if they are all offline */
2178 if (prev_state != 'F') {
2181 kdb_printf("%d", start_cpu);
2182 if (start_cpu < i-1)
2183 kdb_printf("-%d", i-1);
2184 if (prev_state != ' ')
2185 kdb_printf("(%c)", prev_state);
2190 static int kdb_cpu(int argc, const char **argv)
2192 unsigned long cpunum;
2201 return KDB_ARGCOUNT;
2203 diag = kdbgetularg(argv[1], &cpunum);
2210 if ((cpunum > NR_CPUS) || !cpu_online(cpunum))
2211 return KDB_BADCPUNUM;
2213 dbg_switch_cpu = cpunum;
2216 * Switch to other cpu
2221 /* The user may not realize that ps/bta with no parameters does not print idle
2222 * or sleeping system daemon processes, so tell them how many were suppressed.
2224 void kdb_ps_suppressed(void)
2226 int idle = 0, daemon = 0;
2227 unsigned long mask_I = kdb_task_state_string("I"),
2228 mask_M = kdb_task_state_string("M");
2230 const struct task_struct *p, *g;
2231 for_each_online_cpu(cpu) {
2232 p = kdb_curr_task(cpu);
2233 if (kdb_task_state(p, mask_I))
2236 kdb_do_each_thread(g, p) {
2237 if (kdb_task_state(p, mask_M))
2239 } kdb_while_each_thread(g, p);
2240 if (idle || daemon) {
2242 kdb_printf("%d idle process%s (state I)%s\n",
2243 idle, idle == 1 ? "" : "es",
2244 daemon ? " and " : "");
2246 kdb_printf("%d sleeping system daemon (state M) "
2247 "process%s", daemon,
2248 daemon == 1 ? "" : "es");
2249 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2254 * kdb_ps - This function implements the 'ps' command which shows a
2255 * list of the active processes.
2256 * ps [DRSTCZEUIMA] All processes, optionally filtered by state
2258 void kdb_ps1(const struct task_struct *p)
2263 if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
2266 cpu = kdb_process_cpu(p);
2267 kdb_printf("0x%p %8d %8d %d %4d %c 0x%p %c%s\n",
2268 (void *)p, p->pid, p->parent->pid,
2269 kdb_task_has_cpu(p), kdb_process_cpu(p),
2270 kdb_task_state_char(p),
2271 (void *)(&p->thread),
2272 p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2274 if (kdb_task_has_cpu(p)) {
2275 if (!KDB_TSK(cpu)) {
2276 kdb_printf(" Error: no saved data for this cpu\n");
2278 if (KDB_TSK(cpu) != p)
2279 kdb_printf(" Error: does not match running "
2280 "process table (0x%p)\n", KDB_TSK(cpu));
2285 static int kdb_ps(int argc, const char **argv)
2287 struct task_struct *g, *p;
2288 unsigned long mask, cpu;
2291 kdb_ps_suppressed();
2292 kdb_printf("%-*s Pid Parent [*] cpu State %-*s Command\n",
2293 (int)(2*sizeof(void *))+2, "Task Addr",
2294 (int)(2*sizeof(void *))+2, "Thread");
2295 mask = kdb_task_state_string(argc ? argv[1] : NULL);
2296 /* Run the active tasks first */
2297 for_each_online_cpu(cpu) {
2298 if (KDB_FLAG(CMD_INTERRUPT))
2300 p = kdb_curr_task(cpu);
2301 if (kdb_task_state(p, mask))
2305 /* Now the real tasks */
2306 kdb_do_each_thread(g, p) {
2307 if (KDB_FLAG(CMD_INTERRUPT))
2309 if (kdb_task_state(p, mask))
2311 } kdb_while_each_thread(g, p);
2317 * kdb_pid - This function implements the 'pid' command which switches
2318 * the currently active process.
2321 static int kdb_pid(int argc, const char **argv)
2323 struct task_struct *p;
2328 return KDB_ARGCOUNT;
2331 if (strcmp(argv[1], "R") == 0) {
2332 p = KDB_TSK(kdb_initial_cpu);
2334 diag = kdbgetularg(argv[1], &val);
2338 p = find_task_by_pid_ns((pid_t)val, &init_pid_ns);
2340 kdb_printf("No task with pid=%d\n", (pid_t)val);
2344 kdb_set_current_task(p);
2346 kdb_printf("KDB current process is %s(pid=%d)\n",
2347 kdb_current_task->comm,
2348 kdb_current_task->pid);
2354 * kdb_ll - This function implements the 'll' command which follows a
2355 * linked list and executes an arbitrary command for each
2358 static int kdb_ll(int argc, const char **argv)
2364 unsigned long linkoffset;
2366 const char *command;
2369 return KDB_ARGCOUNT;
2372 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
2376 diag = kdbgetularg(argv[2], &linkoffset);
2381 * Using the starting address as
2382 * the first element in the list, and assuming that
2383 * the list ends with a null pointer.
2387 command = kdb_strdup(argv[3], GFP_KDB);
2389 kdb_printf("%s: cannot duplicate command\n", __func__);
2392 /* Recursive use of kdb_parse, do not use argv after this point */
2398 if (KDB_FLAG(CMD_INTERRUPT))
2401 sprintf(buf, "%s " kdb_machreg_fmt "\n", command, va);
2402 diag = kdb_parse(buf);
2406 addr = va + linkoffset;
2407 if (kdb_getword(&va, addr, sizeof(va)))
2416 static int kdb_kgdb(int argc, const char **argv)
2418 return KDB_CMD_KGDB;
2422 * kdb_help - This function implements the 'help' and '?' commands.
2424 static int kdb_help(int argc, const char **argv)
2429 kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2430 kdb_printf("-----------------------------"
2431 "-----------------------------\n");
2432 for_each_kdbcmd(kt, i) {
2434 kdb_printf("%-15.15s %-20.20s %s\n", kt->cmd_name,
2435 kt->cmd_usage, kt->cmd_help);
2436 if (KDB_FLAG(CMD_INTERRUPT))
2443 * kdb_kill - This function implements the 'kill' commands.
2445 static int kdb_kill(int argc, const char **argv)
2449 struct task_struct *p;
2450 struct siginfo info;
2453 return KDB_ARGCOUNT;
2455 sig = simple_strtol(argv[1], &endp, 0);
2459 kdb_printf("Invalid signal parameter.<-signal>\n");
2464 pid = simple_strtol(argv[2], &endp, 0);
2468 kdb_printf("Process ID must be large than 0.\n");
2472 /* Find the process. */
2473 p = find_task_by_pid_ns(pid, &init_pid_ns);
2475 kdb_printf("The specified process isn't found.\n");
2478 p = p->group_leader;
2479 info.si_signo = sig;
2481 info.si_code = SI_USER;
2482 info.si_pid = pid; /* same capabilities as process being signalled */
2483 info.si_uid = 0; /* kdb has root authority */
2484 kdb_send_sig_info(p, &info);
2489 int tm_sec; /* seconds */
2490 int tm_min; /* minutes */
2491 int tm_hour; /* hours */
2492 int tm_mday; /* day of the month */
2493 int tm_mon; /* month */
2494 int tm_year; /* year */
2497 static void kdb_gmtime(struct timespec *tv, struct kdb_tm *tm)
2499 /* This will work from 1970-2099, 2100 is not a leap year */
2500 static int mon_day[] = { 31, 29, 31, 30, 31, 30, 31,
2501 31, 30, 31, 30, 31 };
2502 memset(tm, 0, sizeof(*tm));
2503 tm->tm_sec = tv->tv_sec % (24 * 60 * 60);
2504 tm->tm_mday = tv->tv_sec / (24 * 60 * 60) +
2505 (2 * 365 + 1); /* shift base from 1970 to 1968 */
2506 tm->tm_min = tm->tm_sec / 60 % 60;
2507 tm->tm_hour = tm->tm_sec / 60 / 60;
2508 tm->tm_sec = tm->tm_sec % 60;
2509 tm->tm_year = 68 + 4*(tm->tm_mday / (4*365+1));
2510 tm->tm_mday %= (4*365+1);
2512 while (tm->tm_mday >= mon_day[tm->tm_mon]) {
2513 tm->tm_mday -= mon_day[tm->tm_mon];
2514 if (++tm->tm_mon == 12) {
2524 * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2525 * I cannot call that code directly from kdb, it has an unconditional
2526 * cli()/sti() and calls routines that take locks which can stop the debugger.
2528 static void kdb_sysinfo(struct sysinfo *val)
2530 struct timespec uptime;
2531 do_posix_clock_monotonic_gettime(&uptime);
2532 memset(val, 0, sizeof(*val));
2533 val->uptime = uptime.tv_sec;
2534 val->loads[0] = avenrun[0];
2535 val->loads[1] = avenrun[1];
2536 val->loads[2] = avenrun[2];
2537 val->procs = nr_threads-1;
2544 * kdb_summary - This function implements the 'summary' command.
2546 static int kdb_summary(int argc, const char **argv)
2548 struct timespec now;
2553 return KDB_ARGCOUNT;
2555 kdb_printf("sysname %s\n", init_uts_ns.name.sysname);
2556 kdb_printf("release %s\n", init_uts_ns.name.release);
2557 kdb_printf("version %s\n", init_uts_ns.name.version);
2558 kdb_printf("machine %s\n", init_uts_ns.name.machine);
2559 kdb_printf("nodename %s\n", init_uts_ns.name.nodename);
2560 kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2561 kdb_printf("ccversion %s\n", __stringify(CCVERSION));
2563 now = __current_kernel_time();
2564 kdb_gmtime(&now, &tm);
2565 kdb_printf("date %04d-%02d-%02d %02d:%02d:%02d "
2566 "tz_minuteswest %d\n",
2567 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2568 tm.tm_hour, tm.tm_min, tm.tm_sec,
2569 sys_tz.tz_minuteswest);
2572 kdb_printf("uptime ");
2573 if (val.uptime > (24*60*60)) {
2574 int days = val.uptime / (24*60*60);
2575 val.uptime %= (24*60*60);
2576 kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2578 kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2580 /* lifted from fs/proc/proc_misc.c::loadavg_read_proc() */
2582 #define LOAD_INT(x) ((x) >> FSHIFT)
2583 #define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
2584 kdb_printf("load avg %ld.%02ld %ld.%02ld %ld.%02ld\n",
2585 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2586 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2587 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2590 /* Display in kilobytes */
2591 #define K(x) ((x) << (PAGE_SHIFT - 10))
2592 kdb_printf("\nMemTotal: %8lu kB\nMemFree: %8lu kB\n"
2593 "Buffers: %8lu kB\n",
2594 val.totalram, val.freeram, val.bufferram);
2599 * kdb_per_cpu - This function implements the 'per_cpu' command.
2601 static int kdb_per_cpu(int argc, const char **argv)
2604 int cpu, diag, nextarg = 1;
2605 unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2607 if (argc < 1 || argc > 3)
2608 return KDB_ARGCOUNT;
2610 diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2615 diag = kdbgetularg(argv[2], &bytesperword);
2620 bytesperword = KDB_WORD_SIZE;
2621 else if (bytesperword > KDB_WORD_SIZE)
2622 return KDB_BADWIDTH;
2623 sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2625 diag = kdbgetularg(argv[3], &whichcpu);
2628 if (!cpu_online(whichcpu)) {
2629 kdb_printf("cpu %ld is not online\n", whichcpu);
2630 return KDB_BADCPUNUM;
2634 /* Most architectures use __per_cpu_offset[cpu], some use
2635 * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2637 #ifdef __per_cpu_offset
2638 #define KDB_PCU(cpu) __per_cpu_offset(cpu)
2641 #define KDB_PCU(cpu) __per_cpu_offset[cpu]
2643 #define KDB_PCU(cpu) 0
2646 for_each_online_cpu(cpu) {
2647 if (KDB_FLAG(CMD_INTERRUPT))
2650 if (whichcpu != ~0UL && whichcpu != cpu)
2652 addr = symaddr + KDB_PCU(cpu);
2653 diag = kdb_getword(&val, addr, bytesperword);
2655 kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2656 "read, diag=%d\n", cpu, addr, diag);
2659 kdb_printf("%5d ", cpu);
2660 kdb_md_line(fmtstr, addr,
2661 bytesperword == KDB_WORD_SIZE,
2662 1, bytesperword, 1, 1, 0);
2669 * display help for the use of cmd | grep pattern
2671 static int kdb_grep_help(int argc, const char **argv)
2673 kdb_printf("Usage of cmd args | grep pattern:\n");
2674 kdb_printf(" Any command's output may be filtered through an ");
2675 kdb_printf("emulated 'pipe'.\n");
2676 kdb_printf(" 'grep' is just a key word.\n");
2677 kdb_printf(" The pattern may include a very limited set of "
2678 "metacharacters:\n");
2679 kdb_printf(" pattern or ^pattern or pattern$ or ^pattern$\n");
2680 kdb_printf(" And if there are spaces in the pattern, you may "
2682 kdb_printf(" \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2683 " or \"^pat tern$\"\n");
2688 * kdb_register_repeat - This function is used to register a kernel
2692 * func Function to execute the command
2693 * usage A simple usage string showing arguments
2694 * help A simple help string describing command
2695 * repeat Does the command auto repeat on enter?
2697 * zero for success, one if a duplicate command.
2699 #define kdb_command_extend 50 /* arbitrary */
2700 int kdb_register_repeat(char *cmd,
2705 kdb_repeat_t repeat)
2711 * Brute force method to determine duplicates
2713 for_each_kdbcmd(kp, i) {
2714 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2715 kdb_printf("Duplicate kdb command registered: "
2716 "%s, func %p help %s\n", cmd, func, help);
2722 * Insert command into first available location in table
2724 for_each_kdbcmd(kp, i) {
2725 if (kp->cmd_name == NULL)
2729 if (i >= kdb_max_commands) {
2730 kdbtab_t *new = kmalloc((kdb_max_commands - KDB_BASE_CMD_MAX +
2731 kdb_command_extend) * sizeof(*new), GFP_KDB);
2733 kdb_printf("Could not allocate new kdb_command "
2738 memcpy(new, kdb_commands,
2739 (kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new));
2740 kfree(kdb_commands);
2742 memset(new + kdb_max_commands, 0,
2743 kdb_command_extend * sizeof(*new));
2745 kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX;
2746 kdb_max_commands += kdb_command_extend;
2750 kp->cmd_func = func;
2751 kp->cmd_usage = usage;
2752 kp->cmd_help = help;
2754 kp->cmd_minlen = minlen;
2755 kp->cmd_repeat = repeat;
2759 EXPORT_SYMBOL_GPL(kdb_register_repeat);
2763 * kdb_register - Compatibility register function for commands that do
2764 * not need to specify a repeat state. Equivalent to
2765 * kdb_register_repeat with KDB_REPEAT_NONE.
2768 * func Function to execute the command
2769 * usage A simple usage string showing arguments
2770 * help A simple help string describing command
2772 * zero for success, one if a duplicate command.
2774 int kdb_register(char *cmd,
2780 return kdb_register_repeat(cmd, func, usage, help, minlen,
2783 EXPORT_SYMBOL_GPL(kdb_register);
2786 * kdb_unregister - This function is used to unregister a kernel
2787 * debugger command. It is generally called when a module which
2788 * implements kdb commands is unloaded.
2792 * zero for success, one command not registered.
2794 int kdb_unregister(char *cmd)
2802 for_each_kdbcmd(kp, i) {
2803 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2804 kp->cmd_name = NULL;
2809 /* Couldn't find it. */
2812 EXPORT_SYMBOL_GPL(kdb_unregister);
2814 /* Initialize the kdb command table. */
2815 static void __init kdb_inittab(void)
2820 for_each_kdbcmd(kp, i)
2821 kp->cmd_name = NULL;
2823 kdb_register_repeat("md", kdb_md, "<vaddr>",
2824 "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2825 KDB_REPEAT_NO_ARGS);
2826 kdb_register_repeat("mdr", kdb_md, "<vaddr> <bytes>",
2827 "Display Raw Memory", 0, KDB_REPEAT_NO_ARGS);
2828 kdb_register_repeat("mdp", kdb_md, "<paddr> <bytes>",
2829 "Display Physical Memory", 0, KDB_REPEAT_NO_ARGS);
2830 kdb_register_repeat("mds", kdb_md, "<vaddr>",
2831 "Display Memory Symbolically", 0, KDB_REPEAT_NO_ARGS);
2832 kdb_register_repeat("mm", kdb_mm, "<vaddr> <contents>",
2833 "Modify Memory Contents", 0, KDB_REPEAT_NO_ARGS);
2834 kdb_register_repeat("go", kdb_go, "[<vaddr>]",
2835 "Continue Execution", 1, KDB_REPEAT_NONE);
2836 kdb_register_repeat("rd", kdb_rd, "",
2837 "Display Registers", 0, KDB_REPEAT_NONE);
2838 kdb_register_repeat("rm", kdb_rm, "<reg> <contents>",
2839 "Modify Registers", 0, KDB_REPEAT_NONE);
2840 kdb_register_repeat("ef", kdb_ef, "<vaddr>",
2841 "Display exception frame", 0, KDB_REPEAT_NONE);
2842 kdb_register_repeat("bt", kdb_bt, "[<vaddr>]",
2843 "Stack traceback", 1, KDB_REPEAT_NONE);
2844 kdb_register_repeat("btp", kdb_bt, "<pid>",
2845 "Display stack for process <pid>", 0, KDB_REPEAT_NONE);
2846 kdb_register_repeat("bta", kdb_bt, "[DRSTCZEUIMA]",
2847 "Display stack all processes", 0, KDB_REPEAT_NONE);
2848 kdb_register_repeat("btc", kdb_bt, "",
2849 "Backtrace current process on each cpu", 0, KDB_REPEAT_NONE);
2850 kdb_register_repeat("btt", kdb_bt, "<vaddr>",
2851 "Backtrace process given its struct task address", 0,
2853 kdb_register_repeat("ll", kdb_ll, "<first-element> <linkoffset> <cmd>",
2854 "Execute cmd for each element in linked list", 0, KDB_REPEAT_NONE);
2855 kdb_register_repeat("env", kdb_env, "",
2856 "Show environment variables", 0, KDB_REPEAT_NONE);
2857 kdb_register_repeat("set", kdb_set, "",
2858 "Set environment variables", 0, KDB_REPEAT_NONE);
2859 kdb_register_repeat("help", kdb_help, "",
2860 "Display Help Message", 1, KDB_REPEAT_NONE);
2861 kdb_register_repeat("?", kdb_help, "",
2862 "Display Help Message", 0, KDB_REPEAT_NONE);
2863 kdb_register_repeat("cpu", kdb_cpu, "<cpunum>",
2864 "Switch to new cpu", 0, KDB_REPEAT_NONE);
2865 kdb_register_repeat("kgdb", kdb_kgdb, "",
2866 "Enter kgdb mode", 0, KDB_REPEAT_NONE);
2867 kdb_register_repeat("ps", kdb_ps, "[<flags>|A]",
2868 "Display active task list", 0, KDB_REPEAT_NONE);
2869 kdb_register_repeat("pid", kdb_pid, "<pidnum>",
2870 "Switch to another task", 0, KDB_REPEAT_NONE);
2871 kdb_register_repeat("reboot", kdb_reboot, "",
2872 "Reboot the machine immediately", 0, KDB_REPEAT_NONE);
2873 #if defined(CONFIG_MODULES)
2874 kdb_register_repeat("lsmod", kdb_lsmod, "",
2875 "List loaded kernel modules", 0, KDB_REPEAT_NONE);
2877 #if defined(CONFIG_MAGIC_SYSRQ)
2878 kdb_register_repeat("sr", kdb_sr, "<key>",
2879 "Magic SysRq key", 0, KDB_REPEAT_NONE);
2881 #if defined(CONFIG_PRINTK)
2882 kdb_register_repeat("dmesg", kdb_dmesg, "[lines]",
2883 "Display syslog buffer", 0, KDB_REPEAT_NONE);
2885 if (arch_kgdb_ops.enable_nmi) {
2886 kdb_register_repeat("disable_nmi", kdb_disable_nmi, "",
2887 "Disable NMI entry to KDB", 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 */