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