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