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