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 = ARRAY_SIZE(kdbmsgs);
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 = ARRAY_SIZE(__env);
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),
688 memcpy(defcmd_set, save_defcmd_set,
689 defcmd_set_count * sizeof(*defcmd_set));
690 s = defcmd_set + defcmd_set_count;
691 memset(s, 0, sizeof(*s));
693 s->name = kdb_strdup(argv[1], GFP_KDB);
696 s->usage = kdb_strdup(argv[2], GFP_KDB);
699 s->help = kdb_strdup(argv[3], GFP_KDB);
702 if (s->usage[0] == '"') {
703 strcpy(s->usage, argv[2]+1);
704 s->usage[strlen(s->usage)-1] = '\0';
706 if (s->help[0] == '"') {
707 strcpy(s->help, argv[3]+1);
708 s->help[strlen(s->help)-1] = '\0';
711 defcmd_in_progress = 1;
712 kfree(save_defcmd_set);
721 kdb_printf("Could not allocate new defcmd_set entry for %s\n", argv[1]);
722 defcmd_set = save_defcmd_set;
727 * kdb_exec_defcmd - Execute the set of commands associated with this
730 * argc argument count
731 * argv argument vector
733 * zero for success, a kdb diagnostic if error
735 static int kdb_exec_defcmd(int argc, const char **argv)
738 struct defcmd_set *s;
741 for (s = defcmd_set, i = 0; i < defcmd_set_count; ++i, ++s) {
742 if (strcmp(s->name, argv[0]) == 0)
745 if (i == defcmd_set_count) {
746 kdb_printf("kdb_exec_defcmd: could not find commands for %s\n",
750 for (i = 0; i < s->count; ++i) {
751 /* Recursive use of kdb_parse, do not use argv after
754 kdb_printf("[%s]kdb> %s\n", s->name, s->command[i]);
755 ret = kdb_parse(s->command[i]);
762 /* Command history */
763 #define KDB_CMD_HISTORY_COUNT 32
764 #define CMD_BUFLEN 200 /* kdb_printf: max printline
766 static unsigned int cmd_head, cmd_tail;
767 static unsigned int cmdptr;
768 static char cmd_hist[KDB_CMD_HISTORY_COUNT][CMD_BUFLEN];
769 static char cmd_cur[CMD_BUFLEN];
772 * The "str" argument may point to something like | grep xyz
774 static void parse_grep(const char *str)
777 char *cp = (char *)str, *cp2;
779 /* sanity check: we should have been called with the \ first */
785 if (strncmp(cp, "grep ", 5)) {
786 kdb_printf("invalid 'pipe', see grephelp\n");
792 cp2 = strchr(cp, '\n');
794 *cp2 = '\0'; /* remove the trailing newline */
797 kdb_printf("invalid 'pipe', see grephelp\n");
800 /* now cp points to a nonzero length search string */
802 /* allow it be "x y z" by removing the "'s - there must
805 cp2 = strchr(cp, '"');
807 kdb_printf("invalid quoted string, see grephelp\n");
810 *cp2 = '\0'; /* end the string where the 2nd " was */
812 kdb_grep_leading = 0;
814 kdb_grep_leading = 1;
818 kdb_grep_trailing = 0;
819 if (*(cp+len-1) == '$') {
820 kdb_grep_trailing = 1;
826 if (len >= GREP_LEN) {
827 kdb_printf("search string too long\n");
830 strcpy(kdb_grep_string, cp);
836 * kdb_parse - Parse the command line, search the command table for a
837 * matching command and invoke the command function. This
838 * function may be called recursively, if it is, the second call
839 * will overwrite argv and cbuf. It is the caller's
840 * responsibility to save their argv if they recursively call
843 * cmdstr The input command line to be parsed.
844 * regs The registers at the time kdb was entered.
846 * Zero for success, a kdb diagnostic if failure.
848 * Limited to 20 tokens.
850 * Real rudimentary tokenization. Basically only whitespace
851 * is considered a token delimeter (but special consideration
852 * is taken of the '=' sign as used by the 'set' command).
854 * The algorithm used to tokenize the input string relies on
855 * there being at least one whitespace (or otherwise useless)
856 * character between tokens as the character immediately following
857 * the token is altered in-place to a null-byte to terminate the
863 int kdb_parse(const char *cmdstr)
865 static char *argv[MAXARGC];
867 static char cbuf[CMD_BUFLEN+2];
871 int i, escaped, ignore_errors = 0, check_grep;
874 * First tokenize the command string.
877 kdb_grepping_flag = check_grep = 0;
879 if (KDB_FLAG(CMD_INTERRUPT)) {
880 /* Previous command was interrupted, newline must not
881 * repeat the command */
882 KDB_FLAG_CLEAR(CMD_INTERRUPT);
883 KDB_STATE_SET(PAGER);
884 argc = 0; /* no repeat */
887 if (*cp != '\n' && *cp != '\0') {
891 /* skip whitespace */
894 if ((*cp == '\0') || (*cp == '\n') ||
895 (*cp == '#' && !defcmd_in_progress))
897 /* special case: check for | grep pattern */
902 if (cpp >= cbuf + CMD_BUFLEN) {
903 kdb_printf("kdb_parse: command buffer "
904 "overflow, command ignored\n%s\n",
908 if (argc >= MAXARGC - 1) {
909 kdb_printf("kdb_parse: too many arguments, "
910 "command ignored\n%s\n", cmdstr);
916 /* Copy to next unquoted and unescaped
917 * whitespace or '=' */
918 while (*cp && *cp != '\n' &&
919 (escaped || quoted || !isspace(*cp))) {
920 if (cpp >= cbuf + CMD_BUFLEN)
934 else if (*cp == '\'' || *cp == '"')
937 if (*cpp == '=' && !quoted)
941 *cpp++ = '\0'; /* Squash a ws or '=' character */
948 if (defcmd_in_progress) {
949 int result = kdb_defcmd2(cmdstr, argv[0]);
950 if (!defcmd_in_progress) {
951 argc = 0; /* avoid repeat on endefcmd */
956 if (argv[0][0] == '-' && argv[0][1] &&
957 (argv[0][1] < '0' || argv[0][1] > '9')) {
962 for_each_kdbcmd(tp, i) {
965 * If this command is allowed to be abbreviated,
966 * check to see if this is it.
970 && (strlen(argv[0]) <= tp->cmd_minlen)) {
973 tp->cmd_minlen) == 0) {
978 if (strcmp(argv[0], tp->cmd_name) == 0)
984 * If we don't find a command by this name, see if the first
985 * few characters of this match any of the known commands.
986 * e.g., md1c20 should match md.
988 if (i == kdb_max_commands) {
989 for_each_kdbcmd(tp, i) {
993 strlen(tp->cmd_name)) == 0) {
1000 if (i < kdb_max_commands) {
1003 result = (*tp->cmd_func)(argc-1, (const char **)argv);
1004 if (result && ignore_errors && result > KDB_CMD_GO)
1006 KDB_STATE_CLEAR(CMD);
1007 switch (tp->cmd_repeat) {
1008 case KDB_REPEAT_NONE:
1013 case KDB_REPEAT_NO_ARGS:
1018 case KDB_REPEAT_WITH_ARGS:
1025 * If the input with which we were presented does not
1026 * map to an existing command, attempt to parse it as an
1027 * address argument and display the result. Useful for
1028 * obtaining the address of a variable, or the nearest symbol
1029 * to an address contained in a register.
1032 unsigned long value;
1037 if (kdbgetaddrarg(0, (const char **)argv, &nextarg,
1038 &value, &offset, &name)) {
1039 return KDB_NOTFOUND;
1042 kdb_printf("%s = ", argv[0]);
1043 kdb_symbol_print(value, NULL, KDB_SP_DEFAULT);
1050 static int handle_ctrl_cmd(char *cmd)
1055 /* initial situation */
1056 if (cmd_head == cmd_tail)
1060 if (cmdptr != cmd_tail)
1061 cmdptr = (cmdptr-1) % KDB_CMD_HISTORY_COUNT;
1062 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1065 if (cmdptr != cmd_head)
1066 cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT;
1067 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1074 * kdb_reboot - This function implements the 'reboot' command. Reboot
1075 * the system immediately, or loop for ever on failure.
1077 static int kdb_reboot(int argc, const char **argv)
1079 emergency_restart();
1080 kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
1087 static void kdb_dumpregs(struct pt_regs *regs)
1089 int old_lvl = console_loglevel;
1090 console_loglevel = 15;
1095 console_loglevel = old_lvl;
1098 void kdb_set_current_task(struct task_struct *p)
1100 kdb_current_task = p;
1102 if (kdb_task_has_cpu(p)) {
1103 kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p));
1106 kdb_current_regs = NULL;
1110 * kdb_local - The main code for kdb. This routine is invoked on a
1111 * specific processor, it is not global. The main kdb() routine
1112 * ensures that only one processor at a time is in this routine.
1113 * This code is called with the real reason code on the first
1114 * entry to a kdb session, thereafter it is called with reason
1115 * SWITCH, even if the user goes back to the original cpu.
1117 * reason The reason KDB was invoked
1118 * error The hardware-defined error code
1119 * regs The exception frame at time of fault/breakpoint.
1120 * db_result Result code from the break or debug point.
1122 * 0 KDB was invoked for an event which it wasn't responsible
1123 * 1 KDB handled the event for which it was invoked.
1124 * KDB_CMD_GO User typed 'go'.
1125 * KDB_CMD_CPU User switched to another cpu.
1126 * KDB_CMD_SS Single step.
1127 * KDB_CMD_SSB Single step until branch.
1129 static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs,
1130 kdb_dbtrap_t db_result)
1134 struct task_struct *kdb_current =
1135 kdb_curr_task(raw_smp_processor_id());
1137 KDB_DEBUG_STATE("kdb_local 1", reason);
1139 if (reason == KDB_REASON_DEBUG) {
1140 /* special case below */
1142 kdb_printf("\nEntering kdb (current=0x%p, pid %d) ",
1143 kdb_current, kdb_current ? kdb_current->pid : 0);
1144 #if defined(CONFIG_SMP)
1145 kdb_printf("on processor %d ", raw_smp_processor_id());
1150 case KDB_REASON_DEBUG:
1153 * If re-entering kdb after a single step
1154 * command, don't print the message.
1156 switch (db_result) {
1158 kdb_printf("\nEntering kdb (0x%p, pid %d) ",
1159 kdb_current, kdb_current->pid);
1160 #if defined(CONFIG_SMP)
1161 kdb_printf("on processor %d ", raw_smp_processor_id());
1163 kdb_printf("due to Debug @ " kdb_machreg_fmt "\n",
1164 instruction_pointer(regs));
1168 * In the midst of ssb command. Just return.
1170 KDB_DEBUG_STATE("kdb_local 3", reason);
1171 return KDB_CMD_SSB; /* Continue with SSB command */
1177 KDB_DEBUG_STATE("kdb_local 4", reason);
1178 return 1; /* kdba_db_trap did the work */
1180 kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
1187 case KDB_REASON_ENTER:
1188 if (KDB_STATE(KEYBOARD))
1189 kdb_printf("due to Keyboard Entry\n");
1191 kdb_printf("due to KDB_ENTER()\n");
1193 case KDB_REASON_KEYBOARD:
1194 KDB_STATE_SET(KEYBOARD);
1195 kdb_printf("due to Keyboard Entry\n");
1197 case KDB_REASON_ENTER_SLAVE:
1198 /* drop through, slaves only get released via cpu switch */
1199 case KDB_REASON_SWITCH:
1200 kdb_printf("due to cpu switch\n");
1202 case KDB_REASON_OOPS:
1203 kdb_printf("Oops: %s\n", kdb_diemsg);
1204 kdb_printf("due to oops @ " kdb_machreg_fmt "\n",
1205 instruction_pointer(regs));
1208 case KDB_REASON_NMI:
1209 kdb_printf("due to NonMaskable Interrupt @ "
1210 kdb_machreg_fmt "\n",
1211 instruction_pointer(regs));
1214 case KDB_REASON_SSTEP:
1215 case KDB_REASON_BREAK:
1216 kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
1217 reason == KDB_REASON_BREAK ?
1218 "Breakpoint" : "SS trap", instruction_pointer(regs));
1220 * Determine if this breakpoint is one that we
1221 * are interested in.
1223 if (db_result != KDB_DB_BPT) {
1224 kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1226 KDB_DEBUG_STATE("kdb_local 6", reason);
1227 return 0; /* Not for us, dismiss it */
1230 case KDB_REASON_RECURSE:
1231 kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
1232 instruction_pointer(regs));
1235 kdb_printf("kdb: unexpected reason code: %d\n", reason);
1236 KDB_DEBUG_STATE("kdb_local 8", reason);
1237 return 0; /* Not for us, dismiss it */
1242 * Initialize pager context.
1245 KDB_STATE_CLEAR(SUPPRESS);
1249 *(cmd_hist[cmd_head]) = '\0';
1252 #if defined(CONFIG_SMP)
1253 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
1254 raw_smp_processor_id());
1256 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"));
1258 if (defcmd_in_progress)
1259 strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
1262 * Fetch command from keyboard
1264 cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
1265 if (*cmdbuf != '\n') {
1267 if (cmdptr == cmd_head) {
1268 strncpy(cmd_hist[cmd_head], cmd_cur,
1270 *(cmd_hist[cmd_head] +
1271 strlen(cmd_hist[cmd_head])-1) = '\0';
1273 if (!handle_ctrl_cmd(cmdbuf))
1274 *(cmd_cur+strlen(cmd_cur)-1) = '\0';
1276 goto do_full_getstr;
1278 strncpy(cmd_hist[cmd_head], cmd_cur,
1282 cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
1283 if (cmd_head == cmd_tail)
1284 cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
1288 diag = kdb_parse(cmdbuf);
1289 if (diag == KDB_NOTFOUND) {
1290 kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
1293 if (diag == KDB_CMD_GO
1294 || diag == KDB_CMD_CPU
1295 || diag == KDB_CMD_SS
1296 || diag == KDB_CMD_SSB
1297 || diag == KDB_CMD_KGDB)
1303 KDB_DEBUG_STATE("kdb_local 9", diag);
1309 * kdb_print_state - Print the state data for the current processor
1312 * text Identifies the debug point
1313 * value Any integer value to be printed, e.g. reason code.
1315 void kdb_print_state(const char *text, int value)
1317 kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1318 text, raw_smp_processor_id(), value, kdb_initial_cpu,
1323 * kdb_main_loop - After initial setup and assignment of the
1324 * controlling cpu, all cpus are in this loop. One cpu is in
1325 * control and will issue the kdb prompt, the others will spin
1326 * until 'go' or cpu switch.
1328 * To get a consistent view of the kernel stacks for all
1329 * processes, this routine is invoked from the main kdb code via
1330 * an architecture specific routine. kdba_main_loop is
1331 * responsible for making the kernel stacks consistent for all
1332 * processes, there should be no difference between a blocked
1333 * process and a running process as far as kdb is concerned.
1335 * reason The reason KDB was invoked
1336 * error The hardware-defined error code
1337 * reason2 kdb's current reason code.
1338 * Initially error but can change
1339 * according to kdb state.
1340 * db_result Result code from break or debug point.
1341 * regs The exception frame at time of fault/breakpoint.
1342 * should always be valid.
1344 * 0 KDB was invoked for an event which it wasn't responsible
1345 * 1 KDB handled the event for which it was invoked.
1347 int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
1348 kdb_dbtrap_t db_result, struct pt_regs *regs)
1351 /* Stay in kdb() until 'go', 'ss[b]' or an error */
1354 * All processors except the one that is in control
1357 KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1358 while (KDB_STATE(HOLD_CPU)) {
1359 /* state KDB is turned off by kdb_cpu to see if the
1360 * other cpus are still live, each cpu in this loop
1363 if (!KDB_STATE(KDB))
1367 KDB_STATE_CLEAR(SUPPRESS);
1368 KDB_DEBUG_STATE("kdb_main_loop 2", reason);
1369 if (KDB_STATE(LEAVING))
1370 break; /* Another cpu said 'go' */
1371 /* Still using kdb, this processor is in control */
1372 result = kdb_local(reason2, error, regs, db_result);
1373 KDB_DEBUG_STATE("kdb_main_loop 3", result);
1375 if (result == KDB_CMD_CPU)
1378 if (result == KDB_CMD_SS) {
1379 KDB_STATE_SET(DOING_SS);
1383 if (result == KDB_CMD_SSB) {
1384 KDB_STATE_SET(DOING_SS);
1385 KDB_STATE_SET(DOING_SSB);
1389 if (result == KDB_CMD_KGDB) {
1390 if (!KDB_STATE(DOING_KGDB))
1391 kdb_printf("Entering please attach debugger "
1392 "or use $D#44+ or $3#33\n");
1395 if (result && result != 1 && result != KDB_CMD_GO)
1396 kdb_printf("\nUnexpected kdb_local return code %d\n",
1398 KDB_DEBUG_STATE("kdb_main_loop 4", reason);
1401 if (KDB_STATE(DOING_SS))
1402 KDB_STATE_CLEAR(SSBPT);
1404 /* Clean up any keyboard devices before leaving */
1405 kdb_kbd_cleanup_state();
1411 * kdb_mdr - This function implements the guts of the 'mdr', memory
1413 * mdr <addr arg>,<byte count>
1415 * addr Start address
1416 * count Number of bytes
1418 * Always 0. Any errors are detected and printed by kdb_getarea.
1420 static int kdb_mdr(unsigned long addr, unsigned int count)
1424 if (kdb_getarea(c, addr))
1426 kdb_printf("%02x", c);
1434 * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1435 * 'md8' 'mdr' and 'mds' commands.
1437 * md|mds [<addr arg> [<line count> [<radix>]]]
1438 * mdWcN [<addr arg> [<line count> [<radix>]]]
1439 * where W = is the width (1, 2, 4 or 8) and N is the count.
1440 * for eg., md1c20 reads 20 bytes, 1 at a time.
1441 * mdr <addr arg>,<byte count>
1443 static void kdb_md_line(const char *fmtstr, unsigned long addr,
1444 int symbolic, int nosect, int bytesperword,
1445 int num, int repeat, int phys)
1447 /* print just one line of data */
1448 kdb_symtab_t symtab;
1454 memset(cbuf, '\0', sizeof(cbuf));
1456 kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1458 kdb_printf(kdb_machreg_fmt0 " ", addr);
1460 for (i = 0; i < num && repeat--; i++) {
1462 if (kdb_getphysword(&word, addr, bytesperword))
1464 } else if (kdb_getword(&word, addr, bytesperword))
1466 kdb_printf(fmtstr, word);
1468 kdbnearsym(word, &symtab);
1470 memset(&symtab, 0, sizeof(symtab));
1471 if (symtab.sym_name) {
1472 kdb_symbol_print(word, &symtab, 0);
1475 kdb_printf(" %s %s "
1478 kdb_machreg_fmt, symtab.mod_name,
1479 symtab.sec_name, symtab.sec_start,
1480 symtab.sym_start, symtab.sym_end);
1482 addr += bytesperword;
1490 cp = wc.c + 8 - bytesperword;
1495 #define printable_char(c) \
1496 ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1497 switch (bytesperword) {
1499 *c++ = printable_char(*cp++);
1500 *c++ = printable_char(*cp++);
1501 *c++ = printable_char(*cp++);
1502 *c++ = printable_char(*cp++);
1505 *c++ = printable_char(*cp++);
1506 *c++ = printable_char(*cp++);
1509 *c++ = printable_char(*cp++);
1512 *c++ = printable_char(*cp++);
1516 #undef printable_char
1519 kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1523 static int kdb_md(int argc, const char **argv)
1525 static unsigned long last_addr;
1526 static int last_radix, last_bytesperword, last_repeat;
1527 int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1529 char fmtchar, fmtstr[64];
1537 kdbgetintenv("MDCOUNT", &mdcount);
1538 kdbgetintenv("RADIX", &radix);
1539 kdbgetintenv("BYTESPERWORD", &bytesperword);
1541 /* Assume 'md <addr>' and start with environment values */
1542 repeat = mdcount * 16 / bytesperword;
1544 if (strcmp(argv[0], "mdr") == 0) {
1546 return KDB_ARGCOUNT;
1548 } else if (isdigit(argv[0][2])) {
1549 bytesperword = (int)(argv[0][2] - '0');
1550 if (bytesperword == 0) {
1551 bytesperword = last_bytesperword;
1552 if (bytesperword == 0)
1555 last_bytesperword = bytesperword;
1556 repeat = mdcount * 16 / bytesperword;
1559 else if (argv[0][3] == 'c' && argv[0][4]) {
1561 repeat = simple_strtoul(argv[0] + 4, &p, 10);
1562 mdcount = ((repeat * bytesperword) + 15) / 16;
1565 last_repeat = repeat;
1566 } else if (strcmp(argv[0], "md") == 0)
1568 else if (strcmp(argv[0], "mds") == 0)
1570 else if (strcmp(argv[0], "mdp") == 0) {
1574 return KDB_NOTFOUND;
1578 return KDB_ARGCOUNT;
1581 bytesperword = last_bytesperword;
1582 repeat = last_repeat;
1583 mdcount = ((repeat * bytesperword) + 15) / 16;
1588 int diag, nextarg = 1;
1589 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1593 if (argc > nextarg+2)
1594 return KDB_ARGCOUNT;
1596 if (argc >= nextarg) {
1597 diag = kdbgetularg(argv[nextarg], &val);
1599 mdcount = (int) val;
1600 repeat = mdcount * 16 / bytesperword;
1603 if (argc >= nextarg+1) {
1604 diag = kdbgetularg(argv[nextarg+1], &val);
1610 if (strcmp(argv[0], "mdr") == 0)
1611 return kdb_mdr(addr, mdcount);
1624 return KDB_BADRADIX;
1629 if (bytesperword > KDB_WORD_SIZE)
1630 return KDB_BADWIDTH;
1632 switch (bytesperword) {
1634 sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1637 sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1640 sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1643 sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1646 return KDB_BADWIDTH;
1649 last_repeat = repeat;
1650 last_bytesperword = bytesperword;
1652 if (strcmp(argv[0], "mds") == 0) {
1654 /* Do not save these changes as last_*, they are temporary mds
1657 bytesperword = KDB_WORD_SIZE;
1659 kdbgetintenv("NOSECT", &nosect);
1662 /* Round address down modulo BYTESPERWORD */
1664 addr &= ~(bytesperword-1);
1666 while (repeat > 0) {
1668 int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1670 if (KDB_FLAG(CMD_INTERRUPT))
1672 for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1674 if (kdb_getphysword(&word, a, bytesperword)
1677 } else if (kdb_getword(&word, a, bytesperword) || word)
1680 n = min(num, repeat);
1681 kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1683 addr += bytesperword * n;
1685 z = (z + num - 1) / num;
1687 int s = num * (z-2);
1688 kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1689 " zero suppressed\n",
1690 addr, addr + bytesperword * s - 1);
1691 addr += bytesperword * s;
1701 * kdb_mm - This function implements the 'mm' command.
1702 * mm address-expression new-value
1704 * mm works on machine words, mmW works on bytes.
1706 static int kdb_mm(int argc, const char **argv)
1711 unsigned long contents;
1715 if (argv[0][2] && !isdigit(argv[0][2]))
1716 return KDB_NOTFOUND;
1719 return KDB_ARGCOUNT;
1722 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1727 return KDB_ARGCOUNT;
1728 diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1732 if (nextarg != argc + 1)
1733 return KDB_ARGCOUNT;
1735 width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1736 diag = kdb_putword(addr, contents, width);
1740 kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1746 * kdb_go - This function implements the 'go' command.
1747 * go [address-expression]
1749 static int kdb_go(int argc, const char **argv)
1756 if (raw_smp_processor_id() != kdb_initial_cpu) {
1757 kdb_printf("go must execute on the entry cpu, "
1758 "please use \"cpu %d\" and then execute go\n",
1760 return KDB_BADCPUNUM;
1764 diag = kdbgetaddrarg(argc, argv, &nextarg,
1765 &addr, &offset, NULL);
1769 return KDB_ARGCOUNT;
1773 if (KDB_FLAG(CATASTROPHIC)) {
1774 kdb_printf("Catastrophic error detected\n");
1775 kdb_printf("kdb_continue_catastrophic=%d, ",
1776 kdb_continue_catastrophic);
1777 if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1778 kdb_printf("type go a second time if you really want "
1782 if (kdb_continue_catastrophic == 2) {
1783 kdb_printf("forcing reboot\n");
1784 kdb_reboot(0, NULL);
1786 kdb_printf("attempting to continue\n");
1792 * kdb_rd - This function implements the 'rd' command.
1794 static int kdb_rd(int argc, const char **argv)
1796 int len = kdb_check_regs();
1797 #if DBG_MAX_REG_NUM > 0
1809 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1810 rsize = dbg_reg_def[i].size * 2;
1813 if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
1818 len += kdb_printf(" ");
1819 switch(dbg_reg_def[i].size * 8) {
1821 rname = dbg_get_reg(i, ®8, kdb_current_regs);
1824 len += kdb_printf("%s: %02x", rname, reg8);
1827 rname = dbg_get_reg(i, ®16, kdb_current_regs);
1830 len += kdb_printf("%s: %04x", rname, reg16);
1833 rname = dbg_get_reg(i, ®32, kdb_current_regs);
1836 len += kdb_printf("%s: %08x", rname, reg32);
1839 rname = dbg_get_reg(i, ®64, kdb_current_regs);
1842 len += kdb_printf("%s: %016llx", rname, reg64);
1845 len += kdb_printf("%s: ??", dbg_reg_def[i].name);
1853 kdb_dumpregs(kdb_current_regs);
1859 * kdb_rm - This function implements the 'rm' (register modify) command.
1860 * rm register-name new-contents
1862 * Allows register modification with the same restrictions as gdb
1864 static int kdb_rm(int argc, const char **argv)
1866 #if DBG_MAX_REG_NUM > 0
1876 return KDB_ARGCOUNT;
1878 * Allow presence or absence of leading '%' symbol.
1884 diag = kdbgetu64arg(argv[2], ®64);
1888 diag = kdb_check_regs();
1893 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1894 if (strcmp(rname, dbg_reg_def[i].name) == 0) {
1900 switch(dbg_reg_def[i].size * 8) {
1903 dbg_set_reg(i, ®8, kdb_current_regs);
1907 dbg_set_reg(i, ®16, kdb_current_regs);
1911 dbg_set_reg(i, ®32, kdb_current_regs);
1914 dbg_set_reg(i, ®64, kdb_current_regs);
1920 kdb_printf("ERROR: Register set currently not implemented\n");
1925 #if defined(CONFIG_MAGIC_SYSRQ)
1927 * kdb_sr - This function implements the 'sr' (SYSRQ key) command
1928 * which interfaces to the soi-disant MAGIC SYSRQ functionality.
1929 * sr <magic-sysrq-code>
1931 static int kdb_sr(int argc, const char **argv)
1934 return KDB_ARGCOUNT;
1936 __handle_sysrq(*argv[1], false);
1941 #endif /* CONFIG_MAGIC_SYSRQ */
1944 * kdb_ef - This function implements the 'regs' (display exception
1945 * frame) command. This command takes an address and expects to
1946 * find an exception frame at that address, formats and prints
1948 * regs address-expression
1952 static int kdb_ef(int argc, const char **argv)
1960 return KDB_ARGCOUNT;
1963 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1966 show_regs((struct pt_regs *)addr);
1970 #if defined(CONFIG_MODULES)
1972 * kdb_lsmod - This function implements the 'lsmod' command. Lists
1973 * currently loaded kernel modules.
1974 * Mostly taken from userland lsmod.
1976 static int kdb_lsmod(int argc, const char **argv)
1981 return KDB_ARGCOUNT;
1983 kdb_printf("Module Size modstruct Used by\n");
1984 list_for_each_entry(mod, kdb_modules, list) {
1985 if (mod->state == MODULE_STATE_UNFORMED)
1988 kdb_printf("%-20s%8u 0x%p ", mod->name,
1989 mod->core_size, (void *)mod);
1990 #ifdef CONFIG_MODULE_UNLOAD
1991 kdb_printf("%4ld ", module_refcount(mod));
1993 if (mod->state == MODULE_STATE_GOING)
1994 kdb_printf(" (Unloading)");
1995 else if (mod->state == MODULE_STATE_COMING)
1996 kdb_printf(" (Loading)");
1998 kdb_printf(" (Live)");
1999 kdb_printf(" 0x%p", mod->module_core);
2001 #ifdef CONFIG_MODULE_UNLOAD
2003 struct module_use *use;
2005 list_for_each_entry(use, &mod->source_list,
2007 kdb_printf("%s ", use->target->name);
2016 #endif /* CONFIG_MODULES */
2019 * kdb_env - This function implements the 'env' command. Display the
2020 * current environment variables.
2023 static int kdb_env(int argc, const char **argv)
2027 for (i = 0; i < __nenv; i++) {
2029 kdb_printf("%s\n", __env[i]);
2032 if (KDB_DEBUG(MASK))
2033 kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
2038 #ifdef CONFIG_PRINTK
2040 * kdb_dmesg - This function implements the 'dmesg' command to display
2041 * the contents of the syslog buffer.
2042 * dmesg [lines] [adjust]
2044 static int kdb_dmesg(int argc, const char **argv)
2052 struct kmsg_dumper dumper = { .active = 1 };
2057 return KDB_ARGCOUNT;
2060 lines = simple_strtol(argv[1], &cp, 0);
2064 adjust = simple_strtoul(argv[2], &cp, 0);
2065 if (*cp || adjust < 0)
2070 /* disable LOGGING if set */
2071 diag = kdbgetintenv("LOGGING", &logging);
2072 if (!diag && logging) {
2073 const char *setargs[] = { "set", "LOGGING", "0" };
2074 kdb_set(2, setargs);
2077 kmsg_dump_rewind_nolock(&dumper);
2078 while (kmsg_dump_get_line_nolock(&dumper, 1, NULL, 0, NULL))
2083 kdb_printf("buffer only contains %d lines, nothing "
2085 else if (adjust - lines >= n)
2086 kdb_printf("buffer only contains %d lines, last %d "
2087 "lines printed\n", n, n - adjust);
2090 } else if (lines > 0) {
2091 skip = n - lines - adjust;
2094 kdb_printf("buffer only contains %d lines, "
2095 "nothing printed\n", n);
2097 } else if (skip < 0) {
2100 kdb_printf("buffer only contains %d lines, first "
2101 "%d lines printed\n", n, lines);
2107 if (skip >= n || skip < 0)
2110 kmsg_dump_rewind_nolock(&dumper);
2111 while (kmsg_dump_get_line_nolock(&dumper, 1, buf, sizeof(buf), &len)) {
2118 if (KDB_FLAG(CMD_INTERRUPT))
2121 kdb_printf("%.*s\n", (int)len - 1, buf);
2126 #endif /* CONFIG_PRINTK */
2128 /* Make sure we balance enable/disable calls, must disable first. */
2129 static atomic_t kdb_nmi_disabled;
2131 static int kdb_disable_nmi(int argc, const char *argv[])
2133 if (atomic_read(&kdb_nmi_disabled))
2135 atomic_set(&kdb_nmi_disabled, 1);
2136 arch_kgdb_ops.enable_nmi(0);
2140 static int kdb_param_enable_nmi(const char *val, const struct kernel_param *kp)
2142 if (!atomic_add_unless(&kdb_nmi_disabled, -1, 0))
2144 arch_kgdb_ops.enable_nmi(1);
2148 static const struct kernel_param_ops kdb_param_ops_enable_nmi = {
2149 .set = kdb_param_enable_nmi,
2151 module_param_cb(enable_nmi, &kdb_param_ops_enable_nmi, NULL, 0600);
2154 * kdb_cpu - This function implements the 'cpu' command.
2157 * KDB_CMD_CPU for success, a kdb diagnostic if error
2159 static void kdb_cpu_status(void)
2161 int i, start_cpu, first_print = 1;
2162 char state, prev_state = '?';
2164 kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2165 kdb_printf("Available cpus: ");
2166 for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2167 if (!cpu_online(i)) {
2168 state = 'F'; /* cpu is offline */
2170 state = ' '; /* cpu is responding to kdb */
2171 if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2172 state = 'I'; /* idle task */
2174 if (state != prev_state) {
2175 if (prev_state != '?') {
2179 kdb_printf("%d", start_cpu);
2180 if (start_cpu < i-1)
2181 kdb_printf("-%d", i-1);
2182 if (prev_state != ' ')
2183 kdb_printf("(%c)", prev_state);
2189 /* print the trailing cpus, ignoring them if they are all offline */
2190 if (prev_state != 'F') {
2193 kdb_printf("%d", start_cpu);
2194 if (start_cpu < i-1)
2195 kdb_printf("-%d", i-1);
2196 if (prev_state != ' ')
2197 kdb_printf("(%c)", prev_state);
2202 static int kdb_cpu(int argc, const char **argv)
2204 unsigned long cpunum;
2213 return KDB_ARGCOUNT;
2215 diag = kdbgetularg(argv[1], &cpunum);
2222 if ((cpunum > NR_CPUS) || !cpu_online(cpunum))
2223 return KDB_BADCPUNUM;
2225 dbg_switch_cpu = cpunum;
2228 * Switch to other cpu
2233 /* The user may not realize that ps/bta with no parameters does not print idle
2234 * or sleeping system daemon processes, so tell them how many were suppressed.
2236 void kdb_ps_suppressed(void)
2238 int idle = 0, daemon = 0;
2239 unsigned long mask_I = kdb_task_state_string("I"),
2240 mask_M = kdb_task_state_string("M");
2242 const struct task_struct *p, *g;
2243 for_each_online_cpu(cpu) {
2244 p = kdb_curr_task(cpu);
2245 if (kdb_task_state(p, mask_I))
2248 kdb_do_each_thread(g, p) {
2249 if (kdb_task_state(p, mask_M))
2251 } kdb_while_each_thread(g, p);
2252 if (idle || daemon) {
2254 kdb_printf("%d idle process%s (state I)%s\n",
2255 idle, idle == 1 ? "" : "es",
2256 daemon ? " and " : "");
2258 kdb_printf("%d sleeping system daemon (state M) "
2259 "process%s", daemon,
2260 daemon == 1 ? "" : "es");
2261 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2266 * kdb_ps - This function implements the 'ps' command which shows a
2267 * list of the active processes.
2268 * ps [DRSTCZEUIMA] All processes, optionally filtered by state
2270 void kdb_ps1(const struct task_struct *p)
2275 if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
2278 cpu = kdb_process_cpu(p);
2279 kdb_printf("0x%p %8d %8d %d %4d %c 0x%p %c%s\n",
2280 (void *)p, p->pid, p->parent->pid,
2281 kdb_task_has_cpu(p), kdb_process_cpu(p),
2282 kdb_task_state_char(p),
2283 (void *)(&p->thread),
2284 p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2286 if (kdb_task_has_cpu(p)) {
2287 if (!KDB_TSK(cpu)) {
2288 kdb_printf(" Error: no saved data for this cpu\n");
2290 if (KDB_TSK(cpu) != p)
2291 kdb_printf(" Error: does not match running "
2292 "process table (0x%p)\n", KDB_TSK(cpu));
2297 static int kdb_ps(int argc, const char **argv)
2299 struct task_struct *g, *p;
2300 unsigned long mask, cpu;
2303 kdb_ps_suppressed();
2304 kdb_printf("%-*s Pid Parent [*] cpu State %-*s Command\n",
2305 (int)(2*sizeof(void *))+2, "Task Addr",
2306 (int)(2*sizeof(void *))+2, "Thread");
2307 mask = kdb_task_state_string(argc ? argv[1] : NULL);
2308 /* Run the active tasks first */
2309 for_each_online_cpu(cpu) {
2310 if (KDB_FLAG(CMD_INTERRUPT))
2312 p = kdb_curr_task(cpu);
2313 if (kdb_task_state(p, mask))
2317 /* Now the real tasks */
2318 kdb_do_each_thread(g, p) {
2319 if (KDB_FLAG(CMD_INTERRUPT))
2321 if (kdb_task_state(p, mask))
2323 } kdb_while_each_thread(g, p);
2329 * kdb_pid - This function implements the 'pid' command which switches
2330 * the currently active process.
2333 static int kdb_pid(int argc, const char **argv)
2335 struct task_struct *p;
2340 return KDB_ARGCOUNT;
2343 if (strcmp(argv[1], "R") == 0) {
2344 p = KDB_TSK(kdb_initial_cpu);
2346 diag = kdbgetularg(argv[1], &val);
2350 p = find_task_by_pid_ns((pid_t)val, &init_pid_ns);
2352 kdb_printf("No task with pid=%d\n", (pid_t)val);
2356 kdb_set_current_task(p);
2358 kdb_printf("KDB current process is %s(pid=%d)\n",
2359 kdb_current_task->comm,
2360 kdb_current_task->pid);
2365 static int kdb_kgdb(int argc, const char **argv)
2367 return KDB_CMD_KGDB;
2371 * kdb_help - This function implements the 'help' and '?' commands.
2373 static int kdb_help(int argc, const char **argv)
2378 kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2379 kdb_printf("-----------------------------"
2380 "-----------------------------\n");
2381 for_each_kdbcmd(kt, i) {
2383 if (KDB_FLAG(CMD_INTERRUPT))
2387 if (strlen(kt->cmd_usage) > 20)
2389 kdb_printf("%-15.15s %-20s%s%s\n", kt->cmd_name,
2390 kt->cmd_usage, space, kt->cmd_help);
2396 * kdb_kill - This function implements the 'kill' commands.
2398 static int kdb_kill(int argc, const char **argv)
2402 struct task_struct *p;
2403 struct siginfo info;
2406 return KDB_ARGCOUNT;
2408 sig = simple_strtol(argv[1], &endp, 0);
2412 kdb_printf("Invalid signal parameter.<-signal>\n");
2417 pid = simple_strtol(argv[2], &endp, 0);
2421 kdb_printf("Process ID must be large than 0.\n");
2425 /* Find the process. */
2426 p = find_task_by_pid_ns(pid, &init_pid_ns);
2428 kdb_printf("The specified process isn't found.\n");
2431 p = p->group_leader;
2432 info.si_signo = sig;
2434 info.si_code = SI_USER;
2435 info.si_pid = pid; /* same capabilities as process being signalled */
2436 info.si_uid = 0; /* kdb has root authority */
2437 kdb_send_sig_info(p, &info);
2442 int tm_sec; /* seconds */
2443 int tm_min; /* minutes */
2444 int tm_hour; /* hours */
2445 int tm_mday; /* day of the month */
2446 int tm_mon; /* month */
2447 int tm_year; /* year */
2450 static void kdb_gmtime(struct timespec *tv, struct kdb_tm *tm)
2452 /* This will work from 1970-2099, 2100 is not a leap year */
2453 static int mon_day[] = { 31, 29, 31, 30, 31, 30, 31,
2454 31, 30, 31, 30, 31 };
2455 memset(tm, 0, sizeof(*tm));
2456 tm->tm_sec = tv->tv_sec % (24 * 60 * 60);
2457 tm->tm_mday = tv->tv_sec / (24 * 60 * 60) +
2458 (2 * 365 + 1); /* shift base from 1970 to 1968 */
2459 tm->tm_min = tm->tm_sec / 60 % 60;
2460 tm->tm_hour = tm->tm_sec / 60 / 60;
2461 tm->tm_sec = tm->tm_sec % 60;
2462 tm->tm_year = 68 + 4*(tm->tm_mday / (4*365+1));
2463 tm->tm_mday %= (4*365+1);
2465 while (tm->tm_mday >= mon_day[tm->tm_mon]) {
2466 tm->tm_mday -= mon_day[tm->tm_mon];
2467 if (++tm->tm_mon == 12) {
2477 * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2478 * I cannot call that code directly from kdb, it has an unconditional
2479 * cli()/sti() and calls routines that take locks which can stop the debugger.
2481 static void kdb_sysinfo(struct sysinfo *val)
2483 struct timespec uptime;
2484 do_posix_clock_monotonic_gettime(&uptime);
2485 memset(val, 0, sizeof(*val));
2486 val->uptime = uptime.tv_sec;
2487 val->loads[0] = avenrun[0];
2488 val->loads[1] = avenrun[1];
2489 val->loads[2] = avenrun[2];
2490 val->procs = nr_threads-1;
2497 * kdb_summary - This function implements the 'summary' command.
2499 static int kdb_summary(int argc, const char **argv)
2501 struct timespec now;
2506 return KDB_ARGCOUNT;
2508 kdb_printf("sysname %s\n", init_uts_ns.name.sysname);
2509 kdb_printf("release %s\n", init_uts_ns.name.release);
2510 kdb_printf("version %s\n", init_uts_ns.name.version);
2511 kdb_printf("machine %s\n", init_uts_ns.name.machine);
2512 kdb_printf("nodename %s\n", init_uts_ns.name.nodename);
2513 kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2514 kdb_printf("ccversion %s\n", __stringify(CCVERSION));
2516 now = __current_kernel_time();
2517 kdb_gmtime(&now, &tm);
2518 kdb_printf("date %04d-%02d-%02d %02d:%02d:%02d "
2519 "tz_minuteswest %d\n",
2520 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2521 tm.tm_hour, tm.tm_min, tm.tm_sec,
2522 sys_tz.tz_minuteswest);
2525 kdb_printf("uptime ");
2526 if (val.uptime > (24*60*60)) {
2527 int days = val.uptime / (24*60*60);
2528 val.uptime %= (24*60*60);
2529 kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2531 kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2533 /* lifted from fs/proc/proc_misc.c::loadavg_read_proc() */
2535 #define LOAD_INT(x) ((x) >> FSHIFT)
2536 #define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
2537 kdb_printf("load avg %ld.%02ld %ld.%02ld %ld.%02ld\n",
2538 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2539 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2540 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2543 /* Display in kilobytes */
2544 #define K(x) ((x) << (PAGE_SHIFT - 10))
2545 kdb_printf("\nMemTotal: %8lu kB\nMemFree: %8lu kB\n"
2546 "Buffers: %8lu kB\n",
2547 val.totalram, val.freeram, val.bufferram);
2552 * kdb_per_cpu - This function implements the 'per_cpu' command.
2554 static int kdb_per_cpu(int argc, const char **argv)
2557 int cpu, diag, nextarg = 1;
2558 unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2560 if (argc < 1 || argc > 3)
2561 return KDB_ARGCOUNT;
2563 diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2568 diag = kdbgetularg(argv[2], &bytesperword);
2573 bytesperword = KDB_WORD_SIZE;
2574 else if (bytesperword > KDB_WORD_SIZE)
2575 return KDB_BADWIDTH;
2576 sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2578 diag = kdbgetularg(argv[3], &whichcpu);
2581 if (!cpu_online(whichcpu)) {
2582 kdb_printf("cpu %ld is not online\n", whichcpu);
2583 return KDB_BADCPUNUM;
2587 /* Most architectures use __per_cpu_offset[cpu], some use
2588 * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2590 #ifdef __per_cpu_offset
2591 #define KDB_PCU(cpu) __per_cpu_offset(cpu)
2594 #define KDB_PCU(cpu) __per_cpu_offset[cpu]
2596 #define KDB_PCU(cpu) 0
2599 for_each_online_cpu(cpu) {
2600 if (KDB_FLAG(CMD_INTERRUPT))
2603 if (whichcpu != ~0UL && whichcpu != cpu)
2605 addr = symaddr + KDB_PCU(cpu);
2606 diag = kdb_getword(&val, addr, bytesperword);
2608 kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2609 "read, diag=%d\n", cpu, addr, diag);
2612 kdb_printf("%5d ", cpu);
2613 kdb_md_line(fmtstr, addr,
2614 bytesperword == KDB_WORD_SIZE,
2615 1, bytesperword, 1, 1, 0);
2622 * display help for the use of cmd | grep pattern
2624 static int kdb_grep_help(int argc, const char **argv)
2626 kdb_printf("Usage of cmd args | grep pattern:\n");
2627 kdb_printf(" Any command's output may be filtered through an ");
2628 kdb_printf("emulated 'pipe'.\n");
2629 kdb_printf(" 'grep' is just a key word.\n");
2630 kdb_printf(" The pattern may include a very limited set of "
2631 "metacharacters:\n");
2632 kdb_printf(" pattern or ^pattern or pattern$ or ^pattern$\n");
2633 kdb_printf(" And if there are spaces in the pattern, you may "
2635 kdb_printf(" \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2636 " or \"^pat tern$\"\n");
2641 * kdb_register_repeat - This function is used to register a kernel
2645 * func Function to execute the command
2646 * usage A simple usage string showing arguments
2647 * help A simple help string describing command
2648 * repeat Does the command auto repeat on enter?
2650 * zero for success, one if a duplicate command.
2652 #define kdb_command_extend 50 /* arbitrary */
2653 int kdb_register_repeat(char *cmd,
2658 kdb_repeat_t repeat)
2664 * Brute force method to determine duplicates
2666 for_each_kdbcmd(kp, i) {
2667 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2668 kdb_printf("Duplicate kdb command registered: "
2669 "%s, func %p help %s\n", cmd, func, help);
2675 * Insert command into first available location in table
2677 for_each_kdbcmd(kp, i) {
2678 if (kp->cmd_name == NULL)
2682 if (i >= kdb_max_commands) {
2683 kdbtab_t *new = kmalloc((kdb_max_commands - KDB_BASE_CMD_MAX +
2684 kdb_command_extend) * sizeof(*new), GFP_KDB);
2686 kdb_printf("Could not allocate new kdb_command "
2691 memcpy(new, kdb_commands,
2692 (kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new));
2693 kfree(kdb_commands);
2695 memset(new + kdb_max_commands - KDB_BASE_CMD_MAX, 0,
2696 kdb_command_extend * sizeof(*new));
2698 kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX;
2699 kdb_max_commands += kdb_command_extend;
2703 kp->cmd_func = func;
2704 kp->cmd_usage = usage;
2705 kp->cmd_help = help;
2707 kp->cmd_minlen = minlen;
2708 kp->cmd_repeat = repeat;
2712 EXPORT_SYMBOL_GPL(kdb_register_repeat);
2716 * kdb_register - Compatibility register function for commands that do
2717 * not need to specify a repeat state. Equivalent to
2718 * kdb_register_repeat with KDB_REPEAT_NONE.
2721 * func Function to execute the command
2722 * usage A simple usage string showing arguments
2723 * help A simple help string describing command
2725 * zero for success, one if a duplicate command.
2727 int kdb_register(char *cmd,
2733 return kdb_register_repeat(cmd, func, usage, help, minlen,
2736 EXPORT_SYMBOL_GPL(kdb_register);
2739 * kdb_unregister - This function is used to unregister a kernel
2740 * debugger command. It is generally called when a module which
2741 * implements kdb commands is unloaded.
2745 * zero for success, one command not registered.
2747 int kdb_unregister(char *cmd)
2755 for_each_kdbcmd(kp, i) {
2756 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2757 kp->cmd_name = NULL;
2762 /* Couldn't find it. */
2765 EXPORT_SYMBOL_GPL(kdb_unregister);
2767 /* Initialize the kdb command table. */
2768 static void __init kdb_inittab(void)
2773 for_each_kdbcmd(kp, i)
2774 kp->cmd_name = NULL;
2776 kdb_register_repeat("md", kdb_md, "<vaddr>",
2777 "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2778 KDB_REPEAT_NO_ARGS);
2779 kdb_register_repeat("mdr", kdb_md, "<vaddr> <bytes>",
2780 "Display Raw Memory", 0, KDB_REPEAT_NO_ARGS);
2781 kdb_register_repeat("mdp", kdb_md, "<paddr> <bytes>",
2782 "Display Physical Memory", 0, KDB_REPEAT_NO_ARGS);
2783 kdb_register_repeat("mds", kdb_md, "<vaddr>",
2784 "Display Memory Symbolically", 0, KDB_REPEAT_NO_ARGS);
2785 kdb_register_repeat("mm", kdb_mm, "<vaddr> <contents>",
2786 "Modify Memory Contents", 0, KDB_REPEAT_NO_ARGS);
2787 kdb_register_repeat("go", kdb_go, "[<vaddr>]",
2788 "Continue Execution", 1, KDB_REPEAT_NONE);
2789 kdb_register_repeat("rd", kdb_rd, "",
2790 "Display Registers", 0, KDB_REPEAT_NONE);
2791 kdb_register_repeat("rm", kdb_rm, "<reg> <contents>",
2792 "Modify Registers", 0, KDB_REPEAT_NONE);
2793 kdb_register_repeat("ef", kdb_ef, "<vaddr>",
2794 "Display exception frame", 0, KDB_REPEAT_NONE);
2795 kdb_register_repeat("bt", kdb_bt, "[<vaddr>]",
2796 "Stack traceback", 1, KDB_REPEAT_NONE);
2797 kdb_register_repeat("btp", kdb_bt, "<pid>",
2798 "Display stack for process <pid>", 0, KDB_REPEAT_NONE);
2799 kdb_register_repeat("bta", kdb_bt, "[DRSTCZEUIMA]",
2800 "Display stack all processes", 0, KDB_REPEAT_NONE);
2801 kdb_register_repeat("btc", kdb_bt, "",
2802 "Backtrace current process on each cpu", 0, KDB_REPEAT_NONE);
2803 kdb_register_repeat("btt", kdb_bt, "<vaddr>",
2804 "Backtrace process given its struct task address", 0,
2806 kdb_register_repeat("env", kdb_env, "",
2807 "Show environment variables", 0, KDB_REPEAT_NONE);
2808 kdb_register_repeat("set", kdb_set, "",
2809 "Set environment variables", 0, KDB_REPEAT_NONE);
2810 kdb_register_repeat("help", kdb_help, "",
2811 "Display Help Message", 1, KDB_REPEAT_NONE);
2812 kdb_register_repeat("?", kdb_help, "",
2813 "Display Help Message", 0, KDB_REPEAT_NONE);
2814 kdb_register_repeat("cpu", kdb_cpu, "<cpunum>",
2815 "Switch to new cpu", 0, KDB_REPEAT_NONE);
2816 kdb_register_repeat("kgdb", kdb_kgdb, "",
2817 "Enter kgdb mode", 0, KDB_REPEAT_NONE);
2818 kdb_register_repeat("ps", kdb_ps, "[<flags>|A]",
2819 "Display active task list", 0, KDB_REPEAT_NONE);
2820 kdb_register_repeat("pid", kdb_pid, "<pidnum>",
2821 "Switch to another task", 0, KDB_REPEAT_NONE);
2822 kdb_register_repeat("reboot", kdb_reboot, "",
2823 "Reboot the machine immediately", 0, KDB_REPEAT_NONE);
2824 #if defined(CONFIG_MODULES)
2825 kdb_register_repeat("lsmod", kdb_lsmod, "",
2826 "List loaded kernel modules", 0, KDB_REPEAT_NONE);
2828 #if defined(CONFIG_MAGIC_SYSRQ)
2829 kdb_register_repeat("sr", kdb_sr, "<key>",
2830 "Magic SysRq key", 0, KDB_REPEAT_NONE);
2832 #if defined(CONFIG_PRINTK)
2833 kdb_register_repeat("dmesg", kdb_dmesg, "[lines]",
2834 "Display syslog buffer", 0, KDB_REPEAT_NONE);
2836 if (arch_kgdb_ops.enable_nmi) {
2837 kdb_register_repeat("disable_nmi", kdb_disable_nmi, "",
2838 "Disable NMI entry to KDB", 0, KDB_REPEAT_NONE);
2840 kdb_register_repeat("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
2841 "Define a set of commands, down to endefcmd", 0, KDB_REPEAT_NONE);
2842 kdb_register_repeat("kill", kdb_kill, "<-signal> <pid>",
2843 "Send a signal to a process", 0, KDB_REPEAT_NONE);
2844 kdb_register_repeat("summary", kdb_summary, "",
2845 "Summarize the system", 4, KDB_REPEAT_NONE);
2846 kdb_register_repeat("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
2847 "Display per_cpu variables", 3, KDB_REPEAT_NONE);
2848 kdb_register_repeat("grephelp", kdb_grep_help, "",
2849 "Display help on | grep", 0, KDB_REPEAT_NONE);
2852 /* Execute any commands defined in kdb_cmds. */
2853 static void __init kdb_cmd_init(void)
2856 for (i = 0; kdb_cmds[i]; ++i) {
2857 diag = kdb_parse(kdb_cmds[i]);
2859 kdb_printf("kdb command %s failed, kdb diag %d\n",
2862 if (defcmd_in_progress) {
2863 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2864 kdb_parse("endefcmd");
2868 /* Initialize kdb_printf, breakpoint tables and kdb state */
2869 void __init kdb_init(int lvl)
2871 static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2874 if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2876 for (i = kdb_init_lvl; i < lvl; i++) {
2878 case KDB_NOT_INITIALIZED:
2879 kdb_inittab(); /* Initialize Command Table */
2880 kdb_initbptab(); /* Initialize Breakpoints */
2882 case KDB_INIT_EARLY:
2883 kdb_cmd_init(); /* Build kdb_cmds tables */