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