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