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