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