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