kernel/debug/kdb/kdb

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

DEFINITIONS
