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