kernel/debug/kdb/kdb_main.c

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