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 = 0;
 919
 920         /*
 921          * First tokenize the command string.
 922          */
 923         cp = (char *)cmdstr;
 924
 925         if (KDB_FLAG(CMD_INTERRUPT)) {
 926                 /* Previous command was interrupted, newline must not
 927                  * repeat the command */
 928                 KDB_FLAG_CLEAR(CMD_INTERRUPT);
 929                 KDB_STATE_SET(PAGER);
 930                 argc = 0;       /* no repeat */
 931         }
 932
 933         if (*cp != '\n' && *cp != '\0') {
 934                 argc = 0;
 935                 cpp = cbuf;
 936                 while (*cp) {
 937                         /* skip whitespace */
 938                         while (isspace(*cp))
 939                                 cp++;
 940                         if ((*cp == '\0') || (*cp == '\n') ||
 941                             (*cp == '#' && !defcmd_in_progress))
 942                                 break;
 943                         /* special case: check for | grep pattern */
 944                         if (*cp == '|') {
 945                                 check_grep++;
 946                                 break;
 947                         }
 948                         if (cpp >= cbuf + CMD_BUFLEN) {
 949                                 kdb_printf("kdb_parse: command buffer "
 950                                            "overflow, command ignored\n%s\n",
 951                                            cmdstr);
 952                                 return KDB_NOTFOUND;
 953                         }
 954                         if (argc >= MAXARGC - 1) {
 955                                 kdb_printf("kdb_parse: too many arguments, "
 956                                            "command ignored\n%s\n", cmdstr);
 957                                 return KDB_NOTFOUND;
 958                         }
 959                         argv[argc++] = cpp;
 960                         escaped = 0;
 961                         quoted = '\0';
 962                         /* Copy to next unquoted and unescaped
 963                          * whitespace or '=' */
 964                         while (*cp && *cp != '\n' &&
 965                                (escaped || quoted || !isspace(*cp))) {
 966                                 if (cpp >= cbuf + CMD_BUFLEN)
 967                                         break;
 968                                 if (escaped) {
 969                                         escaped = 0;
 970                                         *cpp++ = *cp++;
 971                                         continue;
 972                                 }
 973                                 if (*cp == '\\') {
 974                                         escaped = 1;
 975                                         ++cp;
 976                                         continue;
 977                                 }
 978                                 if (*cp == quoted)
 979                                         quoted = '\0';
 980                                 else if (*cp == '\'' || *cp == '"')
 981                                         quoted = *cp;
 982                                 *cpp = *cp++;
 983                                 if (*cpp == '=' && !quoted)
 984                                         break;
 985                                 ++cpp;
 986                         }
 987                         *cpp++ = '\0';  /* Squash a ws or '=' character */
 988                 }
 989         }
 990         if (!argc)
 991                 return 0;
 992         if (check_grep)
 993                 parse_grep(cp);
 994         if (defcmd_in_progress) {
 995                 int result = kdb_defcmd2(cmdstr, argv[0]);
 996                 if (!defcmd_in_progress) {
 997                         argc = 0;       /* avoid repeat on endefcmd */
 998                         *(argv[0]) = '\0';
 999                 }
1000                 return result;
1001         }
1002         if (argv[0][0] == '-' && argv[0][1] &&
1003             (argv[0][1] < '0' || argv[0][1] > '9')) {
1004                 ignore_errors = 1;
1005                 ++argv[0];
1006         }
1007
1008         for_each_kdbcmd(tp, i) {
1009                 if (tp->cmd_name) {
1010                         /*
1011                          * If this command is allowed to be abbreviated,
1012                          * check to see if this is it.
1013                          */
1014
1015                         if (tp->cmd_minlen
1016                          && (strlen(argv[0]) <= tp->cmd_minlen)) {
1017                                 if (strncmp(argv[0],
1018                                             tp->cmd_name,
1019                                             tp->cmd_minlen) == 0) {
1020                                         break;
1021                                 }
1022                         }
1023
1024                         if (strcmp(argv[0], tp->cmd_name) == 0)
1025                                 break;
1026                 }
1027         }
1028
1029         /*
1030          * If we don't find a command by this name, see if the first
1031          * few characters of this match any of the known commands.
1032          * e.g., md1c20 should match md.
1033          */
1034         if (i == kdb_max_commands) {
1035                 for_each_kdbcmd(tp, i) {
1036                         if (tp->cmd_name) {
1037                                 if (strncmp(argv[0],
1038                                             tp->cmd_name,
1039                                             strlen(tp->cmd_name)) == 0) {
1040                                         break;
1041                                 }
1042                         }
1043                 }
1044         }
1045
1046         if (i < kdb_max_commands) {
1047                 int result;
1048
1049                 if (!kdb_check_flags(tp->cmd_flags, kdb_cmd_enabled, argc <= 1))
1050                         return KDB_NOPERM;
1051
1052                 KDB_STATE_SET(CMD);
1053                 result = (*tp->cmd_func)(argc-1, (const char **)argv);
1054                 if (result && ignore_errors && result > KDB_CMD_GO)
1055                         result = 0;
1056                 KDB_STATE_CLEAR(CMD);
1057
1058                 if (tp->cmd_flags & KDB_REPEAT_WITH_ARGS)
1059                         return result;
1060
1061                 argc = tp->cmd_flags & KDB_REPEAT_NO_ARGS ? 1 : 0;
1062                 if (argv[argc])
1063                         *(argv[argc]) = '\0';
1064                 return result;
1065         }
1066
1067         /*
1068          * If the input with which we were presented does not
1069          * map to an existing command, attempt to parse it as an
1070          * address argument and display the result.   Useful for
1071          * obtaining the address of a variable, or the nearest symbol
1072          * to an address contained in a register.
1073          */
1074         {
1075                 unsigned long value;
1076                 char *name = NULL;
1077                 long offset;
1078                 int nextarg = 0;
1079
1080                 if (kdbgetaddrarg(0, (const char **)argv, &nextarg,
1081                                   &value, &offset, &name)) {
1082                         return KDB_NOTFOUND;
1083                 }
1084
1085                 kdb_printf("%s = ", argv[0]);
1086                 kdb_symbol_print(value, NULL, KDB_SP_DEFAULT);
1087                 kdb_printf("\n");
1088                 return 0;
1089         }
1090 }
1091
1092
1093 static int handle_ctrl_cmd(char *cmd)
1094 {
1095 #define CTRL_P  16
1096 #define CTRL_N  14
1097
1098         /* initial situation */
1099         if (cmd_head == cmd_tail)
1100                 return 0;
1101         switch (*cmd) {
1102         case CTRL_P:
1103                 if (cmdptr != cmd_tail)
1104                         cmdptr = (cmdptr-1) % KDB_CMD_HISTORY_COUNT;
1105                 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1106                 return 1;
1107         case CTRL_N:
1108                 if (cmdptr != cmd_head)
1109                         cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT;
1110                 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1111                 return 1;
1112         }
1113         return 0;
1114 }
1115
1116 /*
1117  * kdb_reboot - This function implements the 'reboot' command.  Reboot
1118  *      the system immediately, or loop for ever on failure.
1119  */
1120 static int kdb_reboot(int argc, const char **argv)
1121 {
1122         emergency_restart();
1123         kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
1124         while (1)
1125                 cpu_relax();
1126         /* NOTREACHED */
1127         return 0;
1128 }
1129
1130 static void kdb_dumpregs(struct pt_regs *regs)
1131 {
1132         int old_lvl = console_loglevel;
1133         console_loglevel = CONSOLE_LOGLEVEL_MOTORMOUTH;
1134         kdb_trap_printk++;
1135         show_regs(regs);
1136         kdb_trap_printk--;
1137         kdb_printf("\n");
1138         console_loglevel = old_lvl;
1139 }
1140
1141 void kdb_set_current_task(struct task_struct *p)
1142 {
1143         kdb_current_task = p;
1144
1145         if (kdb_task_has_cpu(p)) {
1146                 kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p));
1147                 return;
1148         }
1149         kdb_current_regs = NULL;
1150 }
1151
1152 /*
1153  * kdb_local - The main code for kdb.  This routine is invoked on a
1154  *      specific processor, it is not global.  The main kdb() routine
1155  *      ensures that only one processor at a time is in this routine.
1156  *      This code is called with the real reason code on the first
1157  *      entry to a kdb session, thereafter it is called with reason
1158  *      SWITCH, even if the user goes back to the original cpu.
1159  * Inputs:
1160  *      reason          The reason KDB was invoked
1161  *      error           The hardware-defined error code
1162  *      regs            The exception frame at time of fault/breakpoint.
1163  *      db_result       Result code from the break or debug point.
1164  * Returns:
1165  *      0       KDB was invoked for an event which it wasn't responsible
1166  *      1       KDB handled the event for which it was invoked.
1167  *      KDB_CMD_GO      User typed 'go'.
1168  *      KDB_CMD_CPU     User switched to another cpu.
1169  *      KDB_CMD_SS      Single step.
1170  */
1171 static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs,
1172                      kdb_dbtrap_t db_result)
1173 {
1174         char *cmdbuf;
1175         int diag;
1176         struct task_struct *kdb_current =
1177                 kdb_curr_task(raw_smp_processor_id());
1178
1179         KDB_DEBUG_STATE("kdb_local 1", reason);
1180         kdb_go_count = 0;
1181         if (reason == KDB_REASON_DEBUG) {
1182                 /* special case below */
1183         } else {
1184                 kdb_printf("\nEntering kdb (current=0x%p, pid %d) ",
1185                            kdb_current, kdb_current ? kdb_current->pid : 0);
1186 #if defined(CONFIG_SMP)
1187                 kdb_printf("on processor %d ", raw_smp_processor_id());
1188 #endif
1189         }
1190
1191         switch (reason) {
1192         case KDB_REASON_DEBUG:
1193         {
1194                 /*
1195                  * If re-entering kdb after a single step
1196                  * command, don't print the message.
1197                  */
1198                 switch (db_result) {
1199                 case KDB_DB_BPT:
1200                         kdb_printf("\nEntering kdb (0x%p, pid %d) ",
1201                                    kdb_current, kdb_current->pid);
1202 #if defined(CONFIG_SMP)
1203                         kdb_printf("on processor %d ", raw_smp_processor_id());
1204 #endif
1205                         kdb_printf("due to Debug @ " kdb_machreg_fmt "\n",
1206                                    instruction_pointer(regs));
1207                         break;
1208                 case KDB_DB_SS:
1209                         break;
1210                 case KDB_DB_SSBPT:
1211                         KDB_DEBUG_STATE("kdb_local 4", reason);
1212                         return 1;       /* kdba_db_trap did the work */
1213                 default:
1214                         kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
1215                                    db_result);
1216                         break;
1217                 }
1218
1219         }
1220                 break;
1221         case KDB_REASON_ENTER:
1222                 if (KDB_STATE(KEYBOARD))
1223                         kdb_printf("due to Keyboard Entry\n");
1224                 else
1225                         kdb_printf("due to KDB_ENTER()\n");
1226                 break;
1227         case KDB_REASON_KEYBOARD:
1228                 KDB_STATE_SET(KEYBOARD);
1229                 kdb_printf("due to Keyboard Entry\n");
1230                 break;
1231         case KDB_REASON_ENTER_SLAVE:
1232                 /* drop through, slaves only get released via cpu switch */
1233         case KDB_REASON_SWITCH:
1234                 kdb_printf("due to cpu switch\n");
1235                 break;
1236         case KDB_REASON_OOPS:
1237                 kdb_printf("Oops: %s\n", kdb_diemsg);
1238                 kdb_printf("due to oops @ " kdb_machreg_fmt "\n",
1239                            instruction_pointer(regs));
1240                 kdb_dumpregs(regs);
1241                 break;
1242         case KDB_REASON_SYSTEM_NMI:
1243                 kdb_printf("due to System NonMaskable Interrupt\n");
1244                 break;
1245         case KDB_REASON_NMI:
1246                 kdb_printf("due to NonMaskable Interrupt @ "
1247                            kdb_machreg_fmt "\n",
1248                            instruction_pointer(regs));
1249                 break;
1250         case KDB_REASON_SSTEP:
1251         case KDB_REASON_BREAK:
1252                 kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
1253                            reason == KDB_REASON_BREAK ?
1254                            "Breakpoint" : "SS trap", instruction_pointer(regs));
1255                 /*
1256                  * Determine if this breakpoint is one that we
1257                  * are interested in.
1258                  */
1259                 if (db_result != KDB_DB_BPT) {
1260                         kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1261                                    db_result);
1262                         KDB_DEBUG_STATE("kdb_local 6", reason);
1263                         return 0;       /* Not for us, dismiss it */
1264                 }
1265                 break;
1266         case KDB_REASON_RECURSE:
1267                 kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
1268                            instruction_pointer(regs));
1269                 break;
1270         default:
1271                 kdb_printf("kdb: unexpected reason code: %d\n", reason);
1272                 KDB_DEBUG_STATE("kdb_local 8", reason);
1273                 return 0;       /* Not for us, dismiss it */
1274         }
1275
1276         while (1) {
1277                 /*
1278                  * Initialize pager context.
1279                  */
1280                 kdb_nextline = 1;
1281                 KDB_STATE_CLEAR(SUPPRESS);
1282                 kdb_grepping_flag = 0;
1283
1284                 cmdbuf = cmd_cur;
1285                 *cmdbuf = '\0';
1286                 *(cmd_hist[cmd_head]) = '\0';
1287
1288 do_full_getstr:
1289 #if defined(CONFIG_SMP)
1290                 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
1291                          raw_smp_processor_id());
1292 #else
1293                 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"));
1294 #endif
1295                 if (defcmd_in_progress)
1296                         strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
1297
1298                 /*
1299                  * Fetch command from keyboard
1300                  */
1301                 cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
1302                 if (*cmdbuf != '\n') {
1303                         if (*cmdbuf < 32) {
1304                                 if (cmdptr == cmd_head) {
1305                                         strncpy(cmd_hist[cmd_head], cmd_cur,
1306                                                 CMD_BUFLEN);
1307                                         *(cmd_hist[cmd_head] +
1308                                           strlen(cmd_hist[cmd_head])-1) = '\0';
1309                                 }
1310                                 if (!handle_ctrl_cmd(cmdbuf))
1311                                         *(cmd_cur+strlen(cmd_cur)-1) = '\0';
1312                                 cmdbuf = cmd_cur;
1313                                 goto do_full_getstr;
1314                         } else {
1315                                 strncpy(cmd_hist[cmd_head], cmd_cur,
1316                                         CMD_BUFLEN);
1317                         }
1318
1319                         cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
1320                         if (cmd_head == cmd_tail)
1321                                 cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
1322                 }
1323
1324                 cmdptr = cmd_head;
1325                 diag = kdb_parse(cmdbuf);
1326                 if (diag == KDB_NOTFOUND) {
1327                         kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
1328                         diag = 0;
1329                 }
1330                 if (diag == KDB_CMD_GO
1331                  || diag == KDB_CMD_CPU
1332                  || diag == KDB_CMD_SS
1333                  || diag == KDB_CMD_KGDB)
1334                         break;
1335
1336                 if (diag)
1337                         kdb_cmderror(diag);
1338         }
1339         KDB_DEBUG_STATE("kdb_local 9", diag);
1340         return diag;
1341 }
1342
1343
1344 /*
1345  * kdb_print_state - Print the state data for the current processor
1346  *      for debugging.
1347  * Inputs:
1348  *      text            Identifies the debug point
1349  *      value           Any integer value to be printed, e.g. reason code.
1350  */
1351 void kdb_print_state(const char *text, int value)
1352 {
1353         kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1354                    text, raw_smp_processor_id(), value, kdb_initial_cpu,
1355                    kdb_state);
1356 }
1357
1358 /*
1359  * kdb_main_loop - After initial setup and assignment of the
1360  *      controlling cpu, all cpus are in this loop.  One cpu is in
1361  *      control and will issue the kdb prompt, the others will spin
1362  *      until 'go' or cpu switch.
1363  *
1364  *      To get a consistent view of the kernel stacks for all
1365  *      processes, this routine is invoked from the main kdb code via
1366  *      an architecture specific routine.  kdba_main_loop is
1367  *      responsible for making the kernel stacks consistent for all
1368  *      processes, there should be no difference between a blocked
1369  *      process and a running process as far as kdb is concerned.
1370  * Inputs:
1371  *      reason          The reason KDB was invoked
1372  *      error           The hardware-defined error code
1373  *      reason2         kdb's current reason code.
1374  *                      Initially error but can change
1375  *                      according to kdb state.
1376  *      db_result       Result code from break or debug point.
1377  *      regs            The exception frame at time of fault/breakpoint.
1378  *                      should always be valid.
1379  * Returns:
1380  *      0       KDB was invoked for an event which it wasn't responsible
1381  *      1       KDB handled the event for which it was invoked.
1382  */
1383 int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
1384               kdb_dbtrap_t db_result, struct pt_regs *regs)
1385 {
1386         int result = 1;
1387         /* Stay in kdb() until 'go', 'ss[b]' or an error */
1388         while (1) {
1389                 /*
1390                  * All processors except the one that is in control
1391                  * will spin here.
1392                  */
1393                 KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1394                 while (KDB_STATE(HOLD_CPU)) {
1395                         /* state KDB is turned off by kdb_cpu to see if the
1396                          * other cpus are still live, each cpu in this loop
1397                          * turns it back on.
1398                          */
1399                         if (!KDB_STATE(KDB))
1400                                 KDB_STATE_SET(KDB);
1401                 }
1402
1403                 KDB_STATE_CLEAR(SUPPRESS);
1404                 KDB_DEBUG_STATE("kdb_main_loop 2", reason);
1405                 if (KDB_STATE(LEAVING))
1406                         break;  /* Another cpu said 'go' */
1407                 /* Still using kdb, this processor is in control */
1408                 result = kdb_local(reason2, error, regs, db_result);
1409                 KDB_DEBUG_STATE("kdb_main_loop 3", result);
1410
1411                 if (result == KDB_CMD_CPU)
1412                         break;
1413
1414                 if (result == KDB_CMD_SS) {
1415                         KDB_STATE_SET(DOING_SS);
1416                         break;
1417                 }
1418
1419                 if (result == KDB_CMD_KGDB) {
1420                         if (!KDB_STATE(DOING_KGDB))
1421                                 kdb_printf("Entering please attach debugger "
1422                                            "or use $D#44+ or $3#33\n");
1423                         break;
1424                 }
1425                 if (result && result != 1 && result != KDB_CMD_GO)
1426                         kdb_printf("\nUnexpected kdb_local return code %d\n",
1427                                    result);
1428                 KDB_DEBUG_STATE("kdb_main_loop 4", reason);
1429                 break;
1430         }
1431         if (KDB_STATE(DOING_SS))
1432                 KDB_STATE_CLEAR(SSBPT);
1433
1434         /* Clean up any keyboard devices before leaving */
1435         kdb_kbd_cleanup_state();
1436
1437         return result;
1438 }
1439
1440 /*
1441  * kdb_mdr - This function implements the guts of the 'mdr', memory
1442  * read command.
1443  *      mdr  <addr arg>,<byte count>
1444  * Inputs:
1445  *      addr    Start address
1446  *      count   Number of bytes
1447  * Returns:
1448  *      Always 0.  Any errors are detected and printed by kdb_getarea.
1449  */
1450 static int kdb_mdr(unsigned long addr, unsigned int count)
1451 {
1452         unsigned char c;
1453         while (count--) {
1454                 if (kdb_getarea(c, addr))
1455                         return 0;
1456                 kdb_printf("%02x", c);
1457                 addr++;
1458         }
1459         kdb_printf("\n");
1460         return 0;
1461 }
1462
1463 /*
1464  * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1465  *      'md8' 'mdr' and 'mds' commands.
1466  *
1467  *      md|mds  [<addr arg> [<line count> [<radix>]]]
1468  *      mdWcN   [<addr arg> [<line count> [<radix>]]]
1469  *              where W = is the width (1, 2, 4 or 8) and N is the count.
1470  *              for eg., md1c20 reads 20 bytes, 1 at a time.
1471  *      mdr  <addr arg>,<byte count>
1472  */
1473 static void kdb_md_line(const char *fmtstr, unsigned long addr,
1474                         int symbolic, int nosect, int bytesperword,
1475                         int num, int repeat, int phys)
1476 {
1477         /* print just one line of data */
1478         kdb_symtab_t symtab;
1479         char cbuf[32];
1480         char *c = cbuf;
1481         int i;
1482         unsigned long word;
1483
1484         memset(cbuf, '\0', sizeof(cbuf));
1485         if (phys)
1486                 kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1487         else
1488                 kdb_printf(kdb_machreg_fmt0 " ", addr);
1489
1490         for (i = 0; i < num && repeat--; i++) {
1491                 if (phys) {
1492                         if (kdb_getphysword(&word, addr, bytesperword))
1493                                 break;
1494                 } else if (kdb_getword(&word, addr, bytesperword))
1495                         break;
1496                 kdb_printf(fmtstr, word);
1497                 if (symbolic)
1498                         kdbnearsym(word, &symtab);
1499                 else
1500                         memset(&symtab, 0, sizeof(symtab));
1501                 if (symtab.sym_name) {
1502                         kdb_symbol_print(word, &symtab, 0);
1503                         if (!nosect) {
1504                                 kdb_printf("\n");
1505                                 kdb_printf("                       %s %s "
1506                                            kdb_machreg_fmt " "
1507                                            kdb_machreg_fmt " "
1508                                            kdb_machreg_fmt, symtab.mod_name,
1509                                            symtab.sec_name, symtab.sec_start,
1510                                            symtab.sym_start, symtab.sym_end);
1511                         }
1512                         addr += bytesperword;
1513                 } else {
1514                         union {
1515                                 u64 word;
1516                                 unsigned char c[8];
1517                         } wc;
1518                         unsigned char *cp;
1519 #ifdef  __BIG_ENDIAN
1520                         cp = wc.c + 8 - bytesperword;
1521 #else
1522                         cp = wc.c;
1523 #endif
1524                         wc.word = word;
1525 #define printable_char(c) \
1526         ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1527                         switch (bytesperword) {
1528                         case 8:
1529                                 *c++ = printable_char(*cp++);
1530                                 *c++ = printable_char(*cp++);
1531                                 *c++ = printable_char(*cp++);
1532                                 *c++ = printable_char(*cp++);
1533                                 addr += 4;
1534                         case 4:
1535                                 *c++ = printable_char(*cp++);
1536                                 *c++ = printable_char(*cp++);
1537                                 addr += 2;
1538                         case 2:
1539                                 *c++ = printable_char(*cp++);
1540                                 addr++;
1541                         case 1:
1542                                 *c++ = printable_char(*cp++);
1543                                 addr++;
1544                                 break;
1545                         }
1546 #undef printable_char
1547                 }
1548         }
1549         kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1550                    " ", cbuf);
1551 }
1552
1553 static int kdb_md(int argc, const char **argv)
1554 {
1555         static unsigned long last_addr;
1556         static int last_radix, last_bytesperword, last_repeat;
1557         int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1558         int nosect = 0;
1559         char fmtchar, fmtstr[64];
1560         unsigned long addr;
1561         unsigned long word;
1562         long offset = 0;
1563         int symbolic = 0;
1564         int valid = 0;
1565         int phys = 0;
1566
1567         kdbgetintenv("MDCOUNT", &mdcount);
1568         kdbgetintenv("RADIX", &radix);
1569         kdbgetintenv("BYTESPERWORD", &bytesperword);
1570
1571         /* Assume 'md <addr>' and start with environment values */
1572         repeat = mdcount * 16 / bytesperword;
1573
1574         if (strcmp(argv[0], "mdr") == 0) {
1575                 if (argc != 2)
1576                         return KDB_ARGCOUNT;
1577                 valid = 1;
1578         } else if (isdigit(argv[0][2])) {
1579                 bytesperword = (int)(argv[0][2] - '0');
1580                 if (bytesperword == 0) {
1581                         bytesperword = last_bytesperword;
1582                         if (bytesperword == 0)
1583                                 bytesperword = 4;
1584                 }
1585                 last_bytesperword = bytesperword;
1586                 repeat = mdcount * 16 / bytesperword;
1587                 if (!argv[0][3])
1588                         valid = 1;
1589                 else if (argv[0][3] == 'c' && argv[0][4]) {
1590                         char *p;
1591                         repeat = simple_strtoul(argv[0] + 4, &p, 10);
1592                         mdcount = ((repeat * bytesperword) + 15) / 16;
1593                         valid = !*p;
1594                 }
1595                 last_repeat = repeat;
1596         } else if (strcmp(argv[0], "md") == 0)
1597                 valid = 1;
1598         else if (strcmp(argv[0], "mds") == 0)
1599                 valid = 1;
1600         else if (strcmp(argv[0], "mdp") == 0) {
1601                 phys = valid = 1;
1602         }
1603         if (!valid)
1604                 return KDB_NOTFOUND;
1605
1606         if (argc == 0) {
1607                 if (last_addr == 0)
1608                         return KDB_ARGCOUNT;
1609                 addr = last_addr;
1610                 radix = last_radix;
1611                 bytesperword = last_bytesperword;
1612                 repeat = last_repeat;
1613                 mdcount = ((repeat * bytesperword) + 15) / 16;
1614         }
1615
1616         if (argc) {
1617                 unsigned long val;
1618                 int diag, nextarg = 1;
1619                 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1620                                      &offset, NULL);
1621                 if (diag)
1622                         return diag;
1623                 if (argc > nextarg+2)
1624                         return KDB_ARGCOUNT;
1625
1626                 if (argc >= nextarg) {
1627                         diag = kdbgetularg(argv[nextarg], &val);
1628                         if (!diag) {
1629                                 mdcount = (int) val;
1630                                 repeat = mdcount * 16 / bytesperword;
1631                         }
1632                 }
1633                 if (argc >= nextarg+1) {
1634                         diag = kdbgetularg(argv[nextarg+1], &val);
1635                         if (!diag)
1636                                 radix = (int) val;
1637                 }
1638         }
1639
1640         if (strcmp(argv[0], "mdr") == 0)
1641                 return kdb_mdr(addr, mdcount);
1642
1643         switch (radix) {
1644         case 10:
1645                 fmtchar = 'd';
1646                 break;
1647         case 16:
1648                 fmtchar = 'x';
1649                 break;
1650         case 8:
1651                 fmtchar = 'o';
1652                 break;
1653         default:
1654                 return KDB_BADRADIX;
1655         }
1656
1657         last_radix = radix;
1658
1659         if (bytesperword > KDB_WORD_SIZE)
1660                 return KDB_BADWIDTH;
1661
1662         switch (bytesperword) {
1663         case 8:
1664                 sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1665                 break;
1666         case 4:
1667                 sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1668                 break;
1669         case 2:
1670                 sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1671                 break;
1672         case 1:
1673                 sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1674                 break;
1675         default:
1676                 return KDB_BADWIDTH;
1677         }
1678
1679         last_repeat = repeat;
1680         last_bytesperword = bytesperword;
1681
1682         if (strcmp(argv[0], "mds") == 0) {
1683                 symbolic = 1;
1684                 /* Do not save these changes as last_*, they are temporary mds
1685                  * overrides.
1686                  */
1687                 bytesperword = KDB_WORD_SIZE;
1688                 repeat = mdcount;
1689                 kdbgetintenv("NOSECT", &nosect);
1690         }
1691
1692         /* Round address down modulo BYTESPERWORD */
1693
1694         addr &= ~(bytesperword-1);
1695
1696         while (repeat > 0) {
1697                 unsigned long a;
1698                 int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1699
1700                 if (KDB_FLAG(CMD_INTERRUPT))
1701                         return 0;
1702                 for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1703                         if (phys) {
1704                                 if (kdb_getphysword(&word, a, bytesperword)
1705                                                 || word)
1706                                         break;
1707                         } else if (kdb_getword(&word, a, bytesperword) || word)
1708                                 break;
1709                 }
1710                 n = min(num, repeat);
1711                 kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1712                             num, repeat, phys);
1713                 addr += bytesperword * n;
1714                 repeat -= n;
1715                 z = (z + num - 1) / num;
1716                 if (z > 2) {
1717                         int s = num * (z-2);
1718                         kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1719                                    " zero suppressed\n",
1720                                 addr, addr + bytesperword * s - 1);
1721                         addr += bytesperword * s;
1722                         repeat -= s;
1723                 }
1724         }
1725         last_addr = addr;
1726
1727         return 0;
1728 }
1729
1730 /*
1731  * kdb_mm - This function implements the 'mm' command.
1732  *      mm address-expression new-value
1733  * Remarks:
1734  *      mm works on machine words, mmW works on bytes.
1735  */
1736 static int kdb_mm(int argc, const char **argv)
1737 {
1738         int diag;
1739         unsigned long addr;
1740         long offset = 0;
1741         unsigned long contents;
1742         int nextarg;
1743         int width;
1744
1745         if (argv[0][2] && !isdigit(argv[0][2]))
1746                 return KDB_NOTFOUND;
1747
1748         if (argc < 2)
1749                 return KDB_ARGCOUNT;
1750
1751         nextarg = 1;
1752         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1753         if (diag)
1754                 return diag;
1755
1756         if (nextarg > argc)
1757                 return KDB_ARGCOUNT;
1758         diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1759         if (diag)
1760                 return diag;
1761
1762         if (nextarg != argc + 1)
1763                 return KDB_ARGCOUNT;
1764
1765         width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1766         diag = kdb_putword(addr, contents, width);
1767         if (diag)
1768                 return diag;
1769
1770         kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1771
1772         return 0;
1773 }
1774
1775 /*
1776  * kdb_go - This function implements the 'go' command.
1777  *      go [address-expression]
1778  */
1779 static int kdb_go(int argc, const char **argv)
1780 {
1781         unsigned long addr;
1782         int diag;
1783         int nextarg;
1784         long offset;
1785
1786         if (raw_smp_processor_id() != kdb_initial_cpu) {
1787                 kdb_printf("go must execute on the entry cpu, "
1788                            "please use \"cpu %d\" and then execute go\n",
1789                            kdb_initial_cpu);
1790                 return KDB_BADCPUNUM;
1791         }
1792         if (argc == 1) {
1793                 nextarg = 1;
1794                 diag = kdbgetaddrarg(argc, argv, &nextarg,
1795                                      &addr, &offset, NULL);
1796                 if (diag)
1797                         return diag;
1798         } else if (argc) {
1799                 return KDB_ARGCOUNT;
1800         }
1801
1802         diag = KDB_CMD_GO;
1803         if (KDB_FLAG(CATASTROPHIC)) {
1804                 kdb_printf("Catastrophic error detected\n");
1805                 kdb_printf("kdb_continue_catastrophic=%d, ",
1806                         kdb_continue_catastrophic);
1807                 if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1808                         kdb_printf("type go a second time if you really want "
1809                                    "to continue\n");
1810                         return 0;
1811                 }
1812                 if (kdb_continue_catastrophic == 2) {
1813                         kdb_printf("forcing reboot\n");
1814                         kdb_reboot(0, NULL);
1815                 }
1816                 kdb_printf("attempting to continue\n");
1817         }
1818         return diag;
1819 }
1820
1821 /*
1822  * kdb_rd - This function implements the 'rd' command.
1823  */
1824 static int kdb_rd(int argc, const char **argv)
1825 {
1826         int len = kdb_check_regs();
1827 #if DBG_MAX_REG_NUM > 0
1828         int i;
1829         char *rname;
1830         int rsize;
1831         u64 reg64;
1832         u32 reg32;
1833         u16 reg16;
1834         u8 reg8;
1835
1836         if (len)
1837                 return len;
1838
1839         for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1840                 rsize = dbg_reg_def[i].size * 2;
1841                 if (rsize > 16)
1842                         rsize = 2;
1843                 if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
1844                         len = 0;
1845                         kdb_printf("\n");
1846                 }
1847                 if (len)
1848                         len += kdb_printf("  ");
1849                 switch(dbg_reg_def[i].size * 8) {
1850                 case 8:
1851                         rname = dbg_get_reg(i, &reg8, kdb_current_regs);
1852                         if (!rname)
1853                                 break;
1854                         len += kdb_printf("%s: %02x", rname, reg8);
1855                         break;
1856                 case 16:
1857                         rname = dbg_get_reg(i, &reg16, kdb_current_regs);
1858                         if (!rname)
1859                                 break;
1860                         len += kdb_printf("%s: %04x", rname, reg16);
1861                         break;
1862                 case 32:
1863                         rname = dbg_get_reg(i, &reg32, kdb_current_regs);
1864                         if (!rname)
1865                                 break;
1866                         len += kdb_printf("%s: %08x", rname, reg32);
1867                         break;
1868                 case 64:
1869                         rname = dbg_get_reg(i, &reg64, kdb_current_regs);
1870                         if (!rname)
1871                                 break;
1872                         len += kdb_printf("%s: %016llx", rname, reg64);
1873                         break;
1874                 default:
1875                         len += kdb_printf("%s: ??", dbg_reg_def[i].name);
1876                 }
1877         }
1878         kdb_printf("\n");
1879 #else
1880         if (len)
1881                 return len;
1882
1883         kdb_dumpregs(kdb_current_regs);
1884 #endif
1885         return 0;
1886 }
1887
1888 /*
1889  * kdb_rm - This function implements the 'rm' (register modify)  command.
1890  *      rm register-name new-contents
1891  * Remarks:
1892  *      Allows register modification with the same restrictions as gdb
1893  */
1894 static int kdb_rm(int argc, const char **argv)
1895 {
1896 #if DBG_MAX_REG_NUM > 0
1897         int diag;
1898         const char *rname;
1899         int i;
1900         u64 reg64;
1901         u32 reg32;
1902         u16 reg16;
1903         u8 reg8;
1904
1905         if (argc != 2)
1906                 return KDB_ARGCOUNT;
1907         /*
1908          * Allow presence or absence of leading '%' symbol.
1909          */
1910         rname = argv[1];
1911         if (*rname == '%')
1912                 rname++;
1913
1914         diag = kdbgetu64arg(argv[2], &reg64);
1915         if (diag)
1916                 return diag;
1917
1918         diag = kdb_check_regs();
1919         if (diag)
1920                 return diag;
1921
1922         diag = KDB_BADREG;
1923         for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1924                 if (strcmp(rname, dbg_reg_def[i].name) == 0) {
1925                         diag = 0;
1926                         break;
1927                 }
1928         }
1929         if (!diag) {
1930                 switch(dbg_reg_def[i].size * 8) {
1931                 case 8:
1932                         reg8 = reg64;
1933                         dbg_set_reg(i, &reg8, kdb_current_regs);
1934                         break;
1935                 case 16:
1936                         reg16 = reg64;
1937                         dbg_set_reg(i, &reg16, kdb_current_regs);
1938                         break;
1939                 case 32:
1940                         reg32 = reg64;
1941                         dbg_set_reg(i, &reg32, kdb_current_regs);
1942                         break;
1943                 case 64:
1944                         dbg_set_reg(i, &reg64, kdb_current_regs);
1945                         break;
1946                 }
1947         }
1948         return diag;
1949 #else
1950         kdb_printf("ERROR: Register set currently not implemented\n");
1951     return 0;
1952 #endif
1953 }
1954
1955 #if defined(CONFIG_MAGIC_SYSRQ)
1956 /*
1957  * kdb_sr - This function implements the 'sr' (SYSRQ key) command
1958  *      which interfaces to the soi-disant MAGIC SYSRQ functionality.
1959  *              sr <magic-sysrq-code>
1960  */
1961 static int kdb_sr(int argc, const char **argv)
1962 {
1963         bool check_mask =
1964             !kdb_check_flags(KDB_ENABLE_ALL, kdb_cmd_enabled, false);
1965
1966         if (argc != 1)
1967                 return KDB_ARGCOUNT;
1968
1969         kdb_trap_printk++;
1970         __handle_sysrq(*argv[1], check_mask);
1971         kdb_trap_printk--;
1972
1973         return 0;
1974 }
1975 #endif  /* CONFIG_MAGIC_SYSRQ */
1976
1977 /*
1978  * kdb_ef - This function implements the 'regs' (display exception
1979  *      frame) command.  This command takes an address and expects to
1980  *      find an exception frame at that address, formats and prints
1981  *      it.
1982  *              regs address-expression
1983  * Remarks:
1984  *      Not done yet.
1985  */
1986 static int kdb_ef(int argc, const char **argv)
1987 {
1988         int diag;
1989         unsigned long addr;
1990         long offset;
1991         int nextarg;
1992
1993         if (argc != 1)
1994                 return KDB_ARGCOUNT;
1995
1996         nextarg = 1;
1997         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1998         if (diag)
1999                 return diag;
2000         show_regs((struct pt_regs *)addr);
2001         return 0;
2002 }
2003
2004 #if defined(CONFIG_MODULES)
2005 /*
2006  * kdb_lsmod - This function implements the 'lsmod' command.  Lists
2007  *      currently loaded kernel modules.
2008  *      Mostly taken from userland lsmod.
2009  */
2010 static int kdb_lsmod(int argc, const char **argv)
2011 {
2012         struct module *mod;
2013
2014         if (argc != 0)
2015                 return KDB_ARGCOUNT;
2016
2017         kdb_printf("Module                  Size  modstruct     Used by\n");
2018         list_for_each_entry(mod, kdb_modules, list) {
2019                 if (mod->state == MODULE_STATE_UNFORMED)
2020                         continue;
2021
2022                 kdb_printf("%-20s%8u  0x%p ", mod->name,
2023                            mod->core_size, (void *)mod);
2024 #ifdef CONFIG_MODULE_UNLOAD
2025                 kdb_printf("%4d ", module_refcount(mod));
2026 #endif
2027                 if (mod->state == MODULE_STATE_GOING)
2028                         kdb_printf(" (Unloading)");
2029                 else if (mod->state == MODULE_STATE_COMING)
2030                         kdb_printf(" (Loading)");
2031                 else
2032                         kdb_printf(" (Live)");
2033                 kdb_printf(" 0x%p", mod->module_core);
2034
2035 #ifdef CONFIG_MODULE_UNLOAD
2036                 {
2037                         struct module_use *use;
2038                         kdb_printf(" [ ");
2039                         list_for_each_entry(use, &mod->source_list,
2040                                             source_list)
2041                                 kdb_printf("%s ", use->target->name);
2042                         kdb_printf("]\n");
2043                 }
2044 #endif
2045         }
2046
2047         return 0;
2048 }
2049
2050 #endif  /* CONFIG_MODULES */
2051
2052 /*
2053  * kdb_env - This function implements the 'env' command.  Display the
2054  *      current environment variables.
2055  */
2056
2057 static int kdb_env(int argc, const char **argv)
2058 {
2059         int i;
2060
2061         for (i = 0; i < __nenv; i++) {
2062                 if (__env[i])
2063                         kdb_printf("%s\n", __env[i]);
2064         }
2065
2066         if (KDB_DEBUG(MASK))
2067                 kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
2068
2069         return 0;
2070 }
2071
2072 #ifdef CONFIG_PRINTK
2073 /*
2074  * kdb_dmesg - This function implements the 'dmesg' command to display
2075  *      the contents of the syslog buffer.
2076  *              dmesg [lines] [adjust]
2077  */
2078 static int kdb_dmesg(int argc, const char **argv)
2079 {
2080         int diag;
2081         int logging;
2082         int lines = 0;
2083         int adjust = 0;
2084         int n = 0;
2085         int skip = 0;
2086         struct kmsg_dumper dumper = { .active = 1 };
2087         size_t len;
2088         char buf[201];
2089
2090         if (argc > 2)
2091                 return KDB_ARGCOUNT;
2092         if (argc) {
2093                 char *cp;
2094                 lines = simple_strtol(argv[1], &cp, 0);
2095                 if (*cp)
2096                         lines = 0;
2097                 if (argc > 1) {
2098                         adjust = simple_strtoul(argv[2], &cp, 0);
2099                         if (*cp || adjust < 0)
2100                                 adjust = 0;
2101                 }
2102         }
2103
2104         /* disable LOGGING if set */
2105         diag = kdbgetintenv("LOGGING", &logging);
2106         if (!diag && logging) {
2107                 const char *setargs[] = { "set", "LOGGING", "0" };
2108                 kdb_set(2, setargs);
2109         }
2110
2111         kmsg_dump_rewind_nolock(&dumper);
2112         while (kmsg_dump_get_line_nolock(&dumper, 1, NULL, 0, NULL))
2113                 n++;
2114
2115         if (lines < 0) {
2116                 if (adjust >= n)
2117                         kdb_printf("buffer only contains %d lines, nothing "
2118                                    "printed\n", n);
2119                 else if (adjust - lines >= n)
2120                         kdb_printf("buffer only contains %d lines, last %d "
2121                                    "lines printed\n", n, n - adjust);
2122                 skip = adjust;
2123                 lines = abs(lines);
2124         } else if (lines > 0) {
2125                 skip = n - lines - adjust;
2126                 lines = abs(lines);
2127                 if (adjust >= n) {
2128                         kdb_printf("buffer only contains %d lines, "
2129                                    "nothing printed\n", n);
2130                         skip = n;
2131                 } else if (skip < 0) {
2132                         lines += skip;
2133                         skip = 0;
2134                         kdb_printf("buffer only contains %d lines, first "
2135                                    "%d lines printed\n", n, lines);
2136                 }
2137         } else {
2138                 lines = n;
2139         }
2140
2141         if (skip >= n || skip < 0)
2142                 return 0;
2143
2144         kmsg_dump_rewind_nolock(&dumper);
2145         while (kmsg_dump_get_line_nolock(&dumper, 1, buf, sizeof(buf), &len)) {
2146                 if (skip) {
2147                         skip--;
2148                         continue;
2149                 }
2150                 if (!lines--)
2151                         break;
2152                 if (KDB_FLAG(CMD_INTERRUPT))
2153                         return 0;
2154
2155                 kdb_printf("%.*s\n", (int)len - 1, buf);
2156         }
2157
2158         return 0;
2159 }
2160 #endif /* CONFIG_PRINTK */
2161
2162 /* Make sure we balance enable/disable calls, must disable first. */
2163 static atomic_t kdb_nmi_disabled;
2164
2165 static int kdb_disable_nmi(int argc, const char *argv[])
2166 {
2167         if (atomic_read(&kdb_nmi_disabled))
2168                 return 0;
2169         atomic_set(&kdb_nmi_disabled, 1);
2170         arch_kgdb_ops.enable_nmi(0);
2171         return 0;
2172 }
2173
2174 static int kdb_param_enable_nmi(const char *val, const struct kernel_param *kp)
2175 {
2176         if (!atomic_add_unless(&kdb_nmi_disabled, -1, 0))
2177                 return -EINVAL;
2178         arch_kgdb_ops.enable_nmi(1);
2179         return 0;
2180 }
2181
2182 static const struct kernel_param_ops kdb_param_ops_enable_nmi = {
2183         .set = kdb_param_enable_nmi,
2184 };
2185 module_param_cb(enable_nmi, &kdb_param_ops_enable_nmi, NULL, 0600);
2186
2187 /*
2188  * kdb_cpu - This function implements the 'cpu' command.
2189  *      cpu     [<cpunum>]
2190  * Returns:
2191  *      KDB_CMD_CPU for success, a kdb diagnostic if error
2192  */
2193 static void kdb_cpu_status(void)
2194 {
2195         int i, start_cpu, first_print = 1;
2196         char state, prev_state = '?';
2197
2198         kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2199         kdb_printf("Available cpus: ");
2200         for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2201                 if (!cpu_online(i)) {
2202                         state = 'F';    /* cpu is offline */
2203                 } else if (!kgdb_info[i].enter_kgdb) {
2204                         state = 'D';    /* cpu is online but unresponsive */
2205                 } else {
2206                         state = ' ';    /* cpu is responding to kdb */
2207                         if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2208                                 state = 'I';    /* idle task */
2209                 }
2210                 if (state != prev_state) {
2211                         if (prev_state != '?') {
2212                                 if (!first_print)
2213                                         kdb_printf(", ");
2214                                 first_print = 0;
2215                                 kdb_printf("%d", start_cpu);
2216                                 if (start_cpu < i-1)
2217                                         kdb_printf("-%d", i-1);
2218                                 if (prev_state != ' ')
2219                                         kdb_printf("(%c)", prev_state);
2220                         }
2221                         prev_state = state;
2222                         start_cpu = i;
2223                 }
2224         }
2225         /* print the trailing cpus, ignoring them if they are all offline */
2226         if (prev_state != 'F') {
2227                 if (!first_print)
2228                         kdb_printf(", ");
2229                 kdb_printf("%d", start_cpu);
2230                 if (start_cpu < i-1)
2231                         kdb_printf("-%d", i-1);
2232                 if (prev_state != ' ')
2233                         kdb_printf("(%c)", prev_state);
2234         }
2235         kdb_printf("\n");
2236 }
2237
2238 static int kdb_cpu(int argc, const char **argv)
2239 {
2240         unsigned long cpunum;
2241         int diag;
2242
2243         if (argc == 0) {
2244                 kdb_cpu_status();
2245                 return 0;
2246         }
2247
2248         if (argc != 1)
2249                 return KDB_ARGCOUNT;
2250
2251         diag = kdbgetularg(argv[1], &cpunum);
2252         if (diag)
2253                 return diag;
2254
2255         /*
2256          * Validate cpunum
2257          */
2258         if ((cpunum >= CONFIG_NR_CPUS) || !kgdb_info[cpunum].enter_kgdb)
2259                 return KDB_BADCPUNUM;
2260
2261         dbg_switch_cpu = cpunum;
2262
2263         /*
2264          * Switch to other cpu
2265          */
2266         return KDB_CMD_CPU;
2267 }
2268
2269 /* The user may not realize that ps/bta with no parameters does not print idle
2270  * or sleeping system daemon processes, so tell them how many were suppressed.
2271  */
2272 void kdb_ps_suppressed(void)
2273 {
2274         int idle = 0, daemon = 0;
2275         unsigned long mask_I = kdb_task_state_string("I"),
2276                       mask_M = kdb_task_state_string("M");
2277         unsigned long cpu;
2278         const struct task_struct *p, *g;
2279         for_each_online_cpu(cpu) {
2280                 p = kdb_curr_task(cpu);
2281                 if (kdb_task_state(p, mask_I))
2282                         ++idle;
2283         }
2284         kdb_do_each_thread(g, p) {
2285                 if (kdb_task_state(p, mask_M))
2286                         ++daemon;
2287         } kdb_while_each_thread(g, p);
2288         if (idle || daemon) {
2289                 if (idle)
2290                         kdb_printf("%d idle process%s (state I)%s\n",
2291                                    idle, idle == 1 ? "" : "es",
2292                                    daemon ? " and " : "");
2293                 if (daemon)
2294                         kdb_printf("%d sleeping system daemon (state M) "
2295                                    "process%s", daemon,
2296                                    daemon == 1 ? "" : "es");
2297                 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2298         }
2299 }
2300
2301 /*
2302  * kdb_ps - This function implements the 'ps' command which shows a
2303  *      list of the active processes.
2304  *              ps [DRSTCZEUIMA]   All processes, optionally filtered by state
2305  */
2306 void kdb_ps1(const struct task_struct *p)
2307 {
2308         int cpu;
2309         unsigned long tmp;
2310
2311         if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
2312                 return;
2313
2314         cpu = kdb_process_cpu(p);
2315         kdb_printf("0x%p %8d %8d  %d %4d   %c  0x%p %c%s\n",
2316                    (void *)p, p->pid, p->parent->pid,
2317                    kdb_task_has_cpu(p), kdb_process_cpu(p),
2318                    kdb_task_state_char(p),
2319                    (void *)(&p->thread),
2320                    p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2321                    p->comm);
2322         if (kdb_task_has_cpu(p)) {
2323                 if (!KDB_TSK(cpu)) {
2324                         kdb_printf("  Error: no saved data for this cpu\n");
2325                 } else {
2326                         if (KDB_TSK(cpu) != p)
2327                                 kdb_printf("  Error: does not match running "
2328                                    "process table (0x%p)\n", KDB_TSK(cpu));
2329                 }
2330         }
2331 }
2332
2333 static int kdb_ps(int argc, const char **argv)
2334 {
2335         struct task_struct *g, *p;
2336         unsigned long mask, cpu;
2337
2338         if (argc == 0)
2339                 kdb_ps_suppressed();
2340         kdb_printf("%-*s      Pid   Parent [*] cpu State %-*s Command\n",
2341                 (int)(2*sizeof(void *))+2, "Task Addr",
2342                 (int)(2*sizeof(void *))+2, "Thread");
2343         mask = kdb_task_state_string(argc ? argv[1] : NULL);
2344         /* Run the active tasks first */
2345         for_each_online_cpu(cpu) {
2346                 if (KDB_FLAG(CMD_INTERRUPT))
2347                         return 0;
2348                 p = kdb_curr_task(cpu);
2349                 if (kdb_task_state(p, mask))
2350                         kdb_ps1(p);
2351         }
2352         kdb_printf("\n");
2353         /* Now the real tasks */
2354         kdb_do_each_thread(g, p) {
2355                 if (KDB_FLAG(CMD_INTERRUPT))
2356                         return 0;
2357                 if (kdb_task_state(p, mask))
2358                         kdb_ps1(p);
2359         } kdb_while_each_thread(g, p);
2360
2361         return 0;
2362 }
2363
2364 /*
2365  * kdb_pid - This function implements the 'pid' command which switches
2366  *      the currently active process.
2367  *              pid [<pid> | R]
2368  */
2369 static int kdb_pid(int argc, const char **argv)
2370 {
2371         struct task_struct *p;
2372         unsigned long val;
2373         int diag;
2374
2375         if (argc > 1)
2376                 return KDB_ARGCOUNT;
2377
2378         if (argc) {
2379                 if (strcmp(argv[1], "R") == 0) {
2380                         p = KDB_TSK(kdb_initial_cpu);
2381                 } else {
2382                         diag = kdbgetularg(argv[1], &val);
2383                         if (diag)
2384                                 return KDB_BADINT;
2385
2386                         p = find_task_by_pid_ns((pid_t)val,     &init_pid_ns);
2387                         if (!p) {
2388                                 kdb_printf("No task with pid=%d\n", (pid_t)val);
2389                                 return 0;
2390                         }
2391                 }
2392                 kdb_set_current_task(p);
2393         }
2394         kdb_printf("KDB current process is %s(pid=%d)\n",
2395                    kdb_current_task->comm,
2396                    kdb_current_task->pid);
2397
2398         return 0;
2399 }
2400
2401 static int kdb_kgdb(int argc, const char **argv)
2402 {
2403         return KDB_CMD_KGDB;
2404 }
2405
2406 /*
2407  * kdb_help - This function implements the 'help' and '?' commands.
2408  */
2409 static int kdb_help(int argc, const char **argv)
2410 {
2411         kdbtab_t *kt;
2412         int i;
2413
2414         kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2415         kdb_printf("-----------------------------"
2416                    "-----------------------------\n");
2417         for_each_kdbcmd(kt, i) {
2418                 char *space = "";
2419                 if (KDB_FLAG(CMD_INTERRUPT))
2420                         return 0;
2421                 if (!kt->cmd_name)
2422                         continue;
2423                 if (!kdb_check_flags(kt->cmd_flags, kdb_cmd_enabled, true))
2424                         continue;
2425                 if (strlen(kt->cmd_usage) > 20)
2426                         space = "\n                                    ";
2427                 kdb_printf("%-15.15s %-20s%s%s\n", kt->cmd_name,
2428                            kt->cmd_usage, space, kt->cmd_help);
2429         }
2430         return 0;
2431 }
2432
2433 /*
2434  * kdb_kill - This function implements the 'kill' commands.
2435  */
2436 static int kdb_kill(int argc, const char **argv)
2437 {
2438         long sig, pid;
2439         char *endp;
2440         struct task_struct *p;
2441         struct siginfo info;
2442
2443         if (argc != 2)
2444                 return KDB_ARGCOUNT;
2445
2446         sig = simple_strtol(argv[1], &endp, 0);
2447         if (*endp)
2448                 return KDB_BADINT;
2449         if (sig >= 0) {
2450                 kdb_printf("Invalid signal parameter.<-signal>\n");
2451                 return 0;
2452         }
2453         sig = -sig;
2454
2455         pid = simple_strtol(argv[2], &endp, 0);
2456         if (*endp)
2457                 return KDB_BADINT;
2458         if (pid <= 0) {
2459                 kdb_printf("Process ID must be large than 0.\n");
2460                 return 0;
2461         }
2462
2463         /* Find the process. */
2464         p = find_task_by_pid_ns(pid, &init_pid_ns);
2465         if (!p) {
2466                 kdb_printf("The specified process isn't found.\n");
2467                 return 0;
2468         }
2469         p = p->group_leader;
2470         info.si_signo = sig;
2471         info.si_errno = 0;
2472         info.si_code = SI_USER;
2473         info.si_pid = pid;  /* same capabilities as process being signalled */
2474         info.si_uid = 0;    /* kdb has root authority */
2475         kdb_send_sig_info(p, &info);
2476         return 0;
2477 }
2478
2479 struct kdb_tm {
2480         int tm_sec;     /* seconds */
2481         int tm_min;     /* minutes */
2482         int tm_hour;    /* hours */
2483         int tm_mday;    /* day of the month */
2484         int tm_mon;     /* month */
2485         int tm_year;    /* year */
2486 };
2487
2488 static void kdb_gmtime(struct timespec *tv, struct kdb_tm *tm)
2489 {
2490         /* This will work from 1970-2099, 2100 is not a leap year */
2491         static int mon_day[] = { 31, 29, 31, 30, 31, 30, 31,
2492                                  31, 30, 31, 30, 31 };
2493         memset(tm, 0, sizeof(*tm));
2494         tm->tm_sec  = tv->tv_sec % (24 * 60 * 60);
2495         tm->tm_mday = tv->tv_sec / (24 * 60 * 60) +
2496                 (2 * 365 + 1); /* shift base from 1970 to 1968 */
2497         tm->tm_min =  tm->tm_sec / 60 % 60;
2498         tm->tm_hour = tm->tm_sec / 60 / 60;
2499         tm->tm_sec =  tm->tm_sec % 60;
2500         tm->tm_year = 68 + 4*(tm->tm_mday / (4*365+1));
2501         tm->tm_mday %= (4*365+1);
2502         mon_day[1] = 29;
2503         while (tm->tm_mday >= mon_day[tm->tm_mon]) {
2504                 tm->tm_mday -= mon_day[tm->tm_mon];
2505                 if (++tm->tm_mon == 12) {
2506                         tm->tm_mon = 0;
2507                         ++tm->tm_year;
2508                         mon_day[1] = 28;
2509                 }
2510         }
2511         ++tm->tm_mday;
2512 }
2513
2514 /*
2515  * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2516  * I cannot call that code directly from kdb, it has an unconditional
2517  * cli()/sti() and calls routines that take locks which can stop the debugger.
2518  */
2519 static void kdb_sysinfo(struct sysinfo *val)
2520 {
2521         struct timespec uptime;
2522         ktime_get_ts(&uptime);
2523         memset(val, 0, sizeof(*val));
2524         val->uptime = uptime.tv_sec;
2525         val->loads[0] = avenrun[0];
2526         val->loads[1] = avenrun[1];
2527         val->loads[2] = avenrun[2];
2528         val->procs = nr_threads-1;
2529         si_meminfo(val);
2530
2531         return;
2532 }
2533
2534 /*
2535  * kdb_summary - This function implements the 'summary' command.
2536  */
2537 static int kdb_summary(int argc, const char **argv)
2538 {
2539         struct timespec now;
2540         struct kdb_tm tm;
2541         struct sysinfo val;
2542
2543         if (argc)
2544                 return KDB_ARGCOUNT;
2545
2546         kdb_printf("sysname    %s\n", init_uts_ns.name.sysname);
2547         kdb_printf("release    %s\n", init_uts_ns.name.release);
2548         kdb_printf("version    %s\n", init_uts_ns.name.version);
2549         kdb_printf("machine    %s\n", init_uts_ns.name.machine);
2550         kdb_printf("nodename   %s\n", init_uts_ns.name.nodename);
2551         kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2552         kdb_printf("ccversion  %s\n", __stringify(CCVERSION));
2553
2554         now = __current_kernel_time();
2555         kdb_gmtime(&now, &tm);
2556         kdb_printf("date       %04d-%02d-%02d %02d:%02d:%02d "
2557                    "tz_minuteswest %d\n",
2558                 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2559                 tm.tm_hour, tm.tm_min, tm.tm_sec,
2560                 sys_tz.tz_minuteswest);
2561
2562         kdb_sysinfo(&val);
2563         kdb_printf("uptime     ");
2564         if (val.uptime > (24*60*60)) {
2565                 int days = val.uptime / (24*60*60);
2566                 val.uptime %= (24*60*60);
2567                 kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2568         }
2569         kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2570
2571         /* lifted from fs/proc/proc_misc.c::loadavg_read_proc() */
2572
2573 #define LOAD_INT(x) ((x) >> FSHIFT)
2574 #define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
2575         kdb_printf("load avg   %ld.%02ld %ld.%02ld %ld.%02ld\n",
2576                 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2577                 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2578                 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2579 #undef LOAD_INT
2580 #undef LOAD_FRAC
2581         /* Display in kilobytes */
2582 #define K(x) ((x) << (PAGE_SHIFT - 10))
2583         kdb_printf("\nMemTotal:       %8lu kB\nMemFree:        %8lu kB\n"
2584                    "Buffers:        %8lu kB\n",
2585                    K(val.totalram), K(val.freeram), K(val.bufferram));
2586         return 0;
2587 }
2588
2589 /*
2590  * kdb_per_cpu - This function implements the 'per_cpu' command.
2591  */
2592 static int kdb_per_cpu(int argc, const char **argv)
2593 {
2594         char fmtstr[64];
2595         int cpu, diag, nextarg = 1;
2596         unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2597
2598         if (argc < 1 || argc > 3)
2599                 return KDB_ARGCOUNT;
2600
2601         diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2602         if (diag)
2603                 return diag;
2604
2605         if (argc >= 2) {
2606                 diag = kdbgetularg(argv[2], &bytesperword);
2607                 if (diag)
2608                         return diag;
2609         }
2610         if (!bytesperword)
2611                 bytesperword = KDB_WORD_SIZE;
2612         else if (bytesperword > KDB_WORD_SIZE)
2613                 return KDB_BADWIDTH;
2614         sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2615         if (argc >= 3) {
2616                 diag = kdbgetularg(argv[3], &whichcpu);
2617                 if (diag)
2618                         return diag;
2619                 if (!cpu_online(whichcpu)) {
2620                         kdb_printf("cpu %ld is not online\n", whichcpu);
2621                         return KDB_BADCPUNUM;
2622                 }
2623         }
2624
2625         /* Most architectures use __per_cpu_offset[cpu], some use
2626          * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2627          */
2628 #ifdef  __per_cpu_offset
2629 #define KDB_PCU(cpu) __per_cpu_offset(cpu)
2630 #else
2631 #ifdef  CONFIG_SMP
2632 #define KDB_PCU(cpu) __per_cpu_offset[cpu]
2633 #else
2634 #define KDB_PCU(cpu) 0
2635 #endif
2636 #endif
2637         for_each_online_cpu(cpu) {
2638                 if (KDB_FLAG(CMD_INTERRUPT))
2639                         return 0;
2640
2641                 if (whichcpu != ~0UL && whichcpu != cpu)
2642                         continue;
2643                 addr = symaddr + KDB_PCU(cpu);
2644                 diag = kdb_getword(&val, addr, bytesperword);
2645                 if (diag) {
2646                         kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2647                                    "read, diag=%d\n", cpu, addr, diag);
2648                         continue;
2649                 }
2650                 kdb_printf("%5d ", cpu);
2651                 kdb_md_line(fmtstr, addr,
2652                         bytesperword == KDB_WORD_SIZE,
2653                         1, bytesperword, 1, 1, 0);
2654         }
2655 #undef KDB_PCU
2656         return 0;
2657 }
2658
2659 /*
2660  * display help for the use of cmd | grep pattern
2661  */
2662 static int kdb_grep_help(int argc, const char **argv)
2663 {
2664         kdb_printf("Usage of  cmd args | grep pattern:\n");
2665         kdb_printf("  Any command's output may be filtered through an ");
2666         kdb_printf("emulated 'pipe'.\n");
2667         kdb_printf("  'grep' is just a key word.\n");
2668         kdb_printf("  The pattern may include a very limited set of "
2669                    "metacharacters:\n");
2670         kdb_printf("   pattern or ^pattern or pattern$ or ^pattern$\n");
2671         kdb_printf("  And if there are spaces in the pattern, you may "
2672                    "quote it:\n");
2673         kdb_printf("   \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2674                    " or \"^pat tern$\"\n");
2675         return 0;
2676 }
2677
2678 /*
2679  * kdb_register_flags - This function is used to register a kernel
2680  *      debugger command.
2681  * Inputs:
2682  *      cmd     Command name
2683  *      func    Function to execute the command
2684  *      usage   A simple usage string showing arguments
2685  *      help    A simple help string describing command
2686  *      repeat  Does the command auto repeat on enter?
2687  * Returns:
2688  *      zero for success, one if a duplicate command.
2689  */
2690 #define kdb_command_extend 50   /* arbitrary */
2691 int kdb_register_flags(char *cmd,
2692                        kdb_func_t func,
2693                        char *usage,
2694                        char *help,
2695                        short minlen,
2696                        kdb_cmdflags_t flags)
2697 {
2698         int i;
2699         kdbtab_t *kp;
2700
2701         /*
2702          *  Brute force method to determine duplicates
2703          */
2704         for_each_kdbcmd(kp, i) {
2705                 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2706                         kdb_printf("Duplicate kdb command registered: "
2707                                 "%s, func %p help %s\n", cmd, func, help);
2708                         return 1;
2709                 }
2710         }
2711
2712         /*
2713          * Insert command into first available location in table
2714          */
2715         for_each_kdbcmd(kp, i) {
2716                 if (kp->cmd_name == NULL)
2717                         break;
2718         }
2719
2720         if (i >= kdb_max_commands) {
2721                 kdbtab_t *new = kmalloc((kdb_max_commands - KDB_BASE_CMD_MAX +
2722                          kdb_command_extend) * sizeof(*new), GFP_KDB);
2723                 if (!new) {
2724                         kdb_printf("Could not allocate new kdb_command "
2725                                    "table\n");
2726                         return 1;
2727                 }
2728                 if (kdb_commands) {
2729                         memcpy(new, kdb_commands,
2730                           (kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new));
2731                         kfree(kdb_commands);
2732                 }
2733                 memset(new + kdb_max_commands - KDB_BASE_CMD_MAX, 0,
2734                        kdb_command_extend * sizeof(*new));
2735                 kdb_commands = new;
2736                 kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX;
2737                 kdb_max_commands += kdb_command_extend;
2738         }
2739
2740         kp->cmd_name   = cmd;
2741         kp->cmd_func   = func;
2742         kp->cmd_usage  = usage;
2743         kp->cmd_help   = help;
2744         kp->cmd_minlen = minlen;
2745         kp->cmd_flags  = flags;
2746
2747         return 0;
2748 }
2749 EXPORT_SYMBOL_GPL(kdb_register_flags);
2750
2751
2752 /*
2753  * kdb_register - Compatibility register function for commands that do
2754  *      not need to specify a repeat state.  Equivalent to
2755  *      kdb_register_flags with flags set to 0.
2756  * Inputs:
2757  *      cmd     Command name
2758  *      func    Function to execute the command
2759  *      usage   A simple usage string showing arguments
2760  *      help    A simple help string describing command
2761  * Returns:
2762  *      zero for success, one if a duplicate command.
2763  */
2764 int kdb_register(char *cmd,
2765              kdb_func_t func,
2766              char *usage,
2767              char *help,
2768              short minlen)
2769 {
2770         return kdb_register_flags(cmd, func, usage, help, minlen, 0);
2771 }
2772 EXPORT_SYMBOL_GPL(kdb_register);
2773
2774 /*
2775  * kdb_unregister - This function is used to unregister a kernel
2776  *      debugger command.  It is generally called when a module which
2777  *      implements kdb commands is unloaded.
2778  * Inputs:
2779  *      cmd     Command name
2780  * Returns:
2781  *      zero for success, one command not registered.
2782  */
2783 int kdb_unregister(char *cmd)
2784 {
2785         int i;
2786         kdbtab_t *kp;
2787
2788         /*
2789          *  find the command.
2790          */
2791         for_each_kdbcmd(kp, i) {
2792                 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2793                         kp->cmd_name = NULL;
2794                         return 0;
2795                 }
2796         }
2797
2798         /* Couldn't find it.  */
2799         return 1;
2800 }
2801 EXPORT_SYMBOL_GPL(kdb_unregister);
2802
2803 /* Initialize the kdb command table. */
2804 static void __init kdb_inittab(void)
2805 {
2806         int i;
2807         kdbtab_t *kp;
2808
2809         for_each_kdbcmd(kp, i)
2810                 kp->cmd_name = NULL;
2811
2812         kdb_register_flags("md", kdb_md, "<vaddr>",
2813           "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2814           KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2815         kdb_register_flags("mdr", kdb_md, "<vaddr> <bytes>",
2816           "Display Raw Memory", 0,
2817           KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2818         kdb_register_flags("mdp", kdb_md, "<paddr> <bytes>",
2819           "Display Physical Memory", 0,
2820           KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2821         kdb_register_flags("mds", kdb_md, "<vaddr>",
2822           "Display Memory Symbolically", 0,
2823           KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2824         kdb_register_flags("mm", kdb_mm, "<vaddr> <contents>",
2825           "Modify Memory Contents", 0,
2826           KDB_ENABLE_MEM_WRITE | KDB_REPEAT_NO_ARGS);
2827         kdb_register_flags("go", kdb_go, "[<vaddr>]",
2828           "Continue Execution", 1,
2829           KDB_ENABLE_REG_WRITE | KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
2830         kdb_register_flags("rd", kdb_rd, "",
2831           "Display Registers", 0,
2832           KDB_ENABLE_REG_READ);
2833         kdb_register_flags("rm", kdb_rm, "<reg> <contents>",
2834           "Modify Registers", 0,
2835           KDB_ENABLE_REG_WRITE);
2836         kdb_register_flags("ef", kdb_ef, "<vaddr>",
2837           "Display exception frame", 0,
2838           KDB_ENABLE_MEM_READ);
2839         kdb_register_flags("bt", kdb_bt, "[<vaddr>]",
2840           "Stack traceback", 1,
2841           KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS);
2842         kdb_register_flags("btp", kdb_bt, "<pid>",
2843           "Display stack for process <pid>", 0,
2844           KDB_ENABLE_INSPECT);
2845         kdb_register_flags("bta", kdb_bt, "[D|R|S|T|C|Z|E|U|I|M|A]",
2846           "Backtrace all processes matching state flag", 0,
2847           KDB_ENABLE_INSPECT);
2848         kdb_register_flags("btc", kdb_bt, "",
2849           "Backtrace current process on each cpu", 0,
2850           KDB_ENABLE_INSPECT);
2851         kdb_register_flags("btt", kdb_bt, "<vaddr>",
2852           "Backtrace process given its struct task address", 0,
2853           KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS);
2854         kdb_register_flags("env", kdb_env, "",
2855           "Show environment variables", 0,
2856           KDB_ENABLE_ALWAYS_SAFE);
2857         kdb_register_flags("set", kdb_set, "",
2858           "Set environment variables", 0,
2859           KDB_ENABLE_ALWAYS_SAFE);
2860         kdb_register_flags("help", kdb_help, "",
2861           "Display Help Message", 1,
2862           KDB_ENABLE_ALWAYS_SAFE);
2863         kdb_register_flags("?", kdb_help, "",
2864           "Display Help Message", 0,
2865           KDB_ENABLE_ALWAYS_SAFE);
2866         kdb_register_flags("cpu", kdb_cpu, "<cpunum>",
2867           "Switch to new cpu", 0,
2868           KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
2869         kdb_register_flags("kgdb", kdb_kgdb, "",
2870           "Enter kgdb mode", 0, 0);
2871         kdb_register_flags("ps", kdb_ps, "[<flags>|A]",
2872           "Display active task list", 0,
2873           KDB_ENABLE_INSPECT);
2874         kdb_register_flags("pid", kdb_pid, "<pidnum>",
2875           "Switch to another task", 0,
2876           KDB_ENABLE_INSPECT);
2877         kdb_register_flags("reboot", kdb_reboot, "",
2878           "Reboot the machine immediately", 0,
2879           KDB_ENABLE_REBOOT);
2880 #if defined(CONFIG_MODULES)
2881         kdb_register_flags("lsmod", kdb_lsmod, "",
2882           "List loaded kernel modules", 0,
2883           KDB_ENABLE_INSPECT);
2884 #endif
2885 #if defined(CONFIG_MAGIC_SYSRQ)
2886         kdb_register_flags("sr", kdb_sr, "<key>",
2887           "Magic SysRq key", 0,
2888           KDB_ENABLE_ALWAYS_SAFE);
2889 #endif
2890 #if defined(CONFIG_PRINTK)
2891         kdb_register_flags("dmesg", kdb_dmesg, "[lines]",
2892           "Display syslog buffer", 0,
2893           KDB_ENABLE_ALWAYS_SAFE);
2894 #endif
2895         if (arch_kgdb_ops.enable_nmi) {
2896                 kdb_register_flags("disable_nmi", kdb_disable_nmi, "",
2897                   "Disable NMI entry to KDB", 0,
2898                   KDB_ENABLE_ALWAYS_SAFE);
2899         }
2900         kdb_register_flags("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
2901           "Define a set of commands, down to endefcmd", 0,
2902           KDB_ENABLE_ALWAYS_SAFE);
2903         kdb_register_flags("kill", kdb_kill, "<-signal> <pid>",
2904           "Send a signal to a process", 0,
2905           KDB_ENABLE_SIGNAL);
2906         kdb_register_flags("summary", kdb_summary, "",
2907           "Summarize the system", 4,
2908           KDB_ENABLE_ALWAYS_SAFE);
2909         kdb_register_flags("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
2910           "Display per_cpu variables", 3,
2911           KDB_ENABLE_MEM_READ);
2912         kdb_register_flags("grephelp", kdb_grep_help, "",
2913           "Display help on | grep", 0,
2914           KDB_ENABLE_ALWAYS_SAFE);
2915 }
2916
2917 /* Execute any commands defined in kdb_cmds.  */
2918 static void __init kdb_cmd_init(void)
2919 {
2920         int i, diag;
2921         for (i = 0; kdb_cmds[i]; ++i) {
2922                 diag = kdb_parse(kdb_cmds[i]);
2923                 if (diag)
2924                         kdb_printf("kdb command %s failed, kdb diag %d\n",
2925                                 kdb_cmds[i], diag);
2926         }
2927         if (defcmd_in_progress) {
2928                 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2929                 kdb_parse("endefcmd");
2930         }
2931 }
2932
2933 /* Initialize kdb_printf, breakpoint tables and kdb state */
2934 void __init kdb_init(int lvl)
2935 {
2936         static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2937         int i;
2938
2939         if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2940                 return;
2941         for (i = kdb_init_lvl; i < lvl; i++) {
2942                 switch (i) {
2943                 case KDB_NOT_INITIALIZED:
2944                         kdb_inittab();          /* Initialize Command Table */
2945                         kdb_initbptab();        /* Initialize Breakpoints */
2946                         break;
2947                 case KDB_INIT_EARLY:
2948                         kdb_cmd_init();         /* Build kdb_cmds tables */
2949                         break;
2950                 }
2951         }
2952         kdb_init_lvl = lvl;
2953 }