kernel/debug/kdb/kdb_main.c

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