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