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