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