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