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