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