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