kernel/debug/kdb/kdb_main.c

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