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