LCOV - code coverage report
Current view: top level - kernel/debug/kdb - kdb_main.c (source / functions) Hit Total Coverage
Test: Real Lines: 165 1064 15.5 %
Date: 2020-10-17 15:46:43 Functions: 0 55 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       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                 :          0 : struct task_struct *kdb_curr_task(int cpu)
     191                 :            : {
     192                 :          0 :         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                 :          0 :         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                 :          3 :         permissions &= KDB_ENABLE_MASK;
     209                 :          3 :         permissions |= KDB_ENABLE_ALWAYS_SAFE;
     210                 :            : 
     211                 :            :         /* some commands change group when launched with no arguments */
     212                 :          3 :         if (no_args)
     213                 :          0 :                 permissions |= permissions << KDB_ENABLE_NO_ARGS_SHIFT;
     214                 :            : 
     215                 :          3 :         flags |= KDB_ENABLE_ALL;
     216                 :            : 
     217                 :          3 :         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                 :          0 : char *kdbgetenv(const char *match)
     230                 :            : {
     231                 :            :         char **ep = __env;
     232                 :          0 :         int matchlen = strlen(match);
     233                 :            :         int i;
     234                 :            : 
     235                 :          0 :         for (i = 0; i < __nenv; i++) {
     236                 :          0 :                 char *e = *ep++;
     237                 :            : 
     238                 :          0 :                 if (!e)
     239                 :          0 :                         continue;
     240                 :            : 
     241                 :          0 :                 if ((strncmp(match, e, matchlen) == 0)
     242                 :          0 :                  && ((e[matchlen] == '\0')
     243                 :          0 :                    || (e[matchlen] == '='))) {
     244                 :          0 :                         char *cp = strchr(e, '=');
     245                 :          0 :                         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                 :          0 :         if ((KDB_ENVBUFSIZE - envbufsize) >= bytes) {
     275                 :          0 :                 ep = &envbuffer[envbufsize];
     276                 :          0 :                 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                 :          0 : static int kdbgetulenv(const char *match, unsigned long *value)
     292                 :            : {
     293                 :            :         char *ep;
     294                 :            : 
     295                 :          0 :         ep = kdbgetenv(match);
     296                 :          0 :         if (!ep)
     297                 :            :                 return KDB_NOTENV;
     298                 :          0 :         if (strlen(ep) == 0)
     299                 :            :                 return KDB_NOENVVALUE;
     300                 :            : 
     301                 :          0 :         *value = simple_strtoul(ep, NULL, 0);
     302                 :            : 
     303                 :          0 :         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                 :          0 : int kdbgetintenv(const char *match, int *value)
     317                 :            : {
     318                 :            :         unsigned long val;
     319                 :            :         int diag;
     320                 :            : 
     321                 :          0 :         diag = kdbgetulenv(match, &val);
     322                 :          0 :         if (!diag)
     323                 :          0 :                 *value = (int) val;
     324                 :          0 :         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                 :          0 : int kdbgetularg(const char *arg, unsigned long *value)
     338                 :            : {
     339                 :            :         char *endp;
     340                 :            :         unsigned long val;
     341                 :            : 
     342                 :          0 :         val = simple_strtoul(arg, &endp, 0);
     343                 :            : 
     344                 :          0 :         if (endp == arg) {
     345                 :            :                 /*
     346                 :            :                  * Also try base 16, for us folks too lazy to type the
     347                 :            :                  * leading 0x...
     348                 :            :                  */
     349                 :          0 :                 val = simple_strtoul(arg, &endp, 16);
     350                 :          0 :                 if (endp == arg)
     351                 :            :                         return KDB_BADINT;
     352                 :            :         }
     353                 :            : 
     354                 :          0 :         *value = val;
     355                 :            : 
     356                 :          0 :         return 0;
     357                 :            : }
     358                 :            : 
     359                 :          0 : int kdbgetu64arg(const char *arg, u64 *value)
     360                 :            : {
     361                 :            :         char *endp;
     362                 :            :         u64 val;
     363                 :            : 
     364                 :          0 :         val = simple_strtoull(arg, &endp, 0);
     365                 :            : 
     366                 :          0 :         if (endp == arg) {
     367                 :            : 
     368                 :          0 :                 val = simple_strtoull(arg, &endp, 16);
     369                 :          0 :                 if (endp == arg)
     370                 :            :                         return KDB_BADINT;
     371                 :            :         }
     372                 :            : 
     373                 :          0 :         *value = val;
     374                 :            : 
     375                 :          0 :         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                 :          0 : 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                 :          0 :         if (argc == 3) {
     395                 :          0 :                 argv[2] = argv[3];
     396                 :          0 :                 argc--;
     397                 :            :         }
     398                 :            : 
     399                 :          0 :         if (argc != 2)
     400                 :            :                 return KDB_ARGCOUNT;
     401                 :            : 
     402                 :            :         /*
     403                 :            :          * Check for internal variables
     404                 :            :          */
     405                 :          0 :         if (strcmp(argv[1], "KDBDEBUG") == 0) {
     406                 :            :                 unsigned int debugflags;
     407                 :            :                 char *cp;
     408                 :            : 
     409                 :          0 :                 debugflags = simple_strtoul(argv[2], &cp, 0);
     410                 :          0 :                 if (cp == argv[2] || debugflags & ~KDB_DEBUG_FLAG_MASK) {
     411                 :          0 :                         kdb_printf("kdb: illegal debug flags '%s'\n",
     412                 :            :                                     argv[2]);
     413                 :          0 :                         return 0;
     414                 :            :                 }
     415                 :          0 :                 kdb_flags = (kdb_flags &
     416                 :            :                              ~(KDB_DEBUG_FLAG_MASK << KDB_DEBUG_FLAG_SHIFT))
     417                 :          0 :                         | (debugflags << KDB_DEBUG_FLAG_SHIFT);
     418                 :            : 
     419                 :          0 :                 return 0;
     420                 :            :         }
     421                 :            : 
     422                 :            :         /*
     423                 :            :          * Tokenizer squashed the '=' sign.  argv[1] is variable
     424                 :            :          * name, argv[2] = value.
     425                 :            :          */
     426                 :          0 :         varlen = strlen(argv[1]);
     427                 :          0 :         vallen = strlen(argv[2]);
     428                 :          0 :         ep = kdballocenv(varlen + vallen + 2);
     429                 :          0 :         if (ep == (char *)0)
     430                 :            :                 return KDB_ENVBUFFULL;
     431                 :            : 
     432                 :          0 :         sprintf(ep, "%s=%s", argv[1], argv[2]);
     433                 :            : 
     434                 :          0 :         ep[varlen+vallen+1] = '\0';
     435                 :            : 
     436                 :          0 :         for (i = 0; i < __nenv; i++) {
     437                 :          0 :                 if (__env[i]
     438                 :          0 :                  && ((strncmp(__env[i], argv[1], varlen) == 0)
     439                 :          0 :                    && ((__env[i][varlen] == '\0')
     440                 :          0 :                     || (__env[i][varlen] == '=')))) {
     441                 :          0 :                         __env[i] = ep;
     442                 :          0 :                         return 0;
     443                 :            :                 }
     444                 :            :         }
     445                 :            : 
     446                 :            :         /*
     447                 :            :          * Wasn't existing variable.  Fit into slot.
     448                 :            :          */
     449                 :          0 :         for (i = 0; i < __nenv-1; i++) {
     450                 :          0 :                 if (__env[i] == (char *)0) {
     451                 :          0 :                         __env[i] = ep;
     452                 :          0 :                         return 0;
     453                 :            :                 }
     454                 :            :         }
     455                 :            : 
     456                 :            :         return KDB_ENVFULL;
     457                 :            : }
     458                 :            : 
     459                 :            : static int kdb_check_regs(void)
     460                 :            : {
     461                 :          0 :         if (!kdb_current_regs) {
     462                 :          0 :                 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                 :          0 : int kdbgetaddrarg(int argc, const char **argv, int *nextarg,
     495                 :            :                   unsigned long *value,  long *offset,
     496                 :            :                   char **name)
     497                 :            : {
     498                 :            :         unsigned long addr;
     499                 :          0 :         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                 :          0 :         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                 :          0 :         if (*nextarg > argc)
     526                 :            :                 return KDB_ARGCOUNT;
     527                 :            : 
     528                 :          0 :         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                 :          0 :         cp = strpbrk(symname, "+-");
     537                 :          0 :         if (cp != NULL) {
     538                 :          0 :                 symbol = *cp;
     539                 :          0 :                 *cp++ = '\0';
     540                 :            :         }
     541                 :            : 
     542                 :          0 :         if (symname[0] == '$') {
     543                 :          0 :                 diag = kdbgetulenv(&symname[1], &addr);
     544                 :          0 :                 if (diag)
     545                 :            :                         return diag;
     546                 :          0 :         } else if (symname[0] == '%') {
     547                 :            :                 diag = kdb_check_regs();
     548                 :          0 :                 if (diag)
     549                 :          0 :                         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                 :          0 :                 found = kdbgetsymval(symname, &symtab);
     556                 :          0 :                 if (found) {
     557                 :          0 :                         addr = symtab.sym_start;
     558                 :            :                 } else {
     559                 :          0 :                         diag = kdbgetularg(argv[*nextarg], &addr);
     560                 :          0 :                         if (diag)
     561                 :            :                                 return diag;
     562                 :            :                 }
     563                 :            :         }
     564                 :            : 
     565                 :          0 :         if (!found)
     566                 :          0 :                 found = kdbnearsym(addr, &symtab);
     567                 :            : 
     568                 :          0 :         (*nextarg)++;
     569                 :            : 
     570                 :          0 :         if (name)
     571                 :          0 :                 *name = symname;
     572                 :          0 :         if (value)
     573                 :          0 :                 *value = addr;
     574                 :          0 :         if (offset && name && *name)
     575                 :          0 :                 *offset = addr - symtab.sym_start;
     576                 :            : 
     577                 :          0 :         if ((*nextarg > argc)
     578                 :          0 :          && (symbol == '\0'))
     579                 :            :                 return 0;
     580                 :            : 
     581                 :            :         /*
     582                 :            :          * check for +/- and offset
     583                 :            :          */
     584                 :            : 
     585                 :          0 :         if (symbol == '\0') {
     586                 :          0 :                 if ((argv[*nextarg][0] != '+')
     587                 :          0 :                  && (argv[*nextarg][0] != '-')) {
     588                 :            :                         /*
     589                 :            :                          * Not our argument.  Return.
     590                 :            :                          */
     591                 :            :                         return 0;
     592                 :            :                 } else {
     593                 :          0 :                         positive = (argv[*nextarg][0] == '+');
     594                 :          0 :                         (*nextarg)++;
     595                 :            :                 }
     596                 :            :         } else
     597                 :          0 :                 positive = (symbol == '+');
     598                 :            : 
     599                 :            :         /*
     600                 :            :          * Now there must be an offset!
     601                 :            :          */
     602                 :          0 :         if ((*nextarg > argc)
     603                 :          0 :          && (symbol == '\0')) {
     604                 :            :                 return KDB_INVADDRFMT;
     605                 :            :         }
     606                 :            : 
     607                 :          0 :         if (!symbol) {
     608                 :          0 :                 cp = (char *)argv[*nextarg];
     609                 :          0 :                 (*nextarg)++;
     610                 :            :         }
     611                 :            : 
     612                 :          0 :         diag = kdbgetularg(cp, &off);
     613                 :          0 :         if (diag)
     614                 :            :                 return diag;
     615                 :            : 
     616                 :          0 :         if (!positive)
     617                 :          0 :                 off = -off;
     618                 :            : 
     619                 :          0 :         if (offset)
     620                 :          0 :                 *offset += off;
     621                 :            : 
     622                 :          0 :         if (value)
     623                 :          0 :                 *value += off;
     624                 :            : 
     625                 :            :         return 0;
     626                 :            : }
     627                 :            : 
     628                 :          0 : static void kdb_cmderror(int diag)
     629                 :            : {
     630                 :            :         int i;
     631                 :            : 
     632                 :          0 :         if (diag >= 0) {
     633                 :          0 :                 kdb_printf("no error detected (diagnostic is %d)\n", diag);
     634                 :          0 :                 return;
     635                 :            :         }
     636                 :            : 
     637                 :          0 :         for (i = 0; i < __nkdb_err; i++) {
     638                 :          0 :                 if (kdbmsgs[i].km_diag == diag) {
     639                 :          0 :                         kdb_printf("diag: %d: %s\n", diag, kdbmsgs[i].km_msg);
     640                 :          0 :                         return;
     641                 :            :                 }
     642                 :            :         }
     643                 :            : 
     644                 :          0 :         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                 :          3 : static int kdb_defcmd2(const char *cmdstr, const char *argv0)
     675                 :            : {
     676                 :          3 :         struct defcmd_set *s = defcmd_set + defcmd_set_count - 1;
     677                 :          3 :         char **save_command = s->command;
     678                 :          3 :         if (strcmp(argv0, "endefcmd") == 0) {
     679                 :          3 :                 defcmd_in_progress = false;
     680                 :          3 :                 if (!s->count)
     681                 :          0 :                         s->usable = false;
     682                 :          3 :                 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                 :          3 :                         kdb_register_flags(s->name, kdb_exec_defcmd, s->usage,
     688                 :            :                                            s->help, 0,
     689                 :            :                                            KDB_ENABLE_ALWAYS_SAFE);
     690                 :            :                 return 0;
     691                 :            :         }
     692                 :          3 :         if (!s->usable)
     693                 :            :                 return KDB_NOTIMP;
     694                 :          3 :         s->command = kcalloc(s->count + 1, sizeof(*(s->command)), GFP_KDB);
     695                 :          3 :         if (!s->command) {
     696                 :          0 :                 kdb_printf("Could not allocate new kdb_defcmd table for %s\n",
     697                 :            :                            cmdstr);
     698                 :          0 :                 s->usable = false;
     699                 :          0 :                 return KDB_NOTIMP;
     700                 :            :         }
     701                 :          3 :         memcpy(s->command, save_command, s->count * sizeof(*(s->command)));
     702                 :          3 :         s->command[s->count++] = kdb_strdup(cmdstr, GFP_KDB);
     703                 :          3 :         kfree(save_command);
     704                 :          3 :         return 0;
     705                 :            : }
     706                 :            : 
     707                 :          3 : static int kdb_defcmd(int argc, const char **argv)
     708                 :            : {
     709                 :          3 :         struct defcmd_set *save_defcmd_set = defcmd_set, *s;
     710                 :          3 :         if (defcmd_in_progress) {
     711                 :          0 :                 kdb_printf("kdb: nested defcmd detected, assuming missing "
     712                 :            :                            "endefcmd\n");
     713                 :          0 :                 kdb_defcmd2("endefcmd", "endefcmd");
     714                 :            :         }
     715                 :          3 :         if (argc == 0) {
     716                 :            :                 int i;
     717                 :          0 :                 for (s = defcmd_set; s < defcmd_set + defcmd_set_count; ++s) {
     718                 :          0 :                         kdb_printf("defcmd %s \"%s\" \"%s\"\n", s->name,
     719                 :            :                                    s->usage, s->help);
     720                 :          0 :                         for (i = 0; i < s->count; ++i)
     721                 :          0 :                                 kdb_printf("%s", s->command[i]);
     722                 :          0 :                         kdb_printf("endefcmd\n");
     723                 :            :                 }
     724                 :            :                 return 0;
     725                 :            :         }
     726                 :          3 :         if (argc != 3)
     727                 :            :                 return KDB_ARGCOUNT;
     728                 :          3 :         if (in_dbg_master()) {
     729                 :          0 :                 kdb_printf("Command only available during kdb_init()\n");
     730                 :          0 :                 return KDB_NOTIMP;
     731                 :            :         }
     732                 :          3 :         defcmd_set = kmalloc_array(defcmd_set_count + 1, sizeof(*defcmd_set),
     733                 :          3 :                                    GFP_KDB);
     734                 :          3 :         if (!defcmd_set)
     735                 :            :                 goto fail_defcmd;
     736                 :          3 :         memcpy(defcmd_set, save_defcmd_set,
     737                 :            :                defcmd_set_count * sizeof(*defcmd_set));
     738                 :          3 :         s = defcmd_set + defcmd_set_count;
     739                 :          3 :         memset(s, 0, sizeof(*s));
     740                 :          3 :         s->usable = true;
     741                 :          3 :         s->name = kdb_strdup(argv[1], GFP_KDB);
     742                 :          3 :         if (!s->name)
     743                 :            :                 goto fail_name;
     744                 :          3 :         s->usage = kdb_strdup(argv[2], GFP_KDB);
     745                 :          3 :         if (!s->usage)
     746                 :            :                 goto fail_usage;
     747                 :          3 :         s->help = kdb_strdup(argv[3], GFP_KDB);
     748                 :          3 :         if (!s->help)
     749                 :            :                 goto fail_help;
     750                 :          3 :         if (s->usage[0] == '"') {
     751                 :          3 :                 strcpy(s->usage, argv[2]+1);
     752                 :          3 :                 s->usage[strlen(s->usage)-1] = '\0';
     753                 :            :         }
     754                 :          3 :         if (s->help[0] == '"') {
     755                 :          3 :                 strcpy(s->help, argv[3]+1);
     756                 :          3 :                 s->help[strlen(s->help)-1] = '\0';
     757                 :            :         }
     758                 :          3 :         ++defcmd_set_count;
     759                 :          3 :         defcmd_in_progress = true;
     760                 :          3 :         kfree(save_defcmd_set);
     761                 :          3 :         return 0;
     762                 :            : fail_help:
     763                 :          0 :         kfree(s->usage);
     764                 :            : fail_usage:
     765                 :          0 :         kfree(s->name);
     766                 :            : fail_name:
     767                 :          0 :         kfree(defcmd_set);
     768                 :            : fail_defcmd:
     769                 :          0 :         kdb_printf("Could not allocate new defcmd_set entry for %s\n", argv[1]);
     770                 :          0 :         defcmd_set = save_defcmd_set;
     771                 :          0 :         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                 :          0 : static int kdb_exec_defcmd(int argc, const char **argv)
     784                 :            : {
     785                 :            :         int i, ret;
     786                 :            :         struct defcmd_set *s;
     787                 :          0 :         if (argc != 0)
     788                 :            :                 return KDB_ARGCOUNT;
     789                 :          0 :         for (s = defcmd_set, i = 0; i < defcmd_set_count; ++i, ++s) {
     790                 :          0 :                 if (strcmp(s->name, argv[0]) == 0)
     791                 :            :                         break;
     792                 :            :         }
     793                 :          0 :         if (i == defcmd_set_count) {
     794                 :          0 :                 kdb_printf("kdb_exec_defcmd: could not find commands for %s\n",
     795                 :            :                            argv[0]);
     796                 :          0 :                 return KDB_NOTIMP;
     797                 :            :         }
     798                 :          0 :         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                 :          0 :                 kdb_printf("[%s]kdb> %s\n", s->name, s->command[i]);
     803                 :          0 :                 ret = kdb_parse(s->command[i]);
     804                 :          0 :                 if (ret)
     805                 :          0 :                         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                 :          0 : 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                 :          0 :         if (*cp != '|')
     829                 :            :                 return;
     830                 :          0 :         cp++;
     831                 :          0 :         while (isspace(*cp))
     832                 :          0 :                 cp++;
     833                 :          0 :         if (!str_has_prefix(cp, "grep ")) {
     834                 :          0 :                 kdb_printf("invalid 'pipe', see grephelp\n");
     835                 :          0 :                 return;
     836                 :            :         }
     837                 :          0 :         cp += 5;
     838                 :          0 :         while (isspace(*cp))
     839                 :          0 :                 cp++;
     840                 :          0 :         cp2 = strchr(cp, '\n');
     841                 :          0 :         if (cp2)
     842                 :          0 :                 *cp2 = '\0'; /* remove the trailing newline */
     843                 :          0 :         len = strlen(cp);
     844                 :          0 :         if (len == 0) {
     845                 :          0 :                 kdb_printf("invalid 'pipe', see grephelp\n");
     846                 :          0 :                 return;
     847                 :            :         }
     848                 :            :         /* now cp points to a nonzero length search string */
     849                 :          0 :         if (*cp == '"') {
     850                 :            :                 /* allow it be "x y z" by removing the "'s - there must
     851                 :            :                    be two of them */
     852                 :          0 :                 cp++;
     853                 :          0 :                 cp2 = strchr(cp, '"');
     854                 :          0 :                 if (!cp2) {
     855                 :          0 :                         kdb_printf("invalid quoted string, see grephelp\n");
     856                 :          0 :                         return;
     857                 :            :                 }
     858                 :          0 :                 *cp2 = '\0'; /* end the string where the 2nd " was */
     859                 :            :         }
     860                 :          0 :         kdb_grep_leading = 0;
     861                 :          0 :         if (*cp == '^') {
     862                 :          0 :                 kdb_grep_leading = 1;
     863                 :          0 :                 cp++;
     864                 :            :         }
     865                 :          0 :         len = strlen(cp);
     866                 :          0 :         kdb_grep_trailing = 0;
     867                 :          0 :         if (*(cp+len-1) == '$') {
     868                 :          0 :                 kdb_grep_trailing = 1;
     869                 :          0 :                 *(cp+len-1) = '\0';
     870                 :            :         }
     871                 :          0 :         len = strlen(cp);
     872                 :          0 :         if (!len)
     873                 :            :                 return;
     874                 :          0 :         if (len >= KDB_GREP_STRLEN) {
     875                 :          0 :                 kdb_printf("search string too long\n");
     876                 :          0 :                 return;
     877                 :            :         }
     878                 :          0 :         strcpy(kdb_grep_string, cp);
     879                 :          0 :         kdb_grepping_flag++;
     880                 :          0 :         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                 :          3 : 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                 :          3 :         if (KDB_FLAG(CMD_INTERRUPT)) {
     927                 :            :                 /* Previous command was interrupted, newline must not
     928                 :            :                  * repeat the command */
     929                 :          0 :                 KDB_FLAG_CLEAR(CMD_INTERRUPT);
     930                 :          0 :                 KDB_STATE_SET(PAGER);
     931                 :          0 :                 argc = 0;       /* no repeat */
     932                 :            :         }
     933                 :            : 
     934                 :          3 :         if (*cp != '\n' && *cp != '\0') {
     935                 :          3 :                 argc = 0;
     936                 :            :                 cpp = cbuf;
     937                 :          3 :                 while (*cp) {
     938                 :            :                         /* skip whitespace */
     939                 :          3 :                         while (isspace(*cp))
     940                 :          3 :                                 cp++;
     941                 :          3 :                         if ((*cp == '\0') || (*cp == '\n') ||
     942                 :          3 :                             (*cp == '#' && !defcmd_in_progress))
     943                 :            :                                 break;
     944                 :            :                         /* special case: check for | grep pattern */
     945                 :          3 :                         if (*cp == '|') {
     946                 :            :                                 check_grep++;
     947                 :            :                                 break;
     948                 :            :                         }
     949                 :          3 :                         if (cpp >= cbuf + CMD_BUFLEN) {
     950                 :          0 :                                 kdb_printf("kdb_parse: command buffer "
     951                 :            :                                            "overflow, command ignored\n%s\n",
     952                 :            :                                            cmdstr);
     953                 :          0 :                                 return KDB_NOTFOUND;
     954                 :            :                         }
     955                 :          3 :                         if (argc >= MAXARGC - 1) {
     956                 :          0 :                                 kdb_printf("kdb_parse: too many arguments, "
     957                 :            :                                            "command ignored\n%s\n", cmdstr);
     958                 :          0 :                                 return KDB_NOTFOUND;
     959                 :            :                         }
     960                 :          3 :                         argv[argc++] = cpp;
     961                 :            :                         escaped = 0;
     962                 :            :                         quoted = '\0';
     963                 :            :                         /* Copy to next unquoted and unescaped
     964                 :            :                          * whitespace or '=' */
     965                 :          3 :                         while (*cp && *cp != '\n' &&
     966                 :          3 :                                (escaped || quoted || !isspace(*cp))) {
     967                 :          3 :                                 if (cpp >= cbuf + CMD_BUFLEN)
     968                 :            :                                         break;
     969                 :          3 :                                 if (escaped) {
     970                 :            :                                         escaped = 0;
     971                 :          0 :                                         *cpp++ = *cp++;
     972                 :          0 :                                         continue;
     973                 :            :                                 }
     974                 :          3 :                                 if (*cp == '\\') {
     975                 :            :                                         escaped = 1;
     976                 :          0 :                                         ++cp;
     977                 :          0 :                                         continue;
     978                 :            :                                 }
     979                 :          3 :                                 if (*cp == quoted)
     980                 :            :                                         quoted = '\0';
     981                 :          3 :                                 else if (*cp == '\'' || *cp == '"')
     982                 :            :                                         quoted = *cp;
     983                 :          3 :                                 *cpp = *cp++;
     984                 :          3 :                                 if (*cpp == '=' && !quoted)
     985                 :            :                                         break;
     986                 :          3 :                                 ++cpp;
     987                 :            :                         }
     988                 :          3 :                         *cpp++ = '\0';  /* Squash a ws or '=' character */
     989                 :            :                 }
     990                 :            :         }
     991                 :          3 :         if (!argc)
     992                 :            :                 return 0;
     993                 :          3 :         if (check_grep)
     994                 :          0 :                 parse_grep(cp);
     995                 :          3 :         if (defcmd_in_progress) {
     996                 :          3 :                 int result = kdb_defcmd2(cmdstr, argv[0]);
     997                 :          3 :                 if (!defcmd_in_progress) {
     998                 :          3 :                         argc = 0;       /* avoid repeat on endefcmd */
     999                 :          3 :                         *(argv[0]) = '\0';
    1000                 :            :                 }
    1001                 :          3 :                 return result;
    1002                 :            :         }
    1003                 :          3 :         if (argv[0][0] == '-' && argv[0][1] &&
    1004                 :          0 :             (argv[0][1] < '0' || argv[0][1] > '9')) {
    1005                 :            :                 ignore_errors = 1;
    1006                 :          0 :                 ++argv[0];
    1007                 :            :         }
    1008                 :            : 
    1009                 :          3 :         for_each_kdbcmd(tp, i) {
    1010                 :          3 :                 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                 :          3 :                         if (tp->cmd_minlen
    1017                 :          3 :                          && (strlen(argv[0]) <= tp->cmd_minlen)) {
    1018                 :          0 :                                 if (strncmp(argv[0],
    1019                 :            :                                             tp->cmd_name,
    1020                 :            :                                             tp->cmd_minlen) == 0) {
    1021                 :            :                                         break;
    1022                 :            :                                 }
    1023                 :            :                         }
    1024                 :            : 
    1025                 :          3 :                         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                 :          3 :         if (i == kdb_max_commands) {
    1036                 :          0 :                 for_each_kdbcmd(tp, i) {
    1037                 :          0 :                         if (tp->cmd_name) {
    1038                 :          0 :                                 if (strncmp(argv[0],
    1039                 :            :                                             tp->cmd_name,
    1040                 :            :                                             strlen(tp->cmd_name)) == 0) {
    1041                 :            :                                         break;
    1042                 :            :                                 }
    1043                 :            :                         }
    1044                 :            :                 }
    1045                 :            :         }
    1046                 :            : 
    1047                 :          3 :         if (i < kdb_max_commands) {
    1048                 :            :                 int result;
    1049                 :            : 
    1050                 :          3 :                 if (!kdb_check_flags(tp->cmd_flags, kdb_cmd_enabled, argc <= 1))
    1051                 :            :                         return KDB_NOPERM;
    1052                 :            : 
    1053                 :          3 :                 KDB_STATE_SET(CMD);
    1054                 :          3 :                 result = (*tp->cmd_func)(argc-1, (const char **)argv);
    1055                 :          3 :                 if (result && ignore_errors && result > KDB_CMD_GO)
    1056                 :            :                         result = 0;
    1057                 :          3 :                 KDB_STATE_CLEAR(CMD);
    1058                 :            : 
    1059                 :          3 :                 if (tp->cmd_flags & KDB_REPEAT_WITH_ARGS)
    1060                 :            :                         return result;
    1061                 :            : 
    1062                 :          3 :                 argc = tp->cmd_flags & KDB_REPEAT_NO_ARGS ? 1 : 0;
    1063                 :          3 :                 if (argv[argc])
    1064                 :          3 :                         *(argv[argc]) = '\0';
    1065                 :          3 :                 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                 :          0 :                 char *name = NULL;
    1078                 :            :                 long offset;
    1079                 :          0 :                 int nextarg = 0;
    1080                 :            : 
    1081                 :          0 :                 if (kdbgetaddrarg(0, (const char **)argv, &nextarg,
    1082                 :            :                                   &value, &offset, &name)) {
    1083                 :            :                         return KDB_NOTFOUND;
    1084                 :            :                 }
    1085                 :            : 
    1086                 :          0 :                 kdb_printf("%s = ", argv[0]);
    1087                 :          0 :                 kdb_symbol_print(value, NULL, KDB_SP_DEFAULT);
    1088                 :          0 :                 kdb_printf("\n");
    1089                 :          0 :                 return 0;
    1090                 :            :         }
    1091                 :            : }
    1092                 :            : 
    1093                 :            : 
    1094                 :          0 : static int handle_ctrl_cmd(char *cmd)
    1095                 :            : {
    1096                 :            : #define CTRL_P  16
    1097                 :            : #define CTRL_N  14
    1098                 :            : 
    1099                 :            :         /* initial situation */
    1100                 :          0 :         if (cmd_head == cmd_tail)
    1101                 :            :                 return 0;
    1102                 :          0 :         switch (*cmd) {
    1103                 :            :         case CTRL_P:
    1104                 :          0 :                 if (cmdptr != cmd_tail)
    1105                 :          0 :                         cmdptr = (cmdptr-1) % KDB_CMD_HISTORY_COUNT;
    1106                 :          0 :                 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
    1107                 :          0 :                 return 1;
    1108                 :            :         case CTRL_N:
    1109                 :          0 :                 if (cmdptr != cmd_head)
    1110                 :          0 :                         cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT;
    1111                 :          0 :                 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
    1112                 :          0 :                 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                 :          0 : static int kdb_reboot(int argc, const char **argv)
    1122                 :            : {
    1123                 :          0 :         emergency_restart();
    1124                 :          0 :         kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
    1125                 :            :         while (1)
    1126                 :          0 :                 cpu_relax();
    1127                 :            :         /* NOTREACHED */
    1128                 :            :         return 0;
    1129                 :            : }
    1130                 :            : 
    1131                 :          0 : static void kdb_dumpregs(struct pt_regs *regs)
    1132                 :            : {
    1133                 :          0 :         int old_lvl = console_loglevel;
    1134                 :          0 :         console_loglevel = CONSOLE_LOGLEVEL_MOTORMOUTH;
    1135                 :          0 :         kdb_trap_printk++;
    1136                 :          0 :         show_regs(regs);
    1137                 :          0 :         kdb_trap_printk--;
    1138                 :          0 :         kdb_printf("\n");
    1139                 :          0 :         console_loglevel = old_lvl;
    1140                 :          0 : }
    1141                 :            : 
    1142                 :          0 : void kdb_set_current_task(struct task_struct *p)
    1143                 :            : {
    1144                 :          0 :         kdb_current_task = p;
    1145                 :            : 
    1146                 :          0 :         if (kdb_task_has_cpu(p)) {
    1147                 :          0 :                 kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p));
    1148                 :          0 :                 return;
    1149                 :            :         }
    1150                 :          0 :         kdb_current_regs = NULL;
    1151                 :            : }
    1152                 :            : 
    1153                 :          0 : static void drop_newline(char *buf)
    1154                 :            : {
    1155                 :          0 :         size_t len = strlen(buf);
    1156                 :            : 
    1157                 :          0 :         if (len == 0)
    1158                 :          0 :                 return;
    1159                 :          0 :         if (*(buf + len - 1) == '\n')
    1160                 :          0 :                 *(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                 :          0 : 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                 :          0 :                 kdb_curr_task(raw_smp_processor_id());
    1189                 :            : 
    1190                 :          0 :         KDB_DEBUG_STATE("kdb_local 1", reason);
    1191                 :          0 :         kdb_go_count = 0;
    1192                 :          0 :         if (reason == KDB_REASON_DEBUG) {
    1193                 :            :                 /* special case below */
    1194                 :            :         } else {
    1195                 :          0 :                 kdb_printf("\nEntering kdb (current=0x%px, pid %d) ",
    1196                 :            :                            kdb_current, kdb_current ? kdb_current->pid : 0);
    1197                 :            : #if defined(CONFIG_SMP)
    1198                 :          0 :                 kdb_printf("on processor %d ", raw_smp_processor_id());
    1199                 :            : #endif
    1200                 :            :         }
    1201                 :            : 
    1202                 :          0 :         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                 :          0 :                 switch (db_result) {
    1210                 :            :                 case KDB_DB_BPT:
    1211                 :          0 :                         kdb_printf("\nEntering kdb (0x%px, pid %d) ",
    1212                 :            :                                    kdb_current, kdb_current->pid);
    1213                 :            : #if defined(CONFIG_SMP)
    1214                 :          0 :                         kdb_printf("on processor %d ", raw_smp_processor_id());
    1215                 :            : #endif
    1216                 :          0 :                         kdb_printf("due to Debug @ " kdb_machreg_fmt "\n",
    1217                 :            :                                    instruction_pointer(regs));
    1218                 :          0 :                         break;
    1219                 :            :                 case KDB_DB_SS:
    1220                 :            :                         break;
    1221                 :            :                 case KDB_DB_SSBPT:
    1222                 :          0 :                         KDB_DEBUG_STATE("kdb_local 4", reason);
    1223                 :            :                         return 1;       /* kdba_db_trap did the work */
    1224                 :            :                 default:
    1225                 :          0 :                         kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
    1226                 :            :                                    db_result);
    1227                 :          0 :                         break;
    1228                 :            :                 }
    1229                 :            : 
    1230                 :            :         }
    1231                 :            :                 break;
    1232                 :            :         case KDB_REASON_ENTER:
    1233                 :          0 :                 if (KDB_STATE(KEYBOARD))
    1234                 :          0 :                         kdb_printf("due to Keyboard Entry\n");
    1235                 :            :                 else
    1236                 :          0 :                         kdb_printf("due to KDB_ENTER()\n");
    1237                 :            :                 break;
    1238                 :            :         case KDB_REASON_KEYBOARD:
    1239                 :          0 :                 KDB_STATE_SET(KEYBOARD);
    1240                 :          0 :                 kdb_printf("due to Keyboard Entry\n");
    1241                 :          0 :                 break;
    1242                 :            :         case KDB_REASON_ENTER_SLAVE:
    1243                 :            :                 /* drop through, slaves only get released via cpu switch */
    1244                 :            :         case KDB_REASON_SWITCH:
    1245                 :          0 :                 kdb_printf("due to cpu switch\n");
    1246                 :          0 :                 break;
    1247                 :            :         case KDB_REASON_OOPS:
    1248                 :          0 :                 kdb_printf("Oops: %s\n", kdb_diemsg);
    1249                 :          0 :                 kdb_printf("due to oops @ " kdb_machreg_fmt "\n",
    1250                 :            :                            instruction_pointer(regs));
    1251                 :          0 :                 kdb_dumpregs(regs);
    1252                 :          0 :                 break;
    1253                 :            :         case KDB_REASON_SYSTEM_NMI:
    1254                 :          0 :                 kdb_printf("due to System NonMaskable Interrupt\n");
    1255                 :          0 :                 break;
    1256                 :            :         case KDB_REASON_NMI:
    1257                 :          0 :                 kdb_printf("due to NonMaskable Interrupt @ "
    1258                 :            :                            kdb_machreg_fmt "\n",
    1259                 :            :                            instruction_pointer(regs));
    1260                 :          0 :                 break;
    1261                 :            :         case KDB_REASON_SSTEP:
    1262                 :            :         case KDB_REASON_BREAK:
    1263                 :          0 :                 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                 :          0 :                 if (db_result != KDB_DB_BPT) {
    1271                 :          0 :                         kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
    1272                 :            :                                    db_result);
    1273                 :          0 :                         KDB_DEBUG_STATE("kdb_local 6", reason);
    1274                 :            :                         return 0;       /* Not for us, dismiss it */
    1275                 :            :                 }
    1276                 :            :                 break;
    1277                 :            :         case KDB_REASON_RECURSE:
    1278                 :          0 :                 kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
    1279                 :            :                            instruction_pointer(regs));
    1280                 :          0 :                 break;
    1281                 :            :         default:
    1282                 :          0 :                 kdb_printf("kdb: unexpected reason code: %d\n", reason);
    1283                 :          0 :                 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                 :          0 :                 kdb_nextline = 1;
    1292                 :          0 :                 KDB_STATE_CLEAR(SUPPRESS);
    1293                 :          0 :                 kdb_grepping_flag = 0;
    1294                 :            :                 /* ensure the old search does not leak into '/' commands */
    1295                 :          0 :                 kdb_grep_string[0] = '\0';
    1296                 :            : 
    1297                 :            :                 cmdbuf = cmd_cur;
    1298                 :          0 :                 *cmdbuf = '\0';
    1299                 :          0 :                 *(cmd_hist[cmd_head]) = '\0';
    1300                 :            : 
    1301                 :            : do_full_getstr:
    1302                 :            : #if defined(CONFIG_SMP)
    1303                 :          0 :                 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                 :          0 :                 if (defcmd_in_progress)
    1309                 :          0 :                         strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
    1310                 :            : 
    1311                 :            :                 /*
    1312                 :            :                  * Fetch command from keyboard
    1313                 :            :                  */
    1314                 :          0 :                 cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
    1315                 :          0 :                 if (*cmdbuf != '\n') {
    1316                 :          0 :                         if (*cmdbuf < 32) {
    1317                 :          0 :                                 if (cmdptr == cmd_head) {
    1318                 :          0 :                                         strncpy(cmd_hist[cmd_head], cmd_cur,
    1319                 :            :                                                 CMD_BUFLEN);
    1320                 :            :                                         *(cmd_hist[cmd_head] +
    1321                 :          0 :                                           strlen(cmd_hist[cmd_head])-1) = '\0';
    1322                 :            :                                 }
    1323                 :          0 :                                 if (!handle_ctrl_cmd(cmdbuf))
    1324                 :          0 :                                         *(cmd_cur+strlen(cmd_cur)-1) = '\0';
    1325                 :            :                                 cmdbuf = cmd_cur;
    1326                 :            :                                 goto do_full_getstr;
    1327                 :            :                         } else {
    1328                 :          0 :                                 strncpy(cmd_hist[cmd_head], cmd_cur,
    1329                 :            :                                         CMD_BUFLEN);
    1330                 :            :                         }
    1331                 :            : 
    1332                 :          0 :                         cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
    1333                 :          0 :                         if (cmd_head == cmd_tail)
    1334                 :          0 :                                 cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
    1335                 :            :                 }
    1336                 :            : 
    1337                 :          0 :                 cmdptr = cmd_head;
    1338                 :          0 :                 diag = kdb_parse(cmdbuf);
    1339                 :          0 :                 if (diag == KDB_NOTFOUND) {
    1340                 :          0 :                         drop_newline(cmdbuf);
    1341                 :          0 :                         kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
    1342                 :            :                         diag = 0;
    1343                 :            :                 }
    1344                 :          0 :                 if (diag == KDB_CMD_GO
    1345                 :          0 :                  || diag == KDB_CMD_CPU
    1346                 :          0 :                  || diag == KDB_CMD_SS
    1347                 :          0 :                  || diag == KDB_CMD_KGDB)
    1348                 :            :                         break;
    1349                 :            : 
    1350                 :          0 :                 if (diag)
    1351                 :          0 :                         kdb_cmderror(diag);
    1352                 :            :         }
    1353                 :          0 :         KDB_DEBUG_STATE("kdb_local 9", diag);
    1354                 :          0 :         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                 :          0 : void kdb_print_state(const char *text, int value)
    1366                 :            : {
    1367                 :          0 :         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                 :          0 : }
    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                 :          0 : 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                 :          0 :                 KDB_DEBUG_STATE("kdb_main_loop 1", reason);
    1408                 :          0 :                 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                 :          0 :                         if (!KDB_STATE(KDB))
    1414                 :          0 :                                 KDB_STATE_SET(KDB);
    1415                 :            :                 }
    1416                 :            : 
    1417                 :          0 :                 KDB_STATE_CLEAR(SUPPRESS);
    1418                 :          0 :                 KDB_DEBUG_STATE("kdb_main_loop 2", reason);
    1419                 :          0 :                 if (KDB_STATE(LEAVING))
    1420                 :            :                         break;  /* Another cpu said 'go' */
    1421                 :            :                 /* Still using kdb, this processor is in control */
    1422                 :          0 :                 result = kdb_local(reason2, error, regs, db_result);
    1423                 :          0 :                 KDB_DEBUG_STATE("kdb_main_loop 3", result);
    1424                 :            : 
    1425                 :          0 :                 if (result == KDB_CMD_CPU)
    1426                 :            :                         break;
    1427                 :            : 
    1428                 :          0 :                 if (result == KDB_CMD_SS) {
    1429                 :          0 :                         KDB_STATE_SET(DOING_SS);
    1430                 :          0 :                         break;
    1431                 :            :                 }
    1432                 :            : 
    1433                 :          0 :                 if (result == KDB_CMD_KGDB) {
    1434                 :          0 :                         if (!KDB_STATE(DOING_KGDB))
    1435                 :          0 :                                 kdb_printf("Entering please attach debugger "
    1436                 :            :                                            "or use $D#44+ or $3#33\n");
    1437                 :            :                         break;
    1438                 :            :                 }
    1439                 :          0 :                 if (result && result != 1 && result != KDB_CMD_GO)
    1440                 :          0 :                         kdb_printf("\nUnexpected kdb_local return code %d\n",
    1441                 :            :                                    result);
    1442                 :          0 :                 KDB_DEBUG_STATE("kdb_main_loop 4", reason);
    1443                 :            :                 break;
    1444                 :            :         }
    1445                 :          0 :         if (KDB_STATE(DOING_SS))
    1446                 :          0 :                 KDB_STATE_CLEAR(SSBPT);
    1447                 :            : 
    1448                 :            :         /* Clean up any keyboard devices before leaving */
    1449                 :          0 :         kdb_kbd_cleanup_state();
    1450                 :            : 
    1451                 :          0 :         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                 :          0 : static int kdb_mdr(unsigned long addr, unsigned int count)
    1465                 :            : {
    1466                 :            :         unsigned char c;
    1467                 :          0 :         while (count--) {
    1468                 :          0 :                 if (kdb_getarea(c, addr))
    1469                 :            :                         return 0;
    1470                 :          0 :                 kdb_printf("%02x", c);
    1471                 :          0 :                 addr++;
    1472                 :            :         }
    1473                 :          0 :         kdb_printf("\n");
    1474                 :          0 :         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                 :          0 : 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                 :          0 :         memset(cbuf, '\0', sizeof(cbuf));
    1500                 :          0 :         if (phys)
    1501                 :          0 :                 kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
    1502                 :            :         else
    1503                 :          0 :                 kdb_printf(kdb_machreg_fmt0 " ", addr);
    1504                 :            : 
    1505                 :          0 :         for (i = 0; i < num && repeat--; i++) {
    1506                 :          0 :                 if (phys) {
    1507                 :          0 :                         if (kdb_getphysword(&word, addr, bytesperword))
    1508                 :            :                                 break;
    1509                 :          0 :                 } else if (kdb_getword(&word, addr, bytesperword))
    1510                 :            :                         break;
    1511                 :          0 :                 kdb_printf(fmtstr, word);
    1512                 :          0 :                 if (symbolic)
    1513                 :          0 :                         kdbnearsym(word, &symtab);
    1514                 :            :                 else
    1515                 :          0 :                         memset(&symtab, 0, sizeof(symtab));
    1516                 :          0 :                 if (symtab.sym_name) {
    1517                 :          0 :                         kdb_symbol_print(word, &symtab, 0);
    1518                 :          0 :                         if (!nosect) {
    1519                 :          0 :                                 kdb_printf("\n");
    1520                 :          0 :                                 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                 :          0 :                         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                 :          0 :                         wc.word = word;
    1540                 :            : #define printable_char(c) \
    1541                 :            :         ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
    1542                 :          0 :                         for (j = 0; j < bytesperword; j++)
    1543                 :          0 :                                 *c++ = printable_char(*cp++);
    1544                 :          0 :                         addr += bytesperword;
    1545                 :            : #undef printable_char
    1546                 :            :                 }
    1547                 :            :         }
    1548                 :          0 :         kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
    1549                 :            :                    " ", cbuf);
    1550                 :          0 : }
    1551                 :            : 
    1552                 :          0 : 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                 :          0 :         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                 :          0 :         repeat = mdcount * 16 / bytesperword;
    1573                 :            : 
    1574                 :          0 :         if (strcmp(argv[0], "mdr") == 0) {
    1575                 :          0 :                 if (argc == 2 || (argc == 0 && last_addr != 0))
    1576                 :            :                         valid = raw = 1;
    1577                 :            :                 else
    1578                 :            :                         return KDB_ARGCOUNT;
    1579                 :          0 :         } else if (isdigit(argv[0][2])) {
    1580                 :          0 :                 bytesperword = (int)(argv[0][2] - '0');
    1581                 :          0 :                 if (bytesperword == 0) {
    1582                 :          0 :                         bytesperword = last_bytesperword;
    1583                 :          0 :                         if (bytesperword == 0)
    1584                 :            :                                 bytesperword = 4;
    1585                 :            :                 }
    1586                 :          0 :                 last_bytesperword = bytesperword;
    1587                 :          0 :                 repeat = mdcount * 16 / bytesperword;
    1588                 :          0 :                 if (!argv[0][3])
    1589                 :            :                         valid = 1;
    1590                 :          0 :                 else if (argv[0][3] == 'c' && argv[0][4]) {
    1591                 :            :                         char *p;
    1592                 :          0 :                         repeat = simple_strtoul(argv[0] + 4, &p, 10);
    1593                 :          0 :                         mdcount = ((repeat * bytesperword) + 15) / 16;
    1594                 :          0 :                         valid = !*p;
    1595                 :            :                 }
    1596                 :          0 :                 last_repeat = repeat;
    1597                 :          0 :         } else if (strcmp(argv[0], "md") == 0)
    1598                 :            :                 valid = 1;
    1599                 :          0 :         else if (strcmp(argv[0], "mds") == 0)
    1600                 :            :                 valid = 1;
    1601                 :          0 :         else if (strcmp(argv[0], "mdp") == 0) {
    1602                 :            :                 phys = valid = 1;
    1603                 :            :         }
    1604                 :          0 :         if (!valid)
    1605                 :            :                 return KDB_NOTFOUND;
    1606                 :            : 
    1607                 :          0 :         if (argc == 0) {
    1608                 :          0 :                 if (last_addr == 0)
    1609                 :            :                         return KDB_ARGCOUNT;
    1610                 :          0 :                 addr = last_addr;
    1611                 :          0 :                 radix = last_radix;
    1612                 :          0 :                 bytesperword = last_bytesperword;
    1613                 :          0 :                 repeat = last_repeat;
    1614                 :          0 :                 if (raw)
    1615                 :            :                         mdcount = repeat;
    1616                 :            :                 else
    1617                 :          0 :                         mdcount = ((repeat * bytesperword) + 15) / 16;
    1618                 :            :         }
    1619                 :            : 
    1620                 :          0 :         if (argc) {
    1621                 :            :                 unsigned long val;
    1622                 :          0 :                 int diag, nextarg = 1;
    1623                 :          0 :                 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
    1624                 :            :                                      &offset, NULL);
    1625                 :          0 :                 if (diag)
    1626                 :          0 :                         return diag;
    1627                 :          0 :                 if (argc > nextarg+2)
    1628                 :            :                         return KDB_ARGCOUNT;
    1629                 :            : 
    1630                 :          0 :                 if (argc >= nextarg) {
    1631                 :          0 :                         diag = kdbgetularg(argv[nextarg], &val);
    1632                 :          0 :                         if (!diag) {
    1633                 :          0 :                                 mdcount = (int) val;
    1634                 :          0 :                                 if (raw)
    1635                 :            :                                         repeat = mdcount;
    1636                 :            :                                 else
    1637                 :          0 :                                         repeat = mdcount * 16 / bytesperword;
    1638                 :            :                         }
    1639                 :            :                 }
    1640                 :          0 :                 if (argc >= nextarg+1) {
    1641                 :          0 :                         diag = kdbgetularg(argv[nextarg+1], &val);
    1642                 :          0 :                         if (!diag)
    1643                 :          0 :                                 radix = (int) val;
    1644                 :            :                 }
    1645                 :            :         }
    1646                 :            : 
    1647                 :          0 :         if (strcmp(argv[0], "mdr") == 0) {
    1648                 :            :                 int ret;
    1649                 :          0 :                 last_addr = addr;
    1650                 :          0 :                 ret = kdb_mdr(addr, mdcount);
    1651                 :          0 :                 last_addr += mdcount;
    1652                 :          0 :                 last_repeat = mdcount;
    1653                 :          0 :                 last_bytesperword = bytesperword; // to make REPEAT happy
    1654                 :          0 :                 return ret;
    1655                 :            :         }
    1656                 :            : 
    1657                 :          0 :         switch (radix) {
    1658                 :            :         case 10:
    1659                 :            :                 fmtchar = 'd';
    1660                 :            :                 break;
    1661                 :            :         case 16:
    1662                 :            :                 fmtchar = 'x';
    1663                 :          0 :                 break;
    1664                 :            :         case 8:
    1665                 :            :                 fmtchar = 'o';
    1666                 :          0 :                 break;
    1667                 :            :         default:
    1668                 :            :                 return KDB_BADRADIX;
    1669                 :            :         }
    1670                 :            : 
    1671                 :          0 :         last_radix = radix;
    1672                 :            : 
    1673                 :          0 :         if (bytesperword > KDB_WORD_SIZE)
    1674                 :            :                 return KDB_BADWIDTH;
    1675                 :            : 
    1676                 :          0 :         switch (bytesperword) {
    1677                 :            :         case 8:
    1678                 :          0 :                 sprintf(fmtstr, "%%16.16l%c ", fmtchar);
    1679                 :          0 :                 break;
    1680                 :            :         case 4:
    1681                 :          0 :                 sprintf(fmtstr, "%%8.8l%c ", fmtchar);
    1682                 :          0 :                 break;
    1683                 :            :         case 2:
    1684                 :          0 :                 sprintf(fmtstr, "%%4.4l%c ", fmtchar);
    1685                 :          0 :                 break;
    1686                 :            :         case 1:
    1687                 :          0 :                 sprintf(fmtstr, "%%2.2l%c ", fmtchar);
    1688                 :          0 :                 break;
    1689                 :            :         default:
    1690                 :            :                 return KDB_BADWIDTH;
    1691                 :            :         }
    1692                 :            : 
    1693                 :          0 :         last_repeat = repeat;
    1694                 :          0 :         last_bytesperword = bytesperword;
    1695                 :            : 
    1696                 :          0 :         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                 :          0 :         addr &= ~(bytesperword-1);
    1709                 :            : 
    1710                 :          0 :         while (repeat > 0) {
    1711                 :            :                 unsigned long a;
    1712                 :          0 :                 int n, z, num = (symbolic ? 1 : (16 / bytesperword));
    1713                 :            : 
    1714                 :          0 :                 if (KDB_FLAG(CMD_INTERRUPT))
    1715                 :            :                         return 0;
    1716                 :          0 :                 for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
    1717                 :          0 :                         if (phys) {
    1718                 :          0 :                                 if (kdb_getphysword(&word, a, bytesperword)
    1719                 :          0 :                                                 || word)
    1720                 :            :                                         break;
    1721                 :          0 :                         } else if (kdb_getword(&word, a, bytesperword) || word)
    1722                 :            :                                 break;
    1723                 :            :                 }
    1724                 :          0 :                 n = min(num, repeat);
    1725                 :          0 :                 kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
    1726                 :            :                             num, repeat, phys);
    1727                 :          0 :                 addr += bytesperword * n;
    1728                 :          0 :                 repeat -= n;
    1729                 :          0 :                 z = (z + num - 1) / num;
    1730                 :          0 :                 if (z > 2) {
    1731                 :          0 :                         int s = num * (z-2);
    1732                 :          0 :                         kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
    1733                 :            :                                    " zero suppressed\n",
    1734                 :          0 :                                 addr, addr + bytesperword * s - 1);
    1735                 :          0 :                         addr += bytesperword * s;
    1736                 :          0 :                         repeat -= s;
    1737                 :            :                 }
    1738                 :            :         }
    1739                 :          0 :         last_addr = addr;
    1740                 :            : 
    1741                 :          0 :         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                 :          0 : static int kdb_mm(int argc, const char **argv)
    1751                 :            : {
    1752                 :            :         int diag;
    1753                 :            :         unsigned long addr;
    1754                 :          0 :         long offset = 0;
    1755                 :            :         unsigned long contents;
    1756                 :            :         int nextarg;
    1757                 :            :         int width;
    1758                 :            : 
    1759                 :          0 :         if (argv[0][2] && !isdigit(argv[0][2]))
    1760                 :            :                 return KDB_NOTFOUND;
    1761                 :            : 
    1762                 :          0 :         if (argc < 2)
    1763                 :            :                 return KDB_ARGCOUNT;
    1764                 :            : 
    1765                 :          0 :         nextarg = 1;
    1766                 :          0 :         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
    1767                 :          0 :         if (diag)
    1768                 :            :                 return diag;
    1769                 :            : 
    1770                 :          0 :         if (nextarg > argc)
    1771                 :            :                 return KDB_ARGCOUNT;
    1772                 :          0 :         diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
    1773                 :          0 :         if (diag)
    1774                 :            :                 return diag;
    1775                 :            : 
    1776                 :          0 :         if (nextarg != argc + 1)
    1777                 :            :                 return KDB_ARGCOUNT;
    1778                 :            : 
    1779                 :          0 :         width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
    1780                 :          0 :         diag = kdb_putword(addr, contents, width);
    1781                 :          0 :         if (diag)
    1782                 :            :                 return diag;
    1783                 :            : 
    1784                 :          0 :         kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
    1785                 :            : 
    1786                 :          0 :         return 0;
    1787                 :            : }
    1788                 :            : 
    1789                 :            : /*
    1790                 :            :  * kdb_go - This function implements the 'go' command.
    1791                 :            :  *      go [address-expression]
    1792                 :            :  */
    1793                 :          0 : 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                 :          0 :         if (raw_smp_processor_id() != kdb_initial_cpu) {
    1801                 :          0 :                 kdb_printf("go must execute on the entry cpu, "
    1802                 :            :                            "please use \"cpu %d\" and then execute go\n",
    1803                 :            :                            kdb_initial_cpu);
    1804                 :          0 :                 return KDB_BADCPUNUM;
    1805                 :            :         }
    1806                 :          0 :         if (argc == 1) {
    1807                 :          0 :                 nextarg = 1;
    1808                 :          0 :                 diag = kdbgetaddrarg(argc, argv, &nextarg,
    1809                 :            :                                      &addr, &offset, NULL);
    1810                 :          0 :                 if (diag)
    1811                 :            :                         return diag;
    1812                 :          0 :         } else if (argc) {
    1813                 :            :                 return KDB_ARGCOUNT;
    1814                 :            :         }
    1815                 :            : 
    1816                 :            :         diag = KDB_CMD_GO;
    1817                 :          0 :         if (KDB_FLAG(CATASTROPHIC)) {
    1818                 :          0 :                 kdb_printf("Catastrophic error detected\n");
    1819                 :          0 :                 kdb_printf("kdb_continue_catastrophic=%d, ",
    1820                 :            :                         kdb_continue_catastrophic);
    1821                 :          0 :                 if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
    1822                 :          0 :                         kdb_printf("type go a second time if you really want "
    1823                 :            :                                    "to continue\n");
    1824                 :          0 :                         return 0;
    1825                 :            :                 }
    1826                 :          0 :                 if (kdb_continue_catastrophic == 2) {
    1827                 :          0 :                         kdb_printf("forcing reboot\n");
    1828                 :            :                         kdb_reboot(0, NULL);
    1829                 :            :                 }
    1830                 :          0 :                 kdb_printf("attempting to continue\n");
    1831                 :            :         }
    1832                 :            :         return diag;
    1833                 :            : }
    1834                 :            : 
    1835                 :            : /*
    1836                 :            :  * kdb_rd - This function implements the 'rd' command.
    1837                 :            :  */
    1838                 :          0 : 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                 :          0 :         if (len)
    1851                 :            :                 return len;
    1852                 :            : 
    1853                 :          0 :         for (i = 0; i < DBG_MAX_REG_NUM; i++) {
    1854                 :          0 :                 rsize = dbg_reg_def[i].size * 2;
    1855                 :          0 :                 if (rsize > 16)
    1856                 :            :                         rsize = 2;
    1857                 :          0 :                 if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
    1858                 :            :                         len = 0;
    1859                 :          0 :                         kdb_printf("\n");
    1860                 :            :                 }
    1861                 :          0 :                 if (len)
    1862                 :          0 :                         len += kdb_printf("  ");
    1863                 :          0 :                 switch(dbg_reg_def[i].size * 8) {
    1864                 :            :                 case 8:
    1865                 :          0 :                         rname = dbg_get_reg(i, &reg8, kdb_current_regs);
    1866                 :          0 :                         if (!rname)
    1867                 :            :                                 break;
    1868                 :          0 :                         len += kdb_printf("%s: %02x", rname, reg8);
    1869                 :          0 :                         break;
    1870                 :            :                 case 16:
    1871                 :          0 :                         rname = dbg_get_reg(i, &reg16, kdb_current_regs);
    1872                 :          0 :                         if (!rname)
    1873                 :            :                                 break;
    1874                 :          0 :                         len += kdb_printf("%s: %04x", rname, reg16);
    1875                 :          0 :                         break;
    1876                 :            :                 case 32:
    1877                 :          0 :                         rname = dbg_get_reg(i, &reg32, kdb_current_regs);
    1878                 :          0 :                         if (!rname)
    1879                 :            :                                 break;
    1880                 :          0 :                         len += kdb_printf("%s: %08x", rname, reg32);
    1881                 :          0 :                         break;
    1882                 :            :                 case 64:
    1883                 :          0 :                         rname = dbg_get_reg(i, &reg64, kdb_current_regs);
    1884                 :          0 :                         if (!rname)
    1885                 :            :                                 break;
    1886                 :          0 :                         len += kdb_printf("%s: %016llx", rname, reg64);
    1887                 :          0 :                         break;
    1888                 :            :                 default:
    1889                 :          0 :                         len += kdb_printf("%s: ??", dbg_reg_def[i].name);
    1890                 :            :                 }
    1891                 :            :         }
    1892                 :          0 :         kdb_printf("\n");
    1893                 :            : #else
    1894                 :            :         if (len)
    1895                 :            :                 return len;
    1896                 :            : 
    1897                 :            :         kdb_dumpregs(kdb_current_regs);
    1898                 :            : #endif
    1899                 :          0 :         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                 :          0 : 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                 :          0 :         if (argc != 2)
    1920                 :            :                 return KDB_ARGCOUNT;
    1921                 :            :         /*
    1922                 :            :          * Allow presence or absence of leading '%' symbol.
    1923                 :            :          */
    1924                 :          0 :         rname = argv[1];
    1925                 :          0 :         if (*rname == '%')
    1926                 :          0 :                 rname++;
    1927                 :            : 
    1928                 :          0 :         diag = kdbgetu64arg(argv[2], &reg64);
    1929                 :          0 :         if (diag)
    1930                 :            :                 return diag;
    1931                 :            : 
    1932                 :            :         diag = kdb_check_regs();
    1933                 :          0 :         if (diag)
    1934                 :            :                 return diag;
    1935                 :            : 
    1936                 :            :         diag = KDB_BADREG;
    1937                 :          0 :         for (i = 0; i < DBG_MAX_REG_NUM; i++) {
    1938                 :          0 :                 if (strcmp(rname, dbg_reg_def[i].name) == 0) {
    1939                 :            :                         diag = 0;
    1940                 :            :                         break;
    1941                 :            :                 }
    1942                 :            :         }
    1943                 :          0 :         if (!diag) {
    1944                 :          0 :                 switch(dbg_reg_def[i].size * 8) {
    1945                 :            :                 case 8:
    1946                 :          0 :                         reg8 = reg64;
    1947                 :          0 :                         dbg_set_reg(i, &reg8, kdb_current_regs);
    1948                 :          0 :                         break;
    1949                 :            :                 case 16:
    1950                 :          0 :                         reg16 = reg64;
    1951                 :          0 :                         dbg_set_reg(i, &reg16, kdb_current_regs);
    1952                 :          0 :                         break;
    1953                 :            :                 case 32:
    1954                 :          0 :                         reg32 = reg64;
    1955                 :          0 :                         dbg_set_reg(i, &reg32, kdb_current_regs);
    1956                 :          0 :                         break;
    1957                 :            :                 case 64:
    1958                 :          0 :                         dbg_set_reg(i, &reg64, kdb_current_regs);
    1959                 :          0 :                         break;
    1960                 :            :                 }
    1961                 :            :         }
    1962                 :          0 :         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                 :          0 : static int kdb_sr(int argc, const char **argv)
    1976                 :            : {
    1977                 :            :         bool check_mask =
    1978                 :          0 :             !kdb_check_flags(KDB_ENABLE_ALL, kdb_cmd_enabled, false);
    1979                 :            : 
    1980                 :          0 :         if (argc != 1)
    1981                 :            :                 return KDB_ARGCOUNT;
    1982                 :            : 
    1983                 :          0 :         kdb_trap_printk++;
    1984                 :          0 :         __handle_sysrq(*argv[1], check_mask);
    1985                 :          0 :         kdb_trap_printk--;
    1986                 :            : 
    1987                 :          0 :         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                 :          0 : 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                 :          0 :         if (argc != 1)
    2008                 :            :                 return KDB_ARGCOUNT;
    2009                 :            : 
    2010                 :          0 :         nextarg = 1;
    2011                 :          0 :         diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
    2012                 :          0 :         if (diag)
    2013                 :            :                 return diag;
    2014                 :          0 :         show_regs((struct pt_regs *)addr);
    2015                 :          0 :         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                 :          0 : static int kdb_lsmod(int argc, const char **argv)
    2025                 :            : {
    2026                 :            :         struct module *mod;
    2027                 :            : 
    2028                 :          0 :         if (argc != 0)
    2029                 :            :                 return KDB_ARGCOUNT;
    2030                 :            : 
    2031                 :          0 :         kdb_printf("Module                  Size  modstruct     Used by\n");
    2032                 :          0 :         list_for_each_entry(mod, kdb_modules, list) {
    2033                 :          0 :                 if (mod->state == MODULE_STATE_UNFORMED)
    2034                 :          0 :                         continue;
    2035                 :            : 
    2036                 :          0 :                 kdb_printf("%-20s%8u  0x%px ", mod->name,
    2037                 :            :                            mod->core_layout.size, (void *)mod);
    2038                 :            : #ifdef CONFIG_MODULE_UNLOAD
    2039                 :          0 :                 kdb_printf("%4d ", module_refcount(mod));
    2040                 :            : #endif
    2041                 :          0 :                 if (mod->state == MODULE_STATE_GOING)
    2042                 :          0 :                         kdb_printf(" (Unloading)");
    2043                 :          0 :                 else if (mod->state == MODULE_STATE_COMING)
    2044                 :          0 :                         kdb_printf(" (Loading)");
    2045                 :            :                 else
    2046                 :          0 :                         kdb_printf(" (Live)");
    2047                 :          0 :                 kdb_printf(" 0x%px", mod->core_layout.base);
    2048                 :            : 
    2049                 :            : #ifdef CONFIG_MODULE_UNLOAD
    2050                 :            :                 {
    2051                 :            :                         struct module_use *use;
    2052                 :          0 :                         kdb_printf(" [ ");
    2053                 :          0 :                         list_for_each_entry(use, &mod->source_list,
    2054                 :            :                                             source_list)
    2055                 :          0 :                                 kdb_printf("%s ", use->target->name);
    2056                 :          0 :                         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                 :          0 : static int kdb_env(int argc, const char **argv)
    2072                 :            : {
    2073                 :            :         int i;
    2074                 :            : 
    2075                 :          0 :         for (i = 0; i < __nenv; i++) {
    2076                 :          0 :                 if (__env[i])
    2077                 :          0 :                         kdb_printf("%s\n", __env[i]);
    2078                 :            :         }
    2079                 :            : 
    2080                 :          0 :         if (KDB_DEBUG(MASK))
    2081                 :          0 :                 kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
    2082                 :            : 
    2083                 :          0 :         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                 :          0 : 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                 :          0 :         struct kmsg_dumper dumper = { .active = 1 };
    2101                 :            :         size_t len;
    2102                 :            :         char buf[201];
    2103                 :            : 
    2104                 :          0 :         if (argc > 2)
    2105                 :            :                 return KDB_ARGCOUNT;
    2106                 :          0 :         if (argc) {
    2107                 :            :                 char *cp;
    2108                 :          0 :                 lines = simple_strtol(argv[1], &cp, 0);
    2109                 :          0 :                 if (*cp)
    2110                 :            :                         lines = 0;
    2111                 :          0 :                 if (argc > 1) {
    2112                 :          0 :                         adjust = simple_strtoul(argv[2], &cp, 0);
    2113                 :          0 :                         if (*cp || adjust < 0)
    2114                 :            :                                 adjust = 0;
    2115                 :            :                 }
    2116                 :            :         }
    2117                 :            : 
    2118                 :            :         /* disable LOGGING if set */
    2119                 :            :         diag = kdbgetintenv("LOGGING", &logging);
    2120                 :          0 :         if (!diag && logging) {
    2121                 :          0 :                 const char *setargs[] = { "set", "LOGGING", "0" };
    2122                 :          0 :                 kdb_set(2, setargs);
    2123                 :            :         }
    2124                 :            : 
    2125                 :          0 :         kmsg_dump_rewind_nolock(&dumper);
    2126                 :          0 :         while (kmsg_dump_get_line_nolock(&dumper, 1, NULL, 0, NULL))
    2127                 :          0 :                 n++;
    2128                 :            : 
    2129                 :          0 :         if (lines < 0) {
    2130                 :          0 :                 if (adjust >= n)
    2131                 :          0 :                         kdb_printf("buffer only contains %d lines, nothing "
    2132                 :            :                                    "printed\n", n);
    2133                 :          0 :                 else if (adjust - lines >= n)
    2134                 :          0 :                         kdb_printf("buffer only contains %d lines, last %d "
    2135                 :            :                                    "lines printed\n", n, n - adjust);
    2136                 :            :                 skip = adjust;
    2137                 :          0 :                 lines = abs(lines);
    2138                 :          0 :         } else if (lines > 0) {
    2139                 :          0 :                 skip = n - lines - adjust;
    2140                 :          0 :                 lines = abs(lines);
    2141                 :          0 :                 if (adjust >= n) {
    2142                 :          0 :                         kdb_printf("buffer only contains %d lines, "
    2143                 :            :                                    "nothing printed\n", n);
    2144                 :          0 :                         skip = n;
    2145                 :          0 :                 } else if (skip < 0) {
    2146                 :          0 :                         lines += skip;
    2147                 :            :                         skip = 0;
    2148                 :          0 :                         kdb_printf("buffer only contains %d lines, first "
    2149                 :            :                                    "%d lines printed\n", n, lines);
    2150                 :            :                 }
    2151                 :            :         } else {
    2152                 :          0 :                 lines = n;
    2153                 :            :         }
    2154                 :            : 
    2155                 :          0 :         if (skip >= n || skip < 0)
    2156                 :            :                 return 0;
    2157                 :            : 
    2158                 :          0 :         kmsg_dump_rewind_nolock(&dumper);
    2159                 :          0 :         while (kmsg_dump_get_line_nolock(&dumper, 1, buf, sizeof(buf), &len)) {
    2160                 :          0 :                 if (skip) {
    2161                 :          0 :                         skip--;
    2162                 :          0 :                         continue;
    2163                 :            :                 }
    2164                 :          0 :                 if (!lines--)
    2165                 :            :                         break;
    2166                 :          0 :                 if (KDB_FLAG(CMD_INTERRUPT))
    2167                 :            :                         return 0;
    2168                 :            : 
    2169                 :          0 :                 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                 :          0 : static int kdb_disable_nmi(int argc, const char *argv[])
    2180                 :            : {
    2181                 :          0 :         if (atomic_read(&kdb_nmi_disabled))
    2182                 :            :                 return 0;
    2183                 :            :         atomic_set(&kdb_nmi_disabled, 1);
    2184                 :          0 :         arch_kgdb_ops.enable_nmi(0);
    2185                 :          0 :         return 0;
    2186                 :            : }
    2187                 :            : 
    2188                 :          0 : static int kdb_param_enable_nmi(const char *val, const struct kernel_param *kp)
    2189                 :            : {
    2190                 :          0 :         if (!atomic_add_unless(&kdb_nmi_disabled, -1, 0))
    2191                 :            :                 return -EINVAL;
    2192                 :          0 :         arch_kgdb_ops.enable_nmi(1);
    2193                 :          0 :         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                 :          0 : static void kdb_cpu_status(void)
    2208                 :            : {
    2209                 :            :         int i, start_cpu, first_print = 1;
    2210                 :            :         char state, prev_state = '?';
    2211                 :            : 
    2212                 :          0 :         kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
    2213                 :          0 :         kdb_printf("Available cpus: ");
    2214                 :          0 :         for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
    2215                 :          0 :                 if (!cpu_online(i)) {
    2216                 :            :                         state = 'F';    /* cpu is offline */
    2217                 :          0 :                 } 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                 :          0 :                         if (kdb_task_state_char(KDB_TSK(i)) == 'I')
    2222                 :            :                                 state = 'I';    /* idle task */
    2223                 :            :                 }
    2224                 :          0 :                 if (state != prev_state) {
    2225                 :          0 :                         if (prev_state != '?') {
    2226                 :          0 :                                 if (!first_print)
    2227                 :          0 :                                         kdb_printf(", ");
    2228                 :            :                                 first_print = 0;
    2229                 :          0 :                                 kdb_printf("%d", start_cpu);
    2230                 :          0 :                                 if (start_cpu < i-1)
    2231                 :          0 :                                         kdb_printf("-%d", i-1);
    2232                 :          0 :                                 if (prev_state != ' ')
    2233                 :          0 :                                         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                 :          0 :         if (prev_state != 'F') {
    2241                 :          0 :                 if (!first_print)
    2242                 :          0 :                         kdb_printf(", ");
    2243                 :          0 :                 kdb_printf("%d", start_cpu);
    2244                 :          0 :                 if (start_cpu < i-1)
    2245                 :          0 :                         kdb_printf("-%d", i-1);
    2246                 :          0 :                 if (prev_state != ' ')
    2247                 :          0 :                         kdb_printf("(%c)", prev_state);
    2248                 :            :         }
    2249                 :          0 :         kdb_printf("\n");
    2250                 :          0 : }
    2251                 :            : 
    2252                 :          0 : static int kdb_cpu(int argc, const char **argv)
    2253                 :            : {
    2254                 :            :         unsigned long cpunum;
    2255                 :            :         int diag;
    2256                 :            : 
    2257                 :          0 :         if (argc == 0) {
    2258                 :          0 :                 kdb_cpu_status();
    2259                 :          0 :                 return 0;
    2260                 :            :         }
    2261                 :            : 
    2262                 :          0 :         if (argc != 1)
    2263                 :            :                 return KDB_ARGCOUNT;
    2264                 :            : 
    2265                 :          0 :         diag = kdbgetularg(argv[1], &cpunum);
    2266                 :          0 :         if (diag)
    2267                 :            :                 return diag;
    2268                 :            : 
    2269                 :            :         /*
    2270                 :            :          * Validate cpunum
    2271                 :            :          */
    2272                 :          0 :         if ((cpunum >= CONFIG_NR_CPUS) || !kgdb_info[cpunum].enter_kgdb)
    2273                 :            :                 return KDB_BADCPUNUM;
    2274                 :            : 
    2275                 :          0 :         dbg_switch_cpu = cpunum;
    2276                 :            : 
    2277                 :            :         /*
    2278                 :            :          * Switch to other cpu
    2279                 :            :          */
    2280                 :          0 :         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                 :          0 : void kdb_ps_suppressed(void)
    2287                 :            : {
    2288                 :            :         int idle = 0, daemon = 0;
    2289                 :          0 :         unsigned long mask_I = kdb_task_state_string("I"),
    2290                 :          0 :                       mask_M = kdb_task_state_string("M");
    2291                 :            :         unsigned long cpu;
    2292                 :            :         const struct task_struct *p, *g;
    2293                 :          0 :         for_each_online_cpu(cpu) {
    2294                 :          0 :                 p = kdb_curr_task(cpu);
    2295                 :          0 :                 if (kdb_task_state(p, mask_I))
    2296                 :          0 :                         ++idle;
    2297                 :            :         }
    2298                 :          0 :         kdb_do_each_thread(g, p) {
    2299                 :          0 :                 if (kdb_task_state(p, mask_M))
    2300                 :          0 :                         ++daemon;
    2301                 :          0 :         } kdb_while_each_thread(g, p);
    2302                 :          0 :         if (idle || daemon) {
    2303                 :          0 :                 if (idle)
    2304                 :          0 :                         kdb_printf("%d idle process%s (state I)%s\n",
    2305                 :            :                                    idle, idle == 1 ? "" : "es",
    2306                 :            :                                    daemon ? " and " : "");
    2307                 :          0 :                 if (daemon)
    2308                 :          0 :                         kdb_printf("%d sleeping system daemon (state M) "
    2309                 :            :                                    "process%s", daemon,
    2310                 :            :                                    daemon == 1 ? "" : "es");
    2311                 :          0 :                 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
    2312                 :            :         }
    2313                 :          0 : }
    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                 :          0 : void kdb_ps1(const struct task_struct *p)
    2321                 :            : {
    2322                 :            :         int cpu;
    2323                 :            :         unsigned long tmp;
    2324                 :            : 
    2325                 :          0 :         if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
    2326                 :          0 :                 return;
    2327                 :            : 
    2328                 :            :         cpu = kdb_process_cpu(p);
    2329                 :          0 :         kdb_printf("0x%px %8d %8d  %d %4d   %c  0x%px %c%s\n",
    2330                 :          0 :                    (void *)p, p->pid, p->parent->pid,
    2331                 :            :                    kdb_task_has_cpu(p), kdb_process_cpu(p),
    2332                 :          0 :                    kdb_task_state_char(p),
    2333                 :          0 :                    (void *)(&p->thread),
    2334                 :          0 :                    p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
    2335                 :          0 :                    p->comm);
    2336                 :          0 :         if (kdb_task_has_cpu(p)) {
    2337                 :          0 :                 if (!KDB_TSK(cpu)) {
    2338                 :          0 :                         kdb_printf("  Error: no saved data for this cpu\n");
    2339                 :            :                 } else {
    2340                 :          0 :                         if (KDB_TSK(cpu) != p)
    2341                 :          0 :                                 kdb_printf("  Error: does not match running "
    2342                 :            :                                    "process table (0x%px)\n", KDB_TSK(cpu));
    2343                 :            :                 }
    2344                 :            :         }
    2345                 :            : }
    2346                 :            : 
    2347                 :          0 : static int kdb_ps(int argc, const char **argv)
    2348                 :            : {
    2349                 :            :         struct task_struct *g, *p;
    2350                 :            :         unsigned long mask, cpu;
    2351                 :            : 
    2352                 :          0 :         if (argc == 0)
    2353                 :          0 :                 kdb_ps_suppressed();
    2354                 :          0 :         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                 :          0 :         mask = kdb_task_state_string(argc ? argv[1] : NULL);
    2358                 :            :         /* Run the active tasks first */
    2359                 :          0 :         for_each_online_cpu(cpu) {
    2360                 :          0 :                 if (KDB_FLAG(CMD_INTERRUPT))
    2361                 :            :                         return 0;
    2362                 :          0 :                 p = kdb_curr_task(cpu);
    2363                 :          0 :                 if (kdb_task_state(p, mask))
    2364                 :          0 :                         kdb_ps1(p);
    2365                 :            :         }
    2366                 :          0 :         kdb_printf("\n");
    2367                 :            :         /* Now the real tasks */
    2368                 :          0 :         kdb_do_each_thread(g, p) {
    2369                 :          0 :                 if (KDB_FLAG(CMD_INTERRUPT))
    2370                 :            :                         return 0;
    2371                 :          0 :                 if (kdb_task_state(p, mask))
    2372                 :          0 :                         kdb_ps1(p);
    2373                 :          0 :         } 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                 :          0 : static int kdb_pid(int argc, const char **argv)
    2384                 :            : {
    2385                 :            :         struct task_struct *p;
    2386                 :            :         unsigned long val;
    2387                 :            :         int diag;
    2388                 :            : 
    2389                 :          0 :         if (argc > 1)
    2390                 :            :                 return KDB_ARGCOUNT;
    2391                 :            : 
    2392                 :          0 :         if (argc) {
    2393                 :          0 :                 if (strcmp(argv[1], "R") == 0) {
    2394                 :          0 :                         p = KDB_TSK(kdb_initial_cpu);
    2395                 :            :                 } else {
    2396                 :          0 :                         diag = kdbgetularg(argv[1], &val);
    2397                 :          0 :                         if (diag)
    2398                 :            :                                 return KDB_BADINT;
    2399                 :            : 
    2400                 :          0 :                         p = find_task_by_pid_ns((pid_t)val,     &init_pid_ns);
    2401                 :          0 :                         if (!p) {
    2402                 :          0 :                                 kdb_printf("No task with pid=%d\n", (pid_t)val);
    2403                 :          0 :                                 return 0;
    2404                 :            :                         }
    2405                 :            :                 }
    2406                 :          0 :                 kdb_set_current_task(p);
    2407                 :            :         }
    2408                 :          0 :         kdb_printf("KDB current process is %s(pid=%d)\n",
    2409                 :          0 :                    kdb_current_task->comm,
    2410                 :            :                    kdb_current_task->pid);
    2411                 :            : 
    2412                 :          0 :         return 0;
    2413                 :            : }
    2414                 :            : 
    2415                 :          0 : static int kdb_kgdb(int argc, const char **argv)
    2416                 :            : {
    2417                 :          0 :         return KDB_CMD_KGDB;
    2418                 :            : }
    2419                 :            : 
    2420                 :            : /*
    2421                 :            :  * kdb_help - This function implements the 'help' and '?' commands.
    2422                 :            :  */
    2423                 :          0 : static int kdb_help(int argc, const char **argv)
    2424                 :            : {
    2425                 :            :         kdbtab_t *kt;
    2426                 :            :         int i;
    2427                 :            : 
    2428                 :          0 :         kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
    2429                 :          0 :         kdb_printf("-----------------------------"
    2430                 :            :                    "-----------------------------\n");
    2431                 :          0 :         for_each_kdbcmd(kt, i) {
    2432                 :            :                 char *space = "";
    2433                 :          0 :                 if (KDB_FLAG(CMD_INTERRUPT))
    2434                 :            :                         return 0;
    2435                 :          0 :                 if (!kt->cmd_name)
    2436                 :          0 :                         continue;
    2437                 :          0 :                 if (!kdb_check_flags(kt->cmd_flags, kdb_cmd_enabled, true))
    2438                 :          0 :                         continue;
    2439                 :          0 :                 if (strlen(kt->cmd_usage) > 20)
    2440                 :            :                         space = "\n                                    ";
    2441                 :          0 :                 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                 :          0 : static int kdb_kill(int argc, const char **argv)
    2451                 :            : {
    2452                 :            :         long sig, pid;
    2453                 :            :         char *endp;
    2454                 :            :         struct task_struct *p;
    2455                 :            : 
    2456                 :          0 :         if (argc != 2)
    2457                 :            :                 return KDB_ARGCOUNT;
    2458                 :            : 
    2459                 :          0 :         sig = simple_strtol(argv[1], &endp, 0);
    2460                 :          0 :         if (*endp)
    2461                 :            :                 return KDB_BADINT;
    2462                 :          0 :         if ((sig >= 0) || !valid_signal(-sig)) {
    2463                 :          0 :                 kdb_printf("Invalid signal parameter.<-signal>\n");
    2464                 :          0 :                 return 0;
    2465                 :            :         }
    2466                 :            :         sig = -sig;
    2467                 :            : 
    2468                 :          0 :         pid = simple_strtol(argv[2], &endp, 0);
    2469                 :          0 :         if (*endp)
    2470                 :            :                 return KDB_BADINT;
    2471                 :          0 :         if (pid <= 0) {
    2472                 :          0 :                 kdb_printf("Process ID must be large than 0.\n");
    2473                 :          0 :                 return 0;
    2474                 :            :         }
    2475                 :            : 
    2476                 :            :         /* Find the process. */
    2477                 :          0 :         p = find_task_by_pid_ns(pid, &init_pid_ns);
    2478                 :          0 :         if (!p) {
    2479                 :          0 :                 kdb_printf("The specified process isn't found.\n");
    2480                 :          0 :                 return 0;
    2481                 :            :         }
    2482                 :          0 :         p = p->group_leader;
    2483                 :          0 :         kdb_send_sig(p, sig);
    2484                 :          0 :         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                 :          0 : static void kdb_sysinfo(struct sysinfo *val)
    2493                 :            : {
    2494                 :          0 :         u64 uptime = ktime_get_mono_fast_ns();
    2495                 :            : 
    2496                 :          0 :         memset(val, 0, sizeof(*val));
    2497                 :          0 :         val->uptime = div_u64(uptime, NSEC_PER_SEC);
    2498                 :          0 :         val->loads[0] = avenrun[0];
    2499                 :          0 :         val->loads[1] = avenrun[1];
    2500                 :          0 :         val->loads[2] = avenrun[2];
    2501                 :          0 :         val->procs = nr_threads-1;
    2502                 :          0 :         si_meminfo(val);
    2503                 :            : 
    2504                 :          0 :         return;
    2505                 :            : }
    2506                 :            : 
    2507                 :            : /*
    2508                 :            :  * kdb_summary - This function implements the 'summary' command.
    2509                 :            :  */
    2510                 :          0 : static int kdb_summary(int argc, const char **argv)
    2511                 :            : {
    2512                 :            :         time64_t now;
    2513                 :            :         struct tm tm;
    2514                 :            :         struct sysinfo val;
    2515                 :            : 
    2516                 :          0 :         if (argc)
    2517                 :            :                 return KDB_ARGCOUNT;
    2518                 :            : 
    2519                 :          0 :         kdb_printf("sysname    %s\n", init_uts_ns.name.sysname);
    2520                 :          0 :         kdb_printf("release    %s\n", init_uts_ns.name.release);
    2521                 :          0 :         kdb_printf("version    %s\n", init_uts_ns.name.version);
    2522                 :          0 :         kdb_printf("machine    %s\n", init_uts_ns.name.machine);
    2523                 :          0 :         kdb_printf("nodename   %s\n", init_uts_ns.name.nodename);
    2524                 :          0 :         kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
    2525                 :            : 
    2526                 :          0 :         now = __ktime_get_real_seconds();
    2527                 :          0 :         time64_to_tm(now, 0, &tm);
    2528                 :          0 :         kdb_printf("date       %04ld-%02d-%02d %02d:%02d:%02d "
    2529                 :            :                    "tz_minuteswest %d\n",
    2530                 :          0 :                 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                 :          0 :         kdb_sysinfo(&val);
    2535                 :          0 :         kdb_printf("uptime     ");
    2536                 :          0 :         if (val.uptime > (24*60*60)) {
    2537                 :          0 :                 int days = val.uptime / (24*60*60);
    2538                 :          0 :                 val.uptime %= (24*60*60);
    2539                 :          0 :                 kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
    2540                 :            :         }
    2541                 :          0 :         kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
    2542                 :            : 
    2543                 :          0 :         kdb_printf("load avg   %ld.%02ld %ld.%02ld %ld.%02ld\n",
    2544                 :          0 :                 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
    2545                 :          0 :                 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
    2546                 :          0 :                 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
    2547                 :            : 
    2548                 :            :         /* Display in kilobytes */
    2549                 :            : #define K(x) ((x) << (PAGE_SHIFT - 10))
    2550                 :          0 :         kdb_printf("\nMemTotal:       %8lu kB\nMemFree:        %8lu kB\n"
    2551                 :            :                    "Buffers:        %8lu kB\n",
    2552                 :          0 :                    K(val.totalram), K(val.freeram), K(val.bufferram));
    2553                 :          0 :         return 0;
    2554                 :            : }
    2555                 :            : 
    2556                 :            : /*
    2557                 :            :  * kdb_per_cpu - This function implements the 'per_cpu' command.
    2558                 :            :  */
    2559                 :          0 : static int kdb_per_cpu(int argc, const char **argv)
    2560                 :            : {
    2561                 :            :         char fmtstr[64];
    2562                 :          0 :         int cpu, diag, nextarg = 1;
    2563                 :          0 :         unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
    2564                 :            : 
    2565                 :          0 :         if (argc < 1 || argc > 3)
    2566                 :            :                 return KDB_ARGCOUNT;
    2567                 :            : 
    2568                 :          0 :         diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
    2569                 :          0 :         if (diag)
    2570                 :            :                 return diag;
    2571                 :            : 
    2572                 :          0 :         if (argc >= 2) {
    2573                 :          0 :                 diag = kdbgetularg(argv[2], &bytesperword);
    2574                 :          0 :                 if (diag)
    2575                 :            :                         return diag;
    2576                 :            :         }
    2577                 :          0 :         if (!bytesperword)
    2578                 :          0 :                 bytesperword = KDB_WORD_SIZE;
    2579                 :          0 :         else if (bytesperword > KDB_WORD_SIZE)
    2580                 :            :                 return KDB_BADWIDTH;
    2581                 :          0 :         sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
    2582                 :          0 :         if (argc >= 3) {
    2583                 :          0 :                 diag = kdbgetularg(argv[3], &whichcpu);
    2584                 :          0 :                 if (diag)
    2585                 :            :                         return diag;
    2586                 :          0 :                 if (whichcpu >= nr_cpu_ids || !cpu_online(whichcpu)) {
    2587                 :          0 :                         kdb_printf("cpu %ld is not online\n", whichcpu);
    2588                 :          0 :                         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                 :          0 :         for_each_online_cpu(cpu) {
    2605                 :          0 :                 if (KDB_FLAG(CMD_INTERRUPT))
    2606                 :            :                         return 0;
    2607                 :            : 
    2608                 :          0 :                 if (whichcpu != ~0UL && whichcpu != cpu)
    2609                 :          0 :                         continue;
    2610                 :          0 :                 addr = symaddr + KDB_PCU(cpu);
    2611                 :          0 :                 diag = kdb_getword(&val, addr, bytesperword);
    2612                 :          0 :                 if (diag) {
    2613                 :          0 :                         kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
    2614                 :            :                                    "read, diag=%d\n", cpu, addr, diag);
    2615                 :          0 :                         continue;
    2616                 :            :                 }
    2617                 :          0 :                 kdb_printf("%5d ", cpu);
    2618                 :          0 :                 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                 :          0 : static int kdb_grep_help(int argc, const char **argv)
    2630                 :            : {
    2631                 :          0 :         kdb_printf("Usage of  cmd args | grep pattern:\n");
    2632                 :          0 :         kdb_printf("  Any command's output may be filtered through an ");
    2633                 :          0 :         kdb_printf("emulated 'pipe'.\n");
    2634                 :          0 :         kdb_printf("  'grep' is just a key word.\n");
    2635                 :          0 :         kdb_printf("  The pattern may include a very limited set of "
    2636                 :            :                    "metacharacters:\n");
    2637                 :          0 :         kdb_printf("   pattern or ^pattern or pattern$ or ^pattern$\n");
    2638                 :          0 :         kdb_printf("  And if there are spaces in the pattern, you may "
    2639                 :            :                    "quote it:\n");
    2640                 :          0 :         kdb_printf("   \"pat tern\" or \"^pat tern\" or \"pat tern$\""
    2641                 :            :                    " or \"^pat tern$\"\n");
    2642                 :          0 :         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                 :          3 : 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                 :          3 :         for_each_kdbcmd(kp, i) {
    2672                 :          3 :                 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
    2673                 :          0 :                         kdb_printf("Duplicate kdb command registered: "
    2674                 :            :                                 "%s, func %px help %s\n", cmd, func, help);
    2675                 :          0 :                         return 1;
    2676                 :            :                 }
    2677                 :            :         }
    2678                 :            : 
    2679                 :            :         /*
    2680                 :            :          * Insert command into first available location in table
    2681                 :            :          */
    2682                 :          3 :         for_each_kdbcmd(kp, i) {
    2683                 :          3 :                 if (kp->cmd_name == NULL)
    2684                 :            :                         break;
    2685                 :            :         }
    2686                 :            : 
    2687                 :          3 :         if (i >= kdb_max_commands) {
    2688                 :          0 :                 kdbtab_t *new = kmalloc_array(kdb_max_commands -
    2689                 :            :                                                 KDB_BASE_CMD_MAX +
    2690                 :            :                                                 kdb_command_extend,
    2691                 :            :                                               sizeof(*new),
    2692                 :          0 :                                               GFP_KDB);
    2693                 :          0 :                 if (!new) {
    2694                 :          0 :                         kdb_printf("Could not allocate new kdb_command "
    2695                 :            :                                    "table\n");
    2696                 :          0 :                         return 1;
    2697                 :            :                 }
    2698                 :          0 :                 if (kdb_commands) {
    2699                 :          0 :                         memcpy(new, kdb_commands,
    2700                 :          0 :                           (kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new));
    2701                 :          0 :                         kfree(kdb_commands);
    2702                 :            :                 }
    2703                 :          0 :                 memset(new + kdb_max_commands - KDB_BASE_CMD_MAX, 0,
    2704                 :            :                        kdb_command_extend * sizeof(*new));
    2705                 :          0 :                 kdb_commands = new;
    2706                 :            :                 kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX;
    2707                 :          0 :                 kdb_max_commands += kdb_command_extend;
    2708                 :            :         }
    2709                 :            : 
    2710                 :          3 :         kp->cmd_name   = cmd;
    2711                 :          3 :         kp->cmd_func   = func;
    2712                 :          3 :         kp->cmd_usage  = usage;
    2713                 :          3 :         kp->cmd_help   = help;
    2714                 :          3 :         kp->cmd_minlen = minlen;
    2715                 :          3 :         kp->cmd_flags  = flags;
    2716                 :            : 
    2717                 :          3 :         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                 :          0 : int kdb_register(char *cmd,
    2735                 :            :              kdb_func_t func,
    2736                 :            :              char *usage,
    2737                 :            :              char *help,
    2738                 :            :              short minlen)
    2739                 :            : {
    2740                 :          0 :         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                 :          0 : int kdb_unregister(char *cmd)
    2754                 :            : {
    2755                 :            :         int i;
    2756                 :            :         kdbtab_t *kp;
    2757                 :            : 
    2758                 :            :         /*
    2759                 :            :          *  find the command.
    2760                 :            :          */
    2761                 :          0 :         for_each_kdbcmd(kp, i) {
    2762                 :          0 :                 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
    2763                 :          0 :                         kp->cmd_name = NULL;
    2764                 :          0 :                         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                 :          3 : static void __init kdb_inittab(void)
    2775                 :            : {
    2776                 :            :         int i;
    2777                 :            :         kdbtab_t *kp;
    2778                 :            : 
    2779                 :          3 :         for_each_kdbcmd(kp, i)
    2780                 :          3 :                 kp->cmd_name = NULL;
    2781                 :            : 
    2782                 :          3 :         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                 :          3 :         kdb_register_flags("mdr", kdb_md, "<vaddr> <bytes>",
    2786                 :            :           "Display Raw Memory", 0,
    2787                 :            :           KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
    2788                 :          3 :         kdb_register_flags("mdp", kdb_md, "<paddr> <bytes>",
    2789                 :            :           "Display Physical Memory", 0,
    2790                 :            :           KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
    2791                 :          3 :         kdb_register_flags("mds", kdb_md, "<vaddr>",
    2792                 :            :           "Display Memory Symbolically", 0,
    2793                 :            :           KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
    2794                 :          3 :         kdb_register_flags("mm", kdb_mm, "<vaddr> <contents>",
    2795                 :            :           "Modify Memory Contents", 0,
    2796                 :            :           KDB_ENABLE_MEM_WRITE | KDB_REPEAT_NO_ARGS);
    2797                 :          3 :         kdb_register_flags("go", kdb_go, "[<vaddr>]",
    2798                 :            :           "Continue Execution", 1,
    2799                 :            :           KDB_ENABLE_REG_WRITE | KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
    2800                 :          3 :         kdb_register_flags("rd", kdb_rd, "",
    2801                 :            :           "Display Registers", 0,
    2802                 :            :           KDB_ENABLE_REG_READ);
    2803                 :          3 :         kdb_register_flags("rm", kdb_rm, "<reg> <contents>",
    2804                 :            :           "Modify Registers", 0,
    2805                 :            :           KDB_ENABLE_REG_WRITE);
    2806                 :          3 :         kdb_register_flags("ef", kdb_ef, "<vaddr>",
    2807                 :            :           "Display exception frame", 0,
    2808                 :            :           KDB_ENABLE_MEM_READ);
    2809                 :          3 :         kdb_register_flags("bt", kdb_bt, "[<vaddr>]",
    2810                 :            :           "Stack traceback", 1,
    2811                 :            :           KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS);
    2812                 :          3 :         kdb_register_flags("btp", kdb_bt, "<pid>",
    2813                 :            :           "Display stack for process <pid>", 0,
    2814                 :            :           KDB_ENABLE_INSPECT);
    2815                 :          3 :         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                 :          3 :         kdb_register_flags("btc", kdb_bt, "",
    2819                 :            :           "Backtrace current process on each cpu", 0,
    2820                 :            :           KDB_ENABLE_INSPECT);
    2821                 :          3 :         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                 :          3 :         kdb_register_flags("env", kdb_env, "",
    2825                 :            :           "Show environment variables", 0,
    2826                 :            :           KDB_ENABLE_ALWAYS_SAFE);
    2827                 :          3 :         kdb_register_flags("set", kdb_set, "",
    2828                 :            :           "Set environment variables", 0,
    2829                 :            :           KDB_ENABLE_ALWAYS_SAFE);
    2830                 :          3 :         kdb_register_flags("help", kdb_help, "",
    2831                 :            :           "Display Help Message", 1,
    2832                 :            :           KDB_ENABLE_ALWAYS_SAFE);
    2833                 :          3 :         kdb_register_flags("?", kdb_help, "",
    2834                 :            :           "Display Help Message", 0,
    2835                 :            :           KDB_ENABLE_ALWAYS_SAFE);
    2836                 :          3 :         kdb_register_flags("cpu", kdb_cpu, "<cpunum>",
    2837                 :            :           "Switch to new cpu", 0,
    2838                 :            :           KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
    2839                 :          3 :         kdb_register_flags("kgdb", kdb_kgdb, "",
    2840                 :            :           "Enter kgdb mode", 0, 0);
    2841                 :          3 :         kdb_register_flags("ps", kdb_ps, "[<flags>|A]",
    2842                 :            :           "Display active task list", 0,
    2843                 :            :           KDB_ENABLE_INSPECT);
    2844                 :          3 :         kdb_register_flags("pid", kdb_pid, "<pidnum>",
    2845                 :            :           "Switch to another task", 0,
    2846                 :            :           KDB_ENABLE_INSPECT);
    2847                 :          3 :         kdb_register_flags("reboot", kdb_reboot, "",
    2848                 :            :           "Reboot the machine immediately", 0,
    2849                 :            :           KDB_ENABLE_REBOOT);
    2850                 :            : #if defined(CONFIG_MODULES)
    2851                 :          3 :         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                 :          3 :         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                 :          3 :         kdb_register_flags("dmesg", kdb_dmesg, "[lines]",
    2862                 :            :           "Display syslog buffer", 0,
    2863                 :            :           KDB_ENABLE_ALWAYS_SAFE);
    2864                 :            : #endif
    2865                 :          3 :         if (arch_kgdb_ops.enable_nmi) {
    2866                 :          0 :                 kdb_register_flags("disable_nmi", kdb_disable_nmi, "",
    2867                 :            :                   "Disable NMI entry to KDB", 0,
    2868                 :            :                   KDB_ENABLE_ALWAYS_SAFE);
    2869                 :            :         }
    2870                 :          3 :         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                 :          3 :         kdb_register_flags("kill", kdb_kill, "<-signal> <pid>",
    2874                 :            :           "Send a signal to a process", 0,
    2875                 :            :           KDB_ENABLE_SIGNAL);
    2876                 :          3 :         kdb_register_flags("summary", kdb_summary, "",
    2877                 :            :           "Summarize the system", 4,
    2878                 :            :           KDB_ENABLE_ALWAYS_SAFE);
    2879                 :          3 :         kdb_register_flags("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
    2880                 :            :           "Display per_cpu variables", 3,
    2881                 :            :           KDB_ENABLE_MEM_READ);
    2882                 :          3 :         kdb_register_flags("grephelp", kdb_grep_help, "",
    2883                 :            :           "Display help on | grep", 0,
    2884                 :            :           KDB_ENABLE_ALWAYS_SAFE);
    2885                 :          3 : }
    2886                 :            : 
    2887                 :            : /* Execute any commands defined in kdb_cmds.  */
    2888                 :          3 : static void __init kdb_cmd_init(void)
    2889                 :            : {
    2890                 :            :         int i, diag;
    2891                 :          3 :         for (i = 0; kdb_cmds[i]; ++i) {
    2892                 :          3 :                 diag = kdb_parse(kdb_cmds[i]);
    2893                 :          3 :                 if (diag)
    2894                 :          0 :                         kdb_printf("kdb command %s failed, kdb diag %d\n",
    2895                 :            :                                 kdb_cmds[i], diag);
    2896                 :            :         }
    2897                 :          3 :         if (defcmd_in_progress) {
    2898                 :          0 :                 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
    2899                 :          0 :                 kdb_parse("endefcmd");
    2900                 :            :         }
    2901                 :          3 : }
    2902                 :            : 
    2903                 :            : /* Initialize kdb_printf, breakpoint tables and kdb state */
    2904                 :          3 : void __init kdb_init(int lvl)
    2905                 :            : {
    2906                 :            :         static int kdb_init_lvl = KDB_NOT_INITIALIZED;
    2907                 :            :         int i;
    2908                 :            : 
    2909                 :          3 :         if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
    2910                 :          3 :                 return;
    2911                 :          3 :         for (i = kdb_init_lvl; i < lvl; i++) {
    2912                 :          3 :                 switch (i) {
    2913                 :            :                 case KDB_NOT_INITIALIZED:
    2914                 :          3 :                         kdb_inittab();          /* Initialize Command Table */
    2915                 :          3 :                         kdb_initbptab();        /* Initialize Breakpoints */
    2916                 :          3 :                         break;
    2917                 :            :                 case KDB_INIT_EARLY:
    2918                 :          3 :                         kdb_cmd_init();         /* Build kdb_cmds tables */
    2919                 :          3 :                         break;
    2920                 :            :                 }
    2921                 :            :         }
    2922                 :          3 :         kdb_init_lvl = lvl;
    2923                 :            : }
    

Generated by: LCOV version 1.14