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