4d5f8d5612f349389fee0c22442267b6545c3931
[linux-3.10.git] / kernel / debug / kdb / kdb_main.c
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 <eranian@hpl.hp.com>
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 }