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         kdb_trap_printk++;
1060         show_regs(regs);
1061         kdb_trap_printk--;
1062         kdb_printf("\n");
1063         console_loglevel = old_lvl;
1064 }
1065
1066 void kdb_set_current_task(struct task_struct *p)
1067 {
1068         kdb_current_task = p;
1069
1070         if (kdb_task_has_cpu(p)) {
1071                 kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p));
1072                 return;
1073         }
1074         kdb_current_regs = NULL;
1075 }
1076
1077 /*
1078  * kdb_local - The main code for kdb.  This routine is invoked on a
1079  *      specific processor, it is not global.  The main kdb() routine
1080  *      ensures that only one processor at a time is in this routine.
1081  *      This code is called with the real reason code on the first
1082  *      entry to a kdb session, thereafter it is called with reason
1083  *      SWITCH, even if the user goes back to the original cpu.
1084  * Inputs:
1085  *      reason          The reason KDB was invoked
1086  *      error           The hardware-defined error code
1087  *      regs            The exception frame at time of fault/breakpoint.
1088  *      db_result       Result code from the break or debug point.
1089  * Returns:
1090  *      0       KDB was invoked for an event which it wasn't responsible
1091  *      1       KDB handled the event for which it was invoked.
1092  *      KDB_CMD_GO      User typed 'go'.
1093  *      KDB_CMD_CPU     User switched to another cpu.
1094  *      KDB_CMD_SS      Single step.
1095  *      KDB_CMD_SSB     Single step until branch.
1096  */
1097 static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs,
1098                      kdb_dbtrap_t db_result)
1099 {
1100         char *cmdbuf;
1101         int diag;
1102         struct task_struct *kdb_current =
1103                 kdb_curr_task(raw_smp_processor_id());
1104
1105         KDB_DEBUG_STATE("kdb_local 1", reason);
1106         kdb_go_count = 0;
1107         if (reason == KDB_REASON_DEBUG) {
1108                 /* special case below */
1109         } else {
1110                 kdb_printf("\nEntering kdb (current=0x%p, pid %d) ",
1111                            kdb_current, kdb_current->pid);
1112 #if defined(CONFIG_SMP)
1113                 kdb_printf("on processor %d ", raw_smp_processor_id());
1114 #endif
1115         }
1116
1117         switch (reason) {
1118         case KDB_REASON_DEBUG:
1119         {
1120                 /*
1121                  * If re-entering kdb after a single step
1122                  * command, don't print the message.
1123                  */
1124                 switch (db_result) {
1125                 case KDB_DB_BPT:
1126                         kdb_printf("\nEntering kdb (0x%p, pid %d) ",
1127                                    kdb_current, kdb_current->pid);
1128 #if defined(CONFIG_SMP)
1129                         kdb_printf("on processor %d ", raw_smp_processor_id());
1130 #endif
1131                         kdb_printf("due to Debug @ " kdb_machreg_fmt "\n",
1132                                    instruction_pointer(regs));
1133                         break;
1134                 case KDB_DB_SSB:
1135                         /*
1136                          * In the midst of ssb command. Just return.
1137                          */
1138                         KDB_DEBUG_STATE("kdb_local 3", reason);
1139                         return KDB_CMD_SSB;     /* Continue with SSB command */
1140
1141                         break;
1142                 case KDB_DB_SS:
1143                         break;
1144                 case KDB_DB_SSBPT:
1145                         KDB_DEBUG_STATE("kdb_local 4", reason);
1146                         return 1;       /* kdba_db_trap did the work */
1147                 default:
1148                         kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
1149                                    db_result);
1150                         break;
1151                 }
1152
1153         }
1154                 break;
1155         case KDB_REASON_ENTER:
1156                 if (KDB_STATE(KEYBOARD))
1157                         kdb_printf("due to Keyboard Entry\n");
1158                 else
1159                         kdb_printf("due to KDB_ENTER()\n");
1160                 break;
1161         case KDB_REASON_KEYBOARD:
1162                 KDB_STATE_SET(KEYBOARD);
1163                 kdb_printf("due to Keyboard Entry\n");
1164                 break;
1165         case KDB_REASON_ENTER_SLAVE:
1166                 /* drop through, slaves only get released via cpu switch */
1167         case KDB_REASON_SWITCH:
1168                 kdb_printf("due to cpu switch\n");
1169                 break;
1170         case KDB_REASON_OOPS:
1171                 kdb_printf("Oops: %s\n", kdb_diemsg);
1172                 kdb_printf("due to oops @ " kdb_machreg_fmt "\n",
1173                            instruction_pointer(regs));
1174                 kdb_dumpregs(regs);
1175                 break;
1176         case KDB_REASON_NMI:
1177                 kdb_printf("due to NonMaskable Interrupt @ "
1178                            kdb_machreg_fmt "\n",
1179                            instruction_pointer(regs));
1180                 kdb_dumpregs(regs);
1181                 break;
1182         case KDB_REASON_SSTEP:
1183         case KDB_REASON_BREAK:
1184                 kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
1185                            reason == KDB_REASON_BREAK ?
1186                            "Breakpoint" : "SS trap", instruction_pointer(regs));
1187                 /*
1188                  * Determine if this breakpoint is one that we
1189                  * are interested in.
1190                  */
1191                 if (db_result != KDB_DB_BPT) {
1192                         kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1193                                    db_result);
1194                         KDB_DEBUG_STATE("kdb_local 6", reason);
1195                         return 0;       /* Not for us, dismiss it */
1196                 }
1197                 break;
1198         case KDB_REASON_RECURSE:
1199                 kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
1200                            instruction_pointer(regs));
1201                 break;
1202         default:
1203                 kdb_printf("kdb: unexpected reason code: %d\n", reason);
1204                 KDB_DEBUG_STATE("kdb_local 8", reason);
1205                 return 0;       /* Not for us, dismiss it */
1206         }
1207
1208         while (1) {
1209                 /*
1210                  * Initialize pager context.
1211                  */
1212                 kdb_nextline = 1;
1213                 KDB_STATE_CLEAR(SUPPRESS);
1214
1215                 cmdbuf = cmd_cur;
1216                 *cmdbuf = '\0';
1217                 *(cmd_hist[cmd_head]) = '\0';
1218
1219                 if (KDB_FLAG(ONLY_DO_DUMP)) {
1220                         /* kdb is off but a catastrophic error requires a dump.
1221                          * Take the dump and reboot.
1222                          * Turn on logging so the kdb output appears in the log
1223                          * buffer in the dump.
1224                          */
1225                         const char *setargs[] = { "set", "LOGGING", "1" };
1226                         kdb_set(2, setargs);
1227                         kdb_reboot(0, NULL);
1228                         /*NOTREACHED*/
1229                 }
1230
1231 do_full_getstr:
1232 #if defined(CONFIG_SMP)
1233                 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
1234                          raw_smp_processor_id());
1235 #else
1236                 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"));
1237 #endif
1238                 if (defcmd_in_progress)
1239                         strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
1240
1241                 /*
1242                  * Fetch command from keyboard
1243                  */
1244                 cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
1245                 if (*cmdbuf != '\n') {
1246                         if (*cmdbuf < 32) {
1247                                 if (cmdptr == cmd_head) {
1248                                         strncpy(cmd_hist[cmd_head], cmd_cur,
1249                                                 CMD_BUFLEN);
1250                                         *(cmd_hist[cmd_head] +
1251                                           strlen(cmd_hist[cmd_head])-1) = '\0';
1252                                 }
1253                                 if (!handle_ctrl_cmd(cmdbuf))
1254                                         *(cmd_cur+strlen(cmd_cur)-1) = '\0';
1255                                 cmdbuf = cmd_cur;
1256                                 goto do_full_getstr;
1257                         } else {
1258                                 strncpy(cmd_hist[cmd_head], cmd_cur,
1259                                         CMD_BUFLEN);
1260                         }
1261
1262                         cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
1263                         if (cmd_head == cmd_tail)
1264                                 cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
1265                 }
1266
1267                 cmdptr = cmd_head;
1268                 diag = kdb_parse(cmdbuf);
1269                 if (diag == KDB_NOTFOUND) {
1270                         kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
1271                         diag = 0;
1272                 }
1273                 if (diag == KDB_CMD_GO
1274                  || diag == KDB_CMD_CPU
1275                  || diag == KDB_CMD_SS
1276                  || diag == KDB_CMD_SSB
1277                  || diag == KDB_CMD_KGDB)
1278                         break;
1279
1280                 if (diag)
1281                         kdb_cmderror(diag);
1282         }
1283         KDB_DEBUG_STATE("kdb_local 9", diag);
1284         return diag;
1285 }
1286
1287
1288 /*
1289  * kdb_print_state - Print the state data for the current processor
1290  *      for debugging.
1291  * Inputs:
1292  *      text            Identifies the debug point
1293  *      value           Any integer value to be printed, e.g. reason code.
1294  */
1295 void kdb_print_state(const char *text, int value)
1296 {
1297         kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1298                    text, raw_smp_processor_id(), value, kdb_initial_cpu,
1299                    kdb_state);
1300 }
1301
1302 /*
1303  * kdb_main_loop - After initial setup and assignment of the
1304  *      controlling cpu, all cpus are in this loop.  One cpu is in
1305  *      control and will issue the kdb prompt, the others will spin
1306  *      until 'go' or cpu switch.
1307  *
1308  *      To get a consistent view of the kernel stacks for all
1309  *      processes, this routine is invoked from the main kdb code via
1310  *      an architecture specific routine.  kdba_main_loop is
1311  *      responsible for making the kernel stacks consistent for all
1312  *      processes, there should be no difference between a blocked
1313  *      process and a running process as far as kdb is concerned.
1314  * Inputs:
1315  *      reason          The reason KDB was invoked
1316  *      error           The hardware-defined error code
1317  *      reason2         kdb's current reason code.
1318  *                      Initially error but can change
1319  *                      acording to kdb state.
1320  *      db_result       Result code from break or debug point.
1321  *      regs            The exception frame at time of fault/breakpoint.
1322  *                      should always be valid.
1323  * Returns:
1324  *      0       KDB was invoked for an event which it wasn't responsible
1325  *      1       KDB handled the event for which it was invoked.
1326  */
1327 int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
1328               kdb_dbtrap_t db_result, struct pt_regs *regs)
1329 {
1330         int result = 1;
1331         /* Stay in kdb() until 'go', 'ss[b]' or an error */
1332         while (1) {
1333                 /*
1334                  * All processors except the one that is in control
1335                  * will spin here.
1336                  */
1337                 KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1338                 while (KDB_STATE(HOLD_CPU)) {
1339                         /* state KDB is turned off by kdb_cpu to see if the
1340                          * other cpus are still live, each cpu in this loop
1341                          * turns it back on.
1342                          */
1343                         if (!KDB_STATE(KDB))
1344                                 KDB_STATE_SET(KDB);
1345                 }
1346
1347                 KDB_STATE_CLEAR(SUPPRESS);
1348                 KDB_DEBUG_STATE("kdb_main_loop 2", reason);
1349                 if (KDB_STATE(LEAVING))
1350                         break;  /* Another cpu said 'go' */
1351                 /* Still using kdb, this processor is in control */
1352                 result = kdb_local(reason2, error, regs, db_result);
1353                 KDB_DEBUG_STATE("kdb_main_loop 3", result);
1354
1355                 if (result == KDB_CMD_CPU)
1356                         break;
1357
1358                 if (result == KDB_CMD_SS) {
1359                         KDB_STATE_SET(DOING_SS);
1360                         break;
1361                 }
1362
1363                 if (result == KDB_CMD_SSB) {
1364                         KDB_STATE_SET(DOING_SS);
1365                         KDB_STATE_SET(DOING_SSB);
1366                         break;
1367                 }
1368
1369                 if (result == KDB_CMD_KGDB) {
1370                         if (!(KDB_STATE(DOING_KGDB) || KDB_STATE(DOING_KGDB2)))
1371                                 kdb_printf("Entering please attach debugger "
1372                                            "or use $D#44+ or $3#33\n");
1373                         break;
1374                 }
1375                 if (result && result != 1 && result != KDB_CMD_GO)
1376                         kdb_printf("\nUnexpected kdb_local return code %d\n",
1377                                    result);
1378                 KDB_DEBUG_STATE("kdb_main_loop 4", reason);
1379                 break;
1380         }
1381         if (KDB_STATE(DOING_SS))
1382                 KDB_STATE_CLEAR(SSBPT);
1383
1384         return result;
1385 }
1386
1387 /*
1388  * kdb_mdr - This function implements the guts of the 'mdr', memory
1389  * read command.
1390  *      mdr  <addr arg>,<byte count>
1391  * Inputs:
1392  *      addr    Start address
1393  *      count   Number of bytes
1394  * Returns:
1395  *      Always 0.  Any errors are detected and printed by kdb_getarea.
1396  */
1397 static int kdb_mdr(unsigned long addr, unsigned int count)
1398 {
1399         unsigned char c;
1400         while (count--) {
1401                 if (kdb_getarea(c, addr))
1402                         return 0;
1403                 kdb_printf("%02x", c);
1404                 addr++;
1405         }
1406         kdb_printf("\n");
1407         return 0;
1408 }
1409
1410 /*
1411  * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1412  *      'md8' 'mdr' and 'mds' commands.
1413  *
1414  *      md|mds  [<addr arg> [<line count> [<radix>]]]
1415  *      mdWcN   [<addr arg> [<line count> [<radix>]]]
1416  *              where W = is the width (1, 2, 4 or 8) and N is the count.
1417  *              for eg., md1c20 reads 20 bytes, 1 at a time.
1418  *      mdr  <addr arg>,<byte count>
1419  */
1420 static void kdb_md_line(const char *fmtstr, unsigned long addr,
1421                         int symbolic, int nosect, int bytesperword,
1422                         int num, int repeat, int phys)
1423 {
1424         /* print just one line of data */
1425         kdb_symtab_t symtab;
1426         char cbuf[32];
1427         char *c = cbuf;
1428         int i;
1429         unsigned long word;
1430
1431         memset(cbuf, '\0', sizeof(cbuf));
1432         if (phys)
1433                 kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1434         else
1435                 kdb_printf(kdb_machreg_fmt0 " ", addr);
1436
1437         for (i = 0; i < num && repeat--; i++) {
1438                 if (phys) {
1439                         if (kdb_getphysword(&word, addr, bytesperword))
1440                                 break;
1441                 } else if (kdb_getword(&word, addr, bytesperword))
1442                         break;
1443                 kdb_printf(fmtstr, word);
1444                 if (symbolic)
1445                         kdbnearsym(word, &symtab);
1446                 else
1447                         memset(&symtab, 0, sizeof(symtab));
1448                 if (symtab.sym_name) {
1449                         kdb_symbol_print(word, &symtab, 0);
1450                         if (!nosect) {
1451                                 kdb_printf("\n");
1452                                 kdb_printf("                       %s %s "
1453                                            kdb_machreg_fmt " "
1454                                            kdb_machreg_fmt " "
1455                                            kdb_machreg_fmt, symtab.mod_name,
1456                                            symtab.sec_name, symtab.sec_start,
1457                                            symtab.sym_start, symtab.sym_end);
1458                         }
1459                         addr += bytesperword;
1460                 } else {
1461                         union {
1462                                 u64 word;
1463                                 unsigned char c[8];
1464                         } wc;
1465                         unsigned char *cp;
1466 #ifdef  __BIG_ENDIAN
1467                         cp = wc.c + 8 - bytesperword;
1468 #else
1469                         cp = wc.c;
1470 #endif
1471                         wc.word = word;
1472 #define printable_char(c) \
1473         ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1474                         switch (bytesperword) {
1475                         case 8:
1476                                 *c++ = printable_char(*cp++);
1477                                 *c++ = printable_char(*cp++);
1478                                 *c++ = printable_char(*cp++);
1479                                 *c++ = printable_char(*cp++);
1480                                 addr += 4;
1481                         case 4:
1482                                 *c++ = printable_char(*cp++);
1483                                 *c++ = printable_char(*cp++);
1484                                 addr += 2;
1485                         case 2:
1486                                 *c++ = printable_char(*cp++);
1487                                 addr++;
1488                         case 1:
1489                                 *c++ = printable_char(*cp++);
1490                                 addr++;
1491                                 break;
1492                         }
1493 #undef printable_char
1494                 }
1495         }
1496         kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1497                    " ", cbuf);
1498 }
1499
1500 static int kdb_md(int argc, const char **argv)
1501 {
1502         static unsigned long last_addr;
1503         static int last_radix, last_bytesperword, last_repeat;
1504         int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1505         int nosect = 0;
1506         char fmtchar, fmtstr[64];
1507         unsigned long addr;
1508         unsigned long word;
1509         long offset = 0;
1510         int symbolic = 0;
1511         int valid = 0;
1512         int phys = 0;
1513
1514         kdbgetintenv("MDCOUNT", &mdcount);
1515         kdbgetintenv("RADIX", &radix);
1516         kdbgetintenv("BYTESPERWORD", &bytesperword);
1517
1518         /* Assume 'md <addr>' and start with environment values */
1519         repeat = mdcount * 16 / bytesperword;
1520
1521         if (strcmp(argv[0], "mdr") == 0) {
1522                 if (argc != 2)
1523                         return KDB_ARGCOUNT;
1524                 valid = 1;
1525         } else if (isdigit(argv[0][2])) {
1526                 bytesperword = (int)(argv[0][2] - '0');
1527                 if (bytesperword == 0) {
1528                         bytesperword = last_bytesperword;
1529                         if (bytesperword == 0)
1530                                 bytesperword = 4;
1531                 }
1532                 last_bytesperword = bytesperword;
1533                 repeat = mdcount * 16 / bytesperword;
1534                 if (!argv[0][3])
1535                         valid = 1;
1536                 else if (argv[0][3] == 'c' && argv[0][4]) {
1537                         char *p;
1538                         repeat = simple_strtoul(argv[0] + 4, &p, 10);
1539                         mdcount = ((repeat * bytesperword) + 15) / 16;
1540                         valid = !*p;
1541                 }
1542                 last_repeat = repeat;
1543         } else if (strcmp(argv[0], "md") == 0)
1544                 valid = 1;
1545         else if (strcmp(argv[0], "mds") == 0)
1546                 valid = 1;
1547         else if (strcmp(argv[0], "mdp") == 0) {
1548                 phys = valid = 1;
1549         }
1550         if (!valid)
1551                 return KDB_NOTFOUND;
1552
1553         if (argc == 0) {
1554                 if (last_addr == 0)
1555                         return KDB_ARGCOUNT;
1556                 addr = last_addr;
1557                 radix = last_radix;
1558                 bytesperword = last_bytesperword;
1559                 repeat = last_repeat;
1560                 mdcount = ((repeat * bytesperword) + 15) / 16;
1561         }
1562
1563         if (argc) {
1564                 unsigned long val;
1565                 int diag, nextarg = 1;
1566                 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1567                                      &offset, NULL);
1568                 if (diag)
1569                         return diag;
1570                 if (argc > nextarg+2)
1571                         return KDB_ARGCOUNT;
1572
1573                 if (argc >= nextarg) {
1574                         diag = kdbgetularg(argv[nextarg], &val);
1575                         if (!diag) {
1576                                 mdcount = (int) val;
1577                                 repeat = mdcount * 16 / bytesperword;
1578                         }
1579                 }
1580                 if (argc >= nextarg+1) {
1581                         diag = kdbgetularg(argv[nextarg+1], &val);
1582                         if (!diag)
1583                                 radix = (int) val;
1584                 }
1585         }
1586
1587         if (strcmp(argv[0], "mdr") == 0)
1588                 return kdb_mdr(addr, mdcount);
1589
1590         switch (radix) {
1591         case 10:
1592                 fmtchar = 'd';
1593                 break;
1594         case 16:
1595                 fmtchar = 'x';
1596                 break;
1597         case 8:
1598                 fmtchar = 'o';
1599                 break;
1600         default:
1601                 return KDB_BADRADIX;
1602         }
1603
1604         last_radix = radix;
1605
1606         if (bytesperword > KDB_WORD_SIZE)
1607                 return KDB_BADWIDTH;
1608
1609         switch (bytesperword) {
1610         case 8:
1611                 sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1612                 break;
1613         case 4:
1614                 sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1615                 break;
1616         case 2:
1617                 sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1618                 break;
1619         case 1:
1620                 sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1621                 break;
1622         default:
1623                 return KDB_BADWIDTH;
1624         }
1625
1626         last_repeat = repeat;
1627         last_bytesperword = bytesperword;
1628
1629         if (strcmp(argv[0], "mds") == 0) {
1630                 symbolic = 1;
1631                 /* Do not save these changes as last_*, they are temporary mds
1632                  * overrides.
1633                  */
1634                 bytesperword = KDB_WORD_SIZE;
1635                 repeat = mdcount;
1636                 kdbgetintenv("NOSECT", &nosect);
1637         }
1638
1639         /* Round address down modulo BYTESPERWORD */
1640
1641         addr &= ~(bytesperword-1);
1642
1643         while (repeat > 0) {
1644                 unsigned long a;
1645                 int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1646
1647                 if (KDB_FLAG(CMD_INTERRUPT))
1648                         return 0;
1649                 for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1650                         if (phys) {
1651                                 if (kdb_getphysword(&word, a, bytesperword)
1652                                                 || word)
1653                                         break;
1654                         } else if (kdb_getword(&word, a, bytesperword) || word)
1655                                 break;
1656                 }
1657                 n = min(num, repeat);
1658                 kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1659                             num, repeat, phys);
1660                 addr += bytesperword * n;
1661                 repeat -= n;
1662                 z = (z + num - 1) / num;
1663                 if (z > 2) {
1664                         int s = num * (z-2);
1665                         kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1666                                    " zero suppressed\n",
1667                                 addr, addr + bytesperword * s - 1);
1668                         addr += bytesperword * s;
1669                         repeat -= s;
1670                 }
1671         }
1672         last_addr = addr;
1673
1674         return 0;
1675 }
1676
1677 /*
1678  * kdb_mm - This function implements the 'mm' command.
1679  *      mm address-expression new-value
1680  * Remarks:
1681  *      mm works on machine words, mmW works on bytes.
1682  */
1683 static int kdb_mm(int argc, const char **argv)
1684 {
1685         int diag;
1686         unsigned long addr;
1687         long offset = 0;
1688         unsigned long contents;
1689         int nextarg;
1690         int width;
1691
1692         if (argv[0][2] && !isdigit(argv[0][2]))
1693                 return KDB_NOTFOUND;
1694
1695         if (argc < 2)
1696                 return KDB_ARGCOUNT;
1697
1698         nextarg = 1;
1699         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1700         if (diag)
1701                 return diag;
1702
1703         if (nextarg > argc)
1704                 return KDB_ARGCOUNT;
1705         diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1706         if (diag)
1707                 return diag;
1708
1709         if (nextarg != argc + 1)
1710                 return KDB_ARGCOUNT;
1711
1712         width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1713         diag = kdb_putword(addr, contents, width);
1714         if (diag)
1715                 return diag;
1716
1717         kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1718
1719         return 0;
1720 }
1721
1722 /*
1723  * kdb_go - This function implements the 'go' command.
1724  *      go [address-expression]
1725  */
1726 static int kdb_go(int argc, const char **argv)
1727 {
1728         unsigned long addr;
1729         int diag;
1730         int nextarg;
1731         long offset;
1732
1733         if (argc == 1) {
1734                 if (raw_smp_processor_id() != kdb_initial_cpu) {
1735                         kdb_printf("go <address> must be issued from the "
1736                                    "initial cpu, do cpu %d first\n",
1737                                    kdb_initial_cpu);
1738                         return KDB_ARGCOUNT;
1739                 }
1740                 nextarg = 1;
1741                 diag = kdbgetaddrarg(argc, argv, &nextarg,
1742                                      &addr, &offset, NULL);
1743                 if (diag)
1744                         return diag;
1745         } else if (argc) {
1746                 return KDB_ARGCOUNT;
1747         }
1748
1749         diag = KDB_CMD_GO;
1750         if (KDB_FLAG(CATASTROPHIC)) {
1751                 kdb_printf("Catastrophic error detected\n");
1752                 kdb_printf("kdb_continue_catastrophic=%d, ",
1753                         kdb_continue_catastrophic);
1754                 if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1755                         kdb_printf("type go a second time if you really want "
1756                                    "to continue\n");
1757                         return 0;
1758                 }
1759                 if (kdb_continue_catastrophic == 2) {
1760                         kdb_printf("forcing reboot\n");
1761                         kdb_reboot(0, NULL);
1762                 }
1763                 kdb_printf("attempting to continue\n");
1764         }
1765         return diag;
1766 }
1767
1768 /*
1769  * kdb_rd - This function implements the 'rd' command.
1770  */
1771 static int kdb_rd(int argc, const char **argv)
1772 {
1773         int diag = kdb_check_regs();
1774         if (diag)
1775                 return diag;
1776
1777         kdb_dumpregs(kdb_current_regs);
1778         return 0;
1779 }
1780
1781 /*
1782  * kdb_rm - This function implements the 'rm' (register modify)  command.
1783  *      rm register-name new-contents
1784  * Remarks:
1785  *      Currently doesn't allow modification of control or
1786  *      debug registers.
1787  */
1788 static int kdb_rm(int argc, const char **argv)
1789 {
1790         int diag;
1791         int ind = 0;
1792         unsigned long contents;
1793
1794         if (argc != 2)
1795                 return KDB_ARGCOUNT;
1796         /*
1797          * Allow presence or absence of leading '%' symbol.
1798          */
1799         if (argv[1][0] == '%')
1800                 ind = 1;
1801
1802         diag = kdbgetularg(argv[2], &contents);
1803         if (diag)
1804                 return diag;
1805
1806         diag = kdb_check_regs();
1807         if (diag)
1808                 return diag;
1809         kdb_printf("ERROR: Register set currently not implemented\n");
1810         return 0;
1811 }
1812
1813 #if defined(CONFIG_MAGIC_SYSRQ)
1814 /*
1815  * kdb_sr - This function implements the 'sr' (SYSRQ key) command
1816  *      which interfaces to the soi-disant MAGIC SYSRQ functionality.
1817  *              sr <magic-sysrq-code>
1818  */
1819 static int kdb_sr(int argc, const char **argv)
1820 {
1821         if (argc != 1)
1822                 return KDB_ARGCOUNT;
1823         sysrq_toggle_support(1);
1824         kdb_trap_printk++;
1825         handle_sysrq(*argv[1], NULL);
1826         kdb_trap_printk--;
1827
1828         return 0;
1829 }
1830 #endif  /* CONFIG_MAGIC_SYSRQ */
1831
1832 /*
1833  * kdb_ef - This function implements the 'regs' (display exception
1834  *      frame) command.  This command takes an address and expects to
1835  *      find an exception frame at that address, formats and prints
1836  *      it.
1837  *              regs address-expression
1838  * Remarks:
1839  *      Not done yet.
1840  */
1841 static int kdb_ef(int argc, const char **argv)
1842 {
1843         int diag;
1844         unsigned long addr;
1845         long offset;
1846         int nextarg;
1847
1848         if (argc != 1)
1849                 return KDB_ARGCOUNT;
1850
1851         nextarg = 1;
1852         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1853         if (diag)
1854                 return diag;
1855         show_regs((struct pt_regs *)addr);
1856         return 0;
1857 }
1858
1859 #if defined(CONFIG_MODULES)
1860 /*
1861  * kdb_lsmod - This function implements the 'lsmod' command.  Lists
1862  *      currently loaded kernel modules.
1863  *      Mostly taken from userland lsmod.
1864  */
1865 static int kdb_lsmod(int argc, const char **argv)
1866 {
1867         struct module *mod;
1868
1869         if (argc != 0)
1870                 return KDB_ARGCOUNT;
1871
1872         kdb_printf("Module                  Size  modstruct     Used by\n");
1873         list_for_each_entry(mod, kdb_modules, list) {
1874
1875                 kdb_printf("%-20s%8u  0x%p ", mod->name,
1876                            mod->core_size, (void *)mod);
1877 #ifdef CONFIG_MODULE_UNLOAD
1878                 kdb_printf("%4d ", module_refcount(mod));
1879 #endif
1880                 if (mod->state == MODULE_STATE_GOING)
1881                         kdb_printf(" (Unloading)");
1882                 else if (mod->state == MODULE_STATE_COMING)
1883                         kdb_printf(" (Loading)");
1884                 else
1885                         kdb_printf(" (Live)");
1886                 kdb_printf(" 0x%p", mod->module_core);
1887
1888 #ifdef CONFIG_MODULE_UNLOAD
1889                 {
1890                         struct module_use *use;
1891                         kdb_printf(" [ ");
1892                         list_for_each_entry(use, &mod->source_list,
1893                                             source_list)
1894                                 kdb_printf("%s ", use->target->name);
1895                         kdb_printf("]\n");
1896                 }
1897 #endif
1898         }
1899
1900         return 0;
1901 }
1902
1903 #endif  /* CONFIG_MODULES */
1904
1905 /*
1906  * kdb_env - This function implements the 'env' command.  Display the
1907  *      current environment variables.
1908  */
1909
1910 static int kdb_env(int argc, const char **argv)
1911 {
1912         int i;
1913
1914         for (i = 0; i < __nenv; i++) {
1915                 if (__env[i])
1916                         kdb_printf("%s\n", __env[i]);
1917         }
1918
1919         if (KDB_DEBUG(MASK))
1920                 kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
1921
1922         return 0;
1923 }
1924
1925 #ifdef CONFIG_PRINTK
1926 /*
1927  * kdb_dmesg - This function implements the 'dmesg' command to display
1928  *      the contents of the syslog buffer.
1929  *              dmesg [lines] [adjust]
1930  */
1931 static int kdb_dmesg(int argc, const char **argv)
1932 {
1933         char *syslog_data[4], *start, *end, c = '\0', *p;
1934         int diag, logging, logsize, lines = 0, adjust = 0, n;
1935
1936         if (argc > 2)
1937                 return KDB_ARGCOUNT;
1938         if (argc) {
1939                 char *cp;
1940                 lines = simple_strtol(argv[1], &cp, 0);
1941                 if (*cp)
1942                         lines = 0;
1943                 if (argc > 1) {
1944                         adjust = simple_strtoul(argv[2], &cp, 0);
1945                         if (*cp || adjust < 0)
1946                                 adjust = 0;
1947                 }
1948         }
1949
1950         /* disable LOGGING if set */
1951         diag = kdbgetintenv("LOGGING", &logging);
1952         if (!diag && logging) {
1953                 const char *setargs[] = { "set", "LOGGING", "0" };
1954                 kdb_set(2, setargs);
1955         }
1956
1957         /* syslog_data[0,1] physical start, end+1.  syslog_data[2,3]
1958          * logical start, end+1. */
1959         kdb_syslog_data(syslog_data);
1960         if (syslog_data[2] == syslog_data[3])
1961                 return 0;
1962         logsize = syslog_data[1] - syslog_data[0];
1963         start = syslog_data[2];
1964         end = syslog_data[3];
1965 #define KDB_WRAP(p) (((p - syslog_data[0]) % logsize) + syslog_data[0])
1966         for (n = 0, p = start; p < end; ++p) {
1967                 c = *KDB_WRAP(p);
1968                 if (c == '\n')
1969                         ++n;
1970         }
1971         if (c != '\n')
1972                 ++n;
1973         if (lines < 0) {
1974                 if (adjust >= n)
1975                         kdb_printf("buffer only contains %d lines, nothing "
1976                                    "printed\n", n);
1977                 else if (adjust - lines >= n)
1978                         kdb_printf("buffer only contains %d lines, last %d "
1979                                    "lines printed\n", n, n - adjust);
1980                 if (adjust) {
1981                         for (; start < end && adjust; ++start) {
1982                                 if (*KDB_WRAP(start) == '\n')
1983                                         --adjust;
1984                         }
1985                         if (start < end)
1986                                 ++start;
1987                 }
1988                 for (p = start; p < end && lines; ++p) {
1989                         if (*KDB_WRAP(p) == '\n')
1990                                 ++lines;
1991                 }
1992                 end = p;
1993         } else if (lines > 0) {
1994                 int skip = n - (adjust + lines);
1995                 if (adjust >= n) {
1996                         kdb_printf("buffer only contains %d lines, "
1997                                    "nothing printed\n", n);
1998                         skip = n;
1999                 } else if (skip < 0) {
2000                         lines += skip;
2001                         skip = 0;
2002                         kdb_printf("buffer only contains %d lines, first "
2003                                    "%d lines printed\n", n, lines);
2004                 }
2005                 for (; start < end && skip; ++start) {
2006                         if (*KDB_WRAP(start) == '\n')
2007                                 --skip;
2008                 }
2009                 for (p = start; p < end && lines; ++p) {
2010                         if (*KDB_WRAP(p) == '\n')
2011                                 --lines;
2012                 }
2013                 end = p;
2014         }
2015         /* Do a line at a time (max 200 chars) to reduce protocol overhead */
2016         c = '\n';
2017         while (start != end) {
2018                 char buf[201];
2019                 p = buf;
2020                 if (KDB_FLAG(CMD_INTERRUPT))
2021                         return 0;
2022                 while (start < end && (c = *KDB_WRAP(start)) &&
2023                        (p - buf) < sizeof(buf)-1) {
2024                         ++start;
2025                         *p++ = c;
2026                         if (c == '\n')
2027                                 break;
2028                 }
2029                 *p = '\0';
2030                 kdb_printf("%s", buf);
2031         }
2032         if (c != '\n')
2033                 kdb_printf("\n");
2034
2035         return 0;
2036 }
2037 #endif /* CONFIG_PRINTK */
2038 /*
2039  * kdb_cpu - This function implements the 'cpu' command.
2040  *      cpu     [<cpunum>]
2041  * Returns:
2042  *      KDB_CMD_CPU for success, a kdb diagnostic if error
2043  */
2044 static void kdb_cpu_status(void)
2045 {
2046         int i, start_cpu, first_print = 1;
2047         char state, prev_state = '?';
2048
2049         kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2050         kdb_printf("Available cpus: ");
2051         for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2052                 if (!cpu_online(i)) {
2053                         state = 'F';    /* cpu is offline */
2054                 } else {
2055                         state = ' ';    /* cpu is responding to kdb */
2056                         if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2057                                 state = 'I';    /* idle task */
2058                 }
2059                 if (state != prev_state) {
2060                         if (prev_state != '?') {
2061                                 if (!first_print)
2062                                         kdb_printf(", ");
2063                                 first_print = 0;
2064                                 kdb_printf("%d", start_cpu);
2065                                 if (start_cpu < i-1)
2066                                         kdb_printf("-%d", i-1);
2067                                 if (prev_state != ' ')
2068                                         kdb_printf("(%c)", prev_state);
2069                         }
2070                         prev_state = state;
2071                         start_cpu = i;
2072                 }
2073         }
2074         /* print the trailing cpus, ignoring them if they are all offline */
2075         if (prev_state != 'F') {
2076                 if (!first_print)
2077                         kdb_printf(", ");
2078                 kdb_printf("%d", start_cpu);
2079                 if (start_cpu < i-1)
2080                         kdb_printf("-%d", i-1);
2081                 if (prev_state != ' ')
2082                         kdb_printf("(%c)", prev_state);
2083         }
2084         kdb_printf("\n");
2085 }
2086
2087 static int kdb_cpu(int argc, const char **argv)
2088 {
2089         unsigned long cpunum;
2090         int diag;
2091
2092         if (argc == 0) {
2093                 kdb_cpu_status();
2094                 return 0;
2095         }
2096
2097         if (argc != 1)
2098                 return KDB_ARGCOUNT;
2099
2100         diag = kdbgetularg(argv[1], &cpunum);
2101         if (diag)
2102                 return diag;
2103
2104         /*
2105          * Validate cpunum
2106          */
2107         if ((cpunum > NR_CPUS) || !cpu_online(cpunum))
2108                 return KDB_BADCPUNUM;
2109
2110         dbg_switch_cpu = cpunum;
2111
2112         /*
2113          * Switch to other cpu
2114          */
2115         return KDB_CMD_CPU;
2116 }
2117
2118 /* The user may not realize that ps/bta with no parameters does not print idle
2119  * or sleeping system daemon processes, so tell them how many were suppressed.
2120  */
2121 void kdb_ps_suppressed(void)
2122 {
2123         int idle = 0, daemon = 0;
2124         unsigned long mask_I = kdb_task_state_string("I"),
2125                       mask_M = kdb_task_state_string("M");
2126         unsigned long cpu;
2127         const struct task_struct *p, *g;
2128         for_each_online_cpu(cpu) {
2129                 p = kdb_curr_task(cpu);
2130                 if (kdb_task_state(p, mask_I))
2131                         ++idle;
2132         }
2133         kdb_do_each_thread(g, p) {
2134                 if (kdb_task_state(p, mask_M))
2135                         ++daemon;
2136         } kdb_while_each_thread(g, p);
2137         if (idle || daemon) {
2138                 if (idle)
2139                         kdb_printf("%d idle process%s (state I)%s\n",
2140                                    idle, idle == 1 ? "" : "es",
2141                                    daemon ? " and " : "");
2142                 if (daemon)
2143                         kdb_printf("%d sleeping system daemon (state M) "
2144                                    "process%s", daemon,
2145                                    daemon == 1 ? "" : "es");
2146                 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2147         }
2148 }
2149
2150 /*
2151  * kdb_ps - This function implements the 'ps' command which shows a
2152  *      list of the active processes.
2153  *              ps [DRSTCZEUIMA]   All processes, optionally filtered by state
2154  */
2155 void kdb_ps1(const struct task_struct *p)
2156 {
2157         int cpu;
2158         unsigned long tmp;
2159
2160         if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
2161                 return;
2162
2163         cpu = kdb_process_cpu(p);
2164         kdb_printf("0x%p %8d %8d  %d %4d   %c  0x%p %c%s\n",
2165                    (void *)p, p->pid, p->parent->pid,
2166                    kdb_task_has_cpu(p), kdb_process_cpu(p),
2167                    kdb_task_state_char(p),
2168                    (void *)(&p->thread),
2169                    p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2170                    p->comm);
2171         if (kdb_task_has_cpu(p)) {
2172                 if (!KDB_TSK(cpu)) {
2173                         kdb_printf("  Error: no saved data for this cpu\n");
2174                 } else {
2175                         if (KDB_TSK(cpu) != p)
2176                                 kdb_printf("  Error: does not match running "
2177                                    "process table (0x%p)\n", KDB_TSK(cpu));
2178                 }
2179         }
2180 }
2181
2182 static int kdb_ps(int argc, const char **argv)
2183 {
2184         struct task_struct *g, *p;
2185         unsigned long mask, cpu;
2186
2187         if (argc == 0)
2188                 kdb_ps_suppressed();
2189         kdb_printf("%-*s      Pid   Parent [*] cpu State %-*s Command\n",
2190                 (int)(2*sizeof(void *))+2, "Task Addr",
2191                 (int)(2*sizeof(void *))+2, "Thread");
2192         mask = kdb_task_state_string(argc ? argv[1] : NULL);
2193         /* Run the active tasks first */
2194         for_each_online_cpu(cpu) {
2195                 if (KDB_FLAG(CMD_INTERRUPT))
2196                         return 0;
2197                 p = kdb_curr_task(cpu);
2198                 if (kdb_task_state(p, mask))
2199                         kdb_ps1(p);
2200         }
2201         kdb_printf("\n");
2202         /* Now the real tasks */
2203         kdb_do_each_thread(g, p) {
2204                 if (KDB_FLAG(CMD_INTERRUPT))
2205                         return 0;
2206                 if (kdb_task_state(p, mask))
2207                         kdb_ps1(p);
2208         } kdb_while_each_thread(g, p);
2209
2210         return 0;
2211 }
2212
2213 /*
2214  * kdb_pid - This function implements the 'pid' command which switches
2215  *      the currently active process.
2216  *              pid [<pid> | R]
2217  */
2218 static int kdb_pid(int argc, const char **argv)
2219 {
2220         struct task_struct *p;
2221         unsigned long val;
2222         int diag;
2223
2224         if (argc > 1)
2225                 return KDB_ARGCOUNT;
2226
2227         if (argc) {
2228                 if (strcmp(argv[1], "R") == 0) {
2229                         p = KDB_TSK(kdb_initial_cpu);
2230                 } else {
2231                         diag = kdbgetularg(argv[1], &val);
2232                         if (diag)
2233                                 return KDB_BADINT;
2234
2235                         p = find_task_by_pid_ns((pid_t)val,     &init_pid_ns);
2236                         if (!p) {
2237                                 kdb_printf("No task with pid=%d\n", (pid_t)val);
2238                                 return 0;
2239                         }
2240                 }
2241                 kdb_set_current_task(p);
2242         }
2243         kdb_printf("KDB current process is %s(pid=%d)\n",
2244                    kdb_current_task->comm,
2245                    kdb_current_task->pid);
2246
2247         return 0;
2248 }
2249
2250 /*
2251  * kdb_ll - This function implements the 'll' command which follows a
2252  *      linked list and executes an arbitrary command for each
2253  *      element.
2254  */
2255 static int kdb_ll(int argc, const char **argv)
2256 {
2257         int diag;
2258         unsigned long addr;
2259         long offset = 0;
2260         unsigned long va;
2261         unsigned long linkoffset;
2262         int nextarg;
2263         const char *command;
2264
2265         if (argc != 3)
2266                 return KDB_ARGCOUNT;
2267
2268         nextarg = 1;
2269         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
2270         if (diag)
2271                 return diag;
2272
2273         diag = kdbgetularg(argv[2], &linkoffset);
2274         if (diag)
2275                 return diag;
2276
2277         /*
2278          * Using the starting address as
2279          * the first element in the list, and assuming that
2280          * the list ends with a null pointer.
2281          */
2282
2283         va = addr;
2284         command = kdb_strdup(argv[3], GFP_KDB);
2285         if (!command) {
2286                 kdb_printf("%s: cannot duplicate command\n", __func__);
2287                 return 0;
2288         }
2289         /* Recursive use of kdb_parse, do not use argv after this point */
2290         argv = NULL;
2291
2292         while (va) {
2293                 char buf[80];
2294
2295                 if (KDB_FLAG(CMD_INTERRUPT))
2296                         return 0;
2297
2298                 sprintf(buf, "%s " kdb_machreg_fmt "\n", command, va);
2299                 diag = kdb_parse(buf);
2300                 if (diag)
2301                         return diag;
2302
2303                 addr = va + linkoffset;
2304                 if (kdb_getword(&va, addr, sizeof(va)))
2305                         return 0;
2306         }
2307         kfree(command);
2308
2309         return 0;
2310 }
2311
2312 static int kdb_kgdb(int argc, const char **argv)
2313 {
2314         return KDB_CMD_KGDB;
2315 }
2316
2317 /*
2318  * kdb_help - This function implements the 'help' and '?' commands.
2319  */
2320 static int kdb_help(int argc, const char **argv)
2321 {
2322         kdbtab_t *kt;
2323         int i;
2324
2325         kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2326         kdb_printf("-----------------------------"
2327                    "-----------------------------\n");
2328         for_each_kdbcmd(kt, i) {
2329                 if (kt->cmd_name)
2330                         kdb_printf("%-15.15s %-20.20s %s\n", kt->cmd_name,
2331                                    kt->cmd_usage, kt->cmd_help);
2332                 if (KDB_FLAG(CMD_INTERRUPT))
2333                         return 0;
2334         }
2335         return 0;
2336 }
2337
2338 /*
2339  * kdb_kill - This function implements the 'kill' commands.
2340  */
2341 static int kdb_kill(int argc, const char **argv)
2342 {
2343         long sig, pid;
2344         char *endp;
2345         struct task_struct *p;
2346         struct siginfo info;
2347
2348         if (argc != 2)
2349                 return KDB_ARGCOUNT;
2350
2351         sig = simple_strtol(argv[1], &endp, 0);
2352         if (*endp)
2353                 return KDB_BADINT;
2354         if (sig >= 0) {
2355                 kdb_printf("Invalid signal parameter.<-signal>\n");
2356                 return 0;
2357         }
2358         sig = -sig;
2359
2360         pid = simple_strtol(argv[2], &endp, 0);
2361         if (*endp)
2362                 return KDB_BADINT;
2363         if (pid <= 0) {
2364                 kdb_printf("Process ID must be large than 0.\n");
2365                 return 0;
2366         }
2367
2368         /* Find the process. */
2369         p = find_task_by_pid_ns(pid, &init_pid_ns);
2370         if (!p) {
2371                 kdb_printf("The specified process isn't found.\n");
2372                 return 0;
2373         }
2374         p = p->group_leader;
2375         info.si_signo = sig;
2376         info.si_errno = 0;
2377         info.si_code = SI_USER;
2378         info.si_pid = pid;  /* same capabilities as process being signalled */
2379         info.si_uid = 0;    /* kdb has root authority */
2380         kdb_send_sig_info(p, &info);
2381         return 0;
2382 }
2383
2384 struct kdb_tm {
2385         int tm_sec;     /* seconds */
2386         int tm_min;     /* minutes */
2387         int tm_hour;    /* hours */
2388         int tm_mday;    /* day of the month */
2389         int tm_mon;     /* month */
2390         int tm_year;    /* year */
2391 };
2392
2393 static void kdb_gmtime(struct timespec *tv, struct kdb_tm *tm)
2394 {
2395         /* This will work from 1970-2099, 2100 is not a leap year */
2396         static int mon_day[] = { 31, 29, 31, 30, 31, 30, 31,
2397                                  31, 30, 31, 30, 31 };
2398         memset(tm, 0, sizeof(*tm));
2399         tm->tm_sec  = tv->tv_sec % (24 * 60 * 60);
2400         tm->tm_mday = tv->tv_sec / (24 * 60 * 60) +
2401                 (2 * 365 + 1); /* shift base from 1970 to 1968 */
2402         tm->tm_min =  tm->tm_sec / 60 % 60;
2403         tm->tm_hour = tm->tm_sec / 60 / 60;
2404         tm->tm_sec =  tm->tm_sec % 60;
2405         tm->tm_year = 68 + 4*(tm->tm_mday / (4*365+1));
2406         tm->tm_mday %= (4*365+1);
2407         mon_day[1] = 29;
2408         while (tm->tm_mday >= mon_day[tm->tm_mon]) {
2409                 tm->tm_mday -= mon_day[tm->tm_mon];
2410                 if (++tm->tm_mon == 12) {
2411                         tm->tm_mon = 0;
2412                         ++tm->tm_year;
2413                         mon_day[1] = 28;
2414                 }
2415         }
2416         ++tm->tm_mday;
2417 }
2418
2419 /*
2420  * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2421  * I cannot call that code directly from kdb, it has an unconditional
2422  * cli()/sti() and calls routines that take locks which can stop the debugger.
2423  */
2424 static void kdb_sysinfo(struct sysinfo *val)
2425 {
2426         struct timespec uptime;
2427         do_posix_clock_monotonic_gettime(&uptime);
2428         memset(val, 0, sizeof(*val));
2429         val->uptime = uptime.tv_sec;
2430         val->loads[0] = avenrun[0];
2431         val->loads[1] = avenrun[1];
2432         val->loads[2] = avenrun[2];
2433         val->procs = nr_threads-1;
2434         si_meminfo(val);
2435
2436         return;
2437 }
2438
2439 /*
2440  * kdb_summary - This function implements the 'summary' command.
2441  */
2442 static int kdb_summary(int argc, const char **argv)
2443 {
2444         struct kdb_tm tm;
2445         struct sysinfo val;
2446
2447         if (argc)
2448                 return KDB_ARGCOUNT;
2449
2450         kdb_printf("sysname    %s\n", init_uts_ns.name.sysname);
2451         kdb_printf("release    %s\n", init_uts_ns.name.release);
2452         kdb_printf("version    %s\n", init_uts_ns.name.version);
2453         kdb_printf("machine    %s\n", init_uts_ns.name.machine);
2454         kdb_printf("nodename   %s\n", init_uts_ns.name.nodename);
2455         kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2456         kdb_printf("ccversion  %s\n", __stringify(CCVERSION));
2457
2458         kdb_gmtime(&xtime, &tm);
2459         kdb_printf("date       %04d-%02d-%02d %02d:%02d:%02d "
2460                    "tz_minuteswest %d\n",
2461                 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2462                 tm.tm_hour, tm.tm_min, tm.tm_sec,
2463                 sys_tz.tz_minuteswest);
2464
2465         kdb_sysinfo(&val);
2466         kdb_printf("uptime     ");
2467         if (val.uptime > (24*60*60)) {
2468                 int days = val.uptime / (24*60*60);
2469                 val.uptime %= (24*60*60);
2470                 kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2471         }
2472         kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2473
2474         /* lifted from fs/proc/proc_misc.c::loadavg_read_proc() */
2475
2476 #define LOAD_INT(x) ((x) >> FSHIFT)
2477 #define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
2478         kdb_printf("load avg   %ld.%02ld %ld.%02ld %ld.%02ld\n",
2479                 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2480                 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2481                 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2482 #undef LOAD_INT
2483 #undef LOAD_FRAC
2484         /* Display in kilobytes */
2485 #define K(x) ((x) << (PAGE_SHIFT - 10))
2486         kdb_printf("\nMemTotal:       %8lu kB\nMemFree:        %8lu kB\n"
2487                    "Buffers:        %8lu kB\n",
2488                    val.totalram, val.freeram, val.bufferram);
2489         return 0;
2490 }
2491
2492 /*
2493  * kdb_per_cpu - This function implements the 'per_cpu' command.
2494  */
2495 static int kdb_per_cpu(int argc, const char **argv)
2496 {
2497         char buf[256], fmtstr[64];
2498         kdb_symtab_t symtab;
2499         cpumask_t suppress = CPU_MASK_NONE;
2500         int cpu, diag;
2501         unsigned long addr, val, bytesperword = 0, whichcpu = ~0UL;
2502
2503         if (argc < 1 || argc > 3)
2504                 return KDB_ARGCOUNT;
2505
2506         snprintf(buf, sizeof(buf), "per_cpu__%s", argv[1]);
2507         if (!kdbgetsymval(buf, &symtab)) {
2508                 kdb_printf("%s is not a per_cpu variable\n", argv[1]);
2509                 return KDB_BADADDR;
2510         }
2511         if (argc >= 2) {
2512                 diag = kdbgetularg(argv[2], &bytesperword);
2513                 if (diag)
2514                         return diag;
2515         }
2516         if (!bytesperword)
2517                 bytesperword = KDB_WORD_SIZE;
2518         else if (bytesperword > KDB_WORD_SIZE)
2519                 return KDB_BADWIDTH;
2520         sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2521         if (argc >= 3) {
2522                 diag = kdbgetularg(argv[3], &whichcpu);
2523                 if (diag)
2524                         return diag;
2525                 if (!cpu_online(whichcpu)) {
2526                         kdb_printf("cpu %ld is not online\n", whichcpu);
2527                         return KDB_BADCPUNUM;
2528                 }
2529         }
2530
2531         /* Most architectures use __per_cpu_offset[cpu], some use
2532          * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2533          */
2534 #ifdef  __per_cpu_offset
2535 #define KDB_PCU(cpu) __per_cpu_offset(cpu)
2536 #else
2537 #ifdef  CONFIG_SMP
2538 #define KDB_PCU(cpu) __per_cpu_offset[cpu]
2539 #else
2540 #define KDB_PCU(cpu) 0
2541 #endif
2542 #endif
2543
2544         for_each_online_cpu(cpu) {
2545                 if (whichcpu != ~0UL && whichcpu != cpu)
2546                         continue;
2547                 addr = symtab.sym_start + KDB_PCU(cpu);
2548                 diag = kdb_getword(&val, addr, bytesperword);
2549                 if (diag) {
2550                         kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2551                                    "read, diag=%d\n", cpu, addr, diag);
2552                         continue;
2553                 }
2554 #ifdef  CONFIG_SMP
2555                 if (!val) {
2556                         cpu_set(cpu, suppress);
2557                         continue;
2558                 }
2559 #endif  /* CONFIG_SMP */
2560                 kdb_printf("%5d ", cpu);
2561                 kdb_md_line(fmtstr, addr,
2562                         bytesperword == KDB_WORD_SIZE,
2563                         1, bytesperword, 1, 1, 0);
2564         }
2565         if (cpus_weight(suppress) == 0)
2566                 return 0;
2567         kdb_printf("Zero suppressed cpu(s):");
2568         for (cpu = first_cpu(suppress); cpu < num_possible_cpus();
2569              cpu = next_cpu(cpu, suppress)) {
2570                 kdb_printf(" %d", cpu);
2571                 if (cpu == num_possible_cpus() - 1 ||
2572                     next_cpu(cpu, suppress) != cpu + 1)
2573                         continue;
2574                 while (cpu < num_possible_cpus() &&
2575                        next_cpu(cpu, suppress) == cpu + 1)
2576                         ++cpu;
2577                 kdb_printf("-%d", cpu);
2578         }
2579         kdb_printf("\n");
2580
2581 #undef KDB_PCU
2582
2583         return 0;
2584 }
2585
2586 /*
2587  * display help for the use of cmd | grep pattern
2588  */
2589 static int kdb_grep_help(int argc, const char **argv)
2590 {
2591         kdb_printf("Usage of  cmd args | grep pattern:\n");
2592         kdb_printf("  Any command's output may be filtered through an ");
2593         kdb_printf("emulated 'pipe'.\n");
2594         kdb_printf("  'grep' is just a key word.\n");
2595         kdb_printf("  The pattern may include a very limited set of "
2596                    "metacharacters:\n");
2597         kdb_printf("   pattern or ^pattern or pattern$ or ^pattern$\n");
2598         kdb_printf("  And if there are spaces in the pattern, you may "
2599                    "quote it:\n");
2600         kdb_printf("   \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2601                    " or \"^pat tern$\"\n");
2602         return 0;
2603 }
2604
2605 /*
2606  * kdb_register_repeat - This function is used to register a kernel
2607  *      debugger command.
2608  * Inputs:
2609  *      cmd     Command name
2610  *      func    Function to execute the command
2611  *      usage   A simple usage string showing arguments
2612  *      help    A simple help string describing command
2613  *      repeat  Does the command auto repeat on enter?
2614  * Returns:
2615  *      zero for success, one if a duplicate command.
2616  */
2617 #define kdb_command_extend 50   /* arbitrary */
2618 int kdb_register_repeat(char *cmd,
2619                         kdb_func_t func,
2620                         char *usage,
2621                         char *help,
2622                         short minlen,
2623                         kdb_repeat_t repeat)
2624 {
2625         int i;
2626         kdbtab_t *kp;
2627
2628         /*
2629          *  Brute force method to determine duplicates
2630          */
2631         for_each_kdbcmd(kp, i) {
2632                 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2633                         kdb_printf("Duplicate kdb command registered: "
2634                                 "%s, func %p help %s\n", cmd, func, help);
2635                         return 1;
2636                 }
2637         }
2638
2639         /*
2640          * Insert command into first available location in table
2641          */
2642         for_each_kdbcmd(kp, i) {
2643                 if (kp->cmd_name == NULL)
2644                         break;
2645         }
2646
2647         if (i >= kdb_max_commands) {
2648                 kdbtab_t *new = kmalloc((kdb_max_commands - KDB_BASE_CMD_MAX +
2649                          kdb_command_extend) * sizeof(*new), GFP_KDB);
2650                 if (!new) {
2651                         kdb_printf("Could not allocate new kdb_command "
2652                                    "table\n");
2653                         return 1;
2654                 }
2655                 if (kdb_commands) {
2656                         memcpy(new, kdb_commands,
2657                                kdb_max_commands * sizeof(*new));
2658                         kfree(kdb_commands);
2659                 }
2660                 memset(new + kdb_max_commands, 0,
2661                        kdb_command_extend * sizeof(*new));
2662                 kdb_commands = new;
2663                 kp = kdb_commands + kdb_max_commands;
2664                 kdb_max_commands += kdb_command_extend;
2665         }
2666
2667         kp->cmd_name   = cmd;
2668         kp->cmd_func   = func;
2669         kp->cmd_usage  = usage;
2670         kp->cmd_help   = help;
2671         kp->cmd_flags  = 0;
2672         kp->cmd_minlen = minlen;
2673         kp->cmd_repeat = repeat;
2674
2675         return 0;
2676 }
2677
2678 /*
2679  * kdb_register - Compatibility register function for commands that do
2680  *      not need to specify a repeat state.  Equivalent to
2681  *      kdb_register_repeat with KDB_REPEAT_NONE.
2682  * Inputs:
2683  *      cmd     Command name
2684  *      func    Function to execute the command
2685  *      usage   A simple usage string showing arguments
2686  *      help    A simple help string describing command
2687  * Returns:
2688  *      zero for success, one if a duplicate command.
2689  */
2690 int kdb_register(char *cmd,
2691              kdb_func_t func,
2692              char *usage,
2693              char *help,
2694              short minlen)
2695 {
2696         return kdb_register_repeat(cmd, func, usage, help, minlen,
2697                                    KDB_REPEAT_NONE);
2698 }
2699
2700 /*
2701  * kdb_unregister - This function is used to unregister a kernel
2702  *      debugger command.  It is generally called when a module which
2703  *      implements kdb commands is unloaded.
2704  * Inputs:
2705  *      cmd     Command name
2706  * Returns:
2707  *      zero for success, one command not registered.
2708  */
2709 int kdb_unregister(char *cmd)
2710 {
2711         int i;
2712         kdbtab_t *kp;
2713
2714         /*
2715          *  find the command.
2716          */
2717         for (i = 0, kp = kdb_commands; i < kdb_max_commands; i++, kp++) {
2718                 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2719                         kp->cmd_name = NULL;
2720                         return 0;
2721                 }
2722         }
2723
2724         /* Couldn't find it.  */
2725         return 1;
2726 }
2727
2728 /* Initialize the kdb command table. */
2729 static void __init kdb_inittab(void)
2730 {
2731         int i;
2732         kdbtab_t *kp;
2733
2734         for_each_kdbcmd(kp, i)
2735                 kp->cmd_name = NULL;
2736
2737         kdb_register_repeat("md", kdb_md, "<vaddr>",
2738           "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2739                             KDB_REPEAT_NO_ARGS);
2740         kdb_register_repeat("mdr", kdb_md, "<vaddr> <bytes>",
2741           "Display Raw Memory", 0, KDB_REPEAT_NO_ARGS);
2742         kdb_register_repeat("mdp", kdb_md, "<paddr> <bytes>",
2743           "Display Physical Memory", 0, KDB_REPEAT_NO_ARGS);
2744         kdb_register_repeat("mds", kdb_md, "<vaddr>",
2745           "Display Memory Symbolically", 0, KDB_REPEAT_NO_ARGS);
2746         kdb_register_repeat("mm", kdb_mm, "<vaddr> <contents>",
2747           "Modify Memory Contents", 0, KDB_REPEAT_NO_ARGS);
2748         kdb_register_repeat("go", kdb_go, "[<vaddr>]",
2749           "Continue Execution", 1, KDB_REPEAT_NONE);
2750         kdb_register_repeat("rd", kdb_rd, "",
2751           "Display Registers", 0, KDB_REPEAT_NONE);
2752         kdb_register_repeat("rm", kdb_rm, "<reg> <contents>",
2753           "Modify Registers", 0, KDB_REPEAT_NONE);
2754         kdb_register_repeat("ef", kdb_ef, "<vaddr>",
2755           "Display exception frame", 0, KDB_REPEAT_NONE);
2756         kdb_register_repeat("bt", kdb_bt, "[<vaddr>]",
2757           "Stack traceback", 1, KDB_REPEAT_NONE);
2758         kdb_register_repeat("btp", kdb_bt, "<pid>",
2759           "Display stack for process <pid>", 0, KDB_REPEAT_NONE);
2760         kdb_register_repeat("bta", kdb_bt, "[DRSTCZEUIMA]",
2761           "Display stack all processes", 0, KDB_REPEAT_NONE);
2762         kdb_register_repeat("btc", kdb_bt, "",
2763           "Backtrace current process on each cpu", 0, KDB_REPEAT_NONE);
2764         kdb_register_repeat("btt", kdb_bt, "<vaddr>",
2765           "Backtrace process given its struct task address", 0,
2766                             KDB_REPEAT_NONE);
2767         kdb_register_repeat("ll", kdb_ll, "<first-element> <linkoffset> <cmd>",
2768           "Execute cmd for each element in linked list", 0, KDB_REPEAT_NONE);
2769         kdb_register_repeat("env", kdb_env, "",
2770           "Show environment variables", 0, KDB_REPEAT_NONE);
2771         kdb_register_repeat("set", kdb_set, "",
2772           "Set environment variables", 0, KDB_REPEAT_NONE);
2773         kdb_register_repeat("help", kdb_help, "",
2774           "Display Help Message", 1, KDB_REPEAT_NONE);
2775         kdb_register_repeat("?", kdb_help, "",
2776           "Display Help Message", 0, KDB_REPEAT_NONE);
2777         kdb_register_repeat("cpu", kdb_cpu, "<cpunum>",
2778           "Switch to new cpu", 0, KDB_REPEAT_NONE);
2779         kdb_register_repeat("kgdb", kdb_kgdb, "",
2780           "Enter kgdb mode", 0, KDB_REPEAT_NONE);
2781         kdb_register_repeat("ps", kdb_ps, "[<flags>|A]",
2782           "Display active task list", 0, KDB_REPEAT_NONE);
2783         kdb_register_repeat("pid", kdb_pid, "<pidnum>",
2784           "Switch to another task", 0, KDB_REPEAT_NONE);
2785         kdb_register_repeat("reboot", kdb_reboot, "",
2786           "Reboot the machine immediately", 0, KDB_REPEAT_NONE);
2787 #if defined(CONFIG_MODULES)
2788         kdb_register_repeat("lsmod", kdb_lsmod, "",
2789           "List loaded kernel modules", 0, KDB_REPEAT_NONE);
2790 #endif
2791 #if defined(CONFIG_MAGIC_SYSRQ)
2792         kdb_register_repeat("sr", kdb_sr, "<key>",
2793           "Magic SysRq key", 0, KDB_REPEAT_NONE);
2794 #endif
2795 #if defined(CONFIG_PRINTK)
2796         kdb_register_repeat("dmesg", kdb_dmesg, "[lines]",
2797           "Display syslog buffer", 0, KDB_REPEAT_NONE);
2798 #endif
2799         kdb_register_repeat("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
2800           "Define a set of commands, down to endefcmd", 0, KDB_REPEAT_NONE);
2801         kdb_register_repeat("kill", kdb_kill, "<-signal> <pid>",
2802           "Send a signal to a process", 0, KDB_REPEAT_NONE);
2803         kdb_register_repeat("summary", kdb_summary, "",
2804           "Summarize the system", 4, KDB_REPEAT_NONE);
2805         kdb_register_repeat("per_cpu", kdb_per_cpu, "",
2806           "Display per_cpu variables", 3, KDB_REPEAT_NONE);
2807         kdb_register_repeat("grephelp", kdb_grep_help, "",
2808           "Display help on | grep", 0, KDB_REPEAT_NONE);
2809 }
2810
2811 /* Execute any commands defined in kdb_cmds.  */
2812 static void __init kdb_cmd_init(void)
2813 {
2814         int i, diag;
2815         for (i = 0; kdb_cmds[i]; ++i) {
2816                 diag = kdb_parse(kdb_cmds[i]);
2817                 if (diag)
2818                         kdb_printf("kdb command %s failed, kdb diag %d\n",
2819                                 kdb_cmds[i], diag);
2820         }
2821         if (defcmd_in_progress) {
2822                 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2823                 kdb_parse("endefcmd");
2824         }
2825 }
2826
2827 /* Intialize kdb_printf, breakpoint tables and kdb state */
2828 void __init kdb_init(int lvl)
2829 {
2830         static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2831         int i;
2832
2833         if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2834                 return;
2835         for (i = kdb_init_lvl; i < lvl; i++) {
2836                 switch (i) {
2837                 case KDB_NOT_INITIALIZED:
2838                         kdb_inittab();          /* Initialize Command Table */
2839                         kdb_initbptab();        /* Initialize Breakpoints */
2840                         break;
2841                 case KDB_INIT_EARLY:
2842                         kdb_cmd_init();         /* Build kdb_cmds tables */
2843                         break;
2844                 }
2845         }
2846         kdb_init_lvl = lvl;
2847 }