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