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