kernel/debug/kdb/kdb_main.c

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