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