Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
kdb_main.c
Go to the documentation of this file.
1 /*
2  * Kernel Debugger Architecture Independent Main Code
3  *
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
6  * for more details.
7  *
8  * Copyright (C) 1999-2004 Silicon Graphics, Inc. All Rights Reserved.
9  * Copyright (C) 2000 Stephane Eranian <[email protected]>
10  * Xscale (R) modifications copyright (C) 2003 Intel Corporation.
11  * Copyright (c) 2009 Wind River Systems, Inc. All Rights Reserved.
12  */
13 
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>
26 #include <linux/mm.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"
44 
45 #define GREP_LEN 256
46 char kdb_grep_string[GREP_LEN];
47 int kdb_grepping_flag;
48 EXPORT_SYMBOL(kdb_grepping_flag);
49 int kdb_grep_leading;
50 int kdb_grep_trailing;
51 
52 /*
53  * Kernel debugger state flags
54  */
55 int kdb_flags;
56 atomic_t kdb_event;
57 
58 /*
59  * kdb_lock protects updates to kdb_initial_cpu. Used to
60  * single thread processors through the kernel debugger.
61  */
62 int kdb_initial_cpu = -1; /* cpu number that owns kdb */
63 int kdb_nextline = 1;
64 int kdb_state; /* General KDB state */
65 
66 struct task_struct *kdb_current_task;
67 EXPORT_SYMBOL(kdb_current_task);
68 struct pt_regs *kdb_current_regs;
69 
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;
75 #else
76 static unsigned int kdb_continue_catastrophic;
77 #endif
78 
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++)
88 
89 typedef struct _kdbmsg {
90  int km_diag; /* kdb diagnostic */
91  char *km_msg; /* Corresponding message text */
92 } kdbmsg_t;
93 
94 #define KDBMSG(msgnum, text) \
95  { KDB_##msgnum, text }
96 
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"),
111 #else
112  KDBMSG(TOOMANYDBREGS, "More breakpoints than db registers defined"),
113 #endif
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"),
124 };
125 #undef KDBMSG
126 
127 static const int __nkdb_err = sizeof(kdbmsgs) / sizeof(kdbmsg_t);
128 
129 
130 /*
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).
138  */
139 
140 static char *__env[] = {
141 #if defined(CONFIG_SMP)
142  "PROMPT=[%d]kdb> ",
143 #else
144  "PROMPT=kdb> ",
145 #endif
146  "MOREPROMPT=more> ",
147  "RADIX=16",
148  "MDCOUNT=8", /* lines of md output */
149  KDB_PLATFORM_ENV,
150  "DTABCOUNT=30",
151  "NOSECT=1",
152  (char *)0,
153  (char *)0,
154  (char *)0,
155  (char *)0,
156  (char *)0,
157  (char *)0,
158  (char *)0,
159  (char *)0,
160  (char *)0,
161  (char *)0,
162  (char *)0,
163  (char *)0,
164  (char *)0,
165  (char *)0,
166  (char *)0,
167  (char *)0,
168  (char *)0,
169  (char *)0,
170  (char *)0,
171  (char *)0,
172  (char *)0,
173  (char *)0,
174  (char *)0,
175  (char *)0,
176 };
177 
178 static const int __nenv = (sizeof(__env) / sizeof(char *));
179 
180 struct task_struct *kdb_curr_task(int cpu)
181 {
182  struct task_struct *p = curr_task(cpu);
183 #ifdef _TIF_MCA_INIT
184  if ((task_thread_info(p)->flags & _TIF_MCA_INIT) && KDB_TSK(cpu))
185  p = krp->p;
186 #endif
187  return p;
188 }
189 
190 /*
191  * kdbgetenv - This function will return the character string value of
192  * an environment variable.
193  * Parameters:
194  * match A character string representing an environment variable.
195  * Returns:
196  * NULL No environment variable matches 'match'
197  * char* Pointer to string value of environment variable.
198  */
199 char *kdbgetenv(const char *match)
200 {
201  char **ep = __env;
202  int matchlen = strlen(match);
203  int i;
204 
205  for (i = 0; i < __nenv; i++) {
206  char *e = *ep++;
207 
208  if (!e)
209  continue;
210 
211  if ((strncmp(match, e, matchlen) == 0)
212  && ((e[matchlen] == '\0')
213  || (e[matchlen] == '='))) {
214  char *cp = strchr(e, '=');
215  return cp ? ++cp : "";
216  }
217  }
218  return NULL;
219 }
220 
221 /*
222  * kdballocenv - This function is used to allocate bytes for
223  * environment entries.
224  * Parameters:
225  * match A character string representing a numeric value
226  * Outputs:
227  * *value the unsigned long representation of the env variable 'match'
228  * Returns:
229  * Zero on success, a kdb diagnostic on failure.
230  * Remarks:
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
235  * frequently.
236  */
237 static char *kdballocenv(size_t bytes)
238 {
239 #define KDB_ENVBUFSIZE 512
240  static char envbuffer[KDB_ENVBUFSIZE];
241  static int envbufsize;
242  char *ep = NULL;
243 
244  if ((KDB_ENVBUFSIZE - envbufsize) >= bytes) {
245  ep = &envbuffer[envbufsize];
246  envbufsize += bytes;
247  }
248  return ep;
249 }
250 
251 /*
252  * kdbgetulenv - This function will return the value of an unsigned
253  * long-valued environment variable.
254  * Parameters:
255  * match A character string representing a numeric value
256  * Outputs:
257  * *value the unsigned long represntation of the env variable 'match'
258  * Returns:
259  * Zero on success, a kdb diagnostic on failure.
260  */
261 static int kdbgetulenv(const char *match, unsigned long *value)
262 {
263  char *ep;
264 
265  ep = kdbgetenv(match);
266  if (!ep)
267  return KDB_NOTENV;
268  if (strlen(ep) == 0)
269  return KDB_NOENVVALUE;
270 
271  *value = simple_strtoul(ep, NULL, 0);
272 
273  return 0;
274 }
275 
276 /*
277  * kdbgetintenv - This function will return the value of an
278  * integer-valued environment variable.
279  * Parameters:
280  * match A character string representing an integer-valued env variable
281  * Outputs:
282  * *value the integer representation of the environment variable 'match'
283  * Returns:
284  * Zero on success, a kdb diagnostic on failure.
285  */
286 int kdbgetintenv(const char *match, int *value)
287 {
288  unsigned long val;
289  int diag;
290 
291  diag = kdbgetulenv(match, &val);
292  if (!diag)
293  *value = (int) val;
294  return diag;
295 }
296 
297 /*
298  * kdbgetularg - This function will convert a numeric string into an
299  * unsigned long value.
300  * Parameters:
301  * arg A character string representing a numeric value
302  * Outputs:
303  * *value the unsigned long represntation of arg.
304  * Returns:
305  * Zero on success, a kdb diagnostic on failure.
306  */
307 int kdbgetularg(const char *arg, unsigned long *value)
308 {
309  char *endp;
310  unsigned long val;
311 
312  val = simple_strtoul(arg, &endp, 0);
313 
314  if (endp == arg) {
315  /*
316  * Also try base 16, for us folks too lazy to type the
317  * leading 0x...
318  */
319  val = simple_strtoul(arg, &endp, 16);
320  if (endp == arg)
321  return KDB_BADINT;
322  }
323 
324  *value = val;
325 
326  return 0;
327 }
328 
329 int kdbgetu64arg(const char *arg, u64 *value)
330 {
331  char *endp;
332  u64 val;
333 
334  val = simple_strtoull(arg, &endp, 0);
335 
336  if (endp == arg) {
337 
338  val = simple_strtoull(arg, &endp, 16);
339  if (endp == arg)
340  return KDB_BADINT;
341  }
342 
343  *value = val;
344 
345  return 0;
346 }
347 
348 /*
349  * kdb_set - This function implements the 'set' command. Alter an
350  * existing environment variable or create a new one.
351  */
352 int kdb_set(int argc, const char **argv)
353 {
354  int i;
355  char *ep;
356  size_t varlen, vallen;
357 
358  /*
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.
363  */
364  if (argc == 3) {
365  argv[2] = argv[3];
366  argc--;
367  }
368 
369  if (argc != 2)
370  return KDB_ARGCOUNT;
371 
372  /*
373  * Check for internal variables
374  */
375  if (strcmp(argv[1], "KDBDEBUG") == 0) {
376  unsigned int debugflags;
377  char *cp;
378 
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",
382  argv[2]);
383  return 0;
384  }
385  kdb_flags = (kdb_flags &
386  ~(KDB_DEBUG_FLAG_MASK << KDB_DEBUG_FLAG_SHIFT))
387  | (debugflags << KDB_DEBUG_FLAG_SHIFT);
388 
389  return 0;
390  }
391 
392  /*
393  * Tokenizer squashed the '=' sign. argv[1] is variable
394  * name, argv[2] = value.
395  */
396  varlen = strlen(argv[1]);
397  vallen = strlen(argv[2]);
398  ep = kdballocenv(varlen + vallen + 2);
399  if (ep == (char *)0)
400  return KDB_ENVBUFFULL;
401 
402  sprintf(ep, "%s=%s", argv[1], argv[2]);
403 
404  ep[varlen+vallen+1] = '\0';
405 
406  for (i = 0; i < __nenv; i++) {
407  if (__env[i]
408  && ((strncmp(__env[i], argv[1], varlen) == 0)
409  && ((__env[i][varlen] == '\0')
410  || (__env[i][varlen] == '=')))) {
411  __env[i] = ep;
412  return 0;
413  }
414  }
415 
416  /*
417  * Wasn't existing variable. Fit into slot.
418  */
419  for (i = 0; i < __nenv-1; i++) {
420  if (__env[i] == (char *)0) {
421  __env[i] = ep;
422  return 0;
423  }
424  }
425 
426  return KDB_ENVFULL;
427 }
428 
429 static int kdb_check_regs(void)
430 {
431  if (!kdb_current_regs) {
432  kdb_printf("No current kdb registers."
433  " You may need to select another task\n");
434  return KDB_BADREG;
435  }
436  return 0;
437 }
438 
439 /*
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.
443  *
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
449  * (offset).
450  * Parameters:
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
455  * Outputs:
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[]
460  * Returns:
461  * zero is returned on success, a kdb diagnostic code is
462  * returned on error.
463  */
464 int kdbgetaddrarg(int argc, const char **argv, int *nextarg,
465  unsigned long *value, long *offset,
466  char **name)
467 {
468  unsigned long addr;
469  unsigned long off = 0;
470  int positive;
471  int diag;
472  int found = 0;
473  char *symname;
474  char symbol = '\0';
475  char *cp;
476  kdb_symtab_t symtab;
477 
478  /*
479  * Process arguments which follow the following syntax:
480  *
481  * symbol | numeric-address [+/- numeric-offset]
482  * %register
483  * $environment-variable
484  */
485 
486  if (*nextarg > argc)
487  return KDB_ARGCOUNT;
488 
489  symname = (char *)argv[*nextarg];
490 
491  /*
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
496  */
497  cp = strpbrk(symname, "+-");
498  if (cp != NULL) {
499  symbol = *cp;
500  *cp++ = '\0';
501  }
502 
503  if (symname[0] == '$') {
504  diag = kdbgetulenv(&symname[1], &addr);
505  if (diag)
506  return diag;
507  } else if (symname[0] == '%') {
508  diag = kdb_check_regs();
509  if (diag)
510  return diag;
511  /* Implement register values with % at a later time as it is
512  * arch optional.
513  */
514  return KDB_NOTIMP;
515  } else {
516  found = kdbgetsymval(symname, &symtab);
517  if (found) {
518  addr = symtab.sym_start;
519  } else {
520  diag = kdbgetularg(argv[*nextarg], &addr);
521  if (diag)
522  return diag;
523  }
524  }
525 
526  if (!found)
527  found = kdbnearsym(addr, &symtab);
528 
529  (*nextarg)++;
530 
531  if (name)
532  *name = symname;
533  if (value)
534  *value = addr;
535  if (offset && name && *name)
536  *offset = addr - symtab.sym_start;
537 
538  if ((*nextarg > argc)
539  && (symbol == '\0'))
540  return 0;
541 
542  /*
543  * check for +/- and offset
544  */
545 
546  if (symbol == '\0') {
547  if ((argv[*nextarg][0] != '+')
548  && (argv[*nextarg][0] != '-')) {
549  /*
550  * Not our argument. Return.
551  */
552  return 0;
553  } else {
554  positive = (argv[*nextarg][0] == '+');
555  (*nextarg)++;
556  }
557  } else
558  positive = (symbol == '+');
559 
560  /*
561  * Now there must be an offset!
562  */
563  if ((*nextarg > argc)
564  && (symbol == '\0')) {
565  return KDB_INVADDRFMT;
566  }
567 
568  if (!symbol) {
569  cp = (char *)argv[*nextarg];
570  (*nextarg)++;
571  }
572 
573  diag = kdbgetularg(cp, &off);
574  if (diag)
575  return diag;
576 
577  if (!positive)
578  off = -off;
579 
580  if (offset)
581  *offset += off;
582 
583  if (value)
584  *value += off;
585 
586  return 0;
587 }
588 
589 static void kdb_cmderror(int diag)
590 {
591  int i;
592 
593  if (diag >= 0) {
594  kdb_printf("no error detected (diagnostic is %d)\n", diag);
595  return;
596  }
597 
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);
601  return;
602  }
603  }
604 
605  kdb_printf("Unknown diag %d\n", -diag);
606 }
607 
608 /*
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'.
614  * Inputs:
615  * argc argument count
616  * argv argument vector
617  * Returns:
618  * zero for success, a kdb diagnostic if error
619  */
620 struct defcmd_set {
621  int count;
622  int usable;
623  char *name;
624  char *usage;
625  char *help;
626  char **command;
627 };
628 static struct defcmd_set *defcmd_set;
629 static int defcmd_set_count;
630 static int defcmd_in_progress;
631 
632 /* Forward references */
633 static int kdb_exec_defcmd(int argc, const char **argv);
634 
635 static int kdb_defcmd2(const char *cmdstr, const char *argv0)
636 {
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;
641  if (!s->count)
642  s->usable = 0;
643  if (s->usable)
644  kdb_register(s->name, kdb_exec_defcmd,
645  s->usage, s->help, 0);
646  return 0;
647  }
648  if (!s->usable)
649  return KDB_NOTIMP;
650  s->command = kzalloc((s->count + 1) * sizeof(*(s->command)), GFP_KDB);
651  if (!s->command) {
652  kdb_printf("Could not allocate new kdb_defcmd table for %s\n",
653  cmdstr);
654  s->usable = 0;
655  return KDB_NOTIMP;
656  }
657  memcpy(s->command, save_command, s->count * sizeof(*(s->command)));
658  s->command[s->count++] = kdb_strdup(cmdstr, GFP_KDB);
659  kfree(save_command);
660  return 0;
661 }
662 
663 static int kdb_defcmd(int argc, const char **argv)
664 {
665  struct defcmd_set *save_defcmd_set = defcmd_set, *s;
666  if (defcmd_in_progress) {
667  kdb_printf("kdb: nested defcmd detected, assuming missing "
668  "endefcmd\n");
669  kdb_defcmd2("endefcmd", "endefcmd");
670  }
671  if (argc == 0) {
672  int i;
673  for (s = defcmd_set; s < defcmd_set + defcmd_set_count; ++s) {
674  kdb_printf("defcmd %s \"%s\" \"%s\"\n", s->name,
675  s->usage, s->help);
676  for (i = 0; i < s->count; ++i)
677  kdb_printf("%s", s->command[i]);
678  kdb_printf("endefcmd\n");
679  }
680  return 0;
681  }
682  if (argc != 3)
683  return KDB_ARGCOUNT;
684  defcmd_set = kmalloc((defcmd_set_count + 1) * sizeof(*defcmd_set),
685  GFP_KDB);
686  if (!defcmd_set) {
687  kdb_printf("Could not allocate new defcmd_set entry for %s\n",
688  argv[1]);
689  defcmd_set = save_defcmd_set;
690  return KDB_NOTIMP;
691  }
692  memcpy(defcmd_set, save_defcmd_set,
693  defcmd_set_count * sizeof(*defcmd_set));
694  kfree(save_defcmd_set);
695  s = defcmd_set + defcmd_set_count;
696  memset(s, 0, sizeof(*s));
697  s->usable = 1;
698  s->name = kdb_strdup(argv[1], GFP_KDB);
699  s->usage = kdb_strdup(argv[2], GFP_KDB);
700  s->help = kdb_strdup(argv[3], GFP_KDB);
701  if (s->usage[0] == '"') {
702  strcpy(s->usage, s->usage+1);
703  s->usage[strlen(s->usage)-1] = '\0';
704  }
705  if (s->help[0] == '"') {
706  strcpy(s->help, s->help+1);
707  s->help[strlen(s->help)-1] = '\0';
708  }
709  ++defcmd_set_count;
710  defcmd_in_progress = 1;
711  return 0;
712 }
713 
714 /*
715  * kdb_exec_defcmd - Execute the set of commands associated with this
716  * defcmd name.
717  * Inputs:
718  * argc argument count
719  * argv argument vector
720  * Returns:
721  * zero for success, a kdb diagnostic if error
722  */
723 static int kdb_exec_defcmd(int argc, const char **argv)
724 {
725  int i, ret;
726  struct defcmd_set *s;
727  if (argc != 0)
728  return KDB_ARGCOUNT;
729  for (s = defcmd_set, i = 0; i < defcmd_set_count; ++i, ++s) {
730  if (strcmp(s->name, argv[0]) == 0)
731  break;
732  }
733  if (i == defcmd_set_count) {
734  kdb_printf("kdb_exec_defcmd: could not find commands for %s\n",
735  argv[0]);
736  return KDB_NOTIMP;
737  }
738  for (i = 0; i < s->count; ++i) {
739  /* Recursive use of kdb_parse, do not use argv after
740  * this point */
741  argv = NULL;
742  kdb_printf("[%s]kdb> %s\n", s->name, s->command[i]);
743  ret = kdb_parse(s->command[i]);
744  if (ret)
745  return ret;
746  }
747  return 0;
748 }
749 
750 /* Command history */
751 #define KDB_CMD_HISTORY_COUNT 32
752 #define CMD_BUFLEN 200 /* kdb_printf: max printline
753  * size == 256 */
754 static unsigned int cmd_head, cmd_tail;
755 static unsigned int cmdptr;
756 static char cmd_hist[KDB_CMD_HISTORY_COUNT][CMD_BUFLEN];
757 static char cmd_cur[CMD_BUFLEN];
758 
759 /*
760  * The "str" argument may point to something like | grep xyz
761  */
762 static void parse_grep(const char *str)
763 {
764  int len;
765  char *cp = (char *)str, *cp2;
766 
767  /* sanity check: we should have been called with the \ first */
768  if (*cp != '|')
769  return;
770  cp++;
771  while (isspace(*cp))
772  cp++;
773  if (strncmp(cp, "grep ", 5)) {
774  kdb_printf("invalid 'pipe', see grephelp\n");
775  return;
776  }
777  cp += 5;
778  while (isspace(*cp))
779  cp++;
780  cp2 = strchr(cp, '\n');
781  if (cp2)
782  *cp2 = '\0'; /* remove the trailing newline */
783  len = strlen(cp);
784  if (len == 0) {
785  kdb_printf("invalid 'pipe', see grephelp\n");
786  return;
787  }
788  /* now cp points to a nonzero length search string */
789  if (*cp == '"') {
790  /* allow it be "x y z" by removing the "'s - there must
791  be two of them */
792  cp++;
793  cp2 = strchr(cp, '"');
794  if (!cp2) {
795  kdb_printf("invalid quoted string, see grephelp\n");
796  return;
797  }
798  *cp2 = '\0'; /* end the string where the 2nd " was */
799  }
800  kdb_grep_leading = 0;
801  if (*cp == '^') {
802  kdb_grep_leading = 1;
803  cp++;
804  }
805  len = strlen(cp);
806  kdb_grep_trailing = 0;
807  if (*(cp+len-1) == '$') {
808  kdb_grep_trailing = 1;
809  *(cp+len-1) = '\0';
810  }
811  len = strlen(cp);
812  if (!len)
813  return;
814  if (len >= GREP_LEN) {
815  kdb_printf("search string too long\n");
816  return;
817  }
818  strcpy(kdb_grep_string, cp);
819  kdb_grepping_flag++;
820  return;
821 }
822 
823 /*
824  * kdb_parse - Parse the command line, search the command table for a
825  * matching command and invoke the command function. This
826  * function may be called recursively, if it is, the second call
827  * will overwrite argv and cbuf. It is the caller's
828  * responsibility to save their argv if they recursively call
829  * kdb_parse().
830  * Parameters:
831  * cmdstr The input command line to be parsed.
832  * regs The registers at the time kdb was entered.
833  * Returns:
834  * Zero for success, a kdb diagnostic if failure.
835  * Remarks:
836  * Limited to 20 tokens.
837  *
838  * Real rudimentary tokenization. Basically only whitespace
839  * is considered a token delimeter (but special consideration
840  * is taken of the '=' sign as used by the 'set' command).
841  *
842  * The algorithm used to tokenize the input string relies on
843  * there being at least one whitespace (or otherwise useless)
844  * character between tokens as the character immediately following
845  * the token is altered in-place to a null-byte to terminate the
846  * token string.
847  */
848 
849 #define MAXARGC 20
850 
851 int kdb_parse(const char *cmdstr)
852 {
853  static char *argv[MAXARGC];
854  static int argc;
855  static char cbuf[CMD_BUFLEN+2];
856  char *cp;
857  char *cpp, quoted;
858  kdbtab_t *tp;
859  int i, escaped, ignore_errors = 0, check_grep;
860 
861  /*
862  * First tokenize the command string.
863  */
864  cp = (char *)cmdstr;
865  kdb_grepping_flag = check_grep = 0;
866 
867  if (KDB_FLAG(CMD_INTERRUPT)) {
868  /* Previous command was interrupted, newline must not
869  * repeat the command */
870  KDB_FLAG_CLEAR(CMD_INTERRUPT);
871  KDB_STATE_SET(PAGER);
872  argc = 0; /* no repeat */
873  }
874 
875  if (*cp != '\n' && *cp != '\0') {
876  argc = 0;
877  cpp = cbuf;
878  while (*cp) {
879  /* skip whitespace */
880  while (isspace(*cp))
881  cp++;
882  if ((*cp == '\0') || (*cp == '\n') ||
883  (*cp == '#' && !defcmd_in_progress))
884  break;
885  /* special case: check for | grep pattern */
886  if (*cp == '|') {
887  check_grep++;
888  break;
889  }
890  if (cpp >= cbuf + CMD_BUFLEN) {
891  kdb_printf("kdb_parse: command buffer "
892  "overflow, command ignored\n%s\n",
893  cmdstr);
894  return KDB_NOTFOUND;
895  }
896  if (argc >= MAXARGC - 1) {
897  kdb_printf("kdb_parse: too many arguments, "
898  "command ignored\n%s\n", cmdstr);
899  return KDB_NOTFOUND;
900  }
901  argv[argc++] = cpp;
902  escaped = 0;
903  quoted = '\0';
904  /* Copy to next unquoted and unescaped
905  * whitespace or '=' */
906  while (*cp && *cp != '\n' &&
907  (escaped || quoted || !isspace(*cp))) {
908  if (cpp >= cbuf + CMD_BUFLEN)
909  break;
910  if (escaped) {
911  escaped = 0;
912  *cpp++ = *cp++;
913  continue;
914  }
915  if (*cp == '\\') {
916  escaped = 1;
917  ++cp;
918  continue;
919  }
920  if (*cp == quoted)
921  quoted = '\0';
922  else if (*cp == '\'' || *cp == '"')
923  quoted = *cp;
924  *cpp = *cp++;
925  if (*cpp == '=' && !quoted)
926  break;
927  ++cpp;
928  }
929  *cpp++ = '\0'; /* Squash a ws or '=' character */
930  }
931  }
932  if (!argc)
933  return 0;
934  if (check_grep)
935  parse_grep(cp);
936  if (defcmd_in_progress) {
937  int result = kdb_defcmd2(cmdstr, argv[0]);
938  if (!defcmd_in_progress) {
939  argc = 0; /* avoid repeat on endefcmd */
940  *(argv[0]) = '\0';
941  }
942  return result;
943  }
944  if (argv[0][0] == '-' && argv[0][1] &&
945  (argv[0][1] < '0' || argv[0][1] > '9')) {
946  ignore_errors = 1;
947  ++argv[0];
948  }
949 
950  for_each_kdbcmd(tp, i) {
951  if (tp->cmd_name) {
952  /*
953  * If this command is allowed to be abbreviated,
954  * check to see if this is it.
955  */
956 
957  if (tp->cmd_minlen
958  && (strlen(argv[0]) <= tp->cmd_minlen)) {
959  if (strncmp(argv[0],
960  tp->cmd_name,
961  tp->cmd_minlen) == 0) {
962  break;
963  }
964  }
965 
966  if (strcmp(argv[0], tp->cmd_name) == 0)
967  break;
968  }
969  }
970 
971  /*
972  * If we don't find a command by this name, see if the first
973  * few characters of this match any of the known commands.
974  * e.g., md1c20 should match md.
975  */
976  if (i == kdb_max_commands) {
977  for_each_kdbcmd(tp, i) {
978  if (tp->cmd_name) {
979  if (strncmp(argv[0],
980  tp->cmd_name,
981  strlen(tp->cmd_name)) == 0) {
982  break;
983  }
984  }
985  }
986  }
987 
988  if (i < kdb_max_commands) {
989  int result;
990  KDB_STATE_SET(CMD);
991  result = (*tp->cmd_func)(argc-1, (const char **)argv);
992  if (result && ignore_errors && result > KDB_CMD_GO)
993  result = 0;
994  KDB_STATE_CLEAR(CMD);
995  switch (tp->cmd_repeat) {
996  case KDB_REPEAT_NONE:
997  argc = 0;
998  if (argv[0])
999  *(argv[0]) = '\0';
1000  break;
1001  case KDB_REPEAT_NO_ARGS:
1002  argc = 1;
1003  if (argv[1])
1004  *(argv[1]) = '\0';
1005  break;
1006  case KDB_REPEAT_WITH_ARGS:
1007  break;
1008  }
1009  return result;
1010  }
1011 
1012  /*
1013  * If the input with which we were presented does not
1014  * map to an existing command, attempt to parse it as an
1015  * address argument and display the result. Useful for
1016  * obtaining the address of a variable, or the nearest symbol
1017  * to an address contained in a register.
1018  */
1019  {
1020  unsigned long value;
1021  char *name = NULL;
1022  long offset;
1023  int nextarg = 0;
1024 
1025  if (kdbgetaddrarg(0, (const char **)argv, &nextarg,
1026  &value, &offset, &name)) {
1027  return KDB_NOTFOUND;
1028  }
1029 
1030  kdb_printf("%s = ", argv[0]);
1031  kdb_symbol_print(value, NULL, KDB_SP_DEFAULT);
1032  kdb_printf("\n");
1033  return 0;
1034  }
1035 }
1036 
1037 
1038 static int handle_ctrl_cmd(char *cmd)
1039 {
1040 #define CTRL_P 16
1041 #define CTRL_N 14
1042 
1043  /* initial situation */
1044  if (cmd_head == cmd_tail)
1045  return 0;
1046  switch (*cmd) {
1047  case CTRL_P:
1048  if (cmdptr != cmd_tail)
1049  cmdptr = (cmdptr-1) % KDB_CMD_HISTORY_COUNT;
1050  strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1051  return 1;
1052  case CTRL_N:
1053  if (cmdptr != cmd_head)
1054  cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT;
1055  strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1056  return 1;
1057  }
1058  return 0;
1059 }
1060 
1061 /*
1062  * kdb_reboot - This function implements the 'reboot' command. Reboot
1063  * the system immediately, or loop for ever on failure.
1064  */
1065 static int kdb_reboot(int argc, const char **argv)
1066 {
1067  emergency_restart();
1068  kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
1069  while (1)
1070  cpu_relax();
1071  /* NOTREACHED */
1072  return 0;
1073 }
1074 
1075 static void kdb_dumpregs(struct pt_regs *regs)
1076 {
1077  int old_lvl = console_loglevel;
1078  console_loglevel = 15;
1079  kdb_trap_printk++;
1080  show_regs(regs);
1081  kdb_trap_printk--;
1082  kdb_printf("\n");
1083  console_loglevel = old_lvl;
1084 }
1085 
1086 void kdb_set_current_task(struct task_struct *p)
1087 {
1088  kdb_current_task = p;
1089 
1090  if (kdb_task_has_cpu(p)) {
1091  kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p));
1092  return;
1093  }
1094  kdb_current_regs = NULL;
1095 }
1096 
1097 /*
1098  * kdb_local - The main code for kdb. This routine is invoked on a
1099  * specific processor, it is not global. The main kdb() routine
1100  * ensures that only one processor at a time is in this routine.
1101  * This code is called with the real reason code on the first
1102  * entry to a kdb session, thereafter it is called with reason
1103  * SWITCH, even if the user goes back to the original cpu.
1104  * Inputs:
1105  * reason The reason KDB was invoked
1106  * error The hardware-defined error code
1107  * regs The exception frame at time of fault/breakpoint.
1108  * db_result Result code from the break or debug point.
1109  * Returns:
1110  * 0 KDB was invoked for an event which it wasn't responsible
1111  * 1 KDB handled the event for which it was invoked.
1112  * KDB_CMD_GO User typed 'go'.
1113  * KDB_CMD_CPU User switched to another cpu.
1114  * KDB_CMD_SS Single step.
1115  * KDB_CMD_SSB Single step until branch.
1116  */
1117 static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs,
1118  kdb_dbtrap_t db_result)
1119 {
1120  char *cmdbuf;
1121  int diag;
1122  struct task_struct *kdb_current =
1123  kdb_curr_task(raw_smp_processor_id());
1124 
1125  KDB_DEBUG_STATE("kdb_local 1", reason);
1126  kdb_go_count = 0;
1127  if (reason == KDB_REASON_DEBUG) {
1128  /* special case below */
1129  } else {
1130  kdb_printf("\nEntering kdb (current=0x%p, pid %d) ",
1131  kdb_current, kdb_current ? kdb_current->pid : 0);
1132 #if defined(CONFIG_SMP)
1133  kdb_printf("on processor %d ", raw_smp_processor_id());
1134 #endif
1135  }
1136 
1137  switch (reason) {
1138  case KDB_REASON_DEBUG:
1139  {
1140  /*
1141  * If re-entering kdb after a single step
1142  * command, don't print the message.
1143  */
1144  switch (db_result) {
1145  case KDB_DB_BPT:
1146  kdb_printf("\nEntering kdb (0x%p, pid %d) ",
1147  kdb_current, kdb_current->pid);
1148 #if defined(CONFIG_SMP)
1149  kdb_printf("on processor %d ", raw_smp_processor_id());
1150 #endif
1151  kdb_printf("due to Debug @ " kdb_machreg_fmt "\n",
1152  instruction_pointer(regs));
1153  break;
1154  case KDB_DB_SSB:
1155  /*
1156  * In the midst of ssb command. Just return.
1157  */
1158  KDB_DEBUG_STATE("kdb_local 3", reason);
1159  return KDB_CMD_SSB; /* Continue with SSB command */
1160 
1161  break;
1162  case KDB_DB_SS:
1163  break;
1164  case KDB_DB_SSBPT:
1165  KDB_DEBUG_STATE("kdb_local 4", reason);
1166  return 1; /* kdba_db_trap did the work */
1167  default:
1168  kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
1169  db_result);
1170  break;
1171  }
1172 
1173  }
1174  break;
1175  case KDB_REASON_ENTER:
1176  if (KDB_STATE(KEYBOARD))
1177  kdb_printf("due to Keyboard Entry\n");
1178  else
1179  kdb_printf("due to KDB_ENTER()\n");
1180  break;
1181  case KDB_REASON_KEYBOARD:
1182  KDB_STATE_SET(KEYBOARD);
1183  kdb_printf("due to Keyboard Entry\n");
1184  break;
1185  case KDB_REASON_ENTER_SLAVE:
1186  /* drop through, slaves only get released via cpu switch */
1187  case KDB_REASON_SWITCH:
1188  kdb_printf("due to cpu switch\n");
1189  break;
1190  case KDB_REASON_OOPS:
1191  kdb_printf("Oops: %s\n", kdb_diemsg);
1192  kdb_printf("due to oops @ " kdb_machreg_fmt "\n",
1193  instruction_pointer(regs));
1194  kdb_dumpregs(regs);
1195  break;
1196  case KDB_REASON_NMI:
1197  kdb_printf("due to NonMaskable Interrupt @ "
1198  kdb_machreg_fmt "\n",
1199  instruction_pointer(regs));
1200  kdb_dumpregs(regs);
1201  break;
1202  case KDB_REASON_SSTEP:
1203  case KDB_REASON_BREAK:
1204  kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
1205  reason == KDB_REASON_BREAK ?
1206  "Breakpoint" : "SS trap", instruction_pointer(regs));
1207  /*
1208  * Determine if this breakpoint is one that we
1209  * are interested in.
1210  */
1211  if (db_result != KDB_DB_BPT) {
1212  kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1213  db_result);
1214  KDB_DEBUG_STATE("kdb_local 6", reason);
1215  return 0; /* Not for us, dismiss it */
1216  }
1217  break;
1218  case KDB_REASON_RECURSE:
1219  kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
1220  instruction_pointer(regs));
1221  break;
1222  default:
1223  kdb_printf("kdb: unexpected reason code: %d\n", reason);
1224  KDB_DEBUG_STATE("kdb_local 8", reason);
1225  return 0; /* Not for us, dismiss it */
1226  }
1227 
1228  while (1) {
1229  /*
1230  * Initialize pager context.
1231  */
1232  kdb_nextline = 1;
1233  KDB_STATE_CLEAR(SUPPRESS);
1234 
1235  cmdbuf = cmd_cur;
1236  *cmdbuf = '\0';
1237  *(cmd_hist[cmd_head]) = '\0';
1238 
1239 do_full_getstr:
1240 #if defined(CONFIG_SMP)
1241  snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
1242  raw_smp_processor_id());
1243 #else
1244  snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"));
1245 #endif
1246  if (defcmd_in_progress)
1247  strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
1248 
1249  /*
1250  * Fetch command from keyboard
1251  */
1252  cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
1253  if (*cmdbuf != '\n') {
1254  if (*cmdbuf < 32) {
1255  if (cmdptr == cmd_head) {
1256  strncpy(cmd_hist[cmd_head], cmd_cur,
1257  CMD_BUFLEN);
1258  *(cmd_hist[cmd_head] +
1259  strlen(cmd_hist[cmd_head])-1) = '\0';
1260  }
1261  if (!handle_ctrl_cmd(cmdbuf))
1262  *(cmd_cur+strlen(cmd_cur)-1) = '\0';
1263  cmdbuf = cmd_cur;
1264  goto do_full_getstr;
1265  } else {
1266  strncpy(cmd_hist[cmd_head], cmd_cur,
1267  CMD_BUFLEN);
1268  }
1269 
1270  cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
1271  if (cmd_head == cmd_tail)
1272  cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
1273  }
1274 
1275  cmdptr = cmd_head;
1276  diag = kdb_parse(cmdbuf);
1277  if (diag == KDB_NOTFOUND) {
1278  kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
1279  diag = 0;
1280  }
1281  if (diag == KDB_CMD_GO
1282  || diag == KDB_CMD_CPU
1283  || diag == KDB_CMD_SS
1284  || diag == KDB_CMD_SSB
1285  || diag == KDB_CMD_KGDB)
1286  break;
1287 
1288  if (diag)
1289  kdb_cmderror(diag);
1290  }
1291  KDB_DEBUG_STATE("kdb_local 9", diag);
1292  return diag;
1293 }
1294 
1295 
1296 /*
1297  * kdb_print_state - Print the state data for the current processor
1298  * for debugging.
1299  * Inputs:
1300  * text Identifies the debug point
1301  * value Any integer value to be printed, e.g. reason code.
1302  */
1303 void kdb_print_state(const char *text, int value)
1304 {
1305  kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1306  text, raw_smp_processor_id(), value, kdb_initial_cpu,
1307  kdb_state);
1308 }
1309 
1310 /*
1311  * kdb_main_loop - After initial setup and assignment of the
1312  * controlling cpu, all cpus are in this loop. One cpu is in
1313  * control and will issue the kdb prompt, the others will spin
1314  * until 'go' or cpu switch.
1315  *
1316  * To get a consistent view of the kernel stacks for all
1317  * processes, this routine is invoked from the main kdb code via
1318  * an architecture specific routine. kdba_main_loop is
1319  * responsible for making the kernel stacks consistent for all
1320  * processes, there should be no difference between a blocked
1321  * process and a running process as far as kdb is concerned.
1322  * Inputs:
1323  * reason The reason KDB was invoked
1324  * error The hardware-defined error code
1325  * reason2 kdb's current reason code.
1326  * Initially error but can change
1327  * according to kdb state.
1328  * db_result Result code from break or debug point.
1329  * regs The exception frame at time of fault/breakpoint.
1330  * should always be valid.
1331  * Returns:
1332  * 0 KDB was invoked for an event which it wasn't responsible
1333  * 1 KDB handled the event for which it was invoked.
1334  */
1335 int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
1336  kdb_dbtrap_t db_result, struct pt_regs *regs)
1337 {
1338  int result = 1;
1339  /* Stay in kdb() until 'go', 'ss[b]' or an error */
1340  while (1) {
1341  /*
1342  * All processors except the one that is in control
1343  * will spin here.
1344  */
1345  KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1346  while (KDB_STATE(HOLD_CPU)) {
1347  /* state KDB is turned off by kdb_cpu to see if the
1348  * other cpus are still live, each cpu in this loop
1349  * turns it back on.
1350  */
1351  if (!KDB_STATE(KDB))
1352  KDB_STATE_SET(KDB);
1353  }
1354 
1355  KDB_STATE_CLEAR(SUPPRESS);
1356  KDB_DEBUG_STATE("kdb_main_loop 2", reason);
1357  if (KDB_STATE(LEAVING))
1358  break; /* Another cpu said 'go' */
1359  /* Still using kdb, this processor is in control */
1360  result = kdb_local(reason2, error, regs, db_result);
1361  KDB_DEBUG_STATE("kdb_main_loop 3", result);
1362 
1363  if (result == KDB_CMD_CPU)
1364  break;
1365 
1366  if (result == KDB_CMD_SS) {
1367  KDB_STATE_SET(DOING_SS);
1368  break;
1369  }
1370 
1371  if (result == KDB_CMD_SSB) {
1372  KDB_STATE_SET(DOING_SS);
1373  KDB_STATE_SET(DOING_SSB);
1374  break;
1375  }
1376 
1377  if (result == KDB_CMD_KGDB) {
1378  if (!KDB_STATE(DOING_KGDB))
1379  kdb_printf("Entering please attach debugger "
1380  "or use $D#44+ or $3#33\n");
1381  break;
1382  }
1383  if (result && result != 1 && result != KDB_CMD_GO)
1384  kdb_printf("\nUnexpected kdb_local return code %d\n",
1385  result);
1386  KDB_DEBUG_STATE("kdb_main_loop 4", reason);
1387  break;
1388  }
1389  if (KDB_STATE(DOING_SS))
1390  KDB_STATE_CLEAR(SSBPT);
1391 
1392  /* Clean up any keyboard devices before leaving */
1393  kdb_kbd_cleanup_state();
1394 
1395  return result;
1396 }
1397 
1398 /*
1399  * kdb_mdr - This function implements the guts of the 'mdr', memory
1400  * read command.
1401  * mdr <addr arg>,<byte count>
1402  * Inputs:
1403  * addr Start address
1404  * count Number of bytes
1405  * Returns:
1406  * Always 0. Any errors are detected and printed by kdb_getarea.
1407  */
1408 static int kdb_mdr(unsigned long addr, unsigned int count)
1409 {
1410  unsigned char c;
1411  while (count--) {
1412  if (kdb_getarea(c, addr))
1413  return 0;
1414  kdb_printf("%02x", c);
1415  addr++;
1416  }
1417  kdb_printf("\n");
1418  return 0;
1419 }
1420 
1421 /*
1422  * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1423  * 'md8' 'mdr' and 'mds' commands.
1424  *
1425  * md|mds [<addr arg> [<line count> [<radix>]]]
1426  * mdWcN [<addr arg> [<line count> [<radix>]]]
1427  * where W = is the width (1, 2, 4 or 8) and N is the count.
1428  * for eg., md1c20 reads 20 bytes, 1 at a time.
1429  * mdr <addr arg>,<byte count>
1430  */
1431 static void kdb_md_line(const char *fmtstr, unsigned long addr,
1432  int symbolic, int nosect, int bytesperword,
1433  int num, int repeat, int phys)
1434 {
1435  /* print just one line of data */
1436  kdb_symtab_t symtab;
1437  char cbuf[32];
1438  char *c = cbuf;
1439  int i;
1440  unsigned long word;
1441 
1442  memset(cbuf, '\0', sizeof(cbuf));
1443  if (phys)
1444  kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1445  else
1446  kdb_printf(kdb_machreg_fmt0 " ", addr);
1447 
1448  for (i = 0; i < num && repeat--; i++) {
1449  if (phys) {
1450  if (kdb_getphysword(&word, addr, bytesperword))
1451  break;
1452  } else if (kdb_getword(&word, addr, bytesperword))
1453  break;
1454  kdb_printf(fmtstr, word);
1455  if (symbolic)
1456  kdbnearsym(word, &symtab);
1457  else
1458  memset(&symtab, 0, sizeof(symtab));
1459  if (symtab.sym_name) {
1460  kdb_symbol_print(word, &symtab, 0);
1461  if (!nosect) {
1462  kdb_printf("\n");
1463  kdb_printf(" %s %s "
1464  kdb_machreg_fmt " "
1465  kdb_machreg_fmt " "
1466  kdb_machreg_fmt, symtab.mod_name,
1467  symtab.sec_name, symtab.sec_start,
1468  symtab.sym_start, symtab.sym_end);
1469  }
1470  addr += bytesperword;
1471  } else {
1472  union {
1473  u64 word;
1474  unsigned char c[8];
1475  } wc;
1476  unsigned char *cp;
1477 #ifdef __BIG_ENDIAN
1478  cp = wc.c + 8 - bytesperword;
1479 #else
1480  cp = wc.c;
1481 #endif
1482  wc.word = word;
1483 #define printable_char(c) \
1484  ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1485  switch (bytesperword) {
1486  case 8:
1487  *c++ = printable_char(*cp++);
1488  *c++ = printable_char(*cp++);
1489  *c++ = printable_char(*cp++);
1490  *c++ = printable_char(*cp++);
1491  addr += 4;
1492  case 4:
1493  *c++ = printable_char(*cp++);
1494  *c++ = printable_char(*cp++);
1495  addr += 2;
1496  case 2:
1497  *c++ = printable_char(*cp++);
1498  addr++;
1499  case 1:
1500  *c++ = printable_char(*cp++);
1501  addr++;
1502  break;
1503  }
1504 #undef printable_char
1505  }
1506  }
1507  kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1508  " ", cbuf);
1509 }
1510 
1511 static int kdb_md(int argc, const char **argv)
1512 {
1513  static unsigned long last_addr;
1514  static int last_radix, last_bytesperword, last_repeat;
1515  int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1516  int nosect = 0;
1517  char fmtchar, fmtstr[64];
1518  unsigned long addr;
1519  unsigned long word;
1520  long offset = 0;
1521  int symbolic = 0;
1522  int valid = 0;
1523  int phys = 0;
1524 
1525  kdbgetintenv("MDCOUNT", &mdcount);
1526  kdbgetintenv("RADIX", &radix);
1527  kdbgetintenv("BYTESPERWORD", &bytesperword);
1528 
1529  /* Assume 'md <addr>' and start with environment values */
1530  repeat = mdcount * 16 / bytesperword;
1531 
1532  if (strcmp(argv[0], "mdr") == 0) {
1533  if (argc != 2)
1534  return KDB_ARGCOUNT;
1535  valid = 1;
1536  } else if (isdigit(argv[0][2])) {
1537  bytesperword = (int)(argv[0][2] - '0');
1538  if (bytesperword == 0) {
1539  bytesperword = last_bytesperword;
1540  if (bytesperword == 0)
1541  bytesperword = 4;
1542  }
1543  last_bytesperword = bytesperword;
1544  repeat = mdcount * 16 / bytesperword;
1545  if (!argv[0][3])
1546  valid = 1;
1547  else if (argv[0][3] == 'c' && argv[0][4]) {
1548  char *p;
1549  repeat = simple_strtoul(argv[0] + 4, &p, 10);
1550  mdcount = ((repeat * bytesperword) + 15) / 16;
1551  valid = !*p;
1552  }
1553  last_repeat = repeat;
1554  } else if (strcmp(argv[0], "md") == 0)
1555  valid = 1;
1556  else if (strcmp(argv[0], "mds") == 0)
1557  valid = 1;
1558  else if (strcmp(argv[0], "mdp") == 0) {
1559  phys = valid = 1;
1560  }
1561  if (!valid)
1562  return KDB_NOTFOUND;
1563 
1564  if (argc == 0) {
1565  if (last_addr == 0)
1566  return KDB_ARGCOUNT;
1567  addr = last_addr;
1568  radix = last_radix;
1569  bytesperword = last_bytesperword;
1570  repeat = last_repeat;
1571  mdcount = ((repeat * bytesperword) + 15) / 16;
1572  }
1573 
1574  if (argc) {
1575  unsigned long val;
1576  int diag, nextarg = 1;
1577  diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1578  &offset, NULL);
1579  if (diag)
1580  return diag;
1581  if (argc > nextarg+2)
1582  return KDB_ARGCOUNT;
1583 
1584  if (argc >= nextarg) {
1585  diag = kdbgetularg(argv[nextarg], &val);
1586  if (!diag) {
1587  mdcount = (int) val;
1588  repeat = mdcount * 16 / bytesperword;
1589  }
1590  }
1591  if (argc >= nextarg+1) {
1592  diag = kdbgetularg(argv[nextarg+1], &val);
1593  if (!diag)
1594  radix = (int) val;
1595  }
1596  }
1597 
1598  if (strcmp(argv[0], "mdr") == 0)
1599  return kdb_mdr(addr, mdcount);
1600 
1601  switch (radix) {
1602  case 10:
1603  fmtchar = 'd';
1604  break;
1605  case 16:
1606  fmtchar = 'x';
1607  break;
1608  case 8:
1609  fmtchar = 'o';
1610  break;
1611  default:
1612  return KDB_BADRADIX;
1613  }
1614 
1615  last_radix = radix;
1616 
1617  if (bytesperword > KDB_WORD_SIZE)
1618  return KDB_BADWIDTH;
1619 
1620  switch (bytesperword) {
1621  case 8:
1622  sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1623  break;
1624  case 4:
1625  sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1626  break;
1627  case 2:
1628  sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1629  break;
1630  case 1:
1631  sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1632  break;
1633  default:
1634  return KDB_BADWIDTH;
1635  }
1636 
1637  last_repeat = repeat;
1638  last_bytesperword = bytesperword;
1639 
1640  if (strcmp(argv[0], "mds") == 0) {
1641  symbolic = 1;
1642  /* Do not save these changes as last_*, they are temporary mds
1643  * overrides.
1644  */
1645  bytesperword = KDB_WORD_SIZE;
1646  repeat = mdcount;
1647  kdbgetintenv("NOSECT", &nosect);
1648  }
1649 
1650  /* Round address down modulo BYTESPERWORD */
1651 
1652  addr &= ~(bytesperword-1);
1653 
1654  while (repeat > 0) {
1655  unsigned long a;
1656  int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1657 
1658  if (KDB_FLAG(CMD_INTERRUPT))
1659  return 0;
1660  for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1661  if (phys) {
1662  if (kdb_getphysword(&word, a, bytesperword)
1663  || word)
1664  break;
1665  } else if (kdb_getword(&word, a, bytesperword) || word)
1666  break;
1667  }
1668  n = min(num, repeat);
1669  kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1670  num, repeat, phys);
1671  addr += bytesperword * n;
1672  repeat -= n;
1673  z = (z + num - 1) / num;
1674  if (z > 2) {
1675  int s = num * (z-2);
1676  kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1677  " zero suppressed\n",
1678  addr, addr + bytesperword * s - 1);
1679  addr += bytesperword * s;
1680  repeat -= s;
1681  }
1682  }
1683  last_addr = addr;
1684 
1685  return 0;
1686 }
1687 
1688 /*
1689  * kdb_mm - This function implements the 'mm' command.
1690  * mm address-expression new-value
1691  * Remarks:
1692  * mm works on machine words, mmW works on bytes.
1693  */
1694 static int kdb_mm(int argc, const char **argv)
1695 {
1696  int diag;
1697  unsigned long addr;
1698  long offset = 0;
1699  unsigned long contents;
1700  int nextarg;
1701  int width;
1702 
1703  if (argv[0][2] && !isdigit(argv[0][2]))
1704  return KDB_NOTFOUND;
1705 
1706  if (argc < 2)
1707  return KDB_ARGCOUNT;
1708 
1709  nextarg = 1;
1710  diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1711  if (diag)
1712  return diag;
1713 
1714  if (nextarg > argc)
1715  return KDB_ARGCOUNT;
1716  diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1717  if (diag)
1718  return diag;
1719 
1720  if (nextarg != argc + 1)
1721  return KDB_ARGCOUNT;
1722 
1723  width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1724  diag = kdb_putword(addr, contents, width);
1725  if (diag)
1726  return diag;
1727 
1728  kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1729 
1730  return 0;
1731 }
1732 
1733 /*
1734  * kdb_go - This function implements the 'go' command.
1735  * go [address-expression]
1736  */
1737 static int kdb_go(int argc, const char **argv)
1738 {
1739  unsigned long addr;
1740  int diag;
1741  int nextarg;
1742  long offset;
1743 
1744  if (raw_smp_processor_id() != kdb_initial_cpu) {
1745  kdb_printf("go must execute on the entry cpu, "
1746  "please use \"cpu %d\" and then execute go\n",
1747  kdb_initial_cpu);
1748  return KDB_BADCPUNUM;
1749  }
1750  if (argc == 1) {
1751  nextarg = 1;
1752  diag = kdbgetaddrarg(argc, argv, &nextarg,
1753  &addr, &offset, NULL);
1754  if (diag)
1755  return diag;
1756  } else if (argc) {
1757  return KDB_ARGCOUNT;
1758  }
1759 
1760  diag = KDB_CMD_GO;
1761  if (KDB_FLAG(CATASTROPHIC)) {
1762  kdb_printf("Catastrophic error detected\n");
1763  kdb_printf("kdb_continue_catastrophic=%d, ",
1764  kdb_continue_catastrophic);
1765  if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1766  kdb_printf("type go a second time if you really want "
1767  "to continue\n");
1768  return 0;
1769  }
1770  if (kdb_continue_catastrophic == 2) {
1771  kdb_printf("forcing reboot\n");
1772  kdb_reboot(0, NULL);
1773  }
1774  kdb_printf("attempting to continue\n");
1775  }
1776  return diag;
1777 }
1778 
1779 /*
1780  * kdb_rd - This function implements the 'rd' command.
1781  */
1782 static int kdb_rd(int argc, const char **argv)
1783 {
1784  int len = kdb_check_regs();
1785 #if DBG_MAX_REG_NUM > 0
1786  int i;
1787  char *rname;
1788  int rsize;
1789  u64 reg64;
1790  u32 reg32;
1791  u16 reg16;
1792  u8 reg8;
1793 
1794  if (len)
1795  return len;
1796 
1797  for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1798  rsize = dbg_reg_def[i].size * 2;
1799  if (rsize > 16)
1800  rsize = 2;
1801  if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
1802  len = 0;
1803  kdb_printf("\n");
1804  }
1805  if (len)
1806  len += kdb_printf(" ");
1807  switch(dbg_reg_def[i].size * 8) {
1808  case 8:
1809  rname = dbg_get_reg(i, &reg8, kdb_current_regs);
1810  if (!rname)
1811  break;
1812  len += kdb_printf("%s: %02x", rname, reg8);
1813  break;
1814  case 16:
1815  rname = dbg_get_reg(i, &reg16, kdb_current_regs);
1816  if (!rname)
1817  break;
1818  len += kdb_printf("%s: %04x", rname, reg16);
1819  break;
1820  case 32:
1821  rname = dbg_get_reg(i, &reg32, kdb_current_regs);
1822  if (!rname)
1823  break;
1824  len += kdb_printf("%s: %08x", rname, reg32);
1825  break;
1826  case 64:
1827  rname = dbg_get_reg(i, &reg64, kdb_current_regs);
1828  if (!rname)
1829  break;
1830  len += kdb_printf("%s: %016llx", rname, reg64);
1831  break;
1832  default:
1833  len += kdb_printf("%s: ??", dbg_reg_def[i].name);
1834  }
1835  }
1836  kdb_printf("\n");
1837 #else
1838  if (len)
1839  return len;
1840 
1841  kdb_dumpregs(kdb_current_regs);
1842 #endif
1843  return 0;
1844 }
1845 
1846 /*
1847  * kdb_rm - This function implements the 'rm' (register modify) command.
1848  * rm register-name new-contents
1849  * Remarks:
1850  * Allows register modification with the same restrictions as gdb
1851  */
1852 static int kdb_rm(int argc, const char **argv)
1853 {
1854 #if DBG_MAX_REG_NUM > 0
1855  int diag;
1856  const char *rname;
1857  int i;
1858  u64 reg64;
1859  u32 reg32;
1860  u16 reg16;
1861  u8 reg8;
1862 
1863  if (argc != 2)
1864  return KDB_ARGCOUNT;
1865  /*
1866  * Allow presence or absence of leading '%' symbol.
1867  */
1868  rname = argv[1];
1869  if (*rname == '%')
1870  rname++;
1871 
1872  diag = kdbgetu64arg(argv[2], &reg64);
1873  if (diag)
1874  return diag;
1875 
1876  diag = kdb_check_regs();
1877  if (diag)
1878  return diag;
1879 
1880  diag = KDB_BADREG;
1881  for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1882  if (strcmp(rname, dbg_reg_def[i].name) == 0) {
1883  diag = 0;
1884  break;
1885  }
1886  }
1887  if (!diag) {
1888  switch(dbg_reg_def[i].size * 8) {
1889  case 8:
1890  reg8 = reg64;
1891  dbg_set_reg(i, &reg8, kdb_current_regs);
1892  break;
1893  case 16:
1894  reg16 = reg64;
1895  dbg_set_reg(i, &reg16, kdb_current_regs);
1896  break;
1897  case 32:
1898  reg32 = reg64;
1899  dbg_set_reg(i, &reg32, kdb_current_regs);
1900  break;
1901  case 64:
1902  dbg_set_reg(i, &reg64, kdb_current_regs);
1903  break;
1904  }
1905  }
1906  return diag;
1907 #else
1908  kdb_printf("ERROR: Register set currently not implemented\n");
1909  return 0;
1910 #endif
1911 }
1912 
1913 #if defined(CONFIG_MAGIC_SYSRQ)
1914 /*
1915  * kdb_sr - This function implements the 'sr' (SYSRQ key) command
1916  * which interfaces to the soi-disant MAGIC SYSRQ functionality.
1917  * sr <magic-sysrq-code>
1918  */
1919 static int kdb_sr(int argc, const char **argv)
1920 {
1921  if (argc != 1)
1922  return KDB_ARGCOUNT;
1923  kdb_trap_printk++;
1924  __handle_sysrq(*argv[1], false);
1925  kdb_trap_printk--;
1926 
1927  return 0;
1928 }
1929 #endif /* CONFIG_MAGIC_SYSRQ */
1930 
1931 /*
1932  * kdb_ef - This function implements the 'regs' (display exception
1933  * frame) command. This command takes an address and expects to
1934  * find an exception frame at that address, formats and prints
1935  * it.
1936  * regs address-expression
1937  * Remarks:
1938  * Not done yet.
1939  */
1940 static int kdb_ef(int argc, const char **argv)
1941 {
1942  int diag;
1943  unsigned long addr;
1944  long offset;
1945  int nextarg;
1946 
1947  if (argc != 1)
1948  return KDB_ARGCOUNT;
1949 
1950  nextarg = 1;
1951  diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1952  if (diag)
1953  return diag;
1954  show_regs((struct pt_regs *)addr);
1955  return 0;
1956 }
1957 
1958 #if defined(CONFIG_MODULES)
1959 /*
1960  * kdb_lsmod - This function implements the 'lsmod' command. Lists
1961  * currently loaded kernel modules.
1962  * Mostly taken from userland lsmod.
1963  */
1964 static int kdb_lsmod(int argc, const char **argv)
1965 {
1966  struct module *mod;
1967 
1968  if (argc != 0)
1969  return KDB_ARGCOUNT;
1970 
1971  kdb_printf("Module Size modstruct Used by\n");
1972  list_for_each_entry(mod, kdb_modules, list) {
1973 
1974  kdb_printf("%-20s%8u 0x%p ", mod->name,
1975  mod->core_size, (void *)mod);
1976 #ifdef CONFIG_MODULE_UNLOAD
1977  kdb_printf("%4ld ", module_refcount(mod));
1978 #endif
1979  if (mod->state == MODULE_STATE_GOING)
1980  kdb_printf(" (Unloading)");
1981  else if (mod->state == MODULE_STATE_COMING)
1982  kdb_printf(" (Loading)");
1983  else
1984  kdb_printf(" (Live)");
1985  kdb_printf(" 0x%p", mod->module_core);
1986 
1987 #ifdef CONFIG_MODULE_UNLOAD
1988  {
1989  struct module_use *use;
1990  kdb_printf(" [ ");
1991  list_for_each_entry(use, &mod->source_list,
1992  source_list)
1993  kdb_printf("%s ", use->target->name);
1994  kdb_printf("]\n");
1995  }
1996 #endif
1997  }
1998 
1999  return 0;
2000 }
2001 
2002 #endif /* CONFIG_MODULES */
2003 
2004 /*
2005  * kdb_env - This function implements the 'env' command. Display the
2006  * current environment variables.
2007  */
2008 
2009 static int kdb_env(int argc, const char **argv)
2010 {
2011  int i;
2012 
2013  for (i = 0; i < __nenv; i++) {
2014  if (__env[i])
2015  kdb_printf("%s\n", __env[i]);
2016  }
2017 
2018  if (KDB_DEBUG(MASK))
2019  kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
2020 
2021  return 0;
2022 }
2023 
2024 #ifdef CONFIG_PRINTK
2025 /*
2026  * kdb_dmesg - This function implements the 'dmesg' command to display
2027  * the contents of the syslog buffer.
2028  * dmesg [lines] [adjust]
2029  */
2030 static int kdb_dmesg(int argc, const char **argv)
2031 {
2032  int diag;
2033  int logging;
2034  int lines = 0;
2035  int adjust = 0;
2036  int n = 0;
2037  int skip = 0;
2038  struct kmsg_dumper dumper = { .active = 1 };
2039  size_t len;
2040  char buf[201];
2041 
2042  if (argc > 2)
2043  return KDB_ARGCOUNT;
2044  if (argc) {
2045  char *cp;
2046  lines = simple_strtol(argv[1], &cp, 0);
2047  if (*cp)
2048  lines = 0;
2049  if (argc > 1) {
2050  adjust = simple_strtoul(argv[2], &cp, 0);
2051  if (*cp || adjust < 0)
2052  adjust = 0;
2053  }
2054  }
2055 
2056  /* disable LOGGING if set */
2057  diag = kdbgetintenv("LOGGING", &logging);
2058  if (!diag && logging) {
2059  const char *setargs[] = { "set", "LOGGING", "0" };
2060  kdb_set(2, setargs);
2061  }
2062 
2063  kmsg_dump_rewind_nolock(&dumper);
2064  while (kmsg_dump_get_line_nolock(&dumper, 1, NULL, 0, NULL))
2065  n++;
2066 
2067  if (lines < 0) {
2068  if (adjust >= n)
2069  kdb_printf("buffer only contains %d lines, nothing "
2070  "printed\n", n);
2071  else if (adjust - lines >= n)
2072  kdb_printf("buffer only contains %d lines, last %d "
2073  "lines printed\n", n, n - adjust);
2074  skip = adjust;
2075  lines = abs(lines);
2076  } else if (lines > 0) {
2077  skip = n - lines - adjust;
2078  lines = abs(lines);
2079  if (adjust >= n) {
2080  kdb_printf("buffer only contains %d lines, "
2081  "nothing printed\n", n);
2082  skip = n;
2083  } else if (skip < 0) {
2084  lines += skip;
2085  skip = 0;
2086  kdb_printf("buffer only contains %d lines, first "
2087  "%d lines printed\n", n, lines);
2088  }
2089  } else {
2090  lines = n;
2091  }
2092 
2093  if (skip >= n || skip < 0)
2094  return 0;
2095 
2096  kmsg_dump_rewind_nolock(&dumper);
2097  while (kmsg_dump_get_line_nolock(&dumper, 1, buf, sizeof(buf), &len)) {
2098  if (skip) {
2099  skip--;
2100  continue;
2101  }
2102  if (!lines--)
2103  break;
2104  if (KDB_FLAG(CMD_INTERRUPT))
2105  return 0;
2106 
2107  kdb_printf("%.*s\n", (int)len - 1, buf);
2108  }
2109 
2110  return 0;
2111 }
2112 #endif /* CONFIG_PRINTK */
2113 
2114 /* Make sure we balance enable/disable calls, must disable first. */
2115 static atomic_t kdb_nmi_disabled;
2116 
2117 static int kdb_disable_nmi(int argc, const char *argv[])
2118 {
2119  if (atomic_read(&kdb_nmi_disabled))
2120  return 0;
2121  atomic_set(&kdb_nmi_disabled, 1);
2122  arch_kgdb_ops.enable_nmi(0);
2123  return 0;
2124 }
2125 
2126 static int kdb_param_enable_nmi(const char *val, const struct kernel_param *kp)
2127 {
2128  if (!atomic_add_unless(&kdb_nmi_disabled, -1, 0))
2129  return -EINVAL;
2130  arch_kgdb_ops.enable_nmi(1);
2131  return 0;
2132 }
2133 
2134 static const struct kernel_param_ops kdb_param_ops_enable_nmi = {
2135  .set = kdb_param_enable_nmi,
2136 };
2137 module_param_cb(enable_nmi, &kdb_param_ops_enable_nmi, NULL, 0600);
2138 
2139 /*
2140  * kdb_cpu - This function implements the 'cpu' command.
2141  * cpu [<cpunum>]
2142  * Returns:
2143  * KDB_CMD_CPU for success, a kdb diagnostic if error
2144  */
2145 static void kdb_cpu_status(void)
2146 {
2147  int i, start_cpu, first_print = 1;
2148  char state, prev_state = '?';
2149 
2150  kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2151  kdb_printf("Available cpus: ");
2152  for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2153  if (!cpu_online(i)) {
2154  state = 'F'; /* cpu is offline */
2155  } else {
2156  state = ' '; /* cpu is responding to kdb */
2157  if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2158  state = 'I'; /* idle task */
2159  }
2160  if (state != prev_state) {
2161  if (prev_state != '?') {
2162  if (!first_print)
2163  kdb_printf(", ");
2164  first_print = 0;
2165  kdb_printf("%d", start_cpu);
2166  if (start_cpu < i-1)
2167  kdb_printf("-%d", i-1);
2168  if (prev_state != ' ')
2169  kdb_printf("(%c)", prev_state);
2170  }
2171  prev_state = state;
2172  start_cpu = i;
2173  }
2174  }
2175  /* print the trailing cpus, ignoring them if they are all offline */
2176  if (prev_state != 'F') {
2177  if (!first_print)
2178  kdb_printf(", ");
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);
2184  }
2185  kdb_printf("\n");
2186 }
2187 
2188 static int kdb_cpu(int argc, const char **argv)
2189 {
2190  unsigned long cpunum;
2191  int diag;
2192 
2193  if (argc == 0) {
2194  kdb_cpu_status();
2195  return 0;
2196  }
2197 
2198  if (argc != 1)
2199  return KDB_ARGCOUNT;
2200 
2201  diag = kdbgetularg(argv[1], &cpunum);
2202  if (diag)
2203  return diag;
2204 
2205  /*
2206  * Validate cpunum
2207  */
2208  if ((cpunum > NR_CPUS) || !cpu_online(cpunum))
2209  return KDB_BADCPUNUM;
2210 
2211  dbg_switch_cpu = cpunum;
2212 
2213  /*
2214  * Switch to other cpu
2215  */
2216  return KDB_CMD_CPU;
2217 }
2218 
2219 /* The user may not realize that ps/bta with no parameters does not print idle
2220  * or sleeping system daemon processes, so tell them how many were suppressed.
2221  */
2222 void kdb_ps_suppressed(void)
2223 {
2224  int idle = 0, daemon = 0;
2225  unsigned long mask_I = kdb_task_state_string("I"),
2226  mask_M = kdb_task_state_string("M");
2227  unsigned long cpu;
2228  const struct task_struct *p, *g;
2229  for_each_online_cpu(cpu) {
2230  p = kdb_curr_task(cpu);
2231  if (kdb_task_state(p, mask_I))
2232  ++idle;
2233  }
2234  kdb_do_each_thread(g, p) {
2235  if (kdb_task_state(p, mask_M))
2236  ++daemon;
2237  } kdb_while_each_thread(g, p);
2238  if (idle || daemon) {
2239  if (idle)
2240  kdb_printf("%d idle process%s (state I)%s\n",
2241  idle, idle == 1 ? "" : "es",
2242  daemon ? " and " : "");
2243  if (daemon)
2244  kdb_printf("%d sleeping system daemon (state M) "
2245  "process%s", daemon,
2246  daemon == 1 ? "" : "es");
2247  kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2248  }
2249 }
2250 
2251 /*
2252  * kdb_ps - This function implements the 'ps' command which shows a
2253  * list of the active processes.
2254  * ps [DRSTCZEUIMA] All processes, optionally filtered by state
2255  */
2256 void kdb_ps1(const struct task_struct *p)
2257 {
2258  int cpu;
2259  unsigned long tmp;
2260 
2261  if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
2262  return;
2263 
2264  cpu = kdb_process_cpu(p);
2265  kdb_printf("0x%p %8d %8d %d %4d %c 0x%p %c%s\n",
2266  (void *)p, p->pid, p->parent->pid,
2267  kdb_task_has_cpu(p), kdb_process_cpu(p),
2268  kdb_task_state_char(p),
2269  (void *)(&p->thread),
2270  p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2271  p->comm);
2272  if (kdb_task_has_cpu(p)) {
2273  if (!KDB_TSK(cpu)) {
2274  kdb_printf(" Error: no saved data for this cpu\n");
2275  } else {
2276  if (KDB_TSK(cpu) != p)
2277  kdb_printf(" Error: does not match running "
2278  "process table (0x%p)\n", KDB_TSK(cpu));
2279  }
2280  }
2281 }
2282 
2283 static int kdb_ps(int argc, const char **argv)
2284 {
2285  struct task_struct *g, *p;
2286  unsigned long mask, cpu;
2287 
2288  if (argc == 0)
2289  kdb_ps_suppressed();
2290  kdb_printf("%-*s Pid Parent [*] cpu State %-*s Command\n",
2291  (int)(2*sizeof(void *))+2, "Task Addr",
2292  (int)(2*sizeof(void *))+2, "Thread");
2293  mask = kdb_task_state_string(argc ? argv[1] : NULL);
2294  /* Run the active tasks first */
2295  for_each_online_cpu(cpu) {
2296  if (KDB_FLAG(CMD_INTERRUPT))
2297  return 0;
2298  p = kdb_curr_task(cpu);
2299  if (kdb_task_state(p, mask))
2300  kdb_ps1(p);
2301  }
2302  kdb_printf("\n");
2303  /* Now the real tasks */
2304  kdb_do_each_thread(g, p) {
2305  if (KDB_FLAG(CMD_INTERRUPT))
2306  return 0;
2307  if (kdb_task_state(p, mask))
2308  kdb_ps1(p);
2309  } kdb_while_each_thread(g, p);
2310 
2311  return 0;
2312 }
2313 
2314 /*
2315  * kdb_pid - This function implements the 'pid' command which switches
2316  * the currently active process.
2317  * pid [<pid> | R]
2318  */
2319 static int kdb_pid(int argc, const char **argv)
2320 {
2321  struct task_struct *p;
2322  unsigned long val;
2323  int diag;
2324 
2325  if (argc > 1)
2326  return KDB_ARGCOUNT;
2327 
2328  if (argc) {
2329  if (strcmp(argv[1], "R") == 0) {
2330  p = KDB_TSK(kdb_initial_cpu);
2331  } else {
2332  diag = kdbgetularg(argv[1], &val);
2333  if (diag)
2334  return KDB_BADINT;
2335 
2336  p = find_task_by_pid_ns((pid_t)val, &init_pid_ns);
2337  if (!p) {
2338  kdb_printf("No task with pid=%d\n", (pid_t)val);
2339  return 0;
2340  }
2341  }
2342  kdb_set_current_task(p);
2343  }
2344  kdb_printf("KDB current process is %s(pid=%d)\n",
2345  kdb_current_task->comm,
2346  kdb_current_task->pid);
2347 
2348  return 0;
2349 }
2350 
2351 /*
2352  * kdb_ll - This function implements the 'll' command which follows a
2353  * linked list and executes an arbitrary command for each
2354  * element.
2355  */
2356 static int kdb_ll(int argc, const char **argv)
2357 {
2358  int diag = 0;
2359  unsigned long addr;
2360  long offset = 0;
2361  unsigned long va;
2362  unsigned long linkoffset;
2363  int nextarg;
2364  const char *command;
2365 
2366  if (argc != 3)
2367  return KDB_ARGCOUNT;
2368 
2369  nextarg = 1;
2370  diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
2371  if (diag)
2372  return diag;
2373 
2374  diag = kdbgetularg(argv[2], &linkoffset);
2375  if (diag)
2376  return diag;
2377 
2378  /*
2379  * Using the starting address as
2380  * the first element in the list, and assuming that
2381  * the list ends with a null pointer.
2382  */
2383 
2384  va = addr;
2385  command = kdb_strdup(argv[3], GFP_KDB);
2386  if (!command) {
2387  kdb_printf("%s: cannot duplicate command\n", __func__);
2388  return 0;
2389  }
2390  /* Recursive use of kdb_parse, do not use argv after this point */
2391  argv = NULL;
2392 
2393  while (va) {
2394  char buf[80];
2395 
2396  if (KDB_FLAG(CMD_INTERRUPT))
2397  goto out;
2398 
2399  sprintf(buf, "%s " kdb_machreg_fmt "\n", command, va);
2400  diag = kdb_parse(buf);
2401  if (diag)
2402  goto out;
2403 
2404  addr = va + linkoffset;
2405  if (kdb_getword(&va, addr, sizeof(va)))
2406  goto out;
2407  }
2408 
2409 out:
2410  kfree(command);
2411  return diag;
2412 }
2413 
2414 static int kdb_kgdb(int argc, const char **argv)
2415 {
2416  return KDB_CMD_KGDB;
2417 }
2418 
2419 /*
2420  * kdb_help - This function implements the 'help' and '?' commands.
2421  */
2422 static int kdb_help(int argc, const char **argv)
2423 {
2424  kdbtab_t *kt;
2425  int i;
2426 
2427  kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2428  kdb_printf("-----------------------------"
2429  "-----------------------------\n");
2430  for_each_kdbcmd(kt, i) {
2431  if (kt->cmd_name)
2432  kdb_printf("%-15.15s %-20.20s %s\n", kt->cmd_name,
2433  kt->cmd_usage, kt->cmd_help);
2434  if (KDB_FLAG(CMD_INTERRUPT))
2435  return 0;
2436  }
2437  return 0;
2438 }
2439 
2440 /*
2441  * kdb_kill - This function implements the 'kill' commands.
2442  */
2443 static int kdb_kill(int argc, const char **argv)
2444 {
2445  long sig, pid;
2446  char *endp;
2447  struct task_struct *p;
2448  struct siginfo info;
2449 
2450  if (argc != 2)
2451  return KDB_ARGCOUNT;
2452 
2453  sig = simple_strtol(argv[1], &endp, 0);
2454  if (*endp)
2455  return KDB_BADINT;
2456  if (sig >= 0) {
2457  kdb_printf("Invalid signal parameter.<-signal>\n");
2458  return 0;
2459  }
2460  sig = -sig;
2461 
2462  pid = simple_strtol(argv[2], &endp, 0);
2463  if (*endp)
2464  return KDB_BADINT;
2465  if (pid <= 0) {
2466  kdb_printf("Process ID must be large than 0.\n");
2467  return 0;
2468  }
2469 
2470  /* Find the process. */
2471  p = find_task_by_pid_ns(pid, &init_pid_ns);
2472  if (!p) {
2473  kdb_printf("The specified process isn't found.\n");
2474  return 0;
2475  }
2476  p = p->group_leader;
2477  info.si_signo = sig;
2478  info.si_errno = 0;
2479  info.si_code = SI_USER;
2480  info.si_pid = pid; /* same capabilities as process being signalled */
2481  info.si_uid = 0; /* kdb has root authority */
2482  kdb_send_sig_info(p, &info);
2483  return 0;
2484 }
2485 
2486 struct kdb_tm {
2487  int tm_sec; /* seconds */
2488  int tm_min; /* minutes */
2489  int tm_hour; /* hours */
2490  int tm_mday; /* day of the month */
2491  int tm_mon; /* month */
2492  int tm_year; /* year */
2493 };
2494 
2495 static void kdb_gmtime(struct timespec *tv, struct kdb_tm *tm)
2496 {
2497  /* This will work from 1970-2099, 2100 is not a leap year */
2498  static int mon_day[] = { 31, 29, 31, 30, 31, 30, 31,
2499  31, 30, 31, 30, 31 };
2500  memset(tm, 0, sizeof(*tm));
2501  tm->tm_sec = tv->tv_sec % (24 * 60 * 60);
2502  tm->tm_mday = tv->tv_sec / (24 * 60 * 60) +
2503  (2 * 365 + 1); /* shift base from 1970 to 1968 */
2504  tm->tm_min = tm->tm_sec / 60 % 60;
2505  tm->tm_hour = tm->tm_sec / 60 / 60;
2506  tm->tm_sec = tm->tm_sec % 60;
2507  tm->tm_year = 68 + 4*(tm->tm_mday / (4*365+1));
2508  tm->tm_mday %= (4*365+1);
2509  mon_day[1] = 29;
2510  while (tm->tm_mday >= mon_day[tm->tm_mon]) {
2511  tm->tm_mday -= mon_day[tm->tm_mon];
2512  if (++tm->tm_mon == 12) {
2513  tm->tm_mon = 0;
2514  ++tm->tm_year;
2515  mon_day[1] = 28;
2516  }
2517  }
2518  ++tm->tm_mday;
2519 }
2520 
2521 /*
2522  * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2523  * I cannot call that code directly from kdb, it has an unconditional
2524  * cli()/sti() and calls routines that take locks which can stop the debugger.
2525  */
2526 static void kdb_sysinfo(struct sysinfo *val)
2527 {
2528  struct timespec uptime;
2529  do_posix_clock_monotonic_gettime(&uptime);
2530  memset(val, 0, sizeof(*val));
2531  val->uptime = uptime.tv_sec;
2532  val->loads[0] = avenrun[0];
2533  val->loads[1] = avenrun[1];
2534  val->loads[2] = avenrun[2];
2535  val->procs = nr_threads-1;
2536  si_meminfo(val);
2537 
2538  return;
2539 }
2540 
2541 /*
2542  * kdb_summary - This function implements the 'summary' command.
2543  */
2544 static int kdb_summary(int argc, const char **argv)
2545 {
2546  struct timespec now;
2547  struct kdb_tm tm;
2548  struct sysinfo val;
2549 
2550  if (argc)
2551  return KDB_ARGCOUNT;
2552 
2553  kdb_printf("sysname %s\n", init_uts_ns.name.sysname);
2554  kdb_printf("release %s\n", init_uts_ns.name.release);
2555  kdb_printf("version %s\n", init_uts_ns.name.version);
2556  kdb_printf("machine %s\n", init_uts_ns.name.machine);
2557  kdb_printf("nodename %s\n", init_uts_ns.name.nodename);
2558  kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2559  kdb_printf("ccversion %s\n", __stringify(CCVERSION));
2560 
2561  now = __current_kernel_time();
2562  kdb_gmtime(&now, &tm);
2563  kdb_printf("date %04d-%02d-%02d %02d:%02d:%02d "
2564  "tz_minuteswest %d\n",
2565  1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2566  tm.tm_hour, tm.tm_min, tm.tm_sec,
2567  sys_tz.tz_minuteswest);
2568 
2569  kdb_sysinfo(&val);
2570  kdb_printf("uptime ");
2571  if (val.uptime > (24*60*60)) {
2572  int days = val.uptime / (24*60*60);
2573  val.uptime %= (24*60*60);
2574  kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2575  }
2576  kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2577 
2578  /* lifted from fs/proc/proc_misc.c::loadavg_read_proc() */
2579 
2580 #define LOAD_INT(x) ((x) >> FSHIFT)
2581 #define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
2582  kdb_printf("load avg %ld.%02ld %ld.%02ld %ld.%02ld\n",
2583  LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2584  LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2585  LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2586 #undef LOAD_INT
2587 #undef LOAD_FRAC
2588  /* Display in kilobytes */
2589 #define K(x) ((x) << (PAGE_SHIFT - 10))
2590  kdb_printf("\nMemTotal: %8lu kB\nMemFree: %8lu kB\n"
2591  "Buffers: %8lu kB\n",
2592  val.totalram, val.freeram, val.bufferram);
2593  return 0;
2594 }
2595 
2596 /*
2597  * kdb_per_cpu - This function implements the 'per_cpu' command.
2598  */
2599 static int kdb_per_cpu(int argc, const char **argv)
2600 {
2601  char fmtstr[64];
2602  int cpu, diag, nextarg = 1;
2603  unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2604 
2605  if (argc < 1 || argc > 3)
2606  return KDB_ARGCOUNT;
2607 
2608  diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2609  if (diag)
2610  return diag;
2611 
2612  if (argc >= 2) {
2613  diag = kdbgetularg(argv[2], &bytesperword);
2614  if (diag)
2615  return diag;
2616  }
2617  if (!bytesperword)
2618  bytesperword = KDB_WORD_SIZE;
2619  else if (bytesperword > KDB_WORD_SIZE)
2620  return KDB_BADWIDTH;
2621  sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2622  if (argc >= 3) {
2623  diag = kdbgetularg(argv[3], &whichcpu);
2624  if (diag)
2625  return diag;
2626  if (!cpu_online(whichcpu)) {
2627  kdb_printf("cpu %ld is not online\n", whichcpu);
2628  return KDB_BADCPUNUM;
2629  }
2630  }
2631 
2632  /* Most architectures use __per_cpu_offset[cpu], some use
2633  * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2634  */
2635 #ifdef __per_cpu_offset
2636 #define KDB_PCU(cpu) __per_cpu_offset(cpu)
2637 #else
2638 #ifdef CONFIG_SMP
2639 #define KDB_PCU(cpu) __per_cpu_offset[cpu]
2640 #else
2641 #define KDB_PCU(cpu) 0
2642 #endif
2643 #endif
2644  for_each_online_cpu(cpu) {
2645  if (KDB_FLAG(CMD_INTERRUPT))
2646  return 0;
2647 
2648  if (whichcpu != ~0UL && whichcpu != cpu)
2649  continue;
2650  addr = symaddr + KDB_PCU(cpu);
2651  diag = kdb_getword(&val, addr, bytesperword);
2652  if (diag) {
2653  kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2654  "read, diag=%d\n", cpu, addr, diag);
2655  continue;
2656  }
2657  kdb_printf("%5d ", cpu);
2658  kdb_md_line(fmtstr, addr,
2659  bytesperword == KDB_WORD_SIZE,
2660  1, bytesperword, 1, 1, 0);
2661  }
2662 #undef KDB_PCU
2663  return 0;
2664 }
2665 
2666 /*
2667  * display help for the use of cmd | grep pattern
2668  */
2669 static int kdb_grep_help(int argc, const char **argv)
2670 {
2671  kdb_printf("Usage of cmd args | grep pattern:\n");
2672  kdb_printf(" Any command's output may be filtered through an ");
2673  kdb_printf("emulated 'pipe'.\n");
2674  kdb_printf(" 'grep' is just a key word.\n");
2675  kdb_printf(" The pattern may include a very limited set of "
2676  "metacharacters:\n");
2677  kdb_printf(" pattern or ^pattern or pattern$ or ^pattern$\n");
2678  kdb_printf(" And if there are spaces in the pattern, you may "
2679  "quote it:\n");
2680  kdb_printf(" \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2681  " or \"^pat tern$\"\n");
2682  return 0;
2683 }
2684 
2685 /*
2686  * kdb_register_repeat - This function is used to register a kernel
2687  * debugger command.
2688  * Inputs:
2689  * cmd Command name
2690  * func Function to execute the command
2691  * usage A simple usage string showing arguments
2692  * help A simple help string describing command
2693  * repeat Does the command auto repeat on enter?
2694  * Returns:
2695  * zero for success, one if a duplicate command.
2696  */
2697 #define kdb_command_extend 50 /* arbitrary */
2698 int kdb_register_repeat(char *cmd,
2699  kdb_func_t func,
2700  char *usage,
2701  char *help,
2702  short minlen,
2703  kdb_repeat_t repeat)
2704 {
2705  int i;
2706  kdbtab_t *kp;
2707 
2708  /*
2709  * Brute force method to determine duplicates
2710  */
2711  for_each_kdbcmd(kp, i) {
2712  if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2713  kdb_printf("Duplicate kdb command registered: "
2714  "%s, func %p help %s\n", cmd, func, help);
2715  return 1;
2716  }
2717  }
2718 
2719  /*
2720  * Insert command into first available location in table
2721  */
2722  for_each_kdbcmd(kp, i) {
2723  if (kp->cmd_name == NULL)
2724  break;
2725  }
2726 
2727  if (i >= kdb_max_commands) {
2728  kdbtab_t *new = kmalloc((kdb_max_commands - KDB_BASE_CMD_MAX +
2729  kdb_command_extend) * sizeof(*new), GFP_KDB);
2730  if (!new) {
2731  kdb_printf("Could not allocate new kdb_command "
2732  "table\n");
2733  return 1;
2734  }
2735  if (kdb_commands) {
2736  memcpy(new, kdb_commands,
2737  (kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new));
2738  kfree(kdb_commands);
2739  }
2740  memset(new + kdb_max_commands, 0,
2741  kdb_command_extend * sizeof(*new));
2742  kdb_commands = new;
2743  kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX;
2744  kdb_max_commands += kdb_command_extend;
2745  }
2746 
2747  kp->cmd_name = cmd;
2748  kp->cmd_func = func;
2749  kp->cmd_usage = usage;
2750  kp->cmd_help = help;
2751  kp->cmd_flags = 0;
2752  kp->cmd_minlen = minlen;
2753  kp->cmd_repeat = repeat;
2754 
2755  return 0;
2756 }
2757 EXPORT_SYMBOL_GPL(kdb_register_repeat);
2758 
2759 
2760 /*
2761  * kdb_register - Compatibility register function for commands that do
2762  * not need to specify a repeat state. Equivalent to
2763  * kdb_register_repeat with KDB_REPEAT_NONE.
2764  * Inputs:
2765  * cmd Command name
2766  * func Function to execute the command
2767  * usage A simple usage string showing arguments
2768  * help A simple help string describing command
2769  * Returns:
2770  * zero for success, one if a duplicate command.
2771  */
2772 int kdb_register(char *cmd,
2773  kdb_func_t func,
2774  char *usage,
2775  char *help,
2776  short minlen)
2777 {
2778  return kdb_register_repeat(cmd, func, usage, help, minlen,
2779  KDB_REPEAT_NONE);
2780 }
2781 EXPORT_SYMBOL_GPL(kdb_register);
2782 
2783 /*
2784  * kdb_unregister - This function is used to unregister a kernel
2785  * debugger command. It is generally called when a module which
2786  * implements kdb commands is unloaded.
2787  * Inputs:
2788  * cmd Command name
2789  * Returns:
2790  * zero for success, one command not registered.
2791  */
2792 int kdb_unregister(char *cmd)
2793 {
2794  int i;
2795  kdbtab_t *kp;
2796 
2797  /*
2798  * find the command.
2799  */
2800  for_each_kdbcmd(kp, i) {
2801  if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2802  kp->cmd_name = NULL;
2803  return 0;
2804  }
2805  }
2806 
2807  /* Couldn't find it. */
2808  return 1;
2809 }
2810 EXPORT_SYMBOL_GPL(kdb_unregister);
2811 
2812 /* Initialize the kdb command table. */
2813 static void __init kdb_inittab(void)
2814 {
2815  int i;
2816  kdbtab_t *kp;
2817 
2818  for_each_kdbcmd(kp, i)
2819  kp->cmd_name = NULL;
2820 
2821  kdb_register_repeat("md", kdb_md, "<vaddr>",
2822  "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2823  KDB_REPEAT_NO_ARGS);
2824  kdb_register_repeat("mdr", kdb_md, "<vaddr> <bytes>",
2825  "Display Raw Memory", 0, KDB_REPEAT_NO_ARGS);
2826  kdb_register_repeat("mdp", kdb_md, "<paddr> <bytes>",
2827  "Display Physical Memory", 0, KDB_REPEAT_NO_ARGS);
2828  kdb_register_repeat("mds", kdb_md, "<vaddr>",
2829  "Display Memory Symbolically", 0, KDB_REPEAT_NO_ARGS);
2830  kdb_register_repeat("mm", kdb_mm, "<vaddr> <contents>",
2831  "Modify Memory Contents", 0, KDB_REPEAT_NO_ARGS);
2832  kdb_register_repeat("go", kdb_go, "[<vaddr>]",
2833  "Continue Execution", 1, KDB_REPEAT_NONE);
2834  kdb_register_repeat("rd", kdb_rd, "",
2835  "Display Registers", 0, KDB_REPEAT_NONE);
2836  kdb_register_repeat("rm", kdb_rm, "<reg> <contents>",
2837  "Modify Registers", 0, KDB_REPEAT_NONE);
2838  kdb_register_repeat("ef", kdb_ef, "<vaddr>",
2839  "Display exception frame", 0, KDB_REPEAT_NONE);
2840  kdb_register_repeat("bt", kdb_bt, "[<vaddr>]",
2841  "Stack traceback", 1, KDB_REPEAT_NONE);
2842  kdb_register_repeat("btp", kdb_bt, "<pid>",
2843  "Display stack for process <pid>", 0, KDB_REPEAT_NONE);
2844  kdb_register_repeat("bta", kdb_bt, "[DRSTCZEUIMA]",
2845  "Display stack all processes", 0, KDB_REPEAT_NONE);
2846  kdb_register_repeat("btc", kdb_bt, "",
2847  "Backtrace current process on each cpu", 0, KDB_REPEAT_NONE);
2848  kdb_register_repeat("btt", kdb_bt, "<vaddr>",
2849  "Backtrace process given its struct task address", 0,
2850  KDB_REPEAT_NONE);
2851  kdb_register_repeat("ll", kdb_ll, "<first-element> <linkoffset> <cmd>",
2852  "Execute cmd for each element in linked list", 0, KDB_REPEAT_NONE);
2853  kdb_register_repeat("env", kdb_env, "",
2854  "Show environment variables", 0, KDB_REPEAT_NONE);
2855  kdb_register_repeat("set", kdb_set, "",
2856  "Set environment variables", 0, KDB_REPEAT_NONE);
2857  kdb_register_repeat("help", kdb_help, "",
2858  "Display Help Message", 1, KDB_REPEAT_NONE);
2859  kdb_register_repeat("?", kdb_help, "",
2860  "Display Help Message", 0, KDB_REPEAT_NONE);
2861  kdb_register_repeat("cpu", kdb_cpu, "<cpunum>",
2862  "Switch to new cpu", 0, KDB_REPEAT_NONE);
2863  kdb_register_repeat("kgdb", kdb_kgdb, "",
2864  "Enter kgdb mode", 0, KDB_REPEAT_NONE);
2865  kdb_register_repeat("ps", kdb_ps, "[<flags>|A]",
2866  "Display active task list", 0, KDB_REPEAT_NONE);
2867  kdb_register_repeat("pid", kdb_pid, "<pidnum>",
2868  "Switch to another task", 0, KDB_REPEAT_NONE);
2869  kdb_register_repeat("reboot", kdb_reboot, "",
2870  "Reboot the machine immediately", 0, KDB_REPEAT_NONE);
2871 #if defined(CONFIG_MODULES)
2872  kdb_register_repeat("lsmod", kdb_lsmod, "",
2873  "List loaded kernel modules", 0, KDB_REPEAT_NONE);
2874 #endif
2875 #if defined(CONFIG_MAGIC_SYSRQ)
2876  kdb_register_repeat("sr", kdb_sr, "<key>",
2877  "Magic SysRq key", 0, KDB_REPEAT_NONE);
2878 #endif
2879 #if defined(CONFIG_PRINTK)
2880  kdb_register_repeat("dmesg", kdb_dmesg, "[lines]",
2881  "Display syslog buffer", 0, KDB_REPEAT_NONE);
2882 #endif
2883  if (arch_kgdb_ops.enable_nmi) {
2884  kdb_register_repeat("disable_nmi", kdb_disable_nmi, "",
2885  "Disable NMI entry to KDB", 0, KDB_REPEAT_NONE);
2886  }
2887  kdb_register_repeat("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
2888  "Define a set of commands, down to endefcmd", 0, KDB_REPEAT_NONE);
2889  kdb_register_repeat("kill", kdb_kill, "<-signal> <pid>",
2890  "Send a signal to a process", 0, KDB_REPEAT_NONE);
2891  kdb_register_repeat("summary", kdb_summary, "",
2892  "Summarize the system", 4, KDB_REPEAT_NONE);
2893  kdb_register_repeat("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
2894  "Display per_cpu variables", 3, KDB_REPEAT_NONE);
2895  kdb_register_repeat("grephelp", kdb_grep_help, "",
2896  "Display help on | grep", 0, KDB_REPEAT_NONE);
2897 }
2898 
2899 /* Execute any commands defined in kdb_cmds. */
2900 static void __init kdb_cmd_init(void)
2901 {
2902  int i, diag;
2903  for (i = 0; kdb_cmds[i]; ++i) {
2904  diag = kdb_parse(kdb_cmds[i]);
2905  if (diag)
2906  kdb_printf("kdb command %s failed, kdb diag %d\n",
2907  kdb_cmds[i], diag);
2908  }
2909  if (defcmd_in_progress) {
2910  kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2911  kdb_parse("endefcmd");
2912  }
2913 }
2914 
2915 /* Initialize kdb_printf, breakpoint tables and kdb state */
2916 void __init kdb_init(int lvl)
2917 {
2918  static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2919  int i;
2920 
2921  if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2922  return;
2923  for (i = kdb_init_lvl; i < lvl; i++) {
2924  switch (i) {
2925  case KDB_NOT_INITIALIZED:
2926  kdb_inittab(); /* Initialize Command Table */
2927  kdb_initbptab(); /* Initialize Breakpoints */
2928  break;
2929  case KDB_INIT_EARLY:
2930  kdb_cmd_init(); /* Build kdb_cmds tables */
2931  break;
2932  }
2933  }
2934  kdb_init_lvl = lvl;
2935 }
Generated on Thu Jan 10 2013 14:54:23 for Linux Kernel by   doxygen 1.8.2