kernel/debug/kdb/kdb_main.c

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