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