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