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