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