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