kernel/debug/kdb/kdb_main.c

   1 /*
   2  * Kernel Debugger Architecture Independent Main Code
   3  *
   4  * This file is subject to the terms and conditions of the GNU General Public
   5  * License.  See the file "COPYING" in the main directory of this archive
   6  * for more details.
   7  *
   8  * Copyright (C) 1999-2004 Silicon Graphics, Inc.  All Rights Reserved.
   9  * Copyright (C) 2000 Stephane Eranian <eranian@hpl.hp.com>
  10  * Xscale (R) modifications copyright (C) 2003 Intel Corporation.
  11  * Copyright (c) 2009 Wind River Systems, Inc.  All Rights Reserved.
  12  */
  13
  14 #include <linux/ctype.h>
  15 #include <linux/types.h>
  16 #include <linux/string.h>
  17 #include <linux/kernel.h>
  18 #include <linux/kmsg_dump.h>
  19 #include <linux/reboot.h>
  20 #include <linux/sched.h>
  21 #include <linux/sched/loadavg.h>
  22 #include <linux/sched/stat.h>
  23 #include <linux/sched/debug.h>
  24 #include <linux/sysrq.h>
  25 #include <linux/smp.h>
  26 #include <linux/utsname.h>
  27 #include <linux/vmalloc.h>
  28 #include <linux/atomic.h>
  29 #include <linux/module.h>
  30 #include <linux/moduleparam.h>
  31 #include <linux/mm.h>
  32 #include <linux/init.h>
  33 #include <linux/kallsyms.h>
  34 #include <linux/kgdb.h>
  35 #include <linux/kdb.h>
  36 #include <linux/notifier.h>
  37 #include <linux/interrupt.h>
  38 #include <linux/delay.h>
  39 #include <linux/nmi.h>
  40 #include <linux/time.h>
  41 #include <linux/ptrace.h>
  42 #include <linux/sysctl.h>
  43 #include <linux/cpu.h>
  44 #include <linux/kdebug.h>
  45 #include <linux/proc_fs.h>
  46 #include <linux/uaccess.h>
  47 #include <linux/slab.h>
  48 #include "kdb_private.h"
  49
  50 #undef  MODULE_PARAM_PREFIX
  51 #define MODULE_PARAM_PREFIX "kdb."
  52
  53 static int kdb_cmd_enabled = CONFIG_KDB_DEFAULT_ENABLE;
  54 module_param_named(cmd_enable, kdb_cmd_enabled, int, 0600);
  55
  56 char kdb_grep_string[KDB_GREP_STRLEN];
  57 int kdb_grepping_flag;
  58 EXPORT_SYMBOL(kdb_grepping_flag);
  59 int kdb_grep_leading;
  60 int kdb_grep_trailing;
  61
  62 /*
  63  * Kernel debugger state flags
  64  */
  65 int kdb_flags;
  66
  67 /*
  68  * kdb_lock protects updates to kdb_initial_cpu.  Used to
  69  * single thread processors through the kernel debugger.
  70  */
  71 int kdb_initial_cpu = -1;       /* cpu number that owns kdb */
  72 int kdb_nextline = 1;
  73 int kdb_state;                  /* General KDB state */
  74
  75 struct task_struct *kdb_current_task;
  76 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 &
 422                              ~(KDB_DEBUG_FLAG_MASK << KDB_DEBUG_FLAG_SHIFT))
 423                         | (debugflags << KDB_DEBUG_FLAG_SHIFT);
 424
 425                 return 0;
 426         }
 427
 428         /*
 429          * Tokenizer squashed the '=' sign.  argv[1] is variable
 430          * name, argv[2] = value.
 431          */
 432         varlen = strlen(argv[1]);
 433         vallen = strlen(argv[2]);
 434         ep = kdballocenv(varlen + vallen + 2);
 435         if (ep == (char *)0)
 436                 return KDB_ENVBUFFULL;
 437
 438         sprintf(ep, "%s=%s", argv[1], argv[2]);
 439
 440         ep[varlen+vallen+1] = '\0';
 441
 442         for (i = 0; i < __nenv; i++) {
 443                 if (__env[i]
 444                  && ((strncmp(__env[i], argv[1], varlen) == 0)
 445                    && ((__env[i][varlen] == '\0')
 446                     || (__env[i][varlen] == '=')))) {
 447                         __env[i] = ep;
 448                         return 0;
 449                 }
 450         }
 451
 452         /*
 453          * Wasn't existing variable.  Fit into slot.
 454          */
 455         for (i = 0; i < __nenv-1; i++) {
 456                 if (__env[i] == (char *)0) {
 457                         __env[i] = ep;
 458                         return 0;
 459                 }
 460         }
 461
 462         return KDB_ENVFULL;
 463 }
 464
 465 static int kdb_check_regs(void)
 466 {
 467         if (!kdb_current_regs) {
 468                 kdb_printf("No current kdb registers."
 469                            "  You may need to select another task\n");
 470                 return KDB_BADREG;
 471         }
 472         return 0;
 473 }
 474
 475 /*
 476  * kdbgetaddrarg - This function is responsible for parsing an
 477  *      address-expression and returning the value of the expression,
 478  *      symbol name, and offset to the caller.
 479  *
 480  *      The argument may consist of a numeric value (decimal or
 481  *      hexidecimal), a symbol name, a register name (preceded by the
 482  *      percent sign), an environment variable with a numeric value
 483  *      (preceded by a dollar sign) or a simple arithmetic expression
 484  *      consisting of a symbol name, +/-, and a numeric constant value
 485  *      (offset).
 486  * Parameters:
 487  *      argc    - count of arguments in argv
 488  *      argv    - argument vector
 489  *      *nextarg - index to next unparsed argument in argv[]
 490  *      regs    - Register state at time of KDB entry
 491  * Outputs:
 492  *      *value  - receives the value of the address-expression
 493  *      *offset - receives the offset specified, if any
 494  *      *name   - receives the symbol name, if any
 495  *      *nextarg - index to next unparsed argument in argv[]
 496  * Returns:
 497  *      zero is returned on success, a kdb diagnostic code is
 498  *      returned on error.
 499  */
 500 int kdbgetaddrarg(int argc, const char **argv, int *nextarg,
 501                   unsigned long *value,  long *offset,
 502                   char **name)
 503 {
 504         unsigned long addr;
 505         unsigned long off = 0;
 506         int positive;
 507         int diag;
 508         int found = 0;
 509         char *symname;
 510         char symbol = '\0';
 511         char *cp;
 512         kdb_symtab_t symtab;
 513
 514         /*
 515          * If the enable flags prohibit both arbitrary memory access
 516          * and flow control then there are no reasonable grounds to
 517          * provide symbol lookup.
 518          */
 519         if (!kdb_check_flags(KDB_ENABLE_MEM_READ | KDB_ENABLE_FLOW_CTRL,
 520                              kdb_cmd_enabled, false))
 521                 return KDB_NOPERM;
 522
 523         /*
 524          * Process arguments which follow the following syntax:
 525          *
 526          *  symbol | numeric-address [+/- numeric-offset]
 527          *  %register
 528          *  $environment-variable
 529          */
 530
 531         if (*nextarg > argc)
 532                 return KDB_ARGCOUNT;
 533
 534         symname = (char *)argv[*nextarg];
 535
 536         /*
 537          * If there is no whitespace between the symbol
 538          * or address and the '+' or '-' symbols, we
 539          * remember the character and replace it with a
 540          * null so the symbol/value can be properly parsed
 541          */
 542         cp = strpbrk(symname, "+-");
 543         if (cp != NULL) {
 544                 symbol = *cp;
 545                 *cp++ = '\0';
 546         }
 547
 548         if (symname[0] == '$') {
 549                 diag = kdbgetulenv(&symname[1], &addr);
 550                 if (diag)
 551                         return diag;
 552         } else if (symname[0] == '%') {
 553                 diag = kdb_check_regs();
 554                 if (diag)
 555                         return diag;
 556                 /* Implement register values with % at a later time as it is
 557                  * arch optional.
 558                  */
 559                 return KDB_NOTIMP;
 560         } else {
 561                 found = kdbgetsymval(symname, &symtab);
 562                 if (found) {
 563                         addr = symtab.sym_start;
 564                 } else {
 565                         diag = kdbgetularg(argv[*nextarg], &addr);
 566                         if (diag)
 567                                 return diag;
 568                 }
 569         }
 570
 571         if (!found)
 572                 found = kdbnearsym(addr, &symtab);
 573
 574         (*nextarg)++;
 575
 576         if (name)
 577                 *name = symname;
 578         if (value)
 579                 *value = addr;
 580         if (offset && name && *name)
 581                 *offset = addr - symtab.sym_start;
 582
 583         if ((*nextarg > argc)
 584          && (symbol == '\0'))
 585                 return 0;
 586
 587         /*
 588          * check for +/- and offset
 589          */
 590
 591         if (symbol == '\0') {
 592                 if ((argv[*nextarg][0] != '+')
 593                  && (argv[*nextarg][0] != '-')) {
 594                         /*
 595                          * Not our argument.  Return.
 596                          */
 597                         return 0;
 598                 } else {
 599                         positive = (argv[*nextarg][0] == '+');
 600                         (*nextarg)++;
 601                 }
 602         } else
 603                 positive = (symbol == '+');
 604
 605         /*
 606          * Now there must be an offset!
 607          */
 608         if ((*nextarg > argc)
 609          && (symbol == '\0')) {
 610                 return KDB_INVADDRFMT;
 611         }
 612
 613         if (!symbol) {
 614                 cp = (char *)argv[*nextarg];
 615                 (*nextarg)++;
 616         }
 617
 618         diag = kdbgetularg(cp, &off);
 619         if (diag)
 620                 return diag;
 621
 622         if (!positive)
 623                 off = -off;
 624
 625         if (offset)
 626                 *offset += off;
 627
 628         if (value)
 629                 *value += off;
 630
 631         return 0;
 632 }
 633
 634 static void kdb_cmderror(int diag)
 635 {
 636         int i;
 637
 638         if (diag >= 0) {
 639                 kdb_printf("no error detected (diagnostic is %d)\n", diag);
 640                 return;
 641         }
 642
 643         for (i = 0; i < __nkdb_err; i++) {
 644                 if (kdbmsgs[i].km_diag == diag) {
 645                         kdb_printf("diag: %d: %s\n", diag, kdbmsgs[i].km_msg);
 646                         return;
 647                 }
 648         }
 649
 650         kdb_printf("Unknown diag %d\n", -diag);
 651 }
 652
 653 /*
 654  * kdb_defcmd, kdb_defcmd2 - This function implements the 'defcmd'
 655  *      command which defines one command as a set of other commands,
 656  *      terminated by endefcmd.  kdb_defcmd processes the initial
 657  *      'defcmd' command, kdb_defcmd2 is invoked from kdb_parse for
 658  *      the following commands until 'endefcmd'.
 659  * Inputs:
 660  *      argc    argument count
 661  *      argv    argument vector
 662  * Returns:
 663  *      zero for success, a kdb diagnostic if error
 664  */
 665 struct defcmd_set {
 666         int count;
 667         bool usable;
 668         char *name;
 669         char *usage;
 670         char *help;
 671         char **command;
 672 };
 673 static struct defcmd_set *defcmd_set;
 674 static int defcmd_set_count;
 675 static bool defcmd_in_progress;
 676
 677 /* Forward references */
 678 static int kdb_exec_defcmd(int argc, const char **argv);
 679
 680 static int kdb_defcmd2(const char *cmdstr, const char *argv0)
 681 {
 682         struct defcmd_set *s = defcmd_set + defcmd_set_count - 1;
 683         char **save_command = s->command;
 684         if (strcmp(argv0, "endefcmd") == 0) {
 685                 defcmd_in_progress = false;
 686                 if (!s->count)
 687                         s->usable = false;
 688                 if (s->usable)
 689                         /* macros are always safe because when executed each
 690                          * internal command re-enters kdb_parse() and is
 691                          * safety checked individually.
 692                          */
 693                         kdb_register_flags(s->name, kdb_exec_defcmd, s->usage,
 694                                            s->help, 0,
 695                                            KDB_ENABLE_ALWAYS_SAFE);
 696                 return 0;
 697         }
 698         if (!s->usable)
 699                 return KDB_NOTIMP;
 700         s->command = kcalloc(s->count + 1, sizeof(*(s->command)), GFP_KDB);
 701         if (!s->command) {
 702                 kdb_printf("Could not allocate new kdb_defcmd table for %s\n",
 703                            cmdstr);
 704                 s->usable = false;
 705                 return KDB_NOTIMP;
 706         }
 707         memcpy(s->command, save_command, s->count * sizeof(*(s->command)));
 708         s->command[s->count++] = kdb_strdup(cmdstr, GFP_KDB);
 709         kfree(save_command);
 710         return 0;
 711 }
 712
 713 static int kdb_defcmd(int argc, const char **argv)
 714 {
 715         struct defcmd_set *save_defcmd_set = defcmd_set, *s;
 716         if (defcmd_in_progress) {
 717                 kdb_printf("kdb: nested defcmd detected, assuming missing "
 718                            "endefcmd\n");
 719                 kdb_defcmd2("endefcmd", "endefcmd");
 720         }
 721         if (argc == 0) {
 722                 int i;
 723                 for (s = defcmd_set; s < defcmd_set + defcmd_set_count; ++s) {
 724                         kdb_printf("defcmd %s \"%s\" \"%s\"\n", s->name,
 725                                    s->usage, s->help);
 726                         for (i = 0; i < s->count; ++i)
 727                                 kdb_printf("%s", s->command[i]);
 728                         kdb_printf("endefcmd\n");
 729                 }
 730                 return 0;
 731         }
 732         if (argc != 3)
 733                 return KDB_ARGCOUNT;
 734         if (in_dbg_master()) {
 735                 kdb_printf("Command only available during kdb_init()\n");
 736                 return KDB_NOTIMP;
 737         }
 738         defcmd_set = kmalloc_array(defcmd_set_count + 1, sizeof(*defcmd_set),
 739                                    GFP_KDB);
 740         if (!defcmd_set)
 741                 goto fail_defcmd;
 742         memcpy(defcmd_set, save_defcmd_set,
 743                defcmd_set_count * sizeof(*defcmd_set));
 744         s = defcmd_set + defcmd_set_count;
 745         memset(s, 0, sizeof(*s));
 746         s->usable = true;
 747         s->name = kdb_strdup(argv[1], GFP_KDB);
 748         if (!s->name)
 749                 goto fail_name;
 750         s->usage = kdb_strdup(argv[2], GFP_KDB);
 751         if (!s->usage)
 752                 goto fail_usage;
 753         s->help = kdb_strdup(argv[3], GFP_KDB);
 754         if (!s->help)
 755                 goto fail_help;
 756         if (s->usage[0] == '"') {
 757                 strcpy(s->usage, argv[2]+1);
 758                 s->usage[strlen(s->usage)-1] = '\0';
 759         }
 760         if (s->help[0] == '"') {
 761                 strcpy(s->help, argv[3]+1);
 762                 s->help[strlen(s->help)-1] = '\0';
 763         }
 764         ++defcmd_set_count;
 765         defcmd_in_progress = true;
 766         kfree(save_defcmd_set);
 767         return 0;
 768 fail_help:
 769         kfree(s->usage);
 770 fail_usage:
 771         kfree(s->name);
 772 fail_name:
 773         kfree(defcmd_set);
 774 fail_defcmd:
 775         kdb_printf("Could not allocate new defcmd_set entry for %s\n", argv[1]);
 776         defcmd_set = save_defcmd_set;
 777         return KDB_NOTIMP;
 778 }
 779
 780 /*
 781  * kdb_exec_defcmd - Execute the set of commands associated with this
 782  *      defcmd name.
 783  * Inputs:
 784  *      argc    argument count
 785  *      argv    argument vector
 786  * Returns:
 787  *      zero for success, a kdb diagnostic if error
 788  */
 789 static int kdb_exec_defcmd(int argc, const char **argv)
 790 {
 791         int i, ret;
 792         struct defcmd_set *s;
 793         if (argc != 0)
 794                 return KDB_ARGCOUNT;
 795         for (s = defcmd_set, i = 0; i < defcmd_set_count; ++i, ++s) {
 796                 if (strcmp(s->name, argv[0]) == 0)
 797                         break;
 798         }
 799         if (i == defcmd_set_count) {
 800                 kdb_printf("kdb_exec_defcmd: could not find commands for %s\n",
 801                            argv[0]);
 802                 return KDB_NOTIMP;
 803         }
 804         for (i = 0; i < s->count; ++i) {
 805                 /* Recursive use of kdb_parse, do not use argv after
 806                  * this point */
 807                 argv = NULL;
 808                 kdb_printf("[%s]kdb> %s\n", s->name, s->command[i]);
 809                 ret = kdb_parse(s->command[i]);
 810                 if (ret)
 811                         return ret;
 812         }
 813         return 0;
 814 }
 815
 816 /* Command history */
 817 #define KDB_CMD_HISTORY_COUNT   32
 818 #define CMD_BUFLEN              200     /* kdb_printf: max printline
 819                                          * size == 256 */
 820 static unsigned int cmd_head, cmd_tail;
 821 static unsigned int cmdptr;
 822 static char cmd_hist[KDB_CMD_HISTORY_COUNT][CMD_BUFLEN];
 823 static char cmd_cur[CMD_BUFLEN];
 824
 825 /*
 826  * The "str" argument may point to something like  | grep xyz
 827  */
 828 static void parse_grep(const char *str)
 829 {
 830         int     len;
 831         char    *cp = (char *)str, *cp2;
 832
 833         /* sanity check: we should have been called with the \ first */
 834         if (*cp != '|')
 835                 return;
 836         cp++;
 837         while (isspace(*cp))
 838                 cp++;
 839         if (!str_has_prefix(cp, "grep ")) {
 840                 kdb_printf("invalid 'pipe', see grephelp\n");
 841                 return;
 842         }
 843         cp += 5;
 844         while (isspace(*cp))
 845                 cp++;
 846         cp2 = strchr(cp, '\n');
 847         if (cp2)
 848                 *cp2 = '\0'; /* remove the trailing newline */
 849         len = strlen(cp);
 850         if (len == 0) {
 851                 kdb_printf("invalid 'pipe', see grephelp\n");
 852                 return;
 853         }
 854         /* now cp points to a nonzero length search string */
 855         if (*cp == '"') {
 856                 /* allow it be "x y z" by removing the "'s - there must
 857                    be two of them */
 858                 cp++;
 859                 cp2 = strchr(cp, '"');
 860                 if (!cp2) {
 861                         kdb_printf("invalid quoted string, see grephelp\n");
 862                         return;
 863                 }
 864                 *cp2 = '\0'; /* end the string where the 2nd " was */
 865         }
 866         kdb_grep_leading = 0;
 867         if (*cp == '^') {
 868                 kdb_grep_leading = 1;
 869                 cp++;
 870         }
 871         len = strlen(cp);
 872         kdb_grep_trailing = 0;
 873         if (*(cp+len-1) == '$') {
 874                 kdb_grep_trailing = 1;
 875                 *(cp+len-1) = '\0';
 876         }
 877         len = strlen(cp);
 878         if (!len)
 879                 return;
 880         if (len >= KDB_GREP_STRLEN) {
 881                 kdb_printf("search string too long\n");
 882                 return;
 883         }
 884         strcpy(kdb_grep_string, cp);
 885         kdb_grepping_flag++;
 886         return;
 887 }
 888
 889 /*
 890  * kdb_parse - Parse the command line, search the command table for a
 891  *      matching command and invoke the command function.  This
 892  *      function may be called recursively, if it is, the second call
 893  *      will overwrite argv and cbuf.  It is the caller's
 894  *      responsibility to save their argv if they recursively call
 895  *      kdb_parse().
 896  * Parameters:
 897  *      cmdstr  The input command line to be parsed.
 898  *      regs    The registers at the time kdb was entered.
 899  * Returns:
 900  *      Zero for success, a kdb diagnostic if failure.
 901  * Remarks:
 902  *      Limited to 20 tokens.
 903  *
 904  *      Real rudimentary tokenization. Basically only whitespace
 905  *      is considered a token delimeter (but special consideration
 906  *      is taken of the '=' sign as used by the 'set' command).
 907  *
 908  *      The algorithm used to tokenize the input string relies on
 909  *      there being at least one whitespace (or otherwise useless)
 910  *      character between tokens as the character immediately following
 911  *      the token is altered in-place to a null-byte to terminate the
 912  *      token string.
 913  */
 914
 915 #define MAXARGC 20
 916
 917 int kdb_parse(const char *cmdstr)
 918 {
 919         static char *argv[MAXARGC];
 920         static int argc;
 921         static char cbuf[CMD_BUFLEN+2];
 922         char *cp;
 923         char *cpp, quoted;
 924         kdbtab_t *tp;
 925         int i, escaped, ignore_errors = 0, check_grep = 0;
 926
 927         /*
 928          * First tokenize the command string.
 929          */
 930         cp = (char *)cmdstr;
 931
 932         if (KDB_FLAG(CMD_INTERRUPT)) {
 933                 /* Previous command was interrupted, newline must not
 934                  * repeat the command */
 935                 KDB_FLAG_CLEAR(CMD_INTERRUPT);
 936                 KDB_STATE_SET(PAGER);
 937                 argc = 0;       /* no repeat */
 938         }
 939
 940         if (*cp != '\n' && *cp != '\0') {
 941                 argc = 0;
 942                 cpp = cbuf;
 943                 while (*cp) {
 944                         /* skip whitespace */
 945                         while (isspace(*cp))
 946                                 cp++;
 947                         if ((*cp == '\0') || (*cp == '\n') ||
 948                             (*cp == '#' && !defcmd_in_progress))
 949                                 break;
 950                         /* special case: check for | grep pattern */
 951                         if (*cp == '|') {
 952                                 check_grep++;
 953                                 break;
 954                         }
 955                         if (cpp >= cbuf + CMD_BUFLEN) {
 956                                 kdb_printf("kdb_parse: command buffer "
 957                                            "overflow, command ignored\n%s\n",
 958                                            cmdstr);
 959                                 return KDB_NOTFOUND;
 960                         }
 961                         if (argc >= MAXARGC - 1) {
 962                                 kdb_printf("kdb_parse: too many arguments, "
 963                                            "command ignored\n%s\n", cmdstr);
 964                                 return KDB_NOTFOUND;
 965                         }
 966                         argv[argc++] = cpp;
 967                         escaped = 0;
 968                         quoted = '\0';
 969                         /* Copy to next unquoted and unescaped
 970                          * whitespace or '=' */
 971                         while (*cp && *cp != '\n' &&
 972                                (escaped || quoted || !isspace(*cp))) {
 973                                 if (cpp >= cbuf + CMD_BUFLEN)
 974                                         break;
 975                                 if (escaped) {
 976                                         escaped = 0;
 977                                         *cpp++ = *cp++;
 978                                         continue;
 979                                 }
 980                                 if (*cp == '\\') {
 981                                         escaped = 1;
 982                                         ++cp;
 983                                         continue;
 984                                 }
 985                                 if (*cp == quoted)
 986                                         quoted = '\0';
 987                                 else if (*cp == '\'' || *cp == '"')
 988                                         quoted = *cp;
 989                                 *cpp = *cp++;
 990                                 if (*cpp == '=' && !quoted)
 991                                         break;
 992                                 ++cpp;
 993                         }
 994                         *cpp++ = '\0';  /* Squash a ws or '=' character */
 995                 }
 996         }
 997         if (!argc)
 998                 return 0;
 999         if (check_grep)
1000                 parse_grep(cp);
1001         if (defcmd_in_progress) {
1002                 int result = kdb_defcmd2(cmdstr, argv[0]);
1003                 if (!defcmd_in_progress) {
1004                         argc = 0;       /* avoid repeat on endefcmd */
1005                         *(argv[0]) = '\0';
1006                 }
1007                 return result;
1008         }
1009         if (argv[0][0] == '-' && argv[0][1] &&
1010             (argv[0][1] < '0' || argv[0][1] > '9')) {
1011                 ignore_errors = 1;
1012                 ++argv[0];
1013         }
1014
1015         for_each_kdbcmd(tp, i) {
1016                 if (tp->cmd_name) {
1017                         /*
1018                          * If this command is allowed to be abbreviated,
1019                          * check to see if this is it.
1020                          */
1021
1022                         if (tp->cmd_minlen
1023                          && (strlen(argv[0]) <= tp->cmd_minlen)) {
1024                                 if (strncmp(argv[0],
1025                                             tp->cmd_name,
1026                                             tp->cmd_minlen) == 0) {
1027                                         break;
1028                                 }
1029                         }
1030
1031                         if (strcmp(argv[0], tp->cmd_name) == 0)
1032                                 break;
1033                 }
1034         }
1035
1036         /*
1037          * If we don't find a command by this name, see if the first
1038          * few characters of this match any of the known commands.
1039          * e.g., md1c20 should match md.
1040          */
1041         if (i == kdb_max_commands) {
1042                 for_each_kdbcmd(tp, i) {
1043                         if (tp->cmd_name) {
1044                                 if (strncmp(argv[0],
1045                                             tp->cmd_name,
1046                                             strlen(tp->cmd_name)) == 0) {
1047                                         break;
1048                                 }
1049                         }
1050                 }
1051         }
1052
1053         if (i < kdb_max_commands) {
1054                 int result;
1055
1056                 if (!kdb_check_flags(tp->cmd_flags, kdb_cmd_enabled, argc <= 1))
1057                         return KDB_NOPERM;
1058
1059                 KDB_STATE_SET(CMD);
1060                 result = (*tp->cmd_func)(argc-1, (const char **)argv);
1061                 if (result && ignore_errors && result > KDB_CMD_GO)
1062                         result = 0;
1063                 KDB_STATE_CLEAR(CMD);
1064
1065                 if (tp->cmd_flags & KDB_REPEAT_WITH_ARGS)
1066                         return result;
1067
1068                 argc = tp->cmd_flags & KDB_REPEAT_NO_ARGS ? 1 : 0;
1069                 if (argv[argc])
1070                         *(argv[argc]) = '\0';
1071                 return result;
1072         }
1073
1074         /*
1075          * If the input with which we were presented does not
1076          * map to an existing command, attempt to parse it as an
1077          * address argument and display the result.   Useful for
1078          * obtaining the address of a variable, or the nearest symbol
1079          * to an address contained in a register.
1080          */
1081         {
1082                 unsigned long value;
1083                 char *name = NULL;
1084                 long offset;
1085                 int nextarg = 0;
1086
1087                 if (kdbgetaddrarg(0, (const char **)argv, &nextarg,
1088                                   &value, &offset, &name)) {
1089                         return KDB_NOTFOUND;
1090                 }
1091
1092                 kdb_printf("%s = ", argv[0]);
1093                 kdb_symbol_print(value, NULL, KDB_SP_DEFAULT);
1094                 kdb_printf("\n");
1095                 return 0;
1096         }
1097 }
1098
1099
1100 static int handle_ctrl_cmd(char *cmd)
1101 {
1102 #define CTRL_P  16
1103 #define CTRL_N  14
1104
1105         /* initial situation */
1106         if (cmd_head == cmd_tail)
1107                 return 0;
1108         switch (*cmd) {
1109         case CTRL_P:
1110                 if (cmdptr != cmd_tail)
1111                         cmdptr = (cmdptr-1) % 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("KDBFLAGS=0x%x\n", kdb_flags);
2085
2086         return 0;
2087 }
2088
2089 #ifdef CONFIG_PRINTK
2090 /*
2091  * kdb_dmesg - This function implements the 'dmesg' command to display
2092  *      the contents of the syslog buffer.
2093  *              dmesg [lines] [adjust]
2094  */
2095 static int kdb_dmesg(int argc, const char **argv)
2096 {
2097         int diag;
2098         int logging;
2099         int lines = 0;
2100         int adjust = 0;
2101         int n = 0;
2102         int skip = 0;
2103         struct kmsg_dumper dumper = { .active = 1 };
2104         size_t len;
2105         char buf[201];
2106
2107         if (argc > 2)
2108                 return KDB_ARGCOUNT;
2109         if (argc) {
2110                 char *cp;
2111                 lines = simple_strtol(argv[1], &cp, 0);
2112                 if (*cp)
2113                         lines = 0;
2114                 if (argc > 1) {
2115                         adjust = simple_strtoul(argv[2], &cp, 0);
2116                         if (*cp || adjust < 0)
2117                                 adjust = 0;
2118                 }
2119         }
2120
2121         /* disable LOGGING if set */
2122         diag = kdbgetintenv("LOGGING", &logging);
2123         if (!diag && logging) {
2124                 const char *setargs[] = { "set", "LOGGING", "0" };
2125                 kdb_set(2, setargs);
2126         }
2127
2128         kmsg_dump_rewind_nolock(&dumper);
2129         while (kmsg_dump_get_line_nolock(&dumper, 1, NULL, 0, NULL))
2130                 n++;
2131
2132         if (lines < 0) {
2133                 if (adjust >= n)
2134                         kdb_printf("buffer only contains %d lines, nothing "
2135                                    "printed\n", n);
2136                 else if (adjust - lines >= n)
2137                         kdb_printf("buffer only contains %d lines, last %d "
2138                                    "lines printed\n", n, n - adjust);
2139                 skip = adjust;
2140                 lines = abs(lines);
2141         } else if (lines > 0) {
2142                 skip = n - lines - adjust;
2143                 lines = abs(lines);
2144                 if (adjust >= n) {
2145                         kdb_printf("buffer only contains %d lines, "
2146                                    "nothing printed\n", n);
2147                         skip = n;
2148                 } else if (skip < 0) {
2149                         lines += skip;
2150                         skip = 0;
2151                         kdb_printf("buffer only contains %d lines, first "
2152                                    "%d lines printed\n", n, lines);
2153                 }
2154         } else {
2155                 lines = n;
2156         }
2157
2158         if (skip >= n || skip < 0)
2159                 return 0;
2160
2161         kmsg_dump_rewind_nolock(&dumper);
2162         while (kmsg_dump_get_line_nolock(&dumper, 1, buf, sizeof(buf), &len)) {
2163                 if (skip) {
2164                         skip--;
2165                         continue;
2166                 }
2167                 if (!lines--)
2168                         break;
2169                 if (KDB_FLAG(CMD_INTERRUPT))
2170                         return 0;
2171
2172                 kdb_printf("%.*s\n", (int)len - 1, buf);
2173         }
2174
2175         return 0;
2176 }
2177 #endif /* CONFIG_PRINTK */
2178
2179 /* Make sure we balance enable/disable calls, must disable first. */
2180 static atomic_t kdb_nmi_disabled;
2181
2182 static int kdb_disable_nmi(int argc, const char *argv[])
2183 {
2184         if (atomic_read(&kdb_nmi_disabled))
2185                 return 0;
2186         atomic_set(&kdb_nmi_disabled, 1);
2187         arch_kgdb_ops.enable_nmi(0);
2188         return 0;
2189 }
2190
2191 static int kdb_param_enable_nmi(const char *val, const struct kernel_param *kp)
2192 {
2193         if (!atomic_add_unless(&kdb_nmi_disabled, -1, 0))
2194                 return -EINVAL;
2195         arch_kgdb_ops.enable_nmi(1);
2196         return 0;
2197 }
2198
2199 static const struct kernel_param_ops kdb_param_ops_enable_nmi = {
2200         .set = kdb_param_enable_nmi,
2201 };
2202 module_param_cb(enable_nmi, &kdb_param_ops_enable_nmi, NULL, 0600);
2203
2204 /*
2205  * kdb_cpu - This function implements the 'cpu' command.
2206  *      cpu     [<cpunum>]
2207  * Returns:
2208  *      KDB_CMD_CPU for success, a kdb diagnostic if error
2209  */
2210 static void kdb_cpu_status(void)
2211 {
2212         int i, start_cpu, first_print = 1;
2213         char state, prev_state = '?';
2214
2215         kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2216         kdb_printf("Available cpus: ");
2217         for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2218                 if (!cpu_online(i)) {
2219                         state = 'F';    /* cpu is offline */
2220                 } else if (!kgdb_info[i].enter_kgdb) {
2221                         state = 'D';    /* cpu is online but unresponsive */
2222                 } else {
2223                         state = ' ';    /* cpu is responding to kdb */
2224                         if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2225                                 state = 'I';    /* idle task */
2226                 }
2227                 if (state != prev_state) {
2228                         if (prev_state != '?') {
2229                                 if (!first_print)
2230                                         kdb_printf(", ");
2231                                 first_print = 0;
2232                                 kdb_printf("%d", start_cpu);
2233                                 if (start_cpu < i-1)
2234                                         kdb_printf("-%d", i-1);
2235                                 if (prev_state != ' ')
2236                                         kdb_printf("(%c)", prev_state);
2237                         }
2238                         prev_state = state;
2239                         start_cpu = i;
2240                 }
2241         }
2242         /* print the trailing cpus, ignoring them if they are all offline */
2243         if (prev_state != 'F') {
2244                 if (!first_print)
2245                         kdb_printf(", ");
2246                 kdb_printf("%d", start_cpu);
2247                 if (start_cpu < i-1)
2248                         kdb_printf("-%d", i-1);
2249                 if (prev_state != ' ')
2250                         kdb_printf("(%c)", prev_state);
2251         }
2252         kdb_printf("\n");
2253 }
2254
2255 static int kdb_cpu(int argc, const char **argv)
2256 {
2257         unsigned long cpunum;
2258         int diag;
2259
2260         if (argc == 0) {
2261                 kdb_cpu_status();
2262                 return 0;
2263         }
2264
2265         if (argc != 1)
2266                 return KDB_ARGCOUNT;
2267
2268         diag = kdbgetularg(argv[1], &cpunum);
2269         if (diag)
2270                 return diag;
2271
2272         /*
2273          * Validate cpunum
2274          */
2275         if ((cpunum >= CONFIG_NR_CPUS) || !kgdb_info[cpunum].enter_kgdb)
2276                 return KDB_BADCPUNUM;
2277
2278         dbg_switch_cpu = cpunum;
2279
2280         /*
2281          * Switch to other cpu
2282          */
2283         return KDB_CMD_CPU;
2284 }
2285
2286 /* The user may not realize that ps/bta with no parameters does not print idle
2287  * or sleeping system daemon processes, so tell them how many were suppressed.
2288  */
2289 void kdb_ps_suppressed(void)
2290 {
2291         int idle = 0, daemon = 0;
2292         unsigned long mask_I = kdb_task_state_string("I"),
2293                       mask_M = kdb_task_state_string("M");
2294         unsigned long cpu;
2295         const struct task_struct *p, *g;
2296         for_each_online_cpu(cpu) {
2297                 p = kdb_curr_task(cpu);
2298                 if (kdb_task_state(p, mask_I))
2299                         ++idle;
2300         }
2301         kdb_do_each_thread(g, p) {
2302                 if (kdb_task_state(p, mask_M))
2303                         ++daemon;
2304         } kdb_while_each_thread(g, p);
2305         if (idle || daemon) {
2306                 if (idle)
2307                         kdb_printf("%d idle process%s (state I)%s\n",
2308                                    idle, idle == 1 ? "" : "es",
2309                                    daemon ? " and " : "");
2310                 if (daemon)
2311                         kdb_printf("%d sleeping system daemon (state M) "
2312                                    "process%s", daemon,
2313                                    daemon == 1 ? "" : "es");
2314                 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2315         }
2316 }
2317
2318 /*
2319  * kdb_ps - This function implements the 'ps' command which shows a
2320  *      list of the active processes.
2321  *              ps [DRSTCZEUIMA]   All processes, optionally filtered by state
2322  */
2323 void kdb_ps1(const struct task_struct *p)
2324 {
2325         int cpu;
2326         unsigned long tmp;
2327
2328         if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
2329                 return;
2330
2331         cpu = kdb_process_cpu(p);
2332         kdb_printf("0x%px %8d %8d  %d %4d   %c  0x%px %c%s\n",
2333                    (void *)p, p->pid, p->parent->pid,
2334                    kdb_task_has_cpu(p), kdb_process_cpu(p),
2335                    kdb_task_state_char(p),
2336                    (void *)(&p->thread),
2337                    p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2338                    p->comm);
2339         if (kdb_task_has_cpu(p)) {
2340                 if (!KDB_TSK(cpu)) {
2341                         kdb_printf("  Error: no saved data for this cpu\n");
2342                 } else {
2343                         if (KDB_TSK(cpu) != p)
2344                                 kdb_printf("  Error: does not match running "
2345                                    "process table (0x%px)\n", KDB_TSK(cpu));
2346                 }
2347         }
2348 }
2349
2350 static int kdb_ps(int argc, const char **argv)
2351 {
2352         struct task_struct *g, *p;
2353         unsigned long mask, cpu;
2354
2355         if (argc == 0)
2356                 kdb_ps_suppressed();
2357         kdb_printf("%-*s      Pid   Parent [*] cpu State %-*s Command\n",
2358                 (int)(2*sizeof(void *))+2, "Task Addr",
2359                 (int)(2*sizeof(void *))+2, "Thread");
2360         mask = kdb_task_state_string(argc ? argv[1] : NULL);
2361         /* Run the active tasks first */
2362         for_each_online_cpu(cpu) {
2363                 if (KDB_FLAG(CMD_INTERRUPT))
2364                         return 0;
2365                 p = kdb_curr_task(cpu);
2366                 if (kdb_task_state(p, mask))
2367                         kdb_ps1(p);
2368         }
2369         kdb_printf("\n");
2370         /* Now the real tasks */
2371         kdb_do_each_thread(g, p) {
2372                 if (KDB_FLAG(CMD_INTERRUPT))
2373                         return 0;
2374                 if (kdb_task_state(p, mask))
2375                         kdb_ps1(p);
2376         } kdb_while_each_thread(g, p);
2377
2378         return 0;
2379 }
2380
2381 /*
2382  * kdb_pid - This function implements the 'pid' command which switches
2383  *      the currently active process.
2384  *              pid [<pid> | R]
2385  */
2386 static int kdb_pid(int argc, const char **argv)
2387 {
2388         struct task_struct *p;
2389         unsigned long val;
2390         int diag;
2391
2392         if (argc > 1)
2393                 return KDB_ARGCOUNT;
2394
2395         if (argc) {
2396                 if (strcmp(argv[1], "R") == 0) {
2397                         p = KDB_TSK(kdb_initial_cpu);
2398                 } else {
2399                         diag = kdbgetularg(argv[1], &val);
2400                         if (diag)
2401                                 return KDB_BADINT;
2402
2403                         p = find_task_by_pid_ns((pid_t)val,     &init_pid_ns);
2404                         if (!p) {
2405                                 kdb_printf("No task with pid=%d\n", (pid_t)val);
2406                                 return 0;
2407                         }
2408                 }
2409                 kdb_set_current_task(p);
2410         }
2411         kdb_printf("KDB current process is %s(pid=%d)\n",
2412                    kdb_current_task->comm,
2413                    kdb_current_task->pid);
2414
2415         return 0;
2416 }
2417
2418 static int kdb_kgdb(int argc, const char **argv)
2419 {
2420         return KDB_CMD_KGDB;
2421 }
2422
2423 /*
2424  * kdb_help - This function implements the 'help' and '?' commands.
2425  */
2426 static int kdb_help(int argc, const char **argv)
2427 {
2428         kdbtab_t *kt;
2429         int i;
2430
2431         kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2432         kdb_printf("-----------------------------"
2433                    "-----------------------------\n");
2434         for_each_kdbcmd(kt, i) {
2435                 char *space = "";
2436                 if (KDB_FLAG(CMD_INTERRUPT))
2437                         return 0;
2438                 if (!kt->cmd_name)
2439                         continue;
2440                 if (!kdb_check_flags(kt->cmd_flags, kdb_cmd_enabled, true))
2441                         continue;
2442                 if (strlen(kt->cmd_usage) > 20)
2443                         space = "\n                                    ";
2444                 kdb_printf("%-15.15s %-20s%s%s\n", kt->cmd_name,
2445                            kt->cmd_usage, space, kt->cmd_help);
2446         }
2447         return 0;
2448 }
2449
2450 /*
2451  * kdb_kill - This function implements the 'kill' commands.
2452  */
2453 static int kdb_kill(int argc, const char **argv)
2454 {
2455         long sig, pid;
2456         char *endp;
2457         struct task_struct *p;
2458
2459         if (argc != 2)
2460                 return KDB_ARGCOUNT;
2461
2462         sig = simple_strtol(argv[1], &endp, 0);
2463         if (*endp)
2464                 return KDB_BADINT;
2465         if ((sig >= 0) || !valid_signal(-sig)) {
2466                 kdb_printf("Invalid signal parameter.<-signal>\n");
2467                 return 0;
2468         }
2469         sig = -sig;
2470
2471         pid = simple_strtol(argv[2], &endp, 0);
2472         if (*endp)
2473                 return KDB_BADINT;
2474         if (pid <= 0) {
2475                 kdb_printf("Process ID must be large than 0.\n");
2476                 return 0;
2477         }
2478
2479         /* Find the process. */
2480         p = find_task_by_pid_ns(pid, &init_pid_ns);
2481         if (!p) {
2482                 kdb_printf("The specified process isn't found.\n");
2483                 return 0;
2484         }
2485         p = p->group_leader;
2486         kdb_send_sig(p, sig);
2487         return 0;
2488 }
2489
2490 /*
2491  * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2492  * I cannot call that code directly from kdb, it has an unconditional
2493  * cli()/sti() and calls routines that take locks which can stop the debugger.
2494  */
2495 static void kdb_sysinfo(struct sysinfo *val)
2496 {
2497         u64 uptime = ktime_get_mono_fast_ns();
2498
2499         memset(val, 0, sizeof(*val));
2500         val->uptime = div_u64(uptime, NSEC_PER_SEC);
2501         val->loads[0] = avenrun[0];
2502         val->loads[1] = avenrun[1];
2503         val->loads[2] = avenrun[2];
2504         val->procs = nr_threads-1;
2505         si_meminfo(val);
2506
2507         return;
2508 }
2509
2510 /*
2511  * kdb_summary - This function implements the 'summary' command.
2512  */
2513 static int kdb_summary(int argc, const char **argv)
2514 {
2515         time64_t now;
2516         struct tm tm;
2517         struct sysinfo val;
2518
2519         if (argc)
2520                 return KDB_ARGCOUNT;
2521
2522         kdb_printf("sysname    %s\n", init_uts_ns.name.sysname);
2523         kdb_printf("release    %s\n", init_uts_ns.name.release);
2524         kdb_printf("version    %s\n", init_uts_ns.name.version);
2525         kdb_printf("machine    %s\n", init_uts_ns.name.machine);
2526         kdb_printf("nodename   %s\n", init_uts_ns.name.nodename);
2527         kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2528
2529         now = __ktime_get_real_seconds();
2530         time64_to_tm(now, 0, &tm);
2531         kdb_printf("date       %04ld-%02d-%02d %02d:%02d:%02d "
2532                    "tz_minuteswest %d\n",
2533                 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2534                 tm.tm_hour, tm.tm_min, tm.tm_sec,
2535                 sys_tz.tz_minuteswest);
2536
2537         kdb_sysinfo(&val);
2538         kdb_printf("uptime     ");
2539         if (val.uptime > (24*60*60)) {
2540                 int days = val.uptime / (24*60*60);
2541                 val.uptime %= (24*60*60);
2542                 kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2543         }
2544         kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2545
2546         kdb_printf("load avg   %ld.%02ld %ld.%02ld %ld.%02ld\n",
2547                 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2548                 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2549                 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2550
2551         /* Display in kilobytes */
2552 #define K(x) ((x) << (PAGE_SHIFT - 10))
2553         kdb_printf("\nMemTotal:       %8lu kB\nMemFree:        %8lu kB\n"
2554                    "Buffers:        %8lu kB\n",
2555                    K(val.totalram), K(val.freeram), K(val.bufferram));
2556         return 0;
2557 }
2558
2559 /*
2560  * kdb_per_cpu - This function implements the 'per_cpu' command.
2561  */
2562 static int kdb_per_cpu(int argc, const char **argv)
2563 {
2564         char fmtstr[64];
2565         int cpu, diag, nextarg = 1;
2566         unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2567
2568         if (argc < 1 || argc > 3)
2569                 return KDB_ARGCOUNT;
2570
2571         diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2572         if (diag)
2573                 return diag;
2574
2575         if (argc >= 2) {
2576                 diag = kdbgetularg(argv[2], &bytesperword);
2577                 if (diag)
2578                         return diag;
2579         }
2580         if (!bytesperword)
2581                 bytesperword = KDB_WORD_SIZE;
2582         else if (bytesperword > KDB_WORD_SIZE)
2583                 return KDB_BADWIDTH;
2584         sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2585         if (argc >= 3) {
2586                 diag = kdbgetularg(argv[3], &whichcpu);
2587                 if (diag)
2588                         return diag;
2589                 if (whichcpu >= nr_cpu_ids || !cpu_online(whichcpu)) {
2590                         kdb_printf("cpu %ld is not online\n", whichcpu);
2591                         return KDB_BADCPUNUM;
2592                 }
2593         }
2594
2595         /* Most architectures use __per_cpu_offset[cpu], some use
2596          * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2597          */
2598 #ifdef  __per_cpu_offset
2599 #define KDB_PCU(cpu) __per_cpu_offset(cpu)
2600 #else
2601 #ifdef  CONFIG_SMP
2602 #define KDB_PCU(cpu) __per_cpu_offset[cpu]
2603 #else
2604 #define KDB_PCU(cpu) 0
2605 #endif
2606 #endif
2607         for_each_online_cpu(cpu) {
2608                 if (KDB_FLAG(CMD_INTERRUPT))
2609                         return 0;
2610
2611                 if (whichcpu != ~0UL && whichcpu != cpu)
2612                         continue;
2613                 addr = symaddr + KDB_PCU(cpu);
2614                 diag = kdb_getword(&val, addr, bytesperword);
2615                 if (diag) {
2616                         kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2617                                    "read, diag=%d\n", cpu, addr, diag);
2618                         continue;
2619                 }
2620                 kdb_printf("%5d ", cpu);
2621                 kdb_md_line(fmtstr, addr,
2622                         bytesperword == KDB_WORD_SIZE,
2623                         1, bytesperword, 1, 1, 0);
2624         }
2625 #undef KDB_PCU
2626         return 0;
2627 }
2628
2629 /*
2630  * display help for the use of cmd | grep pattern
2631  */
2632 static int kdb_grep_help(int argc, const char **argv)
2633 {
2634         kdb_printf("Usage of  cmd args | grep pattern:\n");
2635         kdb_printf("  Any command's output may be filtered through an ");
2636         kdb_printf("emulated 'pipe'.\n");
2637         kdb_printf("  'grep' is just a key word.\n");
2638         kdb_printf("  The pattern may include a very limited set of "
2639                    "metacharacters:\n");
2640         kdb_printf("   pattern or ^pattern or pattern$ or ^pattern$\n");
2641         kdb_printf("  And if there are spaces in the pattern, you may "
2642                    "quote it:\n");
2643         kdb_printf("   \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2644                    " or \"^pat tern$\"\n");
2645         return 0;
2646 }
2647
2648 /*
2649  * kdb_register_flags - This function is used to register a kernel
2650  *      debugger command.
2651  * Inputs:
2652  *      cmd     Command name
2653  *      func    Function to execute the command
2654  *      usage   A simple usage string showing arguments
2655  *      help    A simple help string describing command
2656  *      repeat  Does the command auto repeat on enter?
2657  * Returns:
2658  *      zero for success, one if a duplicate command.
2659  */
2660 #define kdb_command_extend 50   /* arbitrary */
2661 int kdb_register_flags(char *cmd,
2662                        kdb_func_t func,
2663                        char *usage,
2664                        char *help,
2665                        short minlen,
2666                        kdb_cmdflags_t flags)
2667 {
2668         int i;
2669         kdbtab_t *kp;
2670
2671         /*
2672          *  Brute force method to determine duplicates
2673          */
2674         for_each_kdbcmd(kp, i) {
2675                 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2676                         kdb_printf("Duplicate kdb command registered: "
2677                                 "%s, func %px help %s\n", cmd, func, help);
2678                         return 1;
2679                 }
2680         }
2681
2682         /*
2683          * Insert command into first available location in table
2684          */
2685         for_each_kdbcmd(kp, i) {
2686                 if (kp->cmd_name == NULL)
2687                         break;
2688         }
2689
2690         if (i >= kdb_max_commands) {
2691                 kdbtab_t *new = kmalloc_array(kdb_max_commands -
2692                                                 KDB_BASE_CMD_MAX +
2693                                                 kdb_command_extend,
2694                                               sizeof(*new),
2695                                               GFP_KDB);
2696                 if (!new) {
2697                         kdb_printf("Could not allocate new kdb_command "
2698                                    "table\n");
2699                         return 1;
2700                 }
2701                 if (kdb_commands) {
2702                         memcpy(new, kdb_commands,
2703                           (kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new));
2704                         kfree(kdb_commands);
2705                 }
2706                 memset(new + kdb_max_commands - KDB_BASE_CMD_MAX, 0,
2707                        kdb_command_extend * sizeof(*new));
2708                 kdb_commands = new;
2709                 kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX;
2710                 kdb_max_commands += kdb_command_extend;
2711         }
2712
2713         kp->cmd_name   = cmd;
2714         kp->cmd_func   = func;
2715         kp->cmd_usage  = usage;
2716         kp->cmd_help   = help;
2717         kp->cmd_minlen = minlen;
2718         kp->cmd_flags  = flags;
2719
2720         return 0;
2721 }
2722 EXPORT_SYMBOL_GPL(kdb_register_flags);
2723
2724
2725 /*
2726  * kdb_register - Compatibility register function for commands that do
2727  *      not need to specify a repeat state.  Equivalent to
2728  *      kdb_register_flags with flags set to 0.
2729  * Inputs:
2730  *      cmd     Command name
2731  *      func    Function to execute the command
2732  *      usage   A simple usage string showing arguments
2733  *      help    A simple help string describing command
2734  * Returns:
2735  *      zero for success, one if a duplicate command.
2736  */
2737 int kdb_register(char *cmd,
2738              kdb_func_t func,
2739              char *usage,
2740              char *help,
2741              short minlen)
2742 {
2743         return kdb_register_flags(cmd, func, usage, help, minlen, 0);
2744 }
2745 EXPORT_SYMBOL_GPL(kdb_register);
2746
2747 /*
2748  * kdb_unregister - This function is used to unregister a kernel
2749  *      debugger command.  It is generally called when a module which
2750  *      implements kdb commands is unloaded.
2751  * Inputs:
2752  *      cmd     Command name
2753  * Returns:
2754  *      zero for success, one command not registered.
2755  */
2756 int kdb_unregister(char *cmd)
2757 {
2758         int i;
2759         kdbtab_t *kp;
2760
2761         /*
2762          *  find the command.
2763          */
2764         for_each_kdbcmd(kp, i) {
2765                 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2766                         kp->cmd_name = NULL;
2767                         return 0;
2768                 }
2769         }
2770
2771         /* Couldn't find it.  */
2772         return 1;
2773 }
2774 EXPORT_SYMBOL_GPL(kdb_unregister);
2775
2776 /* Initialize the kdb command table. */
2777 static void __init kdb_inittab(void)
2778 {
2779         int i;
2780         kdbtab_t *kp;
2781
2782         for_each_kdbcmd(kp, i)
2783                 kp->cmd_name = NULL;
2784
2785         kdb_register_flags("md", kdb_md, "<vaddr>",
2786           "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2787           KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2788         kdb_register_flags("mdr", kdb_md, "<vaddr> <bytes>",
2789           "Display Raw Memory", 0,
2790           KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2791         kdb_register_flags("mdp", kdb_md, "<paddr> <bytes>",
2792           "Display Physical Memory", 0,
2793           KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2794         kdb_register_flags("mds", kdb_md, "<vaddr>",
2795           "Display Memory Symbolically", 0,
2796           KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2797         kdb_register_flags("mm", kdb_mm, "<vaddr> <contents>",
2798           "Modify Memory Contents", 0,
2799           KDB_ENABLE_MEM_WRITE | KDB_REPEAT_NO_ARGS);
2800         kdb_register_flags("go", kdb_go, "[<vaddr>]",
2801           "Continue Execution", 1,
2802           KDB_ENABLE_REG_WRITE | KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
2803         kdb_register_flags("rd", kdb_rd, "",
2804           "Display Registers", 0,
2805           KDB_ENABLE_REG_READ);
2806         kdb_register_flags("rm", kdb_rm, "<reg> <contents>",
2807           "Modify Registers", 0,
2808           KDB_ENABLE_REG_WRITE);
2809         kdb_register_flags("ef", kdb_ef, "<vaddr>",
2810           "Display exception frame", 0,
2811           KDB_ENABLE_MEM_READ);
2812         kdb_register_flags("bt", kdb_bt, "[<vaddr>]",
2813           "Stack traceback", 1,
2814           KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS);
2815         kdb_register_flags("btp", kdb_bt, "<pid>",
2816           "Display stack for process <pid>", 0,
2817           KDB_ENABLE_INSPECT);
2818         kdb_register_flags("bta", kdb_bt, "[D|R|S|T|C|Z|E|U|I|M|A]",
2819           "Backtrace all processes matching state flag", 0,
2820           KDB_ENABLE_INSPECT);
2821         kdb_register_flags("btc", kdb_bt, "",
2822           "Backtrace current process on each cpu", 0,
2823           KDB_ENABLE_INSPECT);
2824         kdb_register_flags("btt", kdb_bt, "<vaddr>",
2825           "Backtrace process given its struct task address", 0,
2826           KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS);
2827         kdb_register_flags("env", kdb_env, "",
2828           "Show environment variables", 0,
2829           KDB_ENABLE_ALWAYS_SAFE);
2830         kdb_register_flags("set", kdb_set, "",
2831           "Set environment variables", 0,
2832           KDB_ENABLE_ALWAYS_SAFE);
2833         kdb_register_flags("help", kdb_help, "",
2834           "Display Help Message", 1,
2835           KDB_ENABLE_ALWAYS_SAFE);
2836         kdb_register_flags("?", kdb_help, "",
2837           "Display Help Message", 0,
2838           KDB_ENABLE_ALWAYS_SAFE);
2839         kdb_register_flags("cpu", kdb_cpu, "<cpunum>",
2840           "Switch to new cpu", 0,
2841           KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
2842         kdb_register_flags("kgdb", kdb_kgdb, "",
2843           "Enter kgdb mode", 0, 0);
2844         kdb_register_flags("ps", kdb_ps, "[<flags>|A]",
2845           "Display active task list", 0,
2846           KDB_ENABLE_INSPECT);
2847         kdb_register_flags("pid", kdb_pid, "<pidnum>",
2848           "Switch to another task", 0,
2849           KDB_ENABLE_INSPECT);
2850         kdb_register_flags("reboot", kdb_reboot, "",
2851           "Reboot the machine immediately", 0,
2852           KDB_ENABLE_REBOOT);
2853 #if defined(CONFIG_MODULES)
2854         kdb_register_flags("lsmod", kdb_lsmod, "",
2855           "List loaded kernel modules", 0,
2856           KDB_ENABLE_INSPECT);
2857 #endif
2858 #if defined(CONFIG_MAGIC_SYSRQ)
2859         kdb_register_flags("sr", kdb_sr, "<key>",
2860           "Magic SysRq key", 0,
2861           KDB_ENABLE_ALWAYS_SAFE);
2862 #endif
2863 #if defined(CONFIG_PRINTK)
2864         kdb_register_flags("dmesg", kdb_dmesg, "[lines]",
2865           "Display syslog buffer", 0,
2866           KDB_ENABLE_ALWAYS_SAFE);
2867 #endif
2868         if (arch_kgdb_ops.enable_nmi) {
2869                 kdb_register_flags("disable_nmi", kdb_disable_nmi, "",
2870                   "Disable NMI entry to KDB", 0,
2871                   KDB_ENABLE_ALWAYS_SAFE);
2872         }
2873         kdb_register_flags("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
2874           "Define a set of commands, down to endefcmd", 0,
2875           KDB_ENABLE_ALWAYS_SAFE);
2876         kdb_register_flags("kill", kdb_kill, "<-signal> <pid>",
2877           "Send a signal to a process", 0,
2878           KDB_ENABLE_SIGNAL);
2879         kdb_register_flags("summary", kdb_summary, "",
2880           "Summarize the system", 4,
2881           KDB_ENABLE_ALWAYS_SAFE);
2882         kdb_register_flags("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
2883           "Display per_cpu variables", 3,
2884           KDB_ENABLE_MEM_READ);
2885         kdb_register_flags("grephelp", kdb_grep_help, "",
2886           "Display help on | grep", 0,
2887           KDB_ENABLE_ALWAYS_SAFE);
2888 }
2889
2890 /* Execute any commands defined in kdb_cmds.  */
2891 static void __init kdb_cmd_init(void)
2892 {
2893         int i, diag;
2894         for (i = 0; kdb_cmds[i]; ++i) {
2895                 diag = kdb_parse(kdb_cmds[i]);
2896                 if (diag)
2897                         kdb_printf("kdb command %s failed, kdb diag %d\n",
2898                                 kdb_cmds[i], diag);
2899         }
2900         if (defcmd_in_progress) {
2901                 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2902                 kdb_parse("endefcmd");
2903         }
2904 }
2905
2906 /* Initialize kdb_printf, breakpoint tables and kdb state */
2907 void __init kdb_init(int lvl)
2908 {
2909         static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2910         int i;
2911
2912         if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2913                 return;
2914         for (i = kdb_init_lvl; i < lvl; i++) {
2915                 switch (i) {
2916                 case KDB_NOT_INITIALIZED:
2917                         kdb_inittab();          /* Initialize Command Table */
2918                         kdb_initbptab();        /* Initialize Breakpoints */
2919                         break;
2920                 case KDB_INIT_EARLY:
2921                         kdb_cmd_init();         /* Build kdb_cmds tables */
2922                         break;
2923                 }
2924         }
2925         kdb_init_lvl = lvl;
2926 }