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