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