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