kernel/debug/kdb/kdb_main.c

   1 /*
   2  * Kernel Debugger Architecture Independent Main Code
   3  *
   4  * This file is subject to the terms and conditions of the GNU General Public
   5  * License.  See the file "COPYING" in the main directory of this archive
   6  * for more details.
   7  *
   8  * Copyright (C) 1999-2004 Silicon Graphics, Inc.  All Rights Reserved.
   9  * Copyright (C) 2000 Stephane Eranian <eranian@hpl.hp.com>
  10  * Xscale (R) modifications copyright (C) 2003 Intel Corporation.
  11  * Copyright (c) 2009 Wind River Systems, Inc.  All Rights Reserved.
  12  */
  13
  14 #include <linux/ctype.h>
  15 #include <linux/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%px, 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%px, 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         int j;
1497         unsigned long word;
1498
1499         memset(cbuf, '\0', sizeof(cbuf));
1500         if (phys)
1501                 kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1502         else
1503                 kdb_printf(kdb_machreg_fmt0 " ", addr);
1504
1505         for (i = 0; i < num && repeat--; i++) {
1506                 if (phys) {
1507                         if (kdb_getphysword(&word, addr, bytesperword))
1508                                 break;
1509                 } else if (kdb_getword(&word, addr, bytesperword))
1510                         break;
1511                 kdb_printf(fmtstr, word);
1512                 if (symbolic)
1513                         kdbnearsym(word, &symtab);
1514                 else
1515                         memset(&symtab, 0, sizeof(symtab));
1516                 if (symtab.sym_name) {
1517                         kdb_symbol_print(word, &symtab, 0);
1518                         if (!nosect) {
1519                                 kdb_printf("\n");
1520                                 kdb_printf("                       %s %s "
1521                                            kdb_machreg_fmt " "
1522                                            kdb_machreg_fmt " "
1523                                            kdb_machreg_fmt, symtab.mod_name,
1524                                            symtab.sec_name, symtab.sec_start,
1525                                            symtab.sym_start, symtab.sym_end);
1526                         }
1527                         addr += bytesperword;
1528                 } else {
1529                         union {
1530                                 u64 word;
1531                                 unsigned char c[8];
1532                         } wc;
1533                         unsigned char *cp;
1534 #ifdef  __BIG_ENDIAN
1535                         cp = wc.c + 8 - bytesperword;
1536 #else
1537                         cp = wc.c;
1538 #endif
1539                         wc.word = word;
1540 #define printable_char(c) \
1541         ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1542                         for (j = 0; j < bytesperword; j++)
1543                                 *c++ = printable_char(*cp++);
1544                         addr += bytesperword;
1545 #undef printable_char
1546                 }
1547         }
1548         kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1549                    " ", cbuf);
1550 }
1551
1552 static int kdb_md(int argc, const char **argv)
1553 {
1554         static unsigned long last_addr;
1555         static int last_radix, last_bytesperword, last_repeat;
1556         int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1557         int nosect = 0;
1558         char fmtchar, fmtstr[64];
1559         unsigned long addr;
1560         unsigned long word;
1561         long offset = 0;
1562         int symbolic = 0;
1563         int valid = 0;
1564         int phys = 0;
1565         int raw = 0;
1566
1567         kdbgetintenv("MDCOUNT", &mdcount);
1568         kdbgetintenv("RADIX", &radix);
1569         kdbgetintenv("BYTESPERWORD", &bytesperword);
1570
1571         /* Assume 'md <addr>' and start with environment values */
1572         repeat = mdcount * 16 / bytesperword;
1573
1574         if (strcmp(argv[0], "mdr") == 0) {
1575                 if (argc == 2 || (argc == 0 && last_addr != 0))
1576                         valid = raw = 1;
1577                 else
1578                         return KDB_ARGCOUNT;
1579         } else if (isdigit(argv[0][2])) {
1580                 bytesperword = (int)(argv[0][2] - '0');
1581                 if (bytesperword == 0) {
1582                         bytesperword = last_bytesperword;
1583                         if (bytesperword == 0)
1584                                 bytesperword = 4;
1585                 }
1586                 last_bytesperword = bytesperword;
1587                 repeat = mdcount * 16 / bytesperword;
1588                 if (!argv[0][3])
1589                         valid = 1;
1590                 else if (argv[0][3] == 'c' && argv[0][4]) {
1591                         char *p;
1592                         repeat = simple_strtoul(argv[0] + 4, &p, 10);
1593                         mdcount = ((repeat * bytesperword) + 15) / 16;
1594                         valid = !*p;
1595                 }
1596                 last_repeat = repeat;
1597         } else if (strcmp(argv[0], "md") == 0)
1598                 valid = 1;
1599         else if (strcmp(argv[0], "mds") == 0)
1600                 valid = 1;
1601         else if (strcmp(argv[0], "mdp") == 0) {
1602                 phys = valid = 1;
1603         }
1604         if (!valid)
1605                 return KDB_NOTFOUND;
1606
1607         if (argc == 0) {
1608                 if (last_addr == 0)
1609                         return KDB_ARGCOUNT;
1610                 addr = last_addr;
1611                 radix = last_radix;
1612                 bytesperword = last_bytesperword;
1613                 repeat = last_repeat;
1614                 if (raw)
1615                         mdcount = repeat;
1616                 else
1617                         mdcount = ((repeat * bytesperword) + 15) / 16;
1618         }
1619
1620         if (argc) {
1621                 unsigned long val;
1622                 int diag, nextarg = 1;
1623                 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1624                                      &offset, NULL);
1625                 if (diag)
1626                         return diag;
1627                 if (argc > nextarg+2)
1628                         return KDB_ARGCOUNT;
1629
1630                 if (argc >= nextarg) {
1631                         diag = kdbgetularg(argv[nextarg], &val);
1632                         if (!diag) {
1633                                 mdcount = (int) val;
1634                                 if (raw)
1635                                         repeat = mdcount;
1636                                 else
1637                                         repeat = mdcount * 16 / bytesperword;
1638                         }
1639                 }
1640                 if (argc >= nextarg+1) {
1641                         diag = kdbgetularg(argv[nextarg+1], &val);
1642                         if (!diag)
1643                                 radix = (int) val;
1644                 }
1645         }
1646
1647         if (strcmp(argv[0], "mdr") == 0) {
1648                 int ret;
1649                 last_addr = addr;
1650                 ret = kdb_mdr(addr, mdcount);
1651                 last_addr += mdcount;
1652                 last_repeat = mdcount;
1653                 last_bytesperword = bytesperword; // to make REPEAT happy
1654                 return ret;
1655         }
1656
1657         switch (radix) {
1658         case 10:
1659                 fmtchar = 'd';
1660                 break;
1661         case 16:
1662                 fmtchar = 'x';
1663                 break;
1664         case 8:
1665                 fmtchar = 'o';
1666                 break;
1667         default:
1668                 return KDB_BADRADIX;
1669         }
1670
1671         last_radix = radix;
1672
1673         if (bytesperword > KDB_WORD_SIZE)
1674                 return KDB_BADWIDTH;
1675
1676         switch (bytesperword) {
1677         case 8:
1678                 sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1679                 break;
1680         case 4:
1681                 sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1682                 break;
1683         case 2:
1684                 sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1685                 break;
1686         case 1:
1687                 sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1688                 break;
1689         default:
1690                 return KDB_BADWIDTH;
1691         }
1692
1693         last_repeat = repeat;
1694         last_bytesperword = bytesperword;
1695
1696         if (strcmp(argv[0], "mds") == 0) {
1697                 symbolic = 1;
1698                 /* Do not save these changes as last_*, they are temporary mds
1699                  * overrides.
1700                  */
1701                 bytesperword = KDB_WORD_SIZE;
1702                 repeat = mdcount;
1703                 kdbgetintenv("NOSECT", &nosect);
1704         }
1705
1706         /* Round address down modulo BYTESPERWORD */
1707
1708         addr &= ~(bytesperword-1);
1709
1710         while (repeat > 0) {
1711                 unsigned long a;
1712                 int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1713
1714                 if (KDB_FLAG(CMD_INTERRUPT))
1715                         return 0;
1716                 for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1717                         if (phys) {
1718                                 if (kdb_getphysword(&word, a, bytesperword)
1719                                                 || word)
1720                                         break;
1721                         } else if (kdb_getword(&word, a, bytesperword) || word)
1722                                 break;
1723                 }
1724                 n = min(num, repeat);
1725                 kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1726                             num, repeat, phys);
1727                 addr += bytesperword * n;
1728                 repeat -= n;
1729                 z = (z + num - 1) / num;
1730                 if (z > 2) {
1731                         int s = num * (z-2);
1732                         kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1733                                    " zero suppressed\n",
1734                                 addr, addr + bytesperword * s - 1);
1735                         addr += bytesperword * s;
1736                         repeat -= s;
1737                 }
1738         }
1739         last_addr = addr;
1740
1741         return 0;
1742 }
1743
1744 /*
1745  * kdb_mm - This function implements the 'mm' command.
1746  *      mm address-expression new-value
1747  * Remarks:
1748  *      mm works on machine words, mmW works on bytes.
1749  */
1750 static int kdb_mm(int argc, const char **argv)
1751 {
1752         int diag;
1753         unsigned long addr;
1754         long offset = 0;
1755         unsigned long contents;
1756         int nextarg;
1757         int width;
1758
1759         if (argv[0][2] && !isdigit(argv[0][2]))
1760                 return KDB_NOTFOUND;
1761
1762         if (argc < 2)
1763                 return KDB_ARGCOUNT;
1764
1765         nextarg = 1;
1766         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1767         if (diag)
1768                 return diag;
1769
1770         if (nextarg > argc)
1771                 return KDB_ARGCOUNT;
1772         diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1773         if (diag)
1774                 return diag;
1775
1776         if (nextarg != argc + 1)
1777                 return KDB_ARGCOUNT;
1778
1779         width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1780         diag = kdb_putword(addr, contents, width);
1781         if (diag)
1782                 return diag;
1783
1784         kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1785
1786         return 0;
1787 }
1788
1789 /*
1790  * kdb_go - This function implements the 'go' command.
1791  *      go [address-expression]
1792  */
1793 static int kdb_go(int argc, const char **argv)
1794 {
1795         unsigned long addr;
1796         int diag;
1797         int nextarg;
1798         long offset;
1799
1800         if (raw_smp_processor_id() != kdb_initial_cpu) {
1801                 kdb_printf("go must execute on the entry cpu, "
1802                            "please use \"cpu %d\" and then execute go\n",
1803                            kdb_initial_cpu);
1804                 return KDB_BADCPUNUM;
1805         }
1806         if (argc == 1) {
1807                 nextarg = 1;
1808                 diag = kdbgetaddrarg(argc, argv, &nextarg,
1809                                      &addr, &offset, NULL);
1810                 if (diag)
1811                         return diag;
1812         } else if (argc) {
1813                 return KDB_ARGCOUNT;
1814         }
1815
1816         diag = KDB_CMD_GO;
1817         if (KDB_FLAG(CATASTROPHIC)) {
1818                 kdb_printf("Catastrophic error detected\n");
1819                 kdb_printf("kdb_continue_catastrophic=%d, ",
1820                         kdb_continue_catastrophic);
1821                 if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1822                         kdb_printf("type go a second time if you really want "
1823                                    "to continue\n");
1824                         return 0;
1825                 }
1826                 if (kdb_continue_catastrophic == 2) {
1827                         kdb_printf("forcing reboot\n");
1828                         kdb_reboot(0, NULL);
1829                 }
1830                 kdb_printf("attempting to continue\n");
1831         }
1832         return diag;
1833 }
1834
1835 /*
1836  * kdb_rd - This function implements the 'rd' command.
1837  */
1838 static int kdb_rd(int argc, const char **argv)
1839 {
1840         int len = kdb_check_regs();
1841 #if DBG_MAX_REG_NUM > 0
1842         int i;
1843         char *rname;
1844         int rsize;
1845         u64 reg64;
1846         u32 reg32;
1847         u16 reg16;
1848         u8 reg8;
1849
1850         if (len)
1851                 return len;
1852
1853         for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1854                 rsize = dbg_reg_def[i].size * 2;
1855                 if (rsize > 16)
1856                         rsize = 2;
1857                 if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
1858                         len = 0;
1859                         kdb_printf("\n");
1860                 }
1861                 if (len)
1862                         len += kdb_printf("  ");
1863                 switch(dbg_reg_def[i].size * 8) {
1864                 case 8:
1865                         rname = dbg_get_reg(i, &reg8, kdb_current_regs);
1866                         if (!rname)
1867                                 break;
1868                         len += kdb_printf("%s: %02x", rname, reg8);
1869                         break;
1870                 case 16:
1871                         rname = dbg_get_reg(i, &reg16, kdb_current_regs);
1872                         if (!rname)
1873                                 break;
1874                         len += kdb_printf("%s: %04x", rname, reg16);
1875                         break;
1876                 case 32:
1877                         rname = dbg_get_reg(i, &reg32, kdb_current_regs);
1878                         if (!rname)
1879                                 break;
1880                         len += kdb_printf("%s: %08x", rname, reg32);
1881                         break;
1882                 case 64:
1883                         rname = dbg_get_reg(i, &reg64, kdb_current_regs);
1884                         if (!rname)
1885                                 break;
1886                         len += kdb_printf("%s: %016llx", rname, reg64);
1887                         break;
1888                 default:
1889                         len += kdb_printf("%s: ??", dbg_reg_def[i].name);
1890                 }
1891         }
1892         kdb_printf("\n");
1893 #else
1894         if (len)
1895                 return len;
1896
1897         kdb_dumpregs(kdb_current_regs);
1898 #endif
1899         return 0;
1900 }
1901
1902 /*
1903  * kdb_rm - This function implements the 'rm' (register modify)  command.
1904  *      rm register-name new-contents
1905  * Remarks:
1906  *      Allows register modification with the same restrictions as gdb
1907  */
1908 static int kdb_rm(int argc, const char **argv)
1909 {
1910 #if DBG_MAX_REG_NUM > 0
1911         int diag;
1912         const char *rname;
1913         int i;
1914         u64 reg64;
1915         u32 reg32;
1916         u16 reg16;
1917         u8 reg8;
1918
1919         if (argc != 2)
1920                 return KDB_ARGCOUNT;
1921         /*
1922          * Allow presence or absence of leading '%' symbol.
1923          */
1924         rname = argv[1];
1925         if (*rname == '%')
1926                 rname++;
1927
1928         diag = kdbgetu64arg(argv[2], &reg64);
1929         if (diag)
1930                 return diag;
1931
1932         diag = kdb_check_regs();
1933         if (diag)
1934                 return diag;
1935
1936         diag = KDB_BADREG;
1937         for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1938                 if (strcmp(rname, dbg_reg_def[i].name) == 0) {
1939                         diag = 0;
1940                         break;
1941                 }
1942         }
1943         if (!diag) {
1944                 switch(dbg_reg_def[i].size * 8) {
1945                 case 8:
1946                         reg8 = reg64;
1947                         dbg_set_reg(i, &reg8, kdb_current_regs);
1948                         break;
1949                 case 16:
1950                         reg16 = reg64;
1951                         dbg_set_reg(i, &reg16, kdb_current_regs);
1952                         break;
1953                 case 32:
1954                         reg32 = reg64;
1955                         dbg_set_reg(i, &reg32, kdb_current_regs);
1956                         break;
1957                 case 64:
1958                         dbg_set_reg(i, &reg64, kdb_current_regs);
1959                         break;
1960                 }
1961         }
1962         return diag;
1963 #else
1964         kdb_printf("ERROR: Register set currently not implemented\n");
1965     return 0;
1966 #endif
1967 }
1968
1969 #if defined(CONFIG_MAGIC_SYSRQ)
1970 /*
1971  * kdb_sr - This function implements the 'sr' (SYSRQ key) command
1972  *      which interfaces to the soi-disant MAGIC SYSRQ functionality.
1973  *              sr <magic-sysrq-code>
1974  */
1975 static int kdb_sr(int argc, const char **argv)
1976 {
1977         bool check_mask =
1978             !kdb_check_flags(KDB_ENABLE_ALL, kdb_cmd_enabled, false);
1979
1980         if (argc != 1)
1981                 return KDB_ARGCOUNT;
1982
1983         kdb_trap_printk++;
1984         __handle_sysrq(*argv[1], check_mask);
1985         kdb_trap_printk--;
1986
1987         return 0;
1988 }
1989 #endif  /* CONFIG_MAGIC_SYSRQ */
1990
1991 /*
1992  * kdb_ef - This function implements the 'regs' (display exception
1993  *      frame) command.  This command takes an address and expects to
1994  *      find an exception frame at that address, formats and prints
1995  *      it.
1996  *              regs address-expression
1997  * Remarks:
1998  *      Not done yet.
1999  */
2000 static int kdb_ef(int argc, const char **argv)
2001 {
2002         int diag;
2003         unsigned long addr;
2004         long offset;
2005         int nextarg;
2006
2007         if (argc != 1)
2008                 return KDB_ARGCOUNT;
2009
2010         nextarg = 1;
2011         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
2012         if (diag)
2013                 return diag;
2014         show_regs((struct pt_regs *)addr);
2015         return 0;
2016 }
2017
2018 #if defined(CONFIG_MODULES)
2019 /*
2020  * kdb_lsmod - This function implements the 'lsmod' command.  Lists
2021  *      currently loaded kernel modules.
2022  *      Mostly taken from userland lsmod.
2023  */
2024 static int kdb_lsmod(int argc, const char **argv)
2025 {
2026         struct module *mod;
2027
2028         if (argc != 0)
2029                 return KDB_ARGCOUNT;
2030
2031         kdb_printf("Module                  Size  modstruct     Used by\n");
2032         list_for_each_entry(mod, kdb_modules, list) {
2033                 if (mod->state == MODULE_STATE_UNFORMED)
2034                         continue;
2035
2036                 kdb_printf("%-20s%8u  0x%px ", mod->name,
2037                            mod->core_layout.size, (void *)mod);
2038 #ifdef CONFIG_MODULE_UNLOAD
2039                 kdb_printf("%4d ", module_refcount(mod));
2040 #endif
2041                 if (mod->state == MODULE_STATE_GOING)
2042                         kdb_printf(" (Unloading)");
2043                 else if (mod->state == MODULE_STATE_COMING)
2044                         kdb_printf(" (Loading)");
2045                 else
2046                         kdb_printf(" (Live)");
2047                 kdb_printf(" 0x%px", mod->core_layout.base);
2048
2049 #ifdef CONFIG_MODULE_UNLOAD
2050                 {
2051                         struct module_use *use;
2052                         kdb_printf(" [ ");
2053                         list_for_each_entry(use, &mod->source_list,
2054                                             source_list)
2055                                 kdb_printf("%s ", use->target->name);
2056                         kdb_printf("]\n");
2057                 }
2058 #endif
2059         }
2060
2061         return 0;
2062 }
2063
2064 #endif  /* CONFIG_MODULES */
2065
2066 /*
2067  * kdb_env - This function implements the 'env' command.  Display the
2068  *      current environment variables.
2069  */
2070
2071 static int kdb_env(int argc, const char **argv)
2072 {
2073         int i;
2074
2075         for (i = 0; i < __nenv; i++) {
2076                 if (__env[i])
2077                         kdb_printf("%s\n", __env[i]);
2078         }
2079
2080         if (KDB_DEBUG(MASK))
2081                 kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
2082
2083         return 0;
2084 }
2085
2086 #ifdef CONFIG_PRINTK
2087 /*
2088  * kdb_dmesg - This function implements the 'dmesg' command to display
2089  *      the contents of the syslog buffer.
2090  *              dmesg [lines] [adjust]
2091  */
2092 static int kdb_dmesg(int argc, const char **argv)
2093 {
2094         int diag;
2095         int logging;
2096         int lines = 0;
2097         int adjust = 0;
2098         int n = 0;
2099         int skip = 0;
2100         struct kmsg_dumper dumper = { .active = 1 };
2101         size_t len;
2102         char buf[201];
2103
2104         if (argc > 2)
2105                 return KDB_ARGCOUNT;
2106         if (argc) {
2107                 char *cp;
2108                 lines = simple_strtol(argv[1], &cp, 0);
2109                 if (*cp)
2110                         lines = 0;
2111                 if (argc > 1) {
2112                         adjust = simple_strtoul(argv[2], &cp, 0);
2113                         if (*cp || adjust < 0)
2114                                 adjust = 0;
2115                 }
2116         }
2117
2118         /* disable LOGGING if set */
2119         diag = kdbgetintenv("LOGGING", &logging);
2120         if (!diag && logging) {
2121                 const char *setargs[] = { "set", "LOGGING", "0" };
2122                 kdb_set(2, setargs);
2123         }
2124
2125         kmsg_dump_rewind_nolock(&dumper);
2126         while (kmsg_dump_get_line_nolock(&dumper, 1, NULL, 0, NULL))
2127                 n++;
2128
2129         if (lines < 0) {
2130                 if (adjust >= n)
2131                         kdb_printf("buffer only contains %d lines, nothing "
2132                                    "printed\n", n);
2133                 else if (adjust - lines >= n)
2134                         kdb_printf("buffer only contains %d lines, last %d "
2135                                    "lines printed\n", n, n - adjust);
2136                 skip = adjust;
2137                 lines = abs(lines);
2138         } else if (lines > 0) {
2139                 skip = n - lines - adjust;
2140                 lines = abs(lines);
2141                 if (adjust >= n) {
2142                         kdb_printf("buffer only contains %d lines, "
2143                                    "nothing printed\n", n);
2144                         skip = n;
2145                 } else if (skip < 0) {
2146                         lines += skip;
2147                         skip = 0;
2148                         kdb_printf("buffer only contains %d lines, first "
2149                                    "%d lines printed\n", n, lines);
2150                 }
2151         } else {
2152                 lines = n;
2153         }
2154
2155         if (skip >= n || skip < 0)
2156                 return 0;
2157
2158         kmsg_dump_rewind_nolock(&dumper);
2159         while (kmsg_dump_get_line_nolock(&dumper, 1, buf, sizeof(buf), &len)) {
2160                 if (skip) {
2161                         skip--;
2162                         continue;
2163                 }
2164                 if (!lines--)
2165                         break;
2166                 if (KDB_FLAG(CMD_INTERRUPT))
2167                         return 0;
2168
2169                 kdb_printf("%.*s\n", (int)len - 1, buf);
2170         }
2171
2172         return 0;
2173 }
2174 #endif /* CONFIG_PRINTK */
2175
2176 /* Make sure we balance enable/disable calls, must disable first. */
2177 static atomic_t kdb_nmi_disabled;
2178
2179 static int kdb_disable_nmi(int argc, const char *argv[])
2180 {
2181         if (atomic_read(&kdb_nmi_disabled))
2182                 return 0;
2183         atomic_set(&kdb_nmi_disabled, 1);
2184         arch_kgdb_ops.enable_nmi(0);
2185         return 0;
2186 }
2187
2188 static int kdb_param_enable_nmi(const char *val, const struct kernel_param *kp)
2189 {
2190         if (!atomic_add_unless(&kdb_nmi_disabled, -1, 0))
2191                 return -EINVAL;
2192         arch_kgdb_ops.enable_nmi(1);
2193         return 0;
2194 }
2195
2196 static const struct kernel_param_ops kdb_param_ops_enable_nmi = {
2197         .set = kdb_param_enable_nmi,
2198 };
2199 module_param_cb(enable_nmi, &kdb_param_ops_enable_nmi, NULL, 0600);
2200
2201 /*
2202  * kdb_cpu - This function implements the 'cpu' command.
2203  *      cpu     [<cpunum>]
2204  * Returns:
2205  *      KDB_CMD_CPU for success, a kdb diagnostic if error
2206  */
2207 static void kdb_cpu_status(void)
2208 {
2209         int i, start_cpu, first_print = 1;
2210         char state, prev_state = '?';
2211
2212         kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2213         kdb_printf("Available cpus: ");
2214         for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2215                 if (!cpu_online(i)) {
2216                         state = 'F';    /* cpu is offline */
2217                 } else if (!kgdb_info[i].enter_kgdb) {
2218                         state = 'D';    /* cpu is online but unresponsive */
2219                 } else {
2220                         state = ' ';    /* cpu is responding to kdb */
2221                         if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2222                                 state = 'I';    /* idle task */
2223                 }
2224                 if (state != prev_state) {
2225                         if (prev_state != '?') {
2226                                 if (!first_print)
2227                                         kdb_printf(", ");
2228                                 first_print = 0;
2229                                 kdb_printf("%d", start_cpu);
2230                                 if (start_cpu < i-1)
2231                                         kdb_printf("-%d", i-1);
2232                                 if (prev_state != ' ')
2233                                         kdb_printf("(%c)", prev_state);
2234                         }
2235                         prev_state = state;
2236                         start_cpu = i;
2237                 }
2238         }
2239         /* print the trailing cpus, ignoring them if they are all offline */
2240         if (prev_state != 'F') {
2241                 if (!first_print)
2242                         kdb_printf(", ");
2243                 kdb_printf("%d", start_cpu);
2244                 if (start_cpu < i-1)
2245                         kdb_printf("-%d", i-1);
2246                 if (prev_state != ' ')
2247                         kdb_printf("(%c)", prev_state);
2248         }
2249         kdb_printf("\n");
2250 }
2251
2252 static int kdb_cpu(int argc, const char **argv)
2253 {
2254         unsigned long cpunum;
2255         int diag;
2256
2257         if (argc == 0) {
2258                 kdb_cpu_status();
2259                 return 0;
2260         }
2261
2262         if (argc != 1)
2263                 return KDB_ARGCOUNT;
2264
2265         diag = kdbgetularg(argv[1], &cpunum);
2266         if (diag)
2267                 return diag;
2268
2269         /*
2270          * Validate cpunum
2271          */
2272         if ((cpunum >= CONFIG_NR_CPUS) || !kgdb_info[cpunum].enter_kgdb)
2273                 return KDB_BADCPUNUM;
2274
2275         dbg_switch_cpu = cpunum;
2276
2277         /*
2278          * Switch to other cpu
2279          */
2280         return KDB_CMD_CPU;
2281 }
2282
2283 /* The user may not realize that ps/bta with no parameters does not print idle
2284  * or sleeping system daemon processes, so tell them how many were suppressed.
2285  */
2286 void kdb_ps_suppressed(void)
2287 {
2288         int idle = 0, daemon = 0;
2289         unsigned long mask_I = kdb_task_state_string("I"),
2290                       mask_M = kdb_task_state_string("M");
2291         unsigned long cpu;
2292         const struct task_struct *p, *g;
2293         for_each_online_cpu(cpu) {
2294                 p = kdb_curr_task(cpu);
2295                 if (kdb_task_state(p, mask_I))
2296                         ++idle;
2297         }
2298         kdb_do_each_thread(g, p) {
2299                 if (kdb_task_state(p, mask_M))
2300                         ++daemon;
2301         } kdb_while_each_thread(g, p);
2302         if (idle || daemon) {
2303                 if (idle)
2304                         kdb_printf("%d idle process%s (state I)%s\n",
2305                                    idle, idle == 1 ? "" : "es",
2306                                    daemon ? " and " : "");
2307                 if (daemon)
2308                         kdb_printf("%d sleeping system daemon (state M) "
2309                                    "process%s", daemon,
2310                                    daemon == 1 ? "" : "es");
2311                 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2312         }
2313 }
2314
2315 /*
2316  * kdb_ps - This function implements the 'ps' command which shows a
2317  *      list of the active processes.
2318  *              ps [DRSTCZEUIMA]   All processes, optionally filtered by state
2319  */
2320 void kdb_ps1(const struct task_struct *p)
2321 {
2322         int cpu;
2323         unsigned long tmp;
2324
2325         if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
2326                 return;
2327
2328         cpu = kdb_process_cpu(p);
2329         kdb_printf("0x%px %8d %8d  %d %4d   %c  0x%px %c%s\n",
2330                    (void *)p, p->pid, p->parent->pid,
2331                    kdb_task_has_cpu(p), kdb_process_cpu(p),
2332                    kdb_task_state_char(p),
2333                    (void *)(&p->thread),
2334                    p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2335                    p->comm);
2336         if (kdb_task_has_cpu(p)) {
2337                 if (!KDB_TSK(cpu)) {
2338                         kdb_printf("  Error: no saved data for this cpu\n");
2339                 } else {
2340                         if (KDB_TSK(cpu) != p)
2341                                 kdb_printf("  Error: does not match running "
2342                                    "process table (0x%px)\n", KDB_TSK(cpu));
2343                 }
2344         }
2345 }
2346
2347 static int kdb_ps(int argc, const char **argv)
2348 {
2349         struct task_struct *g, *p;
2350         unsigned long mask, cpu;
2351
2352         if (argc == 0)
2353                 kdb_ps_suppressed();
2354         kdb_printf("%-*s      Pid   Parent [*] cpu State %-*s Command\n",
2355                 (int)(2*sizeof(void *))+2, "Task Addr",
2356                 (int)(2*sizeof(void *))+2, "Thread");
2357         mask = kdb_task_state_string(argc ? argv[1] : NULL);
2358         /* Run the active tasks first */
2359         for_each_online_cpu(cpu) {
2360                 if (KDB_FLAG(CMD_INTERRUPT))
2361                         return 0;
2362                 p = kdb_curr_task(cpu);
2363                 if (kdb_task_state(p, mask))
2364                         kdb_ps1(p);
2365         }
2366         kdb_printf("\n");
2367         /* Now the real tasks */
2368         kdb_do_each_thread(g, p) {
2369                 if (KDB_FLAG(CMD_INTERRUPT))
2370                         return 0;
2371                 if (kdb_task_state(p, mask))
2372                         kdb_ps1(p);
2373         } kdb_while_each_thread(g, p);
2374
2375         return 0;
2376 }
2377
2378 /*
2379  * kdb_pid - This function implements the 'pid' command which switches
2380  *      the currently active process.
2381  *              pid [<pid> | R]
2382  */
2383 static int kdb_pid(int argc, const char **argv)
2384 {
2385         struct task_struct *p;
2386         unsigned long val;
2387         int diag;
2388
2389         if (argc > 1)
2390                 return KDB_ARGCOUNT;
2391
2392         if (argc) {
2393                 if (strcmp(argv[1], "R") == 0) {
2394                         p = KDB_TSK(kdb_initial_cpu);
2395                 } else {
2396                         diag = kdbgetularg(argv[1], &val);
2397                         if (diag)
2398                                 return KDB_BADINT;
2399
2400                         p = find_task_by_pid_ns((pid_t)val,     &init_pid_ns);
2401                         if (!p) {
2402                                 kdb_printf("No task with pid=%d\n", (pid_t)val);
2403                                 return 0;
2404                         }
2405                 }
2406                 kdb_set_current_task(p);
2407         }
2408         kdb_printf("KDB current process is %s(pid=%d)\n",
2409                    kdb_current_task->comm,
2410                    kdb_current_task->pid);
2411
2412         return 0;
2413 }
2414
2415 static int kdb_kgdb(int argc, const char **argv)
2416 {
2417         return KDB_CMD_KGDB;
2418 }
2419
2420 /*
2421  * kdb_help - This function implements the 'help' and '?' commands.
2422  */
2423 static int kdb_help(int argc, const char **argv)
2424 {
2425         kdbtab_t *kt;
2426         int i;
2427
2428         kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2429         kdb_printf("-----------------------------"
2430                    "-----------------------------\n");
2431         for_each_kdbcmd(kt, i) {
2432                 char *space = "";
2433                 if (KDB_FLAG(CMD_INTERRUPT))
2434                         return 0;
2435                 if (!kt->cmd_name)
2436                         continue;
2437                 if (!kdb_check_flags(kt->cmd_flags, kdb_cmd_enabled, true))
2438                         continue;
2439                 if (strlen(kt->cmd_usage) > 20)
2440                         space = "\n                                    ";
2441                 kdb_printf("%-15.15s %-20s%s%s\n", kt->cmd_name,
2442                            kt->cmd_usage, space, kt->cmd_help);
2443         }
2444         return 0;
2445 }
2446
2447 /*
2448  * kdb_kill - This function implements the 'kill' commands.
2449  */
2450 static int kdb_kill(int argc, const char **argv)
2451 {
2452         long sig, pid;
2453         char *endp;
2454         struct task_struct *p;
2455
2456         if (argc != 2)
2457                 return KDB_ARGCOUNT;
2458
2459         sig = simple_strtol(argv[1], &endp, 0);
2460         if (*endp)
2461                 return KDB_BADINT;
2462         if ((sig >= 0) || !valid_signal(-sig)) {
2463                 kdb_printf("Invalid signal parameter.<-signal>\n");
2464                 return 0;
2465         }
2466         sig = -sig;
2467
2468         pid = simple_strtol(argv[2], &endp, 0);
2469         if (*endp)
2470                 return KDB_BADINT;
2471         if (pid <= 0) {
2472                 kdb_printf("Process ID must be large than 0.\n");
2473                 return 0;
2474         }
2475
2476         /* Find the process. */
2477         p = find_task_by_pid_ns(pid, &init_pid_ns);
2478         if (!p) {
2479                 kdb_printf("The specified process isn't found.\n");
2480                 return 0;
2481         }
2482         p = p->group_leader;
2483         kdb_send_sig(p, sig);
2484         return 0;
2485 }
2486
2487 /*
2488  * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2489  * I cannot call that code directly from kdb, it has an unconditional
2490  * cli()/sti() and calls routines that take locks which can stop the debugger.
2491  */
2492 static void kdb_sysinfo(struct sysinfo *val)
2493 {
2494         u64 uptime = ktime_get_mono_fast_ns();
2495
2496         memset(val, 0, sizeof(*val));
2497         val->uptime = div_u64(uptime, NSEC_PER_SEC);
2498         val->loads[0] = avenrun[0];
2499         val->loads[1] = avenrun[1];
2500         val->loads[2] = avenrun[2];
2501         val->procs = nr_threads-1;
2502         si_meminfo(val);
2503
2504         return;
2505 }
2506
2507 /*
2508  * kdb_summary - This function implements the 'summary' command.
2509  */
2510 static int kdb_summary(int argc, const char **argv)
2511 {
2512         time64_t now;
2513         struct tm tm;
2514         struct sysinfo val;
2515
2516         if (argc)
2517                 return KDB_ARGCOUNT;
2518
2519         kdb_printf("sysname    %s\n", init_uts_ns.name.sysname);
2520         kdb_printf("release    %s\n", init_uts_ns.name.release);
2521         kdb_printf("version    %s\n", init_uts_ns.name.version);
2522         kdb_printf("machine    %s\n", init_uts_ns.name.machine);
2523         kdb_printf("nodename   %s\n", init_uts_ns.name.nodename);
2524         kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2525         kdb_printf("ccversion  %s\n", __stringify(CCVERSION));
2526
2527         now = __ktime_get_real_seconds();
2528         time64_to_tm(now, 0, &tm);
2529         kdb_printf("date       %04ld-%02d-%02d %02d:%02d:%02d "
2530                    "tz_minuteswest %d\n",
2531                 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2532                 tm.tm_hour, tm.tm_min, tm.tm_sec,
2533                 sys_tz.tz_minuteswest);
2534
2535         kdb_sysinfo(&val);
2536         kdb_printf("uptime     ");
2537         if (val.uptime > (24*60*60)) {
2538                 int days = val.uptime / (24*60*60);
2539                 val.uptime %= (24*60*60);
2540                 kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2541         }
2542         kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2543
2544         kdb_printf("load avg   %ld.%02ld %ld.%02ld %ld.%02ld\n",
2545                 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2546                 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2547                 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2548
2549         /* Display in kilobytes */
2550 #define K(x) ((x) << (PAGE_SHIFT - 10))
2551         kdb_printf("\nMemTotal:       %8lu kB\nMemFree:        %8lu kB\n"
2552                    "Buffers:        %8lu kB\n",
2553                    K(val.totalram), K(val.freeram), K(val.bufferram));
2554         return 0;
2555 }
2556
2557 /*
2558  * kdb_per_cpu - This function implements the 'per_cpu' command.
2559  */
2560 static int kdb_per_cpu(int argc, const char **argv)
2561 {
2562         char fmtstr[64];
2563         int cpu, diag, nextarg = 1;
2564         unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2565
2566         if (argc < 1 || argc > 3)
2567                 return KDB_ARGCOUNT;
2568
2569         diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2570         if (diag)
2571                 return diag;
2572
2573         if (argc >= 2) {
2574                 diag = kdbgetularg(argv[2], &bytesperword);
2575                 if (diag)
2576                         return diag;
2577         }
2578         if (!bytesperword)
2579                 bytesperword = KDB_WORD_SIZE;
2580         else if (bytesperword > KDB_WORD_SIZE)
2581                 return KDB_BADWIDTH;
2582         sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2583         if (argc >= 3) {
2584                 diag = kdbgetularg(argv[3], &whichcpu);
2585                 if (diag)
2586                         return diag;
2587                 if (!cpu_online(whichcpu)) {
2588                         kdb_printf("cpu %ld is not online\n", whichcpu);
2589                         return KDB_BADCPUNUM;
2590                 }
2591         }
2592
2593         /* Most architectures use __per_cpu_offset[cpu], some use
2594          * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2595          */
2596 #ifdef  __per_cpu_offset
2597 #define KDB_PCU(cpu) __per_cpu_offset(cpu)
2598 #else
2599 #ifdef  CONFIG_SMP
2600 #define KDB_PCU(cpu) __per_cpu_offset[cpu]
2601 #else
2602 #define KDB_PCU(cpu) 0
2603 #endif
2604 #endif
2605         for_each_online_cpu(cpu) {
2606                 if (KDB_FLAG(CMD_INTERRUPT))
2607                         return 0;
2608
2609                 if (whichcpu != ~0UL && whichcpu != cpu)
2610                         continue;
2611                 addr = symaddr + KDB_PCU(cpu);
2612                 diag = kdb_getword(&val, addr, bytesperword);
2613                 if (diag) {
2614                         kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2615                                    "read, diag=%d\n", cpu, addr, diag);
2616                         continue;
2617                 }
2618                 kdb_printf("%5d ", cpu);
2619                 kdb_md_line(fmtstr, addr,
2620                         bytesperword == KDB_WORD_SIZE,
2621                         1, bytesperword, 1, 1, 0);
2622         }
2623 #undef KDB_PCU
2624         return 0;
2625 }
2626
2627 /*
2628  * display help for the use of cmd | grep pattern
2629  */
2630 static int kdb_grep_help(int argc, const char **argv)
2631 {
2632         kdb_printf("Usage of  cmd args | grep pattern:\n");
2633         kdb_printf("  Any command's output may be filtered through an ");
2634         kdb_printf("emulated 'pipe'.\n");
2635         kdb_printf("  'grep' is just a key word.\n");
2636         kdb_printf("  The pattern may include a very limited set of "
2637                    "metacharacters:\n");
2638         kdb_printf("   pattern or ^pattern or pattern$ or ^pattern$\n");
2639         kdb_printf("  And if there are spaces in the pattern, you may "
2640                    "quote it:\n");
2641         kdb_printf("   \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2642                    " or \"^pat tern$\"\n");
2643         return 0;
2644 }
2645
2646 /*
2647  * kdb_register_flags - This function is used to register a kernel
2648  *      debugger command.
2649  * Inputs:
2650  *      cmd     Command name
2651  *      func    Function to execute the command
2652  *      usage   A simple usage string showing arguments
2653  *      help    A simple help string describing command
2654  *      repeat  Does the command auto repeat on enter?
2655  * Returns:
2656  *      zero for success, one if a duplicate command.
2657  */
2658 #define kdb_command_extend 50   /* arbitrary */
2659 int kdb_register_flags(char *cmd,
2660                        kdb_func_t func,
2661                        char *usage,
2662                        char *help,
2663                        short minlen,
2664                        kdb_cmdflags_t flags)
2665 {
2666         int i;
2667         kdbtab_t *kp;
2668
2669         /*
2670          *  Brute force method to determine duplicates
2671          */
2672         for_each_kdbcmd(kp, i) {
2673                 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2674                         kdb_printf("Duplicate kdb command registered: "
2675                                 "%s, func %px help %s\n", cmd, func, help);
2676                         return 1;
2677                 }
2678         }
2679
2680         /*
2681          * Insert command into first available location in table
2682          */
2683         for_each_kdbcmd(kp, i) {
2684                 if (kp->cmd_name == NULL)
2685                         break;
2686         }
2687
2688         if (i >= kdb_max_commands) {
2689                 kdbtab_t *new = kmalloc_array(kdb_max_commands -
2690                                                 KDB_BASE_CMD_MAX +
2691                                                 kdb_command_extend,
2692                                               sizeof(*new),
2693                                               GFP_KDB);
2694                 if (!new) {
2695                         kdb_printf("Could not allocate new kdb_command "
2696                                    "table\n");
2697                         return 1;
2698                 }
2699                 if (kdb_commands) {
2700                         memcpy(new, kdb_commands,
2701                           (kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new));
2702                         kfree(kdb_commands);
2703                 }
2704                 memset(new + kdb_max_commands - KDB_BASE_CMD_MAX, 0,
2705                        kdb_command_extend * sizeof(*new));
2706                 kdb_commands = new;
2707                 kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX;
2708                 kdb_max_commands += kdb_command_extend;
2709         }
2710
2711         kp->cmd_name   = cmd;
2712         kp->cmd_func   = func;
2713         kp->cmd_usage  = usage;
2714         kp->cmd_help   = help;
2715         kp->cmd_minlen = minlen;
2716         kp->cmd_flags  = flags;
2717
2718         return 0;
2719 }
2720 EXPORT_SYMBOL_GPL(kdb_register_flags);
2721
2722
2723 /*
2724  * kdb_register - Compatibility register function for commands that do
2725  *      not need to specify a repeat state.  Equivalent to
2726  *      kdb_register_flags with flags set to 0.
2727  * Inputs:
2728  *      cmd     Command name
2729  *      func    Function to execute the command
2730  *      usage   A simple usage string showing arguments
2731  *      help    A simple help string describing command
2732  * Returns:
2733  *      zero for success, one if a duplicate command.
2734  */
2735 int kdb_register(char *cmd,
2736              kdb_func_t func,
2737              char *usage,
2738              char *help,
2739              short minlen)
2740 {
2741         return kdb_register_flags(cmd, func, usage, help, minlen, 0);
2742 }
2743 EXPORT_SYMBOL_GPL(kdb_register);
2744
2745 /*
2746  * kdb_unregister - This function is used to unregister a kernel
2747  *      debugger command.  It is generally called when a module which
2748  *      implements kdb commands is unloaded.
2749  * Inputs:
2750  *      cmd     Command name
2751  * Returns:
2752  *      zero for success, one command not registered.
2753  */
2754 int kdb_unregister(char *cmd)
2755 {
2756         int i;
2757         kdbtab_t *kp;
2758
2759         /*
2760          *  find the command.
2761          */
2762         for_each_kdbcmd(kp, i) {
2763                 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2764                         kp->cmd_name = NULL;
2765                         return 0;
2766                 }
2767         }
2768
2769         /* Couldn't find it.  */
2770         return 1;
2771 }
2772 EXPORT_SYMBOL_GPL(kdb_unregister);
2773
2774 /* Initialize the kdb command table. */
2775 static void __init kdb_inittab(void)
2776 {
2777         int i;
2778         kdbtab_t *kp;
2779
2780         for_each_kdbcmd(kp, i)
2781                 kp->cmd_name = NULL;
2782
2783         kdb_register_flags("md", kdb_md, "<vaddr>",
2784           "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2785           KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2786         kdb_register_flags("mdr", kdb_md, "<vaddr> <bytes>",
2787           "Display Raw Memory", 0,
2788           KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2789         kdb_register_flags("mdp", kdb_md, "<paddr> <bytes>",
2790           "Display Physical Memory", 0,
2791           KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2792         kdb_register_flags("mds", kdb_md, "<vaddr>",
2793           "Display Memory Symbolically", 0,
2794           KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2795         kdb_register_flags("mm", kdb_mm, "<vaddr> <contents>",
2796           "Modify Memory Contents", 0,
2797           KDB_ENABLE_MEM_WRITE | KDB_REPEAT_NO_ARGS);
2798         kdb_register_flags("go", kdb_go, "[<vaddr>]",
2799           "Continue Execution", 1,
2800           KDB_ENABLE_REG_WRITE | KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
2801         kdb_register_flags("rd", kdb_rd, "",
2802           "Display Registers", 0,
2803           KDB_ENABLE_REG_READ);
2804         kdb_register_flags("rm", kdb_rm, "<reg> <contents>",
2805           "Modify Registers", 0,
2806           KDB_ENABLE_REG_WRITE);
2807         kdb_register_flags("ef", kdb_ef, "<vaddr>",
2808           "Display exception frame", 0,
2809           KDB_ENABLE_MEM_READ);
2810         kdb_register_flags("bt", kdb_bt, "[<vaddr>]",
2811           "Stack traceback", 1,
2812           KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS);
2813         kdb_register_flags("btp", kdb_bt, "<pid>",
2814           "Display stack for process <pid>", 0,
2815           KDB_ENABLE_INSPECT);
2816         kdb_register_flags("bta", kdb_bt, "[D|R|S|T|C|Z|E|U|I|M|A]",
2817           "Backtrace all processes matching state flag", 0,
2818           KDB_ENABLE_INSPECT);
2819         kdb_register_flags("btc", kdb_bt, "",
2820           "Backtrace current process on each cpu", 0,
2821           KDB_ENABLE_INSPECT);
2822         kdb_register_flags("btt", kdb_bt, "<vaddr>",
2823           "Backtrace process given its struct task address", 0,
2824           KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS);
2825         kdb_register_flags("env", kdb_env, "",
2826           "Show environment variables", 0,
2827           KDB_ENABLE_ALWAYS_SAFE);
2828         kdb_register_flags("set", kdb_set, "",
2829           "Set environment variables", 0,
2830           KDB_ENABLE_ALWAYS_SAFE);
2831         kdb_register_flags("help", kdb_help, "",
2832           "Display Help Message", 1,
2833           KDB_ENABLE_ALWAYS_SAFE);
2834         kdb_register_flags("?", kdb_help, "",
2835           "Display Help Message", 0,
2836           KDB_ENABLE_ALWAYS_SAFE);
2837         kdb_register_flags("cpu", kdb_cpu, "<cpunum>",
2838           "Switch to new cpu", 0,
2839           KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
2840         kdb_register_flags("kgdb", kdb_kgdb, "",
2841           "Enter kgdb mode", 0, 0);
2842         kdb_register_flags("ps", kdb_ps, "[<flags>|A]",
2843           "Display active task list", 0,
2844           KDB_ENABLE_INSPECT);
2845         kdb_register_flags("pid", kdb_pid, "<pidnum>",
2846           "Switch to another task", 0,
2847           KDB_ENABLE_INSPECT);
2848         kdb_register_flags("reboot", kdb_reboot, "",
2849           "Reboot the machine immediately", 0,
2850           KDB_ENABLE_REBOOT);
2851 #if defined(CONFIG_MODULES)
2852         kdb_register_flags("lsmod", kdb_lsmod, "",
2853           "List loaded kernel modules", 0,
2854           KDB_ENABLE_INSPECT);
2855 #endif
2856 #if defined(CONFIG_MAGIC_SYSRQ)
2857         kdb_register_flags("sr", kdb_sr, "<key>",
2858           "Magic SysRq key", 0,
2859           KDB_ENABLE_ALWAYS_SAFE);
2860 #endif
2861 #if defined(CONFIG_PRINTK)
2862         kdb_register_flags("dmesg", kdb_dmesg, "[lines]",
2863           "Display syslog buffer", 0,
2864           KDB_ENABLE_ALWAYS_SAFE);
2865 #endif
2866         if (arch_kgdb_ops.enable_nmi) {
2867                 kdb_register_flags("disable_nmi", kdb_disable_nmi, "",
2868                   "Disable NMI entry to KDB", 0,
2869                   KDB_ENABLE_ALWAYS_SAFE);
2870         }
2871         kdb_register_flags("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
2872           "Define a set of commands, down to endefcmd", 0,
2873           KDB_ENABLE_ALWAYS_SAFE);
2874         kdb_register_flags("kill", kdb_kill, "<-signal> <pid>",
2875           "Send a signal to a process", 0,
2876           KDB_ENABLE_SIGNAL);
2877         kdb_register_flags("summary", kdb_summary, "",
2878           "Summarize the system", 4,
2879           KDB_ENABLE_ALWAYS_SAFE);
2880         kdb_register_flags("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
2881           "Display per_cpu variables", 3,
2882           KDB_ENABLE_MEM_READ);
2883         kdb_register_flags("grephelp", kdb_grep_help, "",
2884           "Display help on | grep", 0,
2885           KDB_ENABLE_ALWAYS_SAFE);
2886 }
2887
2888 /* Execute any commands defined in kdb_cmds.  */
2889 static void __init kdb_cmd_init(void)
2890 {
2891         int i, diag;
2892         for (i = 0; kdb_cmds[i]; ++i) {
2893                 diag = kdb_parse(kdb_cmds[i]);
2894                 if (diag)
2895                         kdb_printf("kdb command %s failed, kdb diag %d\n",
2896                                 kdb_cmds[i], diag);
2897         }
2898         if (defcmd_in_progress) {
2899                 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2900                 kdb_parse("endefcmd");
2901         }
2902 }
2903
2904 /* Initialize kdb_printf, breakpoint tables and kdb state */
2905 void __init kdb_init(int lvl)
2906 {
2907         static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2908         int i;
2909
2910         if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2911                 return;
2912         for (i = kdb_init_lvl; i < lvl; i++) {
2913                 switch (i) {
2914                 case KDB_NOT_INITIALIZED:
2915                         kdb_inittab();          /* Initialize Command Table */
2916                         kdb_initbptab();        /* Initialize Breakpoints */
2917                         break;
2918                 case KDB_INIT_EARLY:
2919                         kdb_cmd_init();         /* Build kdb_cmds tables */
2920                         break;
2921                 }
2922         }
2923         kdb_init_lvl = lvl;
2924 }