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