~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/debug/kdb/kdb_main.c

Version: ~ [ linux-5.6-rc3 ] ~ [ linux-5.5.7 ] ~ [ linux-5.4.23 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.107 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.172 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.215 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.215 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp