aboutsummaryrefslogtreecommitdiffstats
path: root/kernel
diff options
context:
space:
mode:
Diffstat (limited to 'kernel')
-rw-r--r--kernel/debug/Makefile1
-rw-r--r--kernel/debug/kdb/.gitignore1
-rw-r--r--kernel/debug/kdb/Makefile24
-rw-r--r--kernel/debug/kdb/kdb_bp.c564
-rw-r--r--kernel/debug/kdb/kdb_bt.c208
-rw-r--r--kernel/debug/kdb/kdb_cmds35
-rw-r--r--kernel/debug/kdb/kdb_debugger.c159
-rw-r--r--kernel/debug/kdb/kdb_io.c789
-rw-r--r--kernel/debug/kdb/kdb_main.c2845
-rw-r--r--kernel/debug/kdb/kdb_private.h301
-rw-r--r--kernel/debug/kdb/kdb_support.c927
11 files changed, 5854 insertions, 0 deletions
diff --git a/kernel/debug/Makefile b/kernel/debug/Makefile
index fd4dc6e7782c..a85edc339985 100644
--- a/kernel/debug/Makefile
+++ b/kernel/debug/Makefile
@@ -3,3 +3,4 @@
3# 3#
4 4
5obj-$(CONFIG_KGDB) += debug_core.o gdbstub.o 5obj-$(CONFIG_KGDB) += debug_core.o gdbstub.o
6obj-$(CONFIG_KGDB_KDB) += kdb/
diff --git a/kernel/debug/kdb/.gitignore b/kernel/debug/kdb/.gitignore
new file mode 100644
index 000000000000..396d12eda9e8
--- /dev/null
+++ b/kernel/debug/kdb/.gitignore
@@ -0,0 +1 @@
gen-kdb_cmds.c
diff --git a/kernel/debug/kdb/Makefile b/kernel/debug/kdb/Makefile
new file mode 100644
index 000000000000..d1e925eddbcd
--- /dev/null
+++ b/kernel/debug/kdb/Makefile
@@ -0,0 +1,24 @@
1# This file is subject to the terms and conditions of the GNU General Public
2# License. See the file "COPYING" in the main directory of this archive
3# for more details.
4#
5# Copyright (c) 1999-2004 Silicon Graphics, Inc. All Rights Reserved.
6# Copyright (c) 2009 Wind River Systems, Inc. All Rights Reserved.
7#
8
9CCVERSION := $(shell $(CC) -v 2>&1 | sed -ne '$$p')
10obj-y := kdb_io.o kdb_main.o kdb_support.o kdb_bt.o gen-kdb_cmds.o kdb_bp.o kdb_debugger.o
11
12clean-files := gen-kdb_cmds.c
13
14quiet_cmd_gen-kdb = GENKDB $@
15 cmd_gen-kdb = $(AWK) 'BEGIN {print "\#include <linux/stddef.h>"; print "\#include <linux/init.h>"} \
16 /^\#/{next} \
17 /^[ \t]*$$/{next} \
18 {gsub(/"/, "\\\"", $$0); \
19 print "static __initdata char kdb_cmd" cmds++ "[] = \"" $$0 "\\n\";"} \
20 END {print "extern char *kdb_cmds[]; char __initdata *kdb_cmds[] = {"; for (i = 0; i < cmds; ++i) {print " kdb_cmd" i ","}; print(" NULL\n};");}' \
21 $(filter-out %/Makefile,$^) > $@#
22
23$(obj)/gen-kdb_cmds.c: $(src)/kdb_cmds $(src)/Makefile
24 $(call cmd,gen-kdb)
diff --git a/kernel/debug/kdb/kdb_bp.c b/kernel/debug/kdb/kdb_bp.c
new file mode 100644
index 000000000000..75bd9b3ebbb7
--- /dev/null
+++ b/kernel/debug/kdb/kdb_bp.c
@@ -0,0 +1,564 @@
1/*
2 * Kernel Debugger Architecture Independent Breakpoint Handler
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) 2009 Wind River Systems, Inc. All Rights Reserved.
10 */
11
12#include <linux/string.h>
13#include <linux/kernel.h>
14#include <linux/init.h>
15#include <linux/kdb.h>
16#include <linux/kgdb.h>
17#include <linux/smp.h>
18#include <linux/sched.h>
19#include <linux/interrupt.h>
20#include "kdb_private.h"
21
22/*
23 * Table of kdb_breakpoints
24 */
25kdb_bp_t kdb_breakpoints[KDB_MAXBPT];
26
27static void kdb_setsinglestep(struct pt_regs *regs)
28{
29 KDB_STATE_SET(DOING_SS);
30}
31
32static char *kdb_rwtypes[] = {
33 "Instruction(i)",
34 "Instruction(Register)",
35 "Data Write",
36 "I/O",
37 "Data Access"
38};
39
40static char *kdb_bptype(kdb_bp_t *bp)
41{
42 if (bp->bp_type < 0 || bp->bp_type > 4)
43 return "";
44
45 return kdb_rwtypes[bp->bp_type];
46}
47
48static int kdb_parsebp(int argc, const char **argv, int *nextargp, kdb_bp_t *bp)
49{
50 int nextarg = *nextargp;
51 int diag;
52
53 bp->bph_length = 1;
54 if ((argc + 1) != nextarg) {
55 if (strnicmp(argv[nextarg], "datar", sizeof("datar")) == 0)
56 bp->bp_type = BP_ACCESS_WATCHPOINT;
57 else if (strnicmp(argv[nextarg], "dataw", sizeof("dataw")) == 0)
58 bp->bp_type = BP_WRITE_WATCHPOINT;
59 else if (strnicmp(argv[nextarg], "inst", sizeof("inst")) == 0)
60 bp->bp_type = BP_HARDWARE_BREAKPOINT;
61 else
62 return KDB_ARGCOUNT;
63
64 bp->bph_length = 1;
65
66 nextarg++;
67
68 if ((argc + 1) != nextarg) {
69 unsigned long len;
70
71 diag = kdbgetularg((char *)argv[nextarg],
72 &len);
73 if (diag)
74 return diag;
75
76
77 if (len > 8)
78 return KDB_BADLENGTH;
79
80 bp->bph_length = len;
81 nextarg++;
82 }
83
84 if ((argc + 1) != nextarg)
85 return KDB_ARGCOUNT;
86 }
87
88 *nextargp = nextarg;
89 return 0;
90}
91
92static int _kdb_bp_remove(kdb_bp_t *bp)
93{
94 int ret = 1;
95 if (!bp->bp_installed)
96 return ret;
97 if (!bp->bp_type)
98 ret = dbg_remove_sw_break(bp->bp_addr);
99 else
100 ret = arch_kgdb_ops.remove_hw_breakpoint(bp->bp_addr,
101 bp->bph_length,
102 bp->bp_type);
103 if (ret == 0)
104 bp->bp_installed = 0;
105 return ret;
106}
107
108static void kdb_handle_bp(struct pt_regs *regs, kdb_bp_t *bp)
109{
110 if (KDB_DEBUG(BP))
111 kdb_printf("regs->ip = 0x%lx\n", instruction_pointer(regs));
112
113 /*
114 * Setup single step
115 */
116 kdb_setsinglestep(regs);
117
118 /*
119 * Reset delay attribute
120 */
121 bp->bp_delay = 0;
122 bp->bp_delayed = 1;
123}
124
125static int _kdb_bp_install(struct pt_regs *regs, kdb_bp_t *bp)
126{
127 int ret;
128 /*
129 * Install the breakpoint, if it is not already installed.
130 */
131
132 if (KDB_DEBUG(BP))
133 kdb_printf("%s: bp_installed %d\n",
134 __func__, bp->bp_installed);
135 if (!KDB_STATE(SSBPT))
136 bp->bp_delay = 0;
137 if (bp->bp_installed)
138 return 1;
139 if (bp->bp_delay || (bp->bp_delayed && KDB_STATE(DOING_SS))) {
140 if (KDB_DEBUG(BP))
141 kdb_printf("%s: delayed bp\n", __func__);
142 kdb_handle_bp(regs, bp);
143 return 0;
144 }
145 if (!bp->bp_type)
146 ret = dbg_set_sw_break(bp->bp_addr);
147 else
148 ret = arch_kgdb_ops.set_hw_breakpoint(bp->bp_addr,
149 bp->bph_length,
150 bp->bp_type);
151 if (ret == 0) {
152 bp->bp_installed = 1;
153 } else {
154 kdb_printf("%s: failed to set breakpoint at 0x%lx\n",
155 __func__, bp->bp_addr);
156 return 1;
157 }
158 return 0;
159}
160
161/*
162 * kdb_bp_install
163 *
164 * Install kdb_breakpoints prior to returning from the
165 * kernel debugger. This allows the kdb_breakpoints to be set
166 * upon functions that are used internally by kdb, such as
167 * printk(). This function is only called once per kdb session.
168 */
169void kdb_bp_install(struct pt_regs *regs)
170{
171 int i;
172
173 for (i = 0; i < KDB_MAXBPT; i++) {
174 kdb_bp_t *bp = &kdb_breakpoints[i];
175
176 if (KDB_DEBUG(BP)) {
177 kdb_printf("%s: bp %d bp_enabled %d\n",
178 __func__, i, bp->bp_enabled);
179 }
180 if (bp->bp_enabled)
181 _kdb_bp_install(regs, bp);
182 }
183}
184
185/*
186 * kdb_bp_remove
187 *
188 * Remove kdb_breakpoints upon entry to the kernel debugger.
189 *
190 * Parameters:
191 * None.
192 * Outputs:
193 * None.
194 * Returns:
195 * None.
196 * Locking:
197 * None.
198 * Remarks:
199 */
200void kdb_bp_remove(void)
201{
202 int i;
203
204 for (i = KDB_MAXBPT - 1; i >= 0; i--) {
205 kdb_bp_t *bp = &kdb_breakpoints[i];
206
207 if (KDB_DEBUG(BP)) {
208 kdb_printf("%s: bp %d bp_enabled %d\n",
209 __func__, i, bp->bp_enabled);
210 }
211 if (bp->bp_enabled)
212 _kdb_bp_remove(bp);
213 }
214}
215
216
217/*
218 * kdb_printbp
219 *
220 * Internal function to format and print a breakpoint entry.
221 *
222 * Parameters:
223 * None.
224 * Outputs:
225 * None.
226 * Returns:
227 * None.
228 * Locking:
229 * None.
230 * Remarks:
231 */
232
233static void kdb_printbp(kdb_bp_t *bp, int i)
234{
235 kdb_printf("%s ", kdb_bptype(bp));
236 kdb_printf("BP #%d at ", i);
237 kdb_symbol_print(bp->bp_addr, NULL, KDB_SP_DEFAULT);
238
239 if (bp->bp_enabled)
240 kdb_printf("\n is enabled");
241 else
242 kdb_printf("\n is disabled");
243
244 kdb_printf("\taddr at %016lx, hardtype=%d installed=%d\n",
245 bp->bp_addr, bp->bp_type, bp->bp_installed);
246
247 kdb_printf("\n");
248}
249
250/*
251 * kdb_bp
252 *
253 * Handle the bp commands.
254 *
255 * [bp|bph] <addr-expression> [DATAR|DATAW]
256 *
257 * Parameters:
258 * argc Count of arguments in argv
259 * argv Space delimited command line arguments
260 * Outputs:
261 * None.
262 * Returns:
263 * Zero for success, a kdb diagnostic if failure.
264 * Locking:
265 * None.
266 * Remarks:
267 *
268 * bp Set breakpoint on all cpus. Only use hardware assist if need.
269 * bph Set breakpoint on all cpus. Force hardware register
270 */
271
272static int kdb_bp(int argc, const char **argv)
273{
274 int i, bpno;
275 kdb_bp_t *bp, *bp_check;
276 int diag;
277 int free;
278 char *symname = NULL;
279 long offset = 0ul;
280 int nextarg;
281 kdb_bp_t template = {0};
282
283 if (argc == 0) {
284 /*
285 * Display breakpoint table
286 */
287 for (bpno = 0, bp = kdb_breakpoints; bpno < KDB_MAXBPT;
288 bpno++, bp++) {
289 if (bp->bp_free)
290 continue;
291 kdb_printbp(bp, bpno);
292 }
293
294 return 0;
295 }
296
297 nextarg = 1;
298 diag = kdbgetaddrarg(argc, argv, &nextarg, &template.bp_addr,
299 &offset, &symname);
300 if (diag)
301 return diag;
302 if (!template.bp_addr)
303 return KDB_BADINT;
304
305 /*
306 * Find an empty bp structure to allocate
307 */
308 free = KDB_MAXBPT;
309 for (bpno = 0, bp = kdb_breakpoints; bpno < KDB_MAXBPT; bpno++, bp++) {
310 if (bp->bp_free)
311 break;
312 }
313
314 if (bpno == KDB_MAXBPT)
315 return KDB_TOOMANYBPT;
316
317 if (strcmp(argv[0], "bph") == 0) {
318 template.bp_type = BP_HARDWARE_BREAKPOINT;
319 diag = kdb_parsebp(argc, argv, &nextarg, &template);
320 if (diag)
321 return diag;
322 } else {
323 template.bp_type = BP_BREAKPOINT;
324 }
325
326 /*
327 * Check for clashing breakpoints.
328 *
329 * Note, in this design we can't have hardware breakpoints
330 * enabled for both read and write on the same address.
331 */
332 for (i = 0, bp_check = kdb_breakpoints; i < KDB_MAXBPT;
333 i++, bp_check++) {
334 if (!bp_check->bp_free &&
335 bp_check->bp_addr == template.bp_addr) {
336 kdb_printf("You already have a breakpoint at "
337 kdb_bfd_vma_fmt0 "\n", template.bp_addr);
338 return KDB_DUPBPT;
339 }
340 }
341
342 template.bp_enabled = 1;
343
344 /*
345 * Actually allocate the breakpoint found earlier
346 */
347 *bp = template;
348 bp->bp_free = 0;
349
350 kdb_printbp(bp, bpno);
351
352 return 0;
353}
354
355/*
356 * kdb_bc
357 *
358 * Handles the 'bc', 'be', and 'bd' commands
359 *
360 * [bd|bc|be] <breakpoint-number>
361 * [bd|bc|be] *
362 *
363 * Parameters:
364 * argc Count of arguments in argv
365 * argv Space delimited command line arguments
366 * Outputs:
367 * None.
368 * Returns:
369 * Zero for success, a kdb diagnostic for failure
370 * Locking:
371 * None.
372 * Remarks:
373 */
374static int kdb_bc(int argc, const char **argv)
375{
376 unsigned long addr;
377 kdb_bp_t *bp = NULL;
378 int lowbp = KDB_MAXBPT;
379 int highbp = 0;
380 int done = 0;
381 int i;
382 int diag = 0;
383
384 int cmd; /* KDBCMD_B? */
385#define KDBCMD_BC 0
386#define KDBCMD_BE 1
387#define KDBCMD_BD 2
388
389 if (strcmp(argv[0], "be") == 0)
390 cmd = KDBCMD_BE;
391 else if (strcmp(argv[0], "bd") == 0)
392 cmd = KDBCMD_BD;
393 else
394 cmd = KDBCMD_BC;
395
396 if (argc != 1)
397 return KDB_ARGCOUNT;
398
399 if (strcmp(argv[1], "*") == 0) {
400 lowbp = 0;
401 highbp = KDB_MAXBPT;
402 } else {
403 diag = kdbgetularg(argv[1], &addr);
404 if (diag)
405 return diag;
406
407 /*
408 * For addresses less than the maximum breakpoint number,
409 * assume that the breakpoint number is desired.
410 */
411 if (addr < KDB_MAXBPT) {
412 bp = &kdb_breakpoints[addr];
413 lowbp = highbp = addr;
414 highbp++;
415 } else {
416 for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT;
417 i++, bp++) {
418 if (bp->bp_addr == addr) {
419 lowbp = highbp = i;
420 highbp++;
421 break;
422 }
423 }
424 }
425 }
426
427 /*
428 * Now operate on the set of breakpoints matching the input
429 * criteria (either '*' for all, or an individual breakpoint).
430 */
431 for (bp = &kdb_breakpoints[lowbp], i = lowbp;
432 i < highbp;
433 i++, bp++) {
434 if (bp->bp_free)
435 continue;
436
437 done++;
438
439 switch (cmd) {
440 case KDBCMD_BC:
441 bp->bp_enabled = 0;
442
443 kdb_printf("Breakpoint %d at "
444 kdb_bfd_vma_fmt " cleared\n",
445 i, bp->bp_addr);
446
447 bp->bp_addr = 0;
448 bp->bp_free = 1;
449
450 break;
451 case KDBCMD_BE:
452 bp->bp_enabled = 1;
453
454 kdb_printf("Breakpoint %d at "
455 kdb_bfd_vma_fmt " enabled",
456 i, bp->bp_addr);
457
458 kdb_printf("\n");
459 break;
460 case KDBCMD_BD:
461 if (!bp->bp_enabled)
462 break;
463
464 bp->bp_enabled = 0;
465
466 kdb_printf("Breakpoint %d at "
467 kdb_bfd_vma_fmt " disabled\n",
468 i, bp->bp_addr);
469
470 break;
471 }
472 if (bp->bp_delay && (cmd == KDBCMD_BC || cmd == KDBCMD_BD)) {
473 bp->bp_delay = 0;
474 KDB_STATE_CLEAR(SSBPT);
475 }
476 }
477
478 return (!done) ? KDB_BPTNOTFOUND : 0;
479}
480
481/*
482 * kdb_ss
483 *
484 * Process the 'ss' (Single Step) and 'ssb' (Single Step to Branch)
485 * commands.
486 *
487 * ss
488 * ssb
489 *
490 * Parameters:
491 * argc Argument count
492 * argv Argument vector
493 * Outputs:
494 * None.
495 * Returns:
496 * KDB_CMD_SS[B] for success, a kdb error if failure.
497 * Locking:
498 * None.
499 * Remarks:
500 *
501 * Set the arch specific option to trigger a debug trap after the next
502 * instruction.
503 *
504 * For 'ssb', set the trace flag in the debug trap handler
505 * after printing the current insn and return directly without
506 * invoking the kdb command processor, until a branch instruction
507 * is encountered.
508 */
509
510static int kdb_ss(int argc, const char **argv)
511{
512 int ssb = 0;
513
514 ssb = (strcmp(argv[0], "ssb") == 0);
515 if (argc != 0)
516 return KDB_ARGCOUNT;
517 /*
518 * Set trace flag and go.
519 */
520 KDB_STATE_SET(DOING_SS);
521 if (ssb) {
522 KDB_STATE_SET(DOING_SSB);
523 return KDB_CMD_SSB;
524 }
525 return KDB_CMD_SS;
526}
527
528/* Initialize the breakpoint table and register breakpoint commands. */
529
530void __init kdb_initbptab(void)
531{
532 int i;
533 kdb_bp_t *bp;
534
535 /*
536 * First time initialization.
537 */
538 memset(&kdb_breakpoints, '\0', sizeof(kdb_breakpoints));
539
540 for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; i++, bp++)
541 bp->bp_free = 1;
542
543 kdb_register_repeat("bp", kdb_bp, "[<vaddr>]",
544 "Set/Display breakpoints", 0, KDB_REPEAT_NO_ARGS);
545 kdb_register_repeat("bl", kdb_bp, "[<vaddr>]",
546 "Display breakpoints", 0, KDB_REPEAT_NO_ARGS);
547 if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT)
548 kdb_register_repeat("bph", kdb_bp, "[<vaddr>]",
549 "[datar [length]|dataw [length]] Set hw brk", 0, KDB_REPEAT_NO_ARGS);
550 kdb_register_repeat("bc", kdb_bc, "<bpnum>",
551 "Clear Breakpoint", 0, KDB_REPEAT_NONE);
552 kdb_register_repeat("be", kdb_bc, "<bpnum>",
553 "Enable Breakpoint", 0, KDB_REPEAT_NONE);
554 kdb_register_repeat("bd", kdb_bc, "<bpnum>",
555 "Disable Breakpoint", 0, KDB_REPEAT_NONE);
556
557 kdb_register_repeat("ss", kdb_ss, "",
558 "Single Step", 1, KDB_REPEAT_NO_ARGS);
559 kdb_register_repeat("ssb", kdb_ss, "",
560 "Single step to branch/call", 0, KDB_REPEAT_NO_ARGS);
561 /*
562 * Architecture dependent initialization.
563 */
564}
diff --git a/kernel/debug/kdb/kdb_bt.c b/kernel/debug/kdb/kdb_bt.c
new file mode 100644
index 000000000000..483fa4e7aaac
--- /dev/null
+++ b/kernel/debug/kdb/kdb_bt.c
@@ -0,0 +1,208 @@
1/*
2 * Kernel Debugger Architecture Independent Stack Traceback
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) 2009 Wind River Systems, Inc. All Rights Reserved.
10 */
11
12#include <linux/ctype.h>
13#include <linux/string.h>
14#include <linux/kernel.h>
15#include <linux/sched.h>
16#include <linux/kdb.h>
17#include <linux/nmi.h>
18#include <asm/system.h>
19#include "kdb_private.h"
20
21
22static void kdb_show_stack(struct task_struct *p, void *addr)
23{
24 int old_lvl = console_loglevel;
25 console_loglevel = 15;
26 kdb_set_current_task(p);
27 if (addr) {
28 show_stack((struct task_struct *)p, addr);
29 } else if (kdb_current_regs) {
30#ifdef CONFIG_X86
31 show_stack(p, &kdb_current_regs->sp);
32#else
33 show_stack(p, NULL);
34#endif
35 } else {
36 show_stack(p, NULL);
37 }
38 console_loglevel = old_lvl;
39}
40
41/*
42 * kdb_bt
43 *
44 * This function implements the 'bt' command. Print a stack
45 * traceback.
46 *
47 * bt [<address-expression>] (addr-exp is for alternate stacks)
48 * btp <pid> Kernel stack for <pid>
49 * btt <address-expression> Kernel stack for task structure at
50 * <address-expression>
51 * bta [DRSTCZEUIMA] All useful processes, optionally
52 * filtered by state
53 * btc [<cpu>] The current process on one cpu,
54 * default is all cpus
55 *
56 * bt <address-expression> refers to a address on the stack, that location
57 * is assumed to contain a return address.
58 *
59 * btt <address-expression> refers to the address of a struct task.
60 *
61 * Inputs:
62 * argc argument count
63 * argv argument vector
64 * Outputs:
65 * None.
66 * Returns:
67 * zero for success, a kdb diagnostic if error
68 * Locking:
69 * none.
70 * Remarks:
71 * Backtrack works best when the code uses frame pointers. But even
72 * without frame pointers we should get a reasonable trace.
73 *
74 * mds comes in handy when examining the stack to do a manual traceback or
75 * to get a starting point for bt <address-expression>.
76 */
77
78static int
79kdb_bt1(struct task_struct *p, unsigned long mask,
80 int argcount, int btaprompt)
81{
82 char buffer[2];
83 if (kdb_getarea(buffer[0], (unsigned long)p) ||
84 kdb_getarea(buffer[0], (unsigned long)(p+1)-1))
85 return KDB_BADADDR;
86 if (!kdb_task_state(p, mask))
87 return 0;
88 kdb_printf("Stack traceback for pid %d\n", p->pid);
89 kdb_ps1(p);
90 kdb_show_stack(p, NULL);
91 if (btaprompt) {
92 kdb_getstr(buffer, sizeof(buffer),
93 "Enter <q> to end, <cr> to continue:");
94 if (buffer[0] == 'q') {
95 kdb_printf("\n");
96 return 1;
97 }
98 }
99 touch_nmi_watchdog();
100 return 0;
101}
102
103int
104kdb_bt(int argc, const char **argv)
105{
106 int diag;
107 int argcount = 5;
108 int btaprompt = 1;
109 int nextarg;
110 unsigned long addr;
111 long offset;
112
113 kdbgetintenv("BTARGS", &argcount); /* Arguments to print */
114 kdbgetintenv("BTAPROMPT", &btaprompt); /* Prompt after each
115 * proc in bta */
116
117 if (strcmp(argv[0], "bta") == 0) {
118 struct task_struct *g, *p;
119 unsigned long cpu;
120 unsigned long mask = kdb_task_state_string(argc ? argv[1] :
121 NULL);
122 if (argc == 0)
123 kdb_ps_suppressed();
124 /* Run the active tasks first */
125 for_each_online_cpu(cpu) {
126 p = kdb_curr_task(cpu);
127 if (kdb_bt1(p, mask, argcount, btaprompt))
128 return 0;
129 }
130 /* Now the inactive tasks */
131 kdb_do_each_thread(g, p) {
132 if (task_curr(p))
133 continue;
134 if (kdb_bt1(p, mask, argcount, btaprompt))
135 return 0;
136 } kdb_while_each_thread(g, p);
137 } else if (strcmp(argv[0], "btp") == 0) {
138 struct task_struct *p;
139 unsigned long pid;
140 if (argc != 1)
141 return KDB_ARGCOUNT;
142 diag = kdbgetularg((char *)argv[1], &pid);
143 if (diag)
144 return diag;
145 p = find_task_by_pid_ns(pid, &init_pid_ns);
146 if (p) {
147 kdb_set_current_task(p);
148 return kdb_bt1(p, ~0UL, argcount, 0);
149 }
150 kdb_printf("No process with pid == %ld found\n", pid);
151 return 0;
152 } else if (strcmp(argv[0], "btt") == 0) {
153 if (argc != 1)
154 return KDB_ARGCOUNT;
155 diag = kdbgetularg((char *)argv[1], &addr);
156 if (diag)
157 return diag;
158 kdb_set_current_task((struct task_struct *)addr);
159 return kdb_bt1((struct task_struct *)addr, ~0UL, argcount, 0);
160 } else if (strcmp(argv[0], "btc") == 0) {
161 unsigned long cpu = ~0;
162 struct task_struct *save_current_task = kdb_current_task;
163 char buf[80];
164 if (argc > 1)
165 return KDB_ARGCOUNT;
166 if (argc == 1) {
167 diag = kdbgetularg((char *)argv[1], &cpu);
168 if (diag)
169 return diag;
170 }
171 /* Recursive use of kdb_parse, do not use argv after
172 * this point */
173 argv = NULL;
174 if (cpu != ~0) {
175 if (cpu >= num_possible_cpus() || !cpu_online(cpu)) {
176 kdb_printf("no process for cpu %ld\n", cpu);
177 return 0;
178 }
179 sprintf(buf, "btt 0x%p\n", KDB_TSK(cpu));
180 kdb_parse(buf);
181 return 0;
182 }
183 kdb_printf("btc: cpu status: ");
184 kdb_parse("cpu\n");
185 for_each_online_cpu(cpu) {
186 sprintf(buf, "btt 0x%p\n", KDB_TSK(cpu));
187 kdb_parse(buf);
188 touch_nmi_watchdog();
189 }
190 kdb_set_current_task(save_current_task);
191 return 0;
192 } else {
193 if (argc) {
194 nextarg = 1;
195 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
196 &offset, NULL);
197 if (diag)
198 return diag;
199 kdb_show_stack(kdb_current_task, (void *)addr);
200 return 0;
201 } else {
202 return kdb_bt1(kdb_current_task, ~0UL, argcount, 0);
203 }
204 }
205
206 /* NOTREACHED */
207 return 0;
208}
diff --git a/kernel/debug/kdb/kdb_cmds b/kernel/debug/kdb/kdb_cmds
new file mode 100644
index 000000000000..56c88e4db309
--- /dev/null
+++ b/kernel/debug/kdb/kdb_cmds
@@ -0,0 +1,35 @@
1# Initial commands for kdb, alter to suit your needs.
2# These commands are executed in kdb_init() context, no SMP, no
3# processes. Commands that require process data (including stack or
4# registers) are not reliable this early. set and bp commands should
5# be safe. Global breakpoint commands affect each cpu as it is booted.
6
7# Standard debugging information for first level support, just type archkdb
8# or archkdbcpu or archkdbshort at the kdb prompt.
9
10defcmd dumpcommon "" "Common kdb debugging"
11 set BTAPROMPT 0
12 set LINES 10000
13 -summary
14 -cpu
15 -ps
16 -dmesg 600
17 -bt
18endefcmd
19
20defcmd dumpall "" "First line debugging"
21 set BTSYMARG 1
22 set BTARGS 9
23 pid R
24 -dumpcommon
25 -bta
26endefcmd
27
28defcmd dumpcpu "" "Same as dumpall but only tasks on cpus"
29 set BTSYMARG 1
30 set BTARGS 9
31 pid R
32 -dumpcommon
33 -btc
34endefcmd
35
diff --git a/kernel/debug/kdb/kdb_debugger.c b/kernel/debug/kdb/kdb_debugger.c
new file mode 100644
index 000000000000..f024c0c4b8c4
--- /dev/null
+++ b/kernel/debug/kdb/kdb_debugger.c
@@ -0,0 +1,159 @@
1/*
2 * Created by: Jason Wessel <jason.wessel@windriver.com>
3 *
4 * Copyright (c) 2009 Wind River Systems, Inc. All Rights Reserved.
5 *
6 * This file is licensed under the terms of the GNU General Public
7 * License version 2. This program is licensed "as is" without any
8 * warranty of any kind, whether express or implied.
9 */
10
11#include <linux/kgdb.h>
12#include <linux/kdb.h>
13#include <linux/kdebug.h>
14#include "kdb_private.h"
15#include "../debug_core.h"
16
17/*
18 * KDB interface to KGDB internals
19 */
20get_char_func kdb_poll_funcs[] = {
21 dbg_io_get_char,
22 NULL,
23};
24
25int kdb_stub(struct kgdb_state *ks)
26{
27 int error = 0;
28 kdb_bp_t *bp;
29 unsigned long addr = kgdb_arch_pc(ks->ex_vector, ks->linux_regs);
30 kdb_reason_t reason = KDB_REASON_OOPS;
31 kdb_dbtrap_t db_result = KDB_DB_NOBPT;
32 int i;
33
34 if (KDB_STATE(REENTRY)) {
35 reason = KDB_REASON_SWITCH;
36 KDB_STATE_CLEAR(REENTRY);
37 addr = instruction_pointer(ks->linux_regs);
38 }
39 ks->pass_exception = 0;
40 if (atomic_read(&kgdb_setting_breakpoint))
41 reason = KDB_REASON_KEYBOARD;
42
43 for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; i++, bp++) {
44 if ((bp->bp_enabled) && (bp->bp_addr == addr)) {
45 reason = KDB_REASON_BREAK;
46 db_result = KDB_DB_BPT;
47 if (addr != instruction_pointer(ks->linux_regs))
48 kgdb_arch_set_pc(ks->linux_regs, addr);
49 break;
50 }
51 }
52 if (reason == KDB_REASON_BREAK || reason == KDB_REASON_SWITCH) {
53 for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; i++, bp++) {
54 if (bp->bp_free)
55 continue;
56 if (bp->bp_addr == addr) {
57 bp->bp_delay = 1;
58 bp->bp_delayed = 1;
59 /*
60 * SSBPT is set when the kernel debugger must single step a
61 * task in order to re-establish an instruction breakpoint
62 * which uses the instruction replacement mechanism. It is
63 * cleared by any action that removes the need to single-step
64 * the breakpoint.
65 */
66 reason = KDB_REASON_BREAK;
67 db_result = KDB_DB_BPT;
68 KDB_STATE_SET(SSBPT);
69 break;
70 }
71 }
72 }
73
74 if (reason != KDB_REASON_BREAK && ks->ex_vector == 0 &&
75 ks->signo == SIGTRAP) {
76 reason = KDB_REASON_SSTEP;
77 db_result = KDB_DB_BPT;
78 }
79 /* Set initial kdb state variables */
80 KDB_STATE_CLEAR(KGDB_TRANS);
81 kdb_initial_cpu = ks->cpu;
82 kdb_current_task = kgdb_info[ks->cpu].task;
83 kdb_current_regs = kgdb_info[ks->cpu].debuggerinfo;
84 /* Remove any breakpoints as needed by kdb and clear single step */
85 kdb_bp_remove();
86 KDB_STATE_CLEAR(DOING_SS);
87 KDB_STATE_CLEAR(DOING_SSB);
88 /* zero out any offline cpu data */
89 for_each_present_cpu(i) {
90 if (!cpu_online(i)) {
91 kgdb_info[i].debuggerinfo = NULL;
92 kgdb_info[i].task = NULL;
93 }
94 }
95 if (ks->err_code == DIE_OOPS || reason == KDB_REASON_OOPS) {
96 ks->pass_exception = 1;
97 KDB_FLAG_SET(CATASTROPHIC);
98 }
99 kdb_initial_cpu = ks->cpu;
100 if (KDB_STATE(SSBPT) && reason == KDB_REASON_SSTEP) {
101 KDB_STATE_CLEAR(SSBPT);
102 KDB_STATE_CLEAR(DOING_SS);
103 } else {
104 /* Start kdb main loop */
105 error = kdb_main_loop(KDB_REASON_ENTER, reason,
106 ks->err_code, db_result, ks->linux_regs);
107 }
108 /*
109 * Upon exit from the kdb main loop setup break points and restart
110 * the system based on the requested continue state
111 */
112 kdb_initial_cpu = -1;
113 kdb_current_task = NULL;
114 kdb_current_regs = NULL;
115 kdbnearsym_cleanup();
116 if (error == KDB_CMD_KGDB) {
117 if (KDB_STATE(DOING_KGDB) || KDB_STATE(DOING_KGDB2)) {
118 /*
119 * This inteface glue which allows kdb to transition in into
120 * the gdb stub. In order to do this the '?' or '' gdb serial
121 * packet response is processed here. And then control is
122 * passed to the gdbstub.
123 */
124 if (KDB_STATE(DOING_KGDB))
125 gdbstub_state(ks, "?");
126 else
127 gdbstub_state(ks, "");
128 KDB_STATE_CLEAR(DOING_KGDB);
129 KDB_STATE_CLEAR(DOING_KGDB2);
130 }
131 return DBG_PASS_EVENT;
132 }
133 kdb_bp_install(ks->linux_regs);
134 dbg_activate_sw_breakpoints();
135 /* Set the exit state to a single step or a continue */
136 if (KDB_STATE(DOING_SS))
137 gdbstub_state(ks, "s");
138 else
139 gdbstub_state(ks, "c");
140
141 KDB_FLAG_CLEAR(CATASTROPHIC);
142
143 /* Invoke arch specific exception handling prior to system resume */
144 kgdb_info[ks->cpu].ret_state = gdbstub_state(ks, "e");
145 if (ks->pass_exception)
146 kgdb_info[ks->cpu].ret_state = 1;
147 if (error == KDB_CMD_CPU) {
148 KDB_STATE_SET(REENTRY);
149 /*
150 * Force clear the single step bit because kdb emulates this
151 * differently vs the gdbstub
152 */
153 kgdb_single_step = 0;
154 dbg_deactivate_sw_breakpoints();
155 return DBG_SWITCH_CPU_EVENT;
156 }
157 return kgdb_info[ks->cpu].ret_state;
158}
159
diff --git a/kernel/debug/kdb/kdb_io.c b/kernel/debug/kdb/kdb_io.c
new file mode 100644
index 000000000000..9e3cec7a925c
--- /dev/null
+++ b/kernel/debug/kdb/kdb_io.c
@@ -0,0 +1,789 @@
1/*
2 * Kernel Debugger Architecture Independent Console I/O handler
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-2006 Silicon Graphics, Inc. All Rights Reserved.
9 * Copyright (c) 2009 Wind River Systems, Inc. All Rights Reserved.
10 */
11
12#include <linux/module.h>
13#include <linux/types.h>
14#include <linux/ctype.h>
15#include <linux/kernel.h>
16#include <linux/init.h>
17#include <linux/kdev_t.h>
18#include <linux/console.h>
19#include <linux/string.h>
20#include <linux/sched.h>
21#include <linux/smp.h>
22#include <linux/nmi.h>
23#include <linux/delay.h>
24#include <linux/kdb.h>
25#include <linux/kallsyms.h>
26#include "kdb_private.h"
27
28#define CMD_BUFLEN 256
29char kdb_prompt_str[CMD_BUFLEN];
30
31
32static void kgdb_transition_check(char *buffer)
33{
34 int slen = strlen(buffer);
35 if (strncmp(buffer, "$?#3f", slen) != 0 &&
36 strncmp(buffer, "$qSupported#37", slen) != 0 &&
37 strncmp(buffer, "+$qSupported#37", slen) != 0) {
38 KDB_STATE_SET(KGDB_TRANS);
39 kdb_printf("%s", buffer);
40 }
41}
42
43static int kdb_read_get_key(char *buffer, size_t bufsize)
44{
45#define ESCAPE_UDELAY 1000
46#define ESCAPE_DELAY (2*1000000/ESCAPE_UDELAY) /* 2 seconds worth of udelays */
47 char escape_data[5]; /* longest vt100 escape sequence is 4 bytes */
48 char *ped = escape_data;
49 int escape_delay = 0;
50 get_char_func *f, *f_escape = NULL;
51 int key;
52
53 for (f = &kdb_poll_funcs[0]; ; ++f) {
54 if (*f == NULL) {
55 /* Reset NMI watchdog once per poll loop */
56 touch_nmi_watchdog();
57 f = &kdb_poll_funcs[0];
58 }
59 if (escape_delay == 2) {
60 *ped = '\0';
61 ped = escape_data;
62 --escape_delay;
63 }
64 if (escape_delay == 1) {
65 key = *ped++;
66 if (!*ped)
67 --escape_delay;
68 break;
69 }
70 key = (*f)();
71 if (key == -1) {
72 if (escape_delay) {
73 udelay(ESCAPE_UDELAY);
74 --escape_delay;
75 }
76 continue;
77 }
78 if (bufsize <= 2) {
79 if (key == '\r')
80 key = '\n';
81 *buffer++ = key;
82 *buffer = '\0';
83 return -1;
84 }
85 if (escape_delay == 0 && key == '\e') {
86 escape_delay = ESCAPE_DELAY;
87 ped = escape_data;
88 f_escape = f;
89 }
90 if (escape_delay) {
91 *ped++ = key;
92 if (f_escape != f) {
93 escape_delay = 2;
94 continue;
95 }
96 if (ped - escape_data == 1) {
97 /* \e */
98 continue;
99 } else if (ped - escape_data == 2) {
100 /* \e<something> */
101 if (key != '[')
102 escape_delay = 2;
103 continue;
104 } else if (ped - escape_data == 3) {
105 /* \e[<something> */
106 int mapkey = 0;
107 switch (key) {
108 case 'A': /* \e[A, up arrow */
109 mapkey = 16;
110 break;
111 case 'B': /* \e[B, down arrow */
112 mapkey = 14;
113 break;
114 case 'C': /* \e[C, right arrow */
115 mapkey = 6;
116 break;
117 case 'D': /* \e[D, left arrow */
118 mapkey = 2;
119 break;
120 case '1': /* dropthrough */
121 case '3': /* dropthrough */
122 /* \e[<1,3,4>], may be home, del, end */
123 case '4':
124 mapkey = -1;
125 break;
126 }
127 if (mapkey != -1) {
128 if (mapkey > 0) {
129 escape_data[0] = mapkey;
130 escape_data[1] = '\0';
131 }
132 escape_delay = 2;
133 }
134 continue;
135 } else if (ped - escape_data == 4) {
136 /* \e[<1,3,4><something> */
137 int mapkey = 0;
138 if (key == '~') {
139 switch (escape_data[2]) {
140 case '1': /* \e[1~, home */
141 mapkey = 1;
142 break;
143 case '3': /* \e[3~, del */
144 mapkey = 4;
145 break;
146 case '4': /* \e[4~, end */
147 mapkey = 5;
148 break;
149 }
150 }
151 if (mapkey > 0) {
152 escape_data[0] = mapkey;
153 escape_data[1] = '\0';
154 }
155 escape_delay = 2;
156 continue;
157 }
158 }
159 break; /* A key to process */
160 }
161 return key;
162}
163
164/*
165 * kdb_read
166 *
167 * This function reads a string of characters, terminated by
168 * a newline, or by reaching the end of the supplied buffer,
169 * from the current kernel debugger console device.
170 * Parameters:
171 * buffer - Address of character buffer to receive input characters.
172 * bufsize - size, in bytes, of the character buffer
173 * Returns:
174 * Returns a pointer to the buffer containing the received
175 * character string. This string will be terminated by a
176 * newline character.
177 * Locking:
178 * No locks are required to be held upon entry to this
179 * function. It is not reentrant - it relies on the fact
180 * that while kdb is running on only one "master debug" cpu.
181 * Remarks:
182 *
183 * The buffer size must be >= 2. A buffer size of 2 means that the caller only
184 * wants a single key.
185 *
186 * An escape key could be the start of a vt100 control sequence such as \e[D
187 * (left arrow) or it could be a character in its own right. The standard
188 * method for detecting the difference is to wait for 2 seconds to see if there
189 * are any other characters. kdb is complicated by the lack of a timer service
190 * (interrupts are off), by multiple input sources and by the need to sometimes
191 * return after just one key. Escape sequence processing has to be done as
192 * states in the polling loop.
193 */
194
195static char *kdb_read(char *buffer, size_t bufsize)
196{
197 char *cp = buffer;
198 char *bufend = buffer+bufsize-2; /* Reserve space for newline
199 * and null byte */
200 char *lastchar;
201 char *p_tmp;
202 char tmp;
203 static char tmpbuffer[CMD_BUFLEN];
204 int len = strlen(buffer);
205 int len_tmp;
206 int tab = 0;
207 int count;
208 int i;
209 int diag, dtab_count;
210 int key;
211
212
213 diag = kdbgetintenv("DTABCOUNT", &dtab_count);
214 if (diag)
215 dtab_count = 30;
216
217 if (len > 0) {
218 cp += len;
219 if (*(buffer+len-1) == '\n')
220 cp--;
221 }
222
223 lastchar = cp;
224 *cp = '\0';
225 kdb_printf("%s", buffer);
226poll_again:
227 key = kdb_read_get_key(buffer, bufsize);
228 if (key == -1)
229 return buffer;
230 if (key != 9)
231 tab = 0;
232 switch (key) {
233 case 8: /* backspace */
234 if (cp > buffer) {
235 if (cp < lastchar) {
236 memcpy(tmpbuffer, cp, lastchar - cp);
237 memcpy(cp-1, tmpbuffer, lastchar - cp);
238 }
239 *(--lastchar) = '\0';
240 --cp;
241 kdb_printf("\b%s \r", cp);
242 tmp = *cp;
243 *cp = '\0';
244 kdb_printf(kdb_prompt_str);
245 kdb_printf("%s", buffer);
246 *cp = tmp;
247 }
248 break;
249 case 13: /* enter */
250 *lastchar++ = '\n';
251 *lastchar++ = '\0';
252 kdb_printf("\n");
253 return buffer;
254 case 4: /* Del */
255 if (cp < lastchar) {
256 memcpy(tmpbuffer, cp+1, lastchar - cp - 1);
257 memcpy(cp, tmpbuffer, lastchar - cp - 1);
258 *(--lastchar) = '\0';
259 kdb_printf("%s \r", cp);
260 tmp = *cp;
261 *cp = '\0';
262 kdb_printf(kdb_prompt_str);
263 kdb_printf("%s", buffer);
264 *cp = tmp;
265 }
266 break;
267 case 1: /* Home */
268 if (cp > buffer) {
269 kdb_printf("\r");
270 kdb_printf(kdb_prompt_str);
271 cp = buffer;
272 }
273 break;
274 case 5: /* End */
275 if (cp < lastchar) {
276 kdb_printf("%s", cp);
277 cp = lastchar;
278 }
279 break;
280 case 2: /* Left */
281 if (cp > buffer) {
282 kdb_printf("\b");
283 --cp;
284 }
285 break;
286 case 14: /* Down */
287 memset(tmpbuffer, ' ',
288 strlen(kdb_prompt_str) + (lastchar-buffer));
289 *(tmpbuffer+strlen(kdb_prompt_str) +
290 (lastchar-buffer)) = '\0';
291 kdb_printf("\r%s\r", tmpbuffer);
292 *lastchar = (char)key;
293 *(lastchar+1) = '\0';
294 return lastchar;
295 case 6: /* Right */
296 if (cp < lastchar) {
297 kdb_printf("%c", *cp);
298 ++cp;
299 }
300 break;
301 case 16: /* Up */
302 memset(tmpbuffer, ' ',
303 strlen(kdb_prompt_str) + (lastchar-buffer));
304 *(tmpbuffer+strlen(kdb_prompt_str) +
305 (lastchar-buffer)) = '\0';
306 kdb_printf("\r%s\r", tmpbuffer);
307 *lastchar = (char)key;
308 *(lastchar+1) = '\0';
309 return lastchar;
310 case 9: /* Tab */
311 if (tab < 2)
312 ++tab;
313 p_tmp = buffer;
314 while (*p_tmp == ' ')
315 p_tmp++;
316 if (p_tmp > cp)
317 break;
318 memcpy(tmpbuffer, p_tmp, cp-p_tmp);
319 *(tmpbuffer + (cp-p_tmp)) = '\0';
320 p_tmp = strrchr(tmpbuffer, ' ');
321 if (p_tmp)
322 ++p_tmp;
323 else
324 p_tmp = tmpbuffer;
325 len = strlen(p_tmp);
326 count = kallsyms_symbol_complete(p_tmp,
327 sizeof(tmpbuffer) -
328 (p_tmp - tmpbuffer));
329 if (tab == 2 && count > 0) {
330 kdb_printf("\n%d symbols are found.", count);
331 if (count > dtab_count) {
332 count = dtab_count;
333 kdb_printf(" But only first %d symbols will"
334 " be printed.\nYou can change the"
335 " environment variable DTABCOUNT.",
336 count);
337 }
338 kdb_printf("\n");
339 for (i = 0; i < count; i++) {
340 if (kallsyms_symbol_next(p_tmp, i) < 0)
341 break;
342 kdb_printf("%s ", p_tmp);
343 *(p_tmp + len) = '\0';
344 }
345 if (i >= dtab_count)
346 kdb_printf("...");
347 kdb_printf("\n");
348 kdb_printf(kdb_prompt_str);
349 kdb_printf("%s", buffer);
350 } else if (tab != 2 && count > 0) {
351 len_tmp = strlen(p_tmp);
352 strncpy(p_tmp+len_tmp, cp, lastchar-cp+1);
353 len_tmp = strlen(p_tmp);
354 strncpy(cp, p_tmp+len, len_tmp-len + 1);
355 len = len_tmp - len;
356 kdb_printf("%s", cp);
357 cp += len;
358 lastchar += len;
359 }
360 kdb_nextline = 1; /* reset output line number */
361 break;
362 default:
363 if (key >= 32 && lastchar < bufend) {
364 if (cp < lastchar) {
365 memcpy(tmpbuffer, cp, lastchar - cp);
366 memcpy(cp+1, tmpbuffer, lastchar - cp);
367 *++lastchar = '\0';
368 *cp = key;
369 kdb_printf("%s\r", cp);
370 ++cp;
371 tmp = *cp;
372 *cp = '\0';
373 kdb_printf(kdb_prompt_str);
374 kdb_printf("%s", buffer);
375 *cp = tmp;
376 } else {
377 *++lastchar = '\0';
378 *cp++ = key;
379 /* The kgdb transition check will hide
380 * printed characters if we think that
381 * kgdb is connecting, until the check
382 * fails */
383 if (!KDB_STATE(KGDB_TRANS))
384 kgdb_transition_check(buffer);
385 else
386 kdb_printf("%c", key);
387 }
388 /* Special escape to kgdb */
389 if (lastchar - buffer >= 5 &&
390 strcmp(lastchar - 5, "$?#3f") == 0) {
391 strcpy(buffer, "kgdb");
392 KDB_STATE_SET(DOING_KGDB);
393 return buffer;
394 }
395 if (lastchar - buffer >= 14 &&
396 strcmp(lastchar - 14, "$qSupported#37") == 0) {
397 strcpy(buffer, "kgdb");
398 KDB_STATE_SET(DOING_KGDB2);
399 return buffer;
400 }
401 }
402 break;
403 }
404 goto poll_again;
405}
406
407/*
408 * kdb_getstr
409 *
410 * Print the prompt string and read a command from the
411 * input device.
412 *
413 * Parameters:
414 * buffer Address of buffer to receive command
415 * bufsize Size of buffer in bytes
416 * prompt Pointer to string to use as prompt string
417 * Returns:
418 * Pointer to command buffer.
419 * Locking:
420 * None.
421 * Remarks:
422 * For SMP kernels, the processor number will be
423 * substituted for %d, %x or %o in the prompt.
424 */
425
426char *kdb_getstr(char *buffer, size_t bufsize, char *prompt)
427{
428 if (prompt && kdb_prompt_str != prompt)
429 strncpy(kdb_prompt_str, prompt, CMD_BUFLEN);
430 kdb_printf(kdb_prompt_str);
431 kdb_nextline = 1; /* Prompt and input resets line number */
432 return kdb_read(buffer, bufsize);
433}
434
435/*
436 * kdb_input_flush
437 *
438 * Get rid of any buffered console input.
439 *
440 * Parameters:
441 * none
442 * Returns:
443 * nothing
444 * Locking:
445 * none
446 * Remarks:
447 * Call this function whenever you want to flush input. If there is any
448 * outstanding input, it ignores all characters until there has been no
449 * data for approximately 1ms.
450 */
451
452static void kdb_input_flush(void)
453{
454 get_char_func *f;
455 int res;
456 int flush_delay = 1;
457 while (flush_delay) {
458 flush_delay--;
459empty:
460 touch_nmi_watchdog();
461 for (f = &kdb_poll_funcs[0]; *f; ++f) {
462 res = (*f)();
463 if (res != -1) {
464 flush_delay = 1;
465 goto empty;
466 }
467 }
468 if (flush_delay)
469 mdelay(1);
470 }
471}
472
473/*
474 * kdb_printf
475 *
476 * Print a string to the output device(s).
477 *
478 * Parameters:
479 * printf-like format and optional args.
480 * Returns:
481 * 0
482 * Locking:
483 * None.
484 * Remarks:
485 * use 'kdbcons->write()' to avoid polluting 'log_buf' with
486 * kdb output.
487 *
488 * If the user is doing a cmd args | grep srch
489 * then kdb_grepping_flag is set.
490 * In that case we need to accumulate full lines (ending in \n) before
491 * searching for the pattern.
492 */
493
494static char kdb_buffer[256]; /* A bit too big to go on stack */
495static char *next_avail = kdb_buffer;
496static int size_avail;
497static int suspend_grep;
498
499/*
500 * search arg1 to see if it contains arg2
501 * (kdmain.c provides flags for ^pat and pat$)
502 *
503 * return 1 for found, 0 for not found
504 */
505static int kdb_search_string(char *searched, char *searchfor)
506{
507 char firstchar, *cp;
508 int len1, len2;
509
510 /* not counting the newline at the end of "searched" */
511 len1 = strlen(searched)-1;
512 len2 = strlen(searchfor);
513 if (len1 < len2)
514 return 0;
515 if (kdb_grep_leading && kdb_grep_trailing && len1 != len2)
516 return 0;
517 if (kdb_grep_leading) {
518 if (!strncmp(searched, searchfor, len2))
519 return 1;
520 } else if (kdb_grep_trailing) {
521 if (!strncmp(searched+len1-len2, searchfor, len2))
522 return 1;
523 } else {
524 firstchar = *searchfor;
525 cp = searched;
526 while ((cp = strchr(cp, firstchar))) {
527 if (!strncmp(cp, searchfor, len2))
528 return 1;
529 cp++;
530 }
531 }
532 return 0;
533}
534
535int kdb_printf(const char *fmt, ...)
536{
537 va_list ap;
538 int diag;
539 int linecount;
540 int logging, saved_loglevel = 0;
541 int got_printf_lock = 0;
542 int retlen = 0;
543 int fnd, len;
544 char *cp, *cp2, *cphold = NULL, replaced_byte = ' ';
545 char *moreprompt = "more> ";
546 struct console *c = console_drivers;
547 static DEFINE_SPINLOCK(kdb_printf_lock);
548 unsigned long uninitialized_var(flags);
549
550 preempt_disable();
551 /* Serialize kdb_printf if multiple cpus try to write at once.
552 * But if any cpu goes recursive in kdb, just print the output,
553 * even if it is interleaved with any other text.
554 */
555 if (!KDB_STATE(PRINTF_LOCK)) {
556 KDB_STATE_SET(PRINTF_LOCK);
557 spin_lock_irqsave(&kdb_printf_lock, flags);
558 got_printf_lock = 1;
559 atomic_inc(&kdb_event);
560 } else {
561 __acquire(kdb_printf_lock);
562 }
563
564 diag = kdbgetintenv("LINES", &linecount);
565 if (diag || linecount <= 1)
566 linecount = 24;
567
568 diag = kdbgetintenv("LOGGING", &logging);
569 if (diag)
570 logging = 0;
571
572 if (!kdb_grepping_flag || suspend_grep) {
573 /* normally, every vsnprintf starts a new buffer */
574 next_avail = kdb_buffer;
575 size_avail = sizeof(kdb_buffer);
576 }
577 va_start(ap, fmt);
578 vsnprintf(next_avail, size_avail, fmt, ap);
579 va_end(ap);
580
581 /*
582 * If kdb_parse() found that the command was cmd xxx | grep yyy
583 * then kdb_grepping_flag is set, and kdb_grep_string contains yyy
584 *
585 * Accumulate the print data up to a newline before searching it.
586 * (vsnprintf does null-terminate the string that it generates)
587 */
588
589 /* skip the search if prints are temporarily unconditional */
590 if (!suspend_grep && kdb_grepping_flag) {
591 cp = strchr(kdb_buffer, '\n');
592 if (!cp) {
593 /*
594 * Special cases that don't end with newlines
595 * but should be written without one:
596 * The "[nn]kdb> " prompt should
597 * appear at the front of the buffer.
598 *
599 * The "[nn]more " prompt should also be
600 * (MOREPROMPT -> moreprompt)
601 * written * but we print that ourselves,
602 * we set the suspend_grep flag to make
603 * it unconditional.
604 *
605 */
606 if (next_avail == kdb_buffer) {
607 /*
608 * these should occur after a newline,
609 * so they will be at the front of the
610 * buffer
611 */
612 cp2 = kdb_buffer;
613 len = strlen(kdb_prompt_str);
614 if (!strncmp(cp2, kdb_prompt_str, len)) {
615 /*
616 * We're about to start a new
617 * command, so we can go back
618 * to normal mode.
619 */
620 kdb_grepping_flag = 0;
621 goto kdb_printit;
622 }
623 }
624 /* no newline; don't search/write the buffer
625 until one is there */
626 len = strlen(kdb_buffer);
627 next_avail = kdb_buffer + len;
628 size_avail = sizeof(kdb_buffer) - len;
629 goto kdb_print_out;
630 }
631
632 /*
633 * The newline is present; print through it or discard
634 * it, depending on the results of the search.
635 */
636 cp++; /* to byte after the newline */
637 replaced_byte = *cp; /* remember what/where it was */
638 cphold = cp;
639 *cp = '\0'; /* end the string for our search */
640
641 /*
642 * We now have a newline at the end of the string
643 * Only continue with this output if it contains the
644 * search string.
645 */
646 fnd = kdb_search_string(kdb_buffer, kdb_grep_string);
647 if (!fnd) {
648 /*
649 * At this point the complete line at the start
650 * of kdb_buffer can be discarded, as it does
651 * not contain what the user is looking for.
652 * Shift the buffer left.
653 */
654 *cphold = replaced_byte;
655 strcpy(kdb_buffer, cphold);
656 len = strlen(kdb_buffer);
657 next_avail = kdb_buffer + len;
658 size_avail = sizeof(kdb_buffer) - len;
659 goto kdb_print_out;
660 }
661 /*
662 * at this point the string is a full line and
663 * should be printed, up to the null.
664 */
665 }
666kdb_printit:
667
668 /*
669 * Write to all consoles.
670 */
671 retlen = strlen(kdb_buffer);
672 while (c) {
673 c->write(c, kdb_buffer, retlen);
674 touch_nmi_watchdog();
675 c = c->next;
676 }
677 if (logging) {
678 saved_loglevel = console_loglevel;
679 console_loglevel = 0;
680 printk(KERN_INFO "%s", kdb_buffer);
681 }
682
683 if (KDB_STATE(PAGER) && strchr(kdb_buffer, '\n'))
684 kdb_nextline++;
685
686 /* check for having reached the LINES number of printed lines */
687 if (kdb_nextline == linecount) {
688 char buf1[16] = "";
689#if defined(CONFIG_SMP)
690 char buf2[32];
691#endif
692
693 /* Watch out for recursion here. Any routine that calls
694 * kdb_printf will come back through here. And kdb_read
695 * uses kdb_printf to echo on serial consoles ...
696 */
697 kdb_nextline = 1; /* In case of recursion */
698
699 /*
700 * Pause until cr.
701 */
702 moreprompt = kdbgetenv("MOREPROMPT");
703 if (moreprompt == NULL)
704 moreprompt = "more> ";
705
706#if defined(CONFIG_SMP)
707 if (strchr(moreprompt, '%')) {
708 sprintf(buf2, moreprompt, get_cpu());
709 put_cpu();
710 moreprompt = buf2;
711 }
712#endif
713
714 kdb_input_flush();
715 c = console_drivers;
716
717 while (c) {
718 c->write(c, moreprompt, strlen(moreprompt));
719 touch_nmi_watchdog();
720 c = c->next;
721 }
722
723 if (logging)
724 printk("%s", moreprompt);
725
726 kdb_read(buf1, 2); /* '2' indicates to return
727 * immediately after getting one key. */
728 kdb_nextline = 1; /* Really set output line 1 */
729
730 /* empty and reset the buffer: */
731 kdb_buffer[0] = '\0';
732 next_avail = kdb_buffer;
733 size_avail = sizeof(kdb_buffer);
734 if ((buf1[0] == 'q') || (buf1[0] == 'Q')) {
735 /* user hit q or Q */
736 KDB_FLAG_SET(CMD_INTERRUPT); /* command interrupted */
737 KDB_STATE_CLEAR(PAGER);
738 /* end of command output; back to normal mode */
739 kdb_grepping_flag = 0;
740 kdb_printf("\n");
741 } else if (buf1[0] == ' ') {
742 kdb_printf("\n");
743 suspend_grep = 1; /* for this recursion */
744 } else if (buf1[0] == '\n') {
745 kdb_nextline = linecount - 1;
746 kdb_printf("\r");
747 suspend_grep = 1; /* for this recursion */
748 } else if (buf1[0] && buf1[0] != '\n') {
749 /* user hit something other than enter */
750 suspend_grep = 1; /* for this recursion */
751 kdb_printf("\nOnly 'q' or 'Q' are processed at more "
752 "prompt, input ignored\n");
753 } else if (kdb_grepping_flag) {
754 /* user hit enter */
755 suspend_grep = 1; /* for this recursion */
756 kdb_printf("\n");
757 }
758 kdb_input_flush();
759 }
760
761 /*
762 * For grep searches, shift the printed string left.
763 * replaced_byte contains the character that was overwritten with
764 * the terminating null, and cphold points to the null.
765 * Then adjust the notion of available space in the buffer.
766 */
767 if (kdb_grepping_flag && !suspend_grep) {
768 *cphold = replaced_byte;
769 strcpy(kdb_buffer, cphold);
770 len = strlen(kdb_buffer);
771 next_avail = kdb_buffer + len;
772 size_avail = sizeof(kdb_buffer) - len;
773 }
774
775kdb_print_out:
776 suspend_grep = 0; /* end of what may have been a recursive call */
777 if (logging)
778 console_loglevel = saved_loglevel;
779 if (KDB_STATE(PRINTF_LOCK) && got_printf_lock) {
780 got_printf_lock = 0;
781 spin_unlock_irqrestore(&kdb_printf_lock, flags);
782 KDB_STATE_CLEAR(PRINTF_LOCK);
783 atomic_dec(&kdb_event);
784 } else {
785 __release(kdb_printf_lock);
786 }
787 preempt_enable();
788 return retlen;
789}
diff --git a/kernel/debug/kdb/kdb_main.c b/kernel/debug/kdb/kdb_main.c
new file mode 100644
index 000000000000..64ef9ac14ba9
--- /dev/null
+++ b/kernel/debug/kdb/kdb_main.c
@@ -0,0 +1,2845 @@
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/string.h>
16#include <linux/kernel.h>
17#include <linux/reboot.h>
18#include <linux/sched.h>
19#include <linux/sysrq.h>
20#include <linux/smp.h>
21#include <linux/utsname.h>
22#include <linux/vmalloc.h>
23#include <linux/module.h>
24#include <linux/mm.h>
25#include <linux/init.h>
26#include <linux/kallsyms.h>
27#include <linux/kgdb.h>
28#include <linux/kdb.h>
29#include <linux/notifier.h>
30#include <linux/interrupt.h>
31#include <linux/delay.h>
32#include <linux/nmi.h>
33#include <linux/time.h>
34#include <linux/ptrace.h>
35#include <linux/sysctl.h>
36#include <linux/cpu.h>
37#include <linux/kdebug.h>
38#include <linux/proc_fs.h>
39#include <linux/uaccess.h>
40#include <linux/slab.h>
41#include "kdb_private.h"
42
43#define GREP_LEN 256
44char kdb_grep_string[GREP_LEN];
45int kdb_grepping_flag;
46EXPORT_SYMBOL(kdb_grepping_flag);
47int kdb_grep_leading;
48int kdb_grep_trailing;
49
50/*
51 * Kernel debugger state flags
52 */
53int kdb_flags;
54atomic_t kdb_event;
55
56/*
57 * kdb_lock protects updates to kdb_initial_cpu. Used to
58 * single thread processors through the kernel debugger.
59 */
60int kdb_initial_cpu = -1; /* cpu number that owns kdb */
61int kdb_nextline = 1;
62int kdb_state; /* General KDB state */
63
64struct task_struct *kdb_current_task;
65EXPORT_SYMBOL(kdb_current_task);
66struct pt_regs *kdb_current_regs;
67
68const char *kdb_diemsg;
69static int kdb_go_count;
70#ifdef CONFIG_KDB_CONTINUE_CATASTROPHIC
71static unsigned int kdb_continue_catastrophic =
72 CONFIG_KDB_CONTINUE_CATASTROPHIC;
73#else
74static unsigned int kdb_continue_catastrophic;
75#endif
76
77/* kdb_commands describes the available commands. */
78static kdbtab_t *kdb_commands;
79#define KDB_BASE_CMD_MAX 50
80static int kdb_max_commands = KDB_BASE_CMD_MAX;
81static kdbtab_t kdb_base_commands[50];
82#define for_each_kdbcmd(cmd, num) \
83 for ((cmd) = kdb_base_commands, (num) = 0; \
84 num < kdb_max_commands; \
85 num == KDB_BASE_CMD_MAX ? cmd = kdb_commands : cmd++, num++)
86
87typedef struct _kdbmsg {
88 int km_diag; /* kdb diagnostic */
89 char *km_msg; /* Corresponding message text */
90} kdbmsg_t;
91
92#define KDBMSG(msgnum, text) \
93 { KDB_##msgnum, text }
94
95static kdbmsg_t kdbmsgs[] = {
96 KDBMSG(NOTFOUND, "Command Not Found"),
97 KDBMSG(ARGCOUNT, "Improper argument count, see usage."),
98 KDBMSG(BADWIDTH, "Illegal value for BYTESPERWORD use 1, 2, 4 or 8, "
99 "8 is only allowed on 64 bit systems"),
100 KDBMSG(BADRADIX, "Illegal value for RADIX use 8, 10 or 16"),
101 KDBMSG(NOTENV, "Cannot find environment variable"),
102 KDBMSG(NOENVVALUE, "Environment variable should have value"),
103 KDBMSG(NOTIMP, "Command not implemented"),
104 KDBMSG(ENVFULL, "Environment full"),
105 KDBMSG(ENVBUFFULL, "Environment buffer full"),
106 KDBMSG(TOOMANYBPT, "Too many breakpoints defined"),
107#ifdef CONFIG_CPU_XSCALE
108 KDBMSG(TOOMANYDBREGS, "More breakpoints than ibcr registers defined"),
109#else
110 KDBMSG(TOOMANYDBREGS, "More breakpoints than db registers defined"),
111#endif
112 KDBMSG(DUPBPT, "Duplicate breakpoint address"),
113 KDBMSG(BPTNOTFOUND, "Breakpoint not found"),
114 KDBMSG(BADMODE, "Invalid IDMODE"),
115 KDBMSG(BADINT, "Illegal numeric value"),
116 KDBMSG(INVADDRFMT, "Invalid symbolic address format"),
117 KDBMSG(BADREG, "Invalid register name"),
118 KDBMSG(BADCPUNUM, "Invalid cpu number"),
119 KDBMSG(BADLENGTH, "Invalid length field"),
120 KDBMSG(NOBP, "No Breakpoint exists"),
121 KDBMSG(BADADDR, "Invalid address"),
122};
123#undef KDBMSG
124
125static const int __nkdb_err = sizeof(kdbmsgs) / sizeof(kdbmsg_t);
126
127
128/*
129 * Initial environment. This is all kept static and local to
130 * this file. We don't want to rely on the memory allocation
131 * mechanisms in the kernel, so we use a very limited allocate-only
132 * heap for new and altered environment variables. The entire
133 * environment is limited to a fixed number of entries (add more
134 * to __env[] if required) and a fixed amount of heap (add more to
135 * KDB_ENVBUFSIZE if required).
136 */
137
138static char *__env[] = {
139#if defined(CONFIG_SMP)
140 "PROMPT=[%d]kdb> ",
141 "MOREPROMPT=[%d]more> ",
142#else
143 "PROMPT=kdb> ",
144 "MOREPROMPT=more> ",
145#endif
146 "RADIX=16",
147 "MDCOUNT=8", /* lines of md output */
148 "BTARGS=9", /* 9 possible args in bt */
149 KDB_PLATFORM_ENV,
150 "DTABCOUNT=30",
151 "NOSECT=1",
152 (char *)0,
153 (char *)0,
154 (char *)0,
155 (char *)0,
156 (char *)0,
157 (char *)0,
158 (char *)0,
159 (char *)0,
160 (char *)0,
161 (char *)0,
162 (char *)0,
163 (char *)0,
164 (char *)0,
165 (char *)0,
166 (char *)0,
167 (char *)0,
168 (char *)0,
169 (char *)0,
170 (char *)0,
171 (char *)0,
172 (char *)0,
173 (char *)0,
174 (char *)0,
175};
176
177static const int __nenv = (sizeof(__env) / sizeof(char *));
178
179struct task_struct *kdb_curr_task(int cpu)
180{
181 struct task_struct *p = curr_task(cpu);
182#ifdef _TIF_MCA_INIT
183 if ((task_thread_info(p)->flags & _TIF_MCA_INIT) && KDB_TSK(cpu))
184 p = krp->p;
185#endif
186 return p;
187}
188
189/*
190 * kdbgetenv - This function will return the character string value of
191 * an environment variable.
192 * Parameters:
193 * match A character string representing an environment variable.
194 * Returns:
195 * NULL No environment variable matches 'match'
196 * char* Pointer to string value of environment variable.
197 */
198char *kdbgetenv(const char *match)
199{
200 char **ep = __env;
201 int matchlen = strlen(match);
202 int i;
203
204 for (i = 0; i < __nenv; i++) {
205 char *e = *ep++;
206
207 if (!e)
208 continue;
209
210 if ((strncmp(match, e, matchlen) == 0)
211 && ((e[matchlen] == '\0')
212 || (e[matchlen] == '='))) {
213 char *cp = strchr(e, '=');
214 return cp ? ++cp : "";
215 }
216 }
217 return NULL;
218}
219
220/*
221 * kdballocenv - This function is used to allocate bytes for
222 * environment entries.
223 * Parameters:
224 * match A character string representing a numeric value
225 * Outputs:
226 * *value the unsigned long representation of the env variable 'match'
227 * Returns:
228 * Zero on success, a kdb diagnostic on failure.
229 * Remarks:
230 * We use a static environment buffer (envbuffer) to hold the values
231 * of dynamically generated environment variables (see kdb_set). Buffer
232 * space once allocated is never free'd, so over time, the amount of space
233 * (currently 512 bytes) will be exhausted if env variables are changed
234 * frequently.
235 */
236static char *kdballocenv(size_t bytes)
237{
238#define KDB_ENVBUFSIZE 512
239 static char envbuffer[KDB_ENVBUFSIZE];
240 static int envbufsize;
241 char *ep = NULL;
242
243 if ((KDB_ENVBUFSIZE - envbufsize) >= bytes) {
244 ep = &envbuffer[envbufsize];
245 envbufsize += bytes;
246 }
247 return ep;
248}
249
250/*
251 * kdbgetulenv - This function will return the value of an unsigned
252 * long-valued environment variable.
253 * Parameters:
254 * match A character string representing a numeric value
255 * Outputs:
256 * *value the unsigned long represntation of the env variable 'match'
257 * Returns:
258 * Zero on success, a kdb diagnostic on failure.
259 */
260static int kdbgetulenv(const char *match, unsigned long *value)
261{
262 char *ep;
263
264 ep = kdbgetenv(match);
265 if (!ep)
266 return KDB_NOTENV;
267 if (strlen(ep) == 0)
268 return KDB_NOENVVALUE;
269
270 *value = simple_strtoul(ep, NULL, 0);
271
272 return 0;
273}
274
275/*
276 * kdbgetintenv - This function will return the value of an
277 * integer-valued environment variable.
278 * Parameters:
279 * match A character string representing an integer-valued env variable
280 * Outputs:
281 * *value the integer representation of the environment variable 'match'
282 * Returns:
283 * Zero on success, a kdb diagnostic on failure.
284 */
285int kdbgetintenv(const char *match, int *value)
286{
287 unsigned long val;
288 int diag;
289
290 diag = kdbgetulenv(match, &val);
291 if (!diag)
292 *value = (int) val;
293 return diag;
294}
295
296/*
297 * kdbgetularg - This function will convert a numeric string into an
298 * unsigned long value.
299 * Parameters:
300 * arg A character string representing a numeric value
301 * Outputs:
302 * *value the unsigned long represntation of arg.
303 * Returns:
304 * Zero on success, a kdb diagnostic on failure.
305 */
306int kdbgetularg(const char *arg, unsigned long *value)
307{
308 char *endp;
309 unsigned long val;
310
311 val = simple_strtoul(arg, &endp, 0);
312
313 if (endp == arg) {
314 /*
315 * Try base 16, for us folks too lazy to type the
316 * leading 0x...
317 */
318 val = simple_strtoul(arg, &endp, 16);
319 if (endp == arg)
320 return KDB_BADINT;
321 }
322
323 *value = val;
324
325 return 0;
326}
327
328/*
329 * kdb_set - This function implements the 'set' command. Alter an
330 * existing environment variable or create a new one.
331 */
332int kdb_set(int argc, const char **argv)
333{
334 int i;
335 char *ep;
336 size_t varlen, vallen;
337
338 /*
339 * we can be invoked two ways:
340 * set var=value argv[1]="var", argv[2]="value"
341 * set var = value argv[1]="var", argv[2]="=", argv[3]="value"
342 * - if the latter, shift 'em down.
343 */
344 if (argc == 3) {
345 argv[2] = argv[3];
346 argc--;
347 }
348
349 if (argc != 2)
350 return KDB_ARGCOUNT;
351
352 /*
353 * Check for internal variables
354 */
355 if (strcmp(argv[1], "KDBDEBUG") == 0) {
356 unsigned int debugflags;
357 char *cp;
358
359 debugflags = simple_strtoul(argv[2], &cp, 0);
360 if (cp == argv[2] || debugflags & ~KDB_DEBUG_FLAG_MASK) {
361 kdb_printf("kdb: illegal debug flags '%s'\n",
362 argv[2]);
363 return 0;
364 }
365 kdb_flags = (kdb_flags &
366 ~(KDB_DEBUG_FLAG_MASK << KDB_DEBUG_FLAG_SHIFT))
367 | (debugflags << KDB_DEBUG_FLAG_SHIFT);
368
369 return 0;
370 }
371
372 /*
373 * Tokenizer squashed the '=' sign. argv[1] is variable
374 * name, argv[2] = value.
375 */
376 varlen = strlen(argv[1]);
377 vallen = strlen(argv[2]);
378 ep = kdballocenv(varlen + vallen + 2);
379 if (ep == (char *)0)
380 return KDB_ENVBUFFULL;
381
382 sprintf(ep, "%s=%s", argv[1], argv[2]);
383
384 ep[varlen+vallen+1] = '\0';
385
386 for (i = 0; i < __nenv; i++) {
387 if (__env[i]
388 && ((strncmp(__env[i], argv[1], varlen) == 0)
389 && ((__env[i][varlen] == '\0')
390 || (__env[i][varlen] == '=')))) {
391 __env[i] = ep;
392 return 0;
393 }
394 }
395
396 /*
397 * Wasn't existing variable. Fit into slot.
398 */
399 for (i = 0; i < __nenv-1; i++) {
400 if (__env[i] == (char *)0) {
401 __env[i] = ep;
402 return 0;
403 }
404 }
405
406 return KDB_ENVFULL;
407}
408
409static int kdb_check_regs(void)
410{
411 if (!kdb_current_regs) {
412 kdb_printf("No current kdb registers."
413 " You may need to select another task\n");
414 return KDB_BADREG;
415 }
416 return 0;
417}
418
419/*
420 * kdbgetaddrarg - This function is responsible for parsing an
421 * address-expression and returning the value of the expression,
422 * symbol name, and offset to the caller.
423 *
424 * The argument may consist of a numeric value (decimal or
425 * hexidecimal), a symbol name, a register name (preceeded by the
426 * percent sign), an environment variable with a numeric value
427 * (preceeded by a dollar sign) or a simple arithmetic expression
428 * consisting of a symbol name, +/-, and a numeric constant value
429 * (offset).
430 * Parameters:
431 * argc - count of arguments in argv
432 * argv - argument vector
433 * *nextarg - index to next unparsed argument in argv[]
434 * regs - Register state at time of KDB entry
435 * Outputs:
436 * *value - receives the value of the address-expression
437 * *offset - receives the offset specified, if any
438 * *name - receives the symbol name, if any
439 * *nextarg - index to next unparsed argument in argv[]
440 * Returns:
441 * zero is returned on success, a kdb diagnostic code is
442 * returned on error.
443 */
444int kdbgetaddrarg(int argc, const char **argv, int *nextarg,
445 unsigned long *value, long *offset,
446 char **name)
447{
448 unsigned long addr;
449 unsigned long off = 0;
450 int positive;
451 int diag;
452 int found = 0;
453 char *symname;
454 char symbol = '\0';
455 char *cp;
456 kdb_symtab_t symtab;
457
458 /*
459 * Process arguments which follow the following syntax:
460 *
461 * symbol | numeric-address [+/- numeric-offset]
462 * %register
463 * $environment-variable
464 */
465
466 if (*nextarg > argc)
467 return KDB_ARGCOUNT;
468
469 symname = (char *)argv[*nextarg];
470
471 /*
472 * If there is no whitespace between the symbol
473 * or address and the '+' or '-' symbols, we
474 * remember the character and replace it with a
475 * null so the symbol/value can be properly parsed
476 */
477 cp = strpbrk(symname, "+-");
478 if (cp != NULL) {
479 symbol = *cp;
480 *cp++ = '\0';
481 }
482
483 if (symname[0] == '$') {
484 diag = kdbgetulenv(&symname[1], &addr);
485 if (diag)
486 return diag;
487 } else if (symname[0] == '%') {
488 diag = kdb_check_regs();
489 if (diag)
490 return diag;
491 /* Implement register values with % at a later time as it is
492 * arch optional.
493 */
494 return KDB_NOTIMP;
495 } else {
496 found = kdbgetsymval(symname, &symtab);
497 if (found) {
498 addr = symtab.sym_start;
499 } else {
500 diag = kdbgetularg(argv[*nextarg], &addr);
501 if (diag)
502 return diag;
503 }
504 }
505
506 if (!found)
507 found = kdbnearsym(addr, &symtab);
508
509 (*nextarg)++;
510
511 if (name)
512 *name = symname;
513 if (value)
514 *value = addr;
515 if (offset && name && *name)
516 *offset = addr - symtab.sym_start;
517
518 if ((*nextarg > argc)
519 && (symbol == '\0'))
520 return 0;
521
522 /*
523 * check for +/- and offset
524 */
525
526 if (symbol == '\0') {
527 if ((argv[*nextarg][0] != '+')
528 && (argv[*nextarg][0] != '-')) {
529 /*
530 * Not our argument. Return.
531 */
532 return 0;
533 } else {
534 positive = (argv[*nextarg][0] == '+');
535 (*nextarg)++;
536 }
537 } else
538 positive = (symbol == '+');
539
540 /*
541 * Now there must be an offset!
542 */
543 if ((*nextarg > argc)
544 && (symbol == '\0')) {
545 return KDB_INVADDRFMT;
546 }
547
548 if (!symbol) {
549 cp = (char *)argv[*nextarg];
550 (*nextarg)++;
551 }
552
553 diag = kdbgetularg(cp, &off);
554 if (diag)
555 return diag;
556
557 if (!positive)
558 off = -off;
559
560 if (offset)
561 *offset += off;
562
563 if (value)
564 *value += off;
565
566 return 0;
567}
568
569static void kdb_cmderror(int diag)
570{
571 int i;
572
573 if (diag >= 0) {
574 kdb_printf("no error detected (diagnostic is %d)\n", diag);
575 return;
576 }
577
578 for (i = 0; i < __nkdb_err; i++) {
579 if (kdbmsgs[i].km_diag == diag) {
580 kdb_printf("diag: %d: %s\n", diag, kdbmsgs[i].km_msg);
581 return;
582 }
583 }
584
585 kdb_printf("Unknown diag %d\n", -diag);
586}
587
588/*
589 * kdb_defcmd, kdb_defcmd2 - This function implements the 'defcmd'
590 * command which defines one command as a set of other commands,
591 * terminated by endefcmd. kdb_defcmd processes the initial
592 * 'defcmd' command, kdb_defcmd2 is invoked from kdb_parse for
593 * the following commands until 'endefcmd'.
594 * Inputs:
595 * argc argument count
596 * argv argument vector
597 * Returns:
598 * zero for success, a kdb diagnostic if error
599 */
600struct defcmd_set {
601 int count;
602 int usable;
603 char *name;
604 char *usage;
605 char *help;
606 char **command;
607};
608static struct defcmd_set *defcmd_set;
609static int defcmd_set_count;
610static int defcmd_in_progress;
611
612/* Forward references */
613static int kdb_exec_defcmd(int argc, const char **argv);
614
615static int kdb_defcmd2(const char *cmdstr, const char *argv0)
616{
617 struct defcmd_set *s = defcmd_set + defcmd_set_count - 1;
618 char **save_command = s->command;
619 if (strcmp(argv0, "endefcmd") == 0) {
620 defcmd_in_progress = 0;
621 if (!s->count)
622 s->usable = 0;
623 if (s->usable)
624 kdb_register(s->name, kdb_exec_defcmd,
625 s->usage, s->help, 0);
626 return 0;
627 }
628 if (!s->usable)
629 return KDB_NOTIMP;
630 s->command = kmalloc((s->count + 1) * sizeof(*(s->command)), GFP_KDB);
631 if (!s->command) {
632 kdb_printf("Could not allocate new kdb_defcmd table for %s\n",
633 cmdstr);
634 s->usable = 0;
635 return KDB_NOTIMP;
636 }
637 memcpy(s->command, save_command, s->count * sizeof(*(s->command)));
638 s->command[s->count++] = kdb_strdup(cmdstr, GFP_KDB);
639 kfree(save_command);
640 return 0;
641}
642
643static int kdb_defcmd(int argc, const char **argv)
644{
645 struct defcmd_set *save_defcmd_set = defcmd_set, *s;
646 if (defcmd_in_progress) {
647 kdb_printf("kdb: nested defcmd detected, assuming missing "
648 "endefcmd\n");
649 kdb_defcmd2("endefcmd", "endefcmd");
650 }
651 if (argc == 0) {
652 int i;
653 for (s = defcmd_set; s < defcmd_set + defcmd_set_count; ++s) {
654 kdb_printf("defcmd %s \"%s\" \"%s\"\n", s->name,
655 s->usage, s->help);
656 for (i = 0; i < s->count; ++i)
657 kdb_printf("%s", s->command[i]);
658 kdb_printf("endefcmd\n");
659 }
660 return 0;
661 }
662 if (argc != 3)
663 return KDB_ARGCOUNT;
664 defcmd_set = kmalloc((defcmd_set_count + 1) * sizeof(*defcmd_set),
665 GFP_KDB);
666 if (!defcmd_set) {
667 kdb_printf("Could not allocate new defcmd_set entry for %s\n",
668 argv[1]);
669 defcmd_set = save_defcmd_set;
670 return KDB_NOTIMP;
671 }
672 memcpy(defcmd_set, save_defcmd_set,
673 defcmd_set_count * sizeof(*defcmd_set));
674 kfree(save_defcmd_set);
675 s = defcmd_set + defcmd_set_count;
676 memset(s, 0, sizeof(*s));
677 s->usable = 1;
678 s->name = kdb_strdup(argv[1], GFP_KDB);
679 s->usage = kdb_strdup(argv[2], GFP_KDB);
680 s->help = kdb_strdup(argv[3], GFP_KDB);
681 if (s->usage[0] == '"') {
682 strcpy(s->usage, s->usage+1);
683 s->usage[strlen(s->usage)-1] = '\0';
684 }
685 if (s->help[0] == '"') {
686 strcpy(s->help, s->help+1);
687 s->help[strlen(s->help)-1] = '\0';
688 }
689 ++defcmd_set_count;
690 defcmd_in_progress = 1;
691 return 0;
692}
693
694/*
695 * kdb_exec_defcmd - Execute the set of commands associated with this
696 * defcmd name.
697 * Inputs:
698 * argc argument count
699 * argv argument vector
700 * Returns:
701 * zero for success, a kdb diagnostic if error
702 */
703static int kdb_exec_defcmd(int argc, const char **argv)
704{
705 int i, ret;
706 struct defcmd_set *s;
707 if (argc != 0)
708 return KDB_ARGCOUNT;
709 for (s = defcmd_set, i = 0; i < defcmd_set_count; ++i, ++s) {
710 if (strcmp(s->name, argv[0]) == 0)
711 break;
712 }
713 if (i == defcmd_set_count) {
714 kdb_printf("kdb_exec_defcmd: could not find commands for %s\n",
715 argv[0]);
716 return KDB_NOTIMP;
717 }
718 for (i = 0; i < s->count; ++i) {
719 /* Recursive use of kdb_parse, do not use argv after
720 * this point */
721 argv = NULL;
722 kdb_printf("[%s]kdb> %s\n", s->name, s->command[i]);
723 ret = kdb_parse(s->command[i]);
724 if (ret)
725 return ret;
726 }
727 return 0;
728}
729
730/* Command history */
731#define KDB_CMD_HISTORY_COUNT 32
732#define CMD_BUFLEN 200 /* kdb_printf: max printline
733 * size == 256 */
734static unsigned int cmd_head, cmd_tail;
735static unsigned int cmdptr;
736static char cmd_hist[KDB_CMD_HISTORY_COUNT][CMD_BUFLEN];
737static char cmd_cur[CMD_BUFLEN];
738
739/*
740 * The "str" argument may point to something like | grep xyz
741 */
742static void parse_grep(const char *str)
743{
744 int len;
745 char *cp = (char *)str, *cp2;
746
747 /* sanity check: we should have been called with the \ first */
748 if (*cp != '|')
749 return;
750 cp++;
751 while (isspace(*cp))
752 cp++;
753 if (strncmp(cp, "grep ", 5)) {
754 kdb_printf("invalid 'pipe', see grephelp\n");
755 return;
756 }
757 cp += 5;
758 while (isspace(*cp))
759 cp++;
760 cp2 = strchr(cp, '\n');
761 if (cp2)
762 *cp2 = '\0'; /* remove the trailing newline */
763 len = strlen(cp);
764 if (len == 0) {
765 kdb_printf("invalid 'pipe', see grephelp\n");
766 return;
767 }
768 /* now cp points to a nonzero length search string */
769 if (*cp == '"') {
770 /* allow it be "x y z" by removing the "'s - there must
771 be two of them */
772 cp++;
773 cp2 = strchr(cp, '"');
774 if (!cp2) {
775 kdb_printf("invalid quoted string, see grephelp\n");
776 return;
777 }
778 *cp2 = '\0'; /* end the string where the 2nd " was */
779 }
780 kdb_grep_leading = 0;
781 if (*cp == '^') {
782 kdb_grep_leading = 1;
783 cp++;
784 }
785 len = strlen(cp);
786 kdb_grep_trailing = 0;
787 if (*(cp+len-1) == '$') {
788 kdb_grep_trailing = 1;
789 *(cp+len-1) = '\0';
790 }
791 len = strlen(cp);
792 if (!len)
793 return;
794 if (len >= GREP_LEN) {
795 kdb_printf("search string too long\n");
796 return;
797 }
798 strcpy(kdb_grep_string, cp);
799 kdb_grepping_flag++;
800 return;
801}
802
803/*
804 * kdb_parse - Parse the command line, search the command table for a
805 * matching command and invoke the command function. This
806 * function may be called recursively, if it is, the second call
807 * will overwrite argv and cbuf. It is the caller's
808 * responsibility to save their argv if they recursively call
809 * kdb_parse().
810 * Parameters:
811 * cmdstr The input command line to be parsed.
812 * regs The registers at the time kdb was entered.
813 * Returns:
814 * Zero for success, a kdb diagnostic if failure.
815 * Remarks:
816 * Limited to 20 tokens.
817 *
818 * Real rudimentary tokenization. Basically only whitespace
819 * is considered a token delimeter (but special consideration
820 * is taken of the '=' sign as used by the 'set' command).
821 *
822 * The algorithm used to tokenize the input string relies on
823 * there being at least one whitespace (or otherwise useless)
824 * character between tokens as the character immediately following
825 * the token is altered in-place to a null-byte to terminate the
826 * token string.
827 */
828
829#define MAXARGC 20
830
831int kdb_parse(const char *cmdstr)
832{
833 static char *argv[MAXARGC];
834 static int argc;
835 static char cbuf[CMD_BUFLEN+2];
836 char *cp;
837 char *cpp, quoted;
838 kdbtab_t *tp;
839 int i, escaped, ignore_errors = 0, check_grep;
840
841 /*
842 * First tokenize the command string.
843 */
844 cp = (char *)cmdstr;
845 kdb_grepping_flag = check_grep = 0;
846
847 if (KDB_FLAG(CMD_INTERRUPT)) {
848 /* Previous command was interrupted, newline must not
849 * repeat the command */
850 KDB_FLAG_CLEAR(CMD_INTERRUPT);
851 KDB_STATE_SET(PAGER);
852 argc = 0; /* no repeat */
853 }
854
855 if (*cp != '\n' && *cp != '\0') {
856 argc = 0;
857 cpp = cbuf;
858 while (*cp) {
859 /* skip whitespace */
860 while (isspace(*cp))
861 cp++;
862 if ((*cp == '\0') || (*cp == '\n') ||
863 (*cp == '#' && !defcmd_in_progress))
864 break;
865 /* special case: check for | grep pattern */
866 if (*cp == '|') {
867 check_grep++;
868 break;
869 }
870 if (cpp >= cbuf + CMD_BUFLEN) {
871 kdb_printf("kdb_parse: command buffer "
872 "overflow, command ignored\n%s\n",
873 cmdstr);
874 return KDB_NOTFOUND;
875 }
876 if (argc >= MAXARGC - 1) {
877 kdb_printf("kdb_parse: too many arguments, "
878 "command ignored\n%s\n", cmdstr);
879 return KDB_NOTFOUND;
880 }
881 argv[argc++] = cpp;
882 escaped = 0;
883 quoted = '\0';
884 /* Copy to next unquoted and unescaped
885 * whitespace or '=' */
886 while (*cp && *cp != '\n' &&
887 (escaped || quoted || !isspace(*cp))) {
888 if (cpp >= cbuf + CMD_BUFLEN)
889 break;
890 if (escaped) {
891 escaped = 0;
892 *cpp++ = *cp++;
893 continue;
894 }
895 if (*cp == '\\') {
896 escaped = 1;
897 ++cp;
898 continue;
899 }
900 if (*cp == quoted)
901 quoted = '\0';
902 else if (*cp == '\'' || *cp == '"')
903 quoted = *cp;
904 *cpp = *cp++;
905 if (*cpp == '=' && !quoted)
906 break;
907 ++cpp;
908 }
909 *cpp++ = '\0'; /* Squash a ws or '=' character */
910 }
911 }
912 if (!argc)
913 return 0;
914 if (check_grep)
915 parse_grep(cp);
916 if (defcmd_in_progress) {
917 int result = kdb_defcmd2(cmdstr, argv[0]);
918 if (!defcmd_in_progress) {
919 argc = 0; /* avoid repeat on endefcmd */
920 *(argv[0]) = '\0';
921 }
922 return result;
923 }
924 if (argv[0][0] == '-' && argv[0][1] &&
925 (argv[0][1] < '0' || argv[0][1] > '9')) {
926 ignore_errors = 1;
927 ++argv[0];
928 }
929
930 for_each_kdbcmd(tp, i) {
931 if (tp->cmd_name) {
932 /*
933 * If this command is allowed to be abbreviated,
934 * check to see if this is it.
935 */
936
937 if (tp->cmd_minlen
938 && (strlen(argv[0]) <= tp->cmd_minlen)) {
939 if (strncmp(argv[0],
940 tp->cmd_name,
941 tp->cmd_minlen) == 0) {
942 break;
943 }
944 }
945
946 if (strcmp(argv[0], tp->cmd_name) == 0)
947 break;
948 }
949 }
950
951 /*
952 * If we don't find a command by this name, see if the first
953 * few characters of this match any of the known commands.
954 * e.g., md1c20 should match md.
955 */
956 if (i == kdb_max_commands) {
957 for_each_kdbcmd(tp, i) {
958 if (tp->cmd_name) {
959 if (strncmp(argv[0],
960 tp->cmd_name,
961 strlen(tp->cmd_name)) == 0) {
962 break;
963 }
964 }
965 }
966 }
967
968 if (i < kdb_max_commands) {
969 int result;
970 KDB_STATE_SET(CMD);
971 result = (*tp->cmd_func)(argc-1, (const char **)argv);
972 if (result && ignore_errors && result > KDB_CMD_GO)
973 result = 0;
974 KDB_STATE_CLEAR(CMD);
975 switch (tp->cmd_repeat) {
976 case KDB_REPEAT_NONE:
977 argc = 0;
978 if (argv[0])
979 *(argv[0]) = '\0';
980 break;
981 case KDB_REPEAT_NO_ARGS:
982 argc = 1;
983 if (argv[1])
984 *(argv[1]) = '\0';
985 break;
986 case KDB_REPEAT_WITH_ARGS:
987 break;
988 }
989 return result;
990 }
991
992 /*
993 * If the input with which we were presented does not
994 * map to an existing command, attempt to parse it as an
995 * address argument and display the result. Useful for
996 * obtaining the address of a variable, or the nearest symbol
997 * to an address contained in a register.
998 */
999 {
1000 unsigned long value;
1001 char *name = NULL;
1002 long offset;
1003 int nextarg = 0;
1004
1005 if (kdbgetaddrarg(0, (const char **)argv, &nextarg,
1006 &value, &offset, &name)) {
1007 return KDB_NOTFOUND;
1008 }
1009
1010 kdb_printf("%s = ", argv[0]);
1011 kdb_symbol_print(value, NULL, KDB_SP_DEFAULT);
1012 kdb_printf("\n");
1013 return 0;
1014 }
1015}
1016
1017
1018static int handle_ctrl_cmd(char *cmd)
1019{
1020#define CTRL_P 16
1021#define CTRL_N 14
1022
1023 /* initial situation */
1024 if (cmd_head == cmd_tail)
1025 return 0;
1026 switch (*cmd) {
1027 case CTRL_P:
1028 if (cmdptr != cmd_tail)
1029 cmdptr = (cmdptr-1) % KDB_CMD_HISTORY_COUNT;
1030 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1031 return 1;
1032 case CTRL_N:
1033 if (cmdptr != cmd_head)
1034 cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT;
1035 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1036 return 1;
1037 }
1038 return 0;
1039}
1040
1041/*
1042 * kdb_reboot - This function implements the 'reboot' command. Reboot
1043 * the system immediately, or loop for ever on failure.
1044 */
1045static int kdb_reboot(int argc, const char **argv)
1046{
1047 emergency_restart();
1048 kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
1049 while (1)
1050 cpu_relax();
1051 /* NOTREACHED */
1052 return 0;
1053}
1054
1055static void kdb_dumpregs(struct pt_regs *regs)
1056{
1057 int old_lvl = console_loglevel;
1058 console_loglevel = 15;
1059 show_regs(regs);
1060 kdb_printf("\n");
1061 console_loglevel = old_lvl;
1062}
1063
1064void kdb_set_current_task(struct task_struct *p)
1065{
1066 kdb_current_task = p;
1067
1068 if (kdb_task_has_cpu(p)) {
1069 kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p));
1070 return;
1071 }
1072 kdb_current_regs = NULL;
1073}
1074
1075/*
1076 * kdb_local - The main code for kdb. This routine is invoked on a
1077 * specific processor, it is not global. The main kdb() routine
1078 * ensures that only one processor at a time is in this routine.
1079 * This code is called with the real reason code on the first
1080 * entry to a kdb session, thereafter it is called with reason
1081 * SWITCH, even if the user goes back to the original cpu.
1082 * Inputs:
1083 * reason The reason KDB was invoked
1084 * error The hardware-defined error code
1085 * regs The exception frame at time of fault/breakpoint.
1086 * db_result Result code from the break or debug point.
1087 * Returns:
1088 * 0 KDB was invoked for an event which it wasn't responsible
1089 * 1 KDB handled the event for which it was invoked.
1090 * KDB_CMD_GO User typed 'go'.
1091 * KDB_CMD_CPU User switched to another cpu.
1092 * KDB_CMD_SS Single step.
1093 * KDB_CMD_SSB Single step until branch.
1094 */
1095static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs,
1096 kdb_dbtrap_t db_result)
1097{
1098 char *cmdbuf;
1099 int diag;
1100 struct task_struct *kdb_current =
1101 kdb_curr_task(raw_smp_processor_id());
1102
1103 KDB_DEBUG_STATE("kdb_local 1", reason);
1104 kdb_go_count = 0;
1105 if (reason == KDB_REASON_DEBUG) {
1106 /* special case below */
1107 } else {
1108 kdb_printf("\nEntering kdb (current=0x%p, pid %d) ",
1109 kdb_current, kdb_current->pid);
1110#if defined(CONFIG_SMP)
1111 kdb_printf("on processor %d ", raw_smp_processor_id());
1112#endif
1113 }
1114
1115 switch (reason) {
1116 case KDB_REASON_DEBUG:
1117 {
1118 /*
1119 * If re-entering kdb after a single step
1120 * command, don't print the message.
1121 */
1122 switch (db_result) {
1123 case KDB_DB_BPT:
1124 kdb_printf("\nEntering kdb (0x%p, pid %d) ",
1125 kdb_current, kdb_current->pid);
1126#if defined(CONFIG_SMP)
1127 kdb_printf("on processor %d ", raw_smp_processor_id());
1128#endif
1129 kdb_printf("due to Debug @ " kdb_machreg_fmt "\n",
1130 instruction_pointer(regs));
1131 break;
1132 case KDB_DB_SSB:
1133 /*
1134 * In the midst of ssb command. Just return.
1135 */
1136 KDB_DEBUG_STATE("kdb_local 3", reason);
1137 return KDB_CMD_SSB; /* Continue with SSB command */
1138
1139 break;
1140 case KDB_DB_SS:
1141 break;
1142 case KDB_DB_SSBPT:
1143 KDB_DEBUG_STATE("kdb_local 4", reason);
1144 return 1; /* kdba_db_trap did the work */
1145 default:
1146 kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
1147 db_result);
1148 break;
1149 }
1150
1151 }
1152 break;
1153 case KDB_REASON_ENTER:
1154 if (KDB_STATE(KEYBOARD))
1155 kdb_printf("due to Keyboard Entry\n");
1156 else
1157 kdb_printf("due to KDB_ENTER()\n");
1158 break;
1159 case KDB_REASON_KEYBOARD:
1160 KDB_STATE_SET(KEYBOARD);
1161 kdb_printf("due to Keyboard Entry\n");
1162 break;
1163 case KDB_REASON_ENTER_SLAVE:
1164 /* drop through, slaves only get released via cpu switch */
1165 case KDB_REASON_SWITCH:
1166 kdb_printf("due to cpu switch\n");
1167 break;
1168 case KDB_REASON_OOPS:
1169 kdb_printf("Oops: %s\n", kdb_diemsg);
1170 kdb_printf("due to oops @ " kdb_machreg_fmt "\n",
1171 instruction_pointer(regs));
1172 kdb_dumpregs(regs);
1173 break;
1174 case KDB_REASON_NMI:
1175 kdb_printf("due to NonMaskable Interrupt @ "
1176 kdb_machreg_fmt "\n",
1177 instruction_pointer(regs));
1178 kdb_dumpregs(regs);
1179 break;
1180 case KDB_REASON_SSTEP:
1181 case KDB_REASON_BREAK:
1182 kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
1183 reason == KDB_REASON_BREAK ?
1184 "Breakpoint" : "SS trap", instruction_pointer(regs));
1185 /*
1186 * Determine if this breakpoint is one that we
1187 * are interested in.
1188 */
1189 if (db_result != KDB_DB_BPT) {
1190 kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1191 db_result);
1192 KDB_DEBUG_STATE("kdb_local 6", reason);
1193 return 0; /* Not for us, dismiss it */
1194 }
1195 break;
1196 case KDB_REASON_RECURSE:
1197 kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
1198 instruction_pointer(regs));
1199 break;
1200 default:
1201 kdb_printf("kdb: unexpected reason code: %d\n", reason);
1202 KDB_DEBUG_STATE("kdb_local 8", reason);
1203 return 0; /* Not for us, dismiss it */
1204 }
1205
1206 while (1) {
1207 /*
1208 * Initialize pager context.
1209 */
1210 kdb_nextline = 1;
1211 KDB_STATE_CLEAR(SUPPRESS);
1212
1213 cmdbuf = cmd_cur;
1214 *cmdbuf = '\0';
1215 *(cmd_hist[cmd_head]) = '\0';
1216
1217 if (KDB_FLAG(ONLY_DO_DUMP)) {
1218 /* kdb is off but a catastrophic error requires a dump.
1219 * Take the dump and reboot.
1220 * Turn on logging so the kdb output appears in the log
1221 * buffer in the dump.
1222 */
1223 const char *setargs[] = { "set", "LOGGING", "1" };
1224 kdb_set(2, setargs);
1225 kdb_reboot(0, NULL);
1226 /*NOTREACHED*/
1227 }
1228
1229do_full_getstr:
1230#if defined(CONFIG_SMP)
1231 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
1232 raw_smp_processor_id());
1233#else
1234 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"));
1235#endif
1236 if (defcmd_in_progress)
1237 strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
1238
1239 /*
1240 * Fetch command from keyboard
1241 */
1242 cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
1243 if (*cmdbuf != '\n') {
1244 if (*cmdbuf < 32) {
1245 if (cmdptr == cmd_head) {
1246 strncpy(cmd_hist[cmd_head], cmd_cur,
1247 CMD_BUFLEN);
1248 *(cmd_hist[cmd_head] +
1249 strlen(cmd_hist[cmd_head])-1) = '\0';
1250 }
1251 if (!handle_ctrl_cmd(cmdbuf))
1252 *(cmd_cur+strlen(cmd_cur)-1) = '\0';
1253 cmdbuf = cmd_cur;
1254 goto do_full_getstr;
1255 } else {
1256 strncpy(cmd_hist[cmd_head], cmd_cur,
1257 CMD_BUFLEN);
1258 }
1259
1260 cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
1261 if (cmd_head == cmd_tail)
1262 cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
1263 }
1264
1265 cmdptr = cmd_head;
1266 diag = kdb_parse(cmdbuf);
1267 if (diag == KDB_NOTFOUND) {
1268 kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
1269 diag = 0;
1270 }
1271 if (diag == KDB_CMD_GO
1272 || diag == KDB_CMD_CPU
1273 || diag == KDB_CMD_SS
1274 || diag == KDB_CMD_SSB
1275 || diag == KDB_CMD_KGDB)
1276 break;
1277
1278 if (diag)
1279 kdb_cmderror(diag);
1280 }
1281 KDB_DEBUG_STATE("kdb_local 9", diag);
1282 return diag;
1283}
1284
1285
1286/*
1287 * kdb_print_state - Print the state data for the current processor
1288 * for debugging.
1289 * Inputs:
1290 * text Identifies the debug point
1291 * value Any integer value to be printed, e.g. reason code.
1292 */
1293void kdb_print_state(const char *text, int value)
1294{
1295 kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1296 text, raw_smp_processor_id(), value, kdb_initial_cpu,
1297 kdb_state);
1298}
1299
1300/*
1301 * kdb_main_loop - After initial setup and assignment of the
1302 * controlling cpu, all cpus are in this loop. One cpu is in
1303 * control and will issue the kdb prompt, the others will spin
1304 * until 'go' or cpu switch.
1305 *
1306 * To get a consistent view of the kernel stacks for all
1307 * processes, this routine is invoked from the main kdb code via
1308 * an architecture specific routine. kdba_main_loop is
1309 * responsible for making the kernel stacks consistent for all
1310 * processes, there should be no difference between a blocked
1311 * process and a running process as far as kdb is concerned.
1312 * Inputs:
1313 * reason The reason KDB was invoked
1314 * error The hardware-defined error code
1315 * reason2 kdb's current reason code.
1316 * Initially error but can change
1317 * acording to kdb state.
1318 * db_result Result code from break or debug point.
1319 * regs The exception frame at time of fault/breakpoint.
1320 * should always be valid.
1321 * Returns:
1322 * 0 KDB was invoked for an event which it wasn't responsible
1323 * 1 KDB handled the event for which it was invoked.
1324 */
1325int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
1326 kdb_dbtrap_t db_result, struct pt_regs *regs)
1327{
1328 int result = 1;
1329 /* Stay in kdb() until 'go', 'ss[b]' or an error */
1330 while (1) {
1331 /*
1332 * All processors except the one that is in control
1333 * will spin here.
1334 */
1335 KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1336 while (KDB_STATE(HOLD_CPU)) {
1337 /* state KDB is turned off by kdb_cpu to see if the
1338 * other cpus are still live, each cpu in this loop
1339 * turns it back on.
1340 */
1341 if (!KDB_STATE(KDB))
1342 KDB_STATE_SET(KDB);
1343 }
1344
1345 KDB_STATE_CLEAR(SUPPRESS);
1346 KDB_DEBUG_STATE("kdb_main_loop 2", reason);
1347 if (KDB_STATE(LEAVING))
1348 break; /* Another cpu said 'go' */
1349 /* Still using kdb, this processor is in control */
1350 result = kdb_local(reason2, error, regs, db_result);
1351 KDB_DEBUG_STATE("kdb_main_loop 3", result);
1352
1353 if (result == KDB_CMD_CPU)
1354 break;
1355
1356 if (result == KDB_CMD_SS) {
1357 KDB_STATE_SET(DOING_SS);
1358 break;
1359 }
1360
1361 if (result == KDB_CMD_SSB) {
1362 KDB_STATE_SET(DOING_SS);
1363 KDB_STATE_SET(DOING_SSB);
1364 break;
1365 }
1366
1367 if (result == KDB_CMD_KGDB) {
1368 if (!(KDB_STATE(DOING_KGDB) || KDB_STATE(DOING_KGDB2)))
1369 kdb_printf("Entering please attach debugger "
1370 "or use $D#44+ or $3#33\n");
1371 break;
1372 }
1373 if (result && result != 1 && result != KDB_CMD_GO)
1374 kdb_printf("\nUnexpected kdb_local return code %d\n",
1375 result);
1376 KDB_DEBUG_STATE("kdb_main_loop 4", reason);
1377 break;
1378 }
1379 if (KDB_STATE(DOING_SS))
1380 KDB_STATE_CLEAR(SSBPT);
1381
1382 return result;
1383}
1384
1385/*
1386 * kdb_mdr - This function implements the guts of the 'mdr', memory
1387 * read command.
1388 * mdr <addr arg>,<byte count>
1389 * Inputs:
1390 * addr Start address
1391 * count Number of bytes
1392 * Returns:
1393 * Always 0. Any errors are detected and printed by kdb_getarea.
1394 */
1395static int kdb_mdr(unsigned long addr, unsigned int count)
1396{
1397 unsigned char c;
1398 while (count--) {
1399 if (kdb_getarea(c, addr))
1400 return 0;
1401 kdb_printf("%02x", c);
1402 addr++;
1403 }
1404 kdb_printf("\n");
1405 return 0;
1406}
1407
1408/*
1409 * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1410 * 'md8' 'mdr' and 'mds' commands.
1411 *
1412 * md|mds [<addr arg> [<line count> [<radix>]]]
1413 * mdWcN [<addr arg> [<line count> [<radix>]]]
1414 * where W = is the width (1, 2, 4 or 8) and N is the count.
1415 * for eg., md1c20 reads 20 bytes, 1 at a time.
1416 * mdr <addr arg>,<byte count>
1417 */
1418static void kdb_md_line(const char *fmtstr, unsigned long addr,
1419 int symbolic, int nosect, int bytesperword,
1420 int num, int repeat, int phys)
1421{
1422 /* print just one line of data */
1423 kdb_symtab_t symtab;
1424 char cbuf[32];
1425 char *c = cbuf;
1426 int i;
1427 unsigned long word;
1428
1429 memset(cbuf, '\0', sizeof(cbuf));
1430 if (phys)
1431 kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1432 else
1433 kdb_printf(kdb_machreg_fmt0 " ", addr);
1434
1435 for (i = 0; i < num && repeat--; i++) {
1436 if (phys) {
1437 if (kdb_getphysword(&word, addr, bytesperword))
1438 break;
1439 } else if (kdb_getword(&word, addr, bytesperword))
1440 break;
1441 kdb_printf(fmtstr, word);
1442 if (symbolic)
1443 kdbnearsym(word, &symtab);
1444 else
1445 memset(&symtab, 0, sizeof(symtab));
1446 if (symtab.sym_name) {
1447 kdb_symbol_print(word, &symtab, 0);
1448 if (!nosect) {
1449 kdb_printf("\n");
1450 kdb_printf(" %s %s "
1451 kdb_machreg_fmt " "
1452 kdb_machreg_fmt " "
1453 kdb_machreg_fmt, symtab.mod_name,
1454 symtab.sec_name, symtab.sec_start,
1455 symtab.sym_start, symtab.sym_end);
1456 }
1457 addr += bytesperword;
1458 } else {
1459 union {
1460 u64 word;
1461 unsigned char c[8];
1462 } wc;
1463 unsigned char *cp;
1464#ifdef __BIG_ENDIAN
1465 cp = wc.c + 8 - bytesperword;
1466#else
1467 cp = wc.c;
1468#endif
1469 wc.word = word;
1470#define printable_char(c) \
1471 ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1472 switch (bytesperword) {
1473 case 8:
1474 *c++ = printable_char(*cp++);
1475 *c++ = printable_char(*cp++);
1476 *c++ = printable_char(*cp++);
1477 *c++ = printable_char(*cp++);
1478 addr += 4;
1479 case 4:
1480 *c++ = printable_char(*cp++);
1481 *c++ = printable_char(*cp++);
1482 addr += 2;
1483 case 2:
1484 *c++ = printable_char(*cp++);
1485 addr++;
1486 case 1:
1487 *c++ = printable_char(*cp++);
1488 addr++;
1489 break;
1490 }
1491#undef printable_char
1492 }
1493 }
1494 kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1495 " ", cbuf);
1496}
1497
1498static int kdb_md(int argc, const char **argv)
1499{
1500 static unsigned long last_addr;
1501 static int last_radix, last_bytesperword, last_repeat;
1502 int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1503 int nosect = 0;
1504 char fmtchar, fmtstr[64];
1505 unsigned long addr;
1506 unsigned long word;
1507 long offset = 0;
1508 int symbolic = 0;
1509 int valid = 0;
1510 int phys = 0;
1511
1512 kdbgetintenv("MDCOUNT", &mdcount);
1513 kdbgetintenv("RADIX", &radix);
1514 kdbgetintenv("BYTESPERWORD", &bytesperword);
1515
1516 /* Assume 'md <addr>' and start with environment values */
1517 repeat = mdcount * 16 / bytesperword;
1518
1519 if (strcmp(argv[0], "mdr") == 0) {
1520 if (argc != 2)
1521 return KDB_ARGCOUNT;
1522 valid = 1;
1523 } else if (isdigit(argv[0][2])) {
1524 bytesperword = (int)(argv[0][2] - '0');
1525 if (bytesperword == 0) {
1526 bytesperword = last_bytesperword;
1527 if (bytesperword == 0)
1528 bytesperword = 4;
1529 }
1530 last_bytesperword = bytesperword;
1531 repeat = mdcount * 16 / bytesperword;
1532 if (!argv[0][3])
1533 valid = 1;
1534 else if (argv[0][3] == 'c' && argv[0][4]) {
1535 char *p;
1536 repeat = simple_strtoul(argv[0] + 4, &p, 10);
1537 mdcount = ((repeat * bytesperword) + 15) / 16;
1538 valid = !*p;
1539 }
1540 last_repeat = repeat;
1541 } else if (strcmp(argv[0], "md") == 0)
1542 valid = 1;
1543 else if (strcmp(argv[0], "mds") == 0)
1544 valid = 1;
1545 else if (strcmp(argv[0], "mdp") == 0) {
1546 phys = valid = 1;
1547 }
1548 if (!valid)
1549 return KDB_NOTFOUND;
1550
1551 if (argc == 0) {
1552 if (last_addr == 0)
1553 return KDB_ARGCOUNT;
1554 addr = last_addr;
1555 radix = last_radix;
1556 bytesperword = last_bytesperword;
1557 repeat = last_repeat;
1558 mdcount = ((repeat * bytesperword) + 15) / 16;
1559 }
1560
1561 if (argc) {
1562 unsigned long val;
1563 int diag, nextarg = 1;
1564 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1565 &offset, NULL);
1566 if (diag)
1567 return diag;
1568 if (argc > nextarg+2)
1569 return KDB_ARGCOUNT;
1570
1571 if (argc >= nextarg) {
1572 diag = kdbgetularg(argv[nextarg], &val);
1573 if (!diag) {
1574 mdcount = (int) val;
1575 repeat = mdcount * 16 / bytesperword;
1576 }
1577 }
1578 if (argc >= nextarg+1) {
1579 diag = kdbgetularg(argv[nextarg+1], &val);
1580 if (!diag)
1581 radix = (int) val;
1582 }
1583 }
1584
1585 if (strcmp(argv[0], "mdr") == 0)
1586 return kdb_mdr(addr, mdcount);
1587
1588 switch (radix) {
1589 case 10:
1590 fmtchar = 'd';
1591 break;
1592 case 16:
1593 fmtchar = 'x';
1594 break;
1595 case 8:
1596 fmtchar = 'o';
1597 break;
1598 default:
1599 return KDB_BADRADIX;
1600 }
1601
1602 last_radix = radix;
1603
1604 if (bytesperword > KDB_WORD_SIZE)
1605 return KDB_BADWIDTH;
1606
1607 switch (bytesperword) {
1608 case 8:
1609 sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1610 break;
1611 case 4:
1612 sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1613 break;
1614 case 2:
1615 sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1616 break;
1617 case 1:
1618 sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1619 break;
1620 default:
1621 return KDB_BADWIDTH;
1622 }
1623
1624 last_repeat = repeat;
1625 last_bytesperword = bytesperword;
1626
1627 if (strcmp(argv[0], "mds") == 0) {
1628 symbolic = 1;
1629 /* Do not save these changes as last_*, they are temporary mds
1630 * overrides.
1631 */
1632 bytesperword = KDB_WORD_SIZE;
1633 repeat = mdcount;
1634 kdbgetintenv("NOSECT", &nosect);
1635 }
1636
1637 /* Round address down modulo BYTESPERWORD */
1638
1639 addr &= ~(bytesperword-1);
1640
1641 while (repeat > 0) {
1642 unsigned long a;
1643 int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1644
1645 if (KDB_FLAG(CMD_INTERRUPT))
1646 return 0;
1647 for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1648 if (phys) {
1649 if (kdb_getphysword(&word, a, bytesperword)
1650 || word)
1651 break;
1652 } else if (kdb_getword(&word, a, bytesperword) || word)
1653 break;
1654 }
1655 n = min(num, repeat);
1656 kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1657 num, repeat, phys);
1658 addr += bytesperword * n;
1659 repeat -= n;
1660 z = (z + num - 1) / num;
1661 if (z > 2) {
1662 int s = num * (z-2);
1663 kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1664 " zero suppressed\n",
1665 addr, addr + bytesperword * s - 1);
1666 addr += bytesperword * s;
1667 repeat -= s;
1668 }
1669 }
1670 last_addr = addr;
1671
1672 return 0;
1673}
1674
1675/*
1676 * kdb_mm - This function implements the 'mm' command.
1677 * mm address-expression new-value
1678 * Remarks:
1679 * mm works on machine words, mmW works on bytes.
1680 */
1681static int kdb_mm(int argc, const char **argv)
1682{
1683 int diag;
1684 unsigned long addr;
1685 long offset = 0;
1686 unsigned long contents;
1687 int nextarg;
1688 int width;
1689
1690 if (argv[0][2] && !isdigit(argv[0][2]))
1691 return KDB_NOTFOUND;
1692
1693 if (argc < 2)
1694 return KDB_ARGCOUNT;
1695
1696 nextarg = 1;
1697 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1698 if (diag)
1699 return diag;
1700
1701 if (nextarg > argc)
1702 return KDB_ARGCOUNT;
1703 diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1704 if (diag)
1705 return diag;
1706
1707 if (nextarg != argc + 1)
1708 return KDB_ARGCOUNT;
1709
1710 width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1711 diag = kdb_putword(addr, contents, width);
1712 if (diag)
1713 return diag;
1714
1715 kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1716
1717 return 0;
1718}
1719
1720/*
1721 * kdb_go - This function implements the 'go' command.
1722 * go [address-expression]
1723 */
1724static int kdb_go(int argc, const char **argv)
1725{
1726 unsigned long addr;
1727 int diag;
1728 int nextarg;
1729 long offset;
1730
1731 if (argc == 1) {
1732 if (raw_smp_processor_id() != kdb_initial_cpu) {
1733 kdb_printf("go <address> must be issued from the "
1734 "initial cpu, do cpu %d first\n",
1735 kdb_initial_cpu);
1736 return KDB_ARGCOUNT;
1737 }
1738 nextarg = 1;
1739 diag = kdbgetaddrarg(argc, argv, &nextarg,
1740 &addr, &offset, NULL);
1741 if (diag)
1742 return diag;
1743 } else if (argc) {
1744 return KDB_ARGCOUNT;
1745 }
1746
1747 diag = KDB_CMD_GO;
1748 if (KDB_FLAG(CATASTROPHIC)) {
1749 kdb_printf("Catastrophic error detected\n");
1750 kdb_printf("kdb_continue_catastrophic=%d, ",
1751 kdb_continue_catastrophic);
1752 if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1753 kdb_printf("type go a second time if you really want "
1754 "to continue\n");
1755 return 0;
1756 }
1757 if (kdb_continue_catastrophic == 2) {
1758 kdb_printf("forcing reboot\n");
1759 kdb_reboot(0, NULL);
1760 }
1761 kdb_printf("attempting to continue\n");
1762 }
1763 return diag;
1764}
1765
1766/*
1767 * kdb_rd - This function implements the 'rd' command.
1768 */
1769static int kdb_rd(int argc, const char **argv)
1770{
1771 int diag = kdb_check_regs();
1772 if (diag)
1773 return diag;
1774
1775 kdb_dumpregs(kdb_current_regs);
1776 return 0;
1777}
1778
1779/*
1780 * kdb_rm - This function implements the 'rm' (register modify) command.
1781 * rm register-name new-contents
1782 * Remarks:
1783 * Currently doesn't allow modification of control or
1784 * debug registers.
1785 */
1786static int kdb_rm(int argc, const char **argv)
1787{
1788 int diag;
1789 int ind = 0;
1790 unsigned long contents;
1791
1792 if (argc != 2)
1793 return KDB_ARGCOUNT;
1794 /*
1795 * Allow presence or absence of leading '%' symbol.
1796 */
1797 if (argv[1][0] == '%')
1798 ind = 1;
1799
1800 diag = kdbgetularg(argv[2], &contents);
1801 if (diag)
1802 return diag;
1803
1804 diag = kdb_check_regs();
1805 if (diag)
1806 return diag;
1807 kdb_printf("ERROR: Register set currently not implemented\n");
1808 return 0;
1809}
1810
1811#if defined(CONFIG_MAGIC_SYSRQ)
1812/*
1813 * kdb_sr - This function implements the 'sr' (SYSRQ key) command
1814 * which interfaces to the soi-disant MAGIC SYSRQ functionality.
1815 * sr <magic-sysrq-code>
1816 */
1817static int kdb_sr(int argc, const char **argv)
1818{
1819 if (argc != 1)
1820 return KDB_ARGCOUNT;
1821 sysrq_toggle_support(1);
1822 handle_sysrq(*argv[1], NULL);
1823
1824 return 0;
1825}
1826#endif /* CONFIG_MAGIC_SYSRQ */
1827
1828/*
1829 * kdb_ef - This function implements the 'regs' (display exception
1830 * frame) command. This command takes an address and expects to
1831 * find an exception frame at that address, formats and prints
1832 * it.
1833 * regs address-expression
1834 * Remarks:
1835 * Not done yet.
1836 */
1837static int kdb_ef(int argc, const char **argv)
1838{
1839 int diag;
1840 unsigned long addr;
1841 long offset;
1842 int nextarg;
1843
1844 if (argc != 1)
1845 return KDB_ARGCOUNT;
1846
1847 nextarg = 1;
1848 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1849 if (diag)
1850 return diag;
1851 show_regs((struct pt_regs *)addr);
1852 return 0;
1853}
1854
1855#if defined(CONFIG_MODULES)
1856/* modules using other modules */
1857struct module_use {
1858 struct list_head list;
1859 struct module *module_which_uses;
1860};
1861
1862/*
1863 * kdb_lsmod - This function implements the 'lsmod' command. Lists
1864 * currently loaded kernel modules.
1865 * Mostly taken from userland lsmod.
1866 */
1867static int kdb_lsmod(int argc, const char **argv)
1868{
1869 struct module *mod;
1870
1871 if (argc != 0)
1872 return KDB_ARGCOUNT;
1873
1874 kdb_printf("Module Size modstruct Used by\n");
1875 list_for_each_entry(mod, kdb_modules, list) {
1876
1877 kdb_printf("%-20s%8u 0x%p ", mod->name,
1878 mod->core_size, (void *)mod);
1879#ifdef CONFIG_MODULE_UNLOAD
1880 kdb_printf("%4d ", module_refcount(mod));
1881#endif
1882 if (mod->state == MODULE_STATE_GOING)
1883 kdb_printf(" (Unloading)");
1884 else if (mod->state == MODULE_STATE_COMING)
1885 kdb_printf(" (Loading)");
1886 else
1887 kdb_printf(" (Live)");
1888
1889#ifdef CONFIG_MODULE_UNLOAD
1890 {
1891 struct module_use *use;
1892 kdb_printf(" [ ");
1893 list_for_each_entry(use, &mod->modules_which_use_me,
1894 list)
1895 kdb_printf("%s ", use->module_which_uses->name);
1896 kdb_printf("]\n");
1897 }
1898#endif
1899 }
1900
1901 return 0;
1902}
1903
1904#endif /* CONFIG_MODULES */
1905
1906/*
1907 * kdb_env - This function implements the 'env' command. Display the
1908 * current environment variables.
1909 */
1910
1911static int kdb_env(int argc, const char **argv)
1912{
1913 int i;
1914
1915 for (i = 0; i < __nenv; i++) {
1916 if (__env[i])
1917 kdb_printf("%s\n", __env[i]);
1918 }
1919
1920 if (KDB_DEBUG(MASK))
1921 kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
1922
1923 return 0;
1924}
1925
1926#ifdef CONFIG_PRINTK
1927/*
1928 * kdb_dmesg - This function implements the 'dmesg' command to display
1929 * the contents of the syslog buffer.
1930 * dmesg [lines] [adjust]
1931 */
1932static int kdb_dmesg(int argc, const char **argv)
1933{
1934 char *syslog_data[4], *start, *end, c = '\0', *p;
1935 int diag, logging, logsize, lines = 0, adjust = 0, n;
1936
1937 if (argc > 2)
1938 return KDB_ARGCOUNT;
1939 if (argc) {
1940 char *cp;
1941 lines = simple_strtol(argv[1], &cp, 0);
1942 if (*cp)
1943 lines = 0;
1944 if (argc > 1) {
1945 adjust = simple_strtoul(argv[2], &cp, 0);
1946 if (*cp || adjust < 0)
1947 adjust = 0;
1948 }
1949 }
1950
1951 /* disable LOGGING if set */
1952 diag = kdbgetintenv("LOGGING", &logging);
1953 if (!diag && logging) {
1954 const char *setargs[] = { "set", "LOGGING", "0" };
1955 kdb_set(2, setargs);
1956 }
1957
1958 /* syslog_data[0,1] physical start, end+1. syslog_data[2,3]
1959 * logical start, end+1. */
1960 kdb_syslog_data(syslog_data);
1961 if (syslog_data[2] == syslog_data[3])
1962 return 0;
1963 logsize = syslog_data[1] - syslog_data[0];
1964 start = syslog_data[2];
1965 end = syslog_data[3];
1966#define KDB_WRAP(p) (((p - syslog_data[0]) % logsize) + syslog_data[0])
1967 for (n = 0, p = start; p < end; ++p) {
1968 c = *KDB_WRAP(p);
1969 if (c == '\n')
1970 ++n;
1971 }
1972 if (c != '\n')
1973 ++n;
1974 if (lines < 0) {
1975 if (adjust >= n)
1976 kdb_printf("buffer only contains %d lines, nothing "
1977 "printed\n", n);
1978 else if (adjust - lines >= n)
1979 kdb_printf("buffer only contains %d lines, last %d "
1980 "lines printed\n", n, n - adjust);
1981 if (adjust) {
1982 for (; start < end && adjust; ++start) {
1983 if (*KDB_WRAP(start) == '\n')
1984 --adjust;
1985 }
1986 if (start < end)
1987 ++start;
1988 }
1989 for (p = start; p < end && lines; ++p) {
1990 if (*KDB_WRAP(p) == '\n')
1991 ++lines;
1992 }
1993 end = p;
1994 } else if (lines > 0) {
1995 int skip = n - (adjust + lines);
1996 if (adjust >= n) {
1997 kdb_printf("buffer only contains %d lines, "
1998 "nothing printed\n", n);
1999 skip = n;
2000 } else if (skip < 0) {
2001 lines += skip;
2002 skip = 0;
2003 kdb_printf("buffer only contains %d lines, first "
2004 "%d lines printed\n", n, lines);
2005 }
2006 for (; start < end && skip; ++start) {
2007 if (*KDB_WRAP(start) == '\n')
2008 --skip;
2009 }
2010 for (p = start; p < end && lines; ++p) {
2011 if (*KDB_WRAP(p) == '\n')
2012 --lines;
2013 }
2014 end = p;
2015 }
2016 /* Do a line at a time (max 200 chars) to reduce protocol overhead */
2017 c = '\n';
2018 while (start != end) {
2019 char buf[201];
2020 p = buf;
2021 if (KDB_FLAG(CMD_INTERRUPT))
2022 return 0;
2023 while (start < end && (c = *KDB_WRAP(start)) &&
2024 (p - buf) < sizeof(buf)-1) {
2025 ++start;
2026 *p++ = c;
2027 if (c == '\n')
2028 break;
2029 }
2030 *p = '\0';
2031 kdb_printf("%s", buf);
2032 }
2033 if (c != '\n')
2034 kdb_printf("\n");
2035
2036 return 0;
2037}
2038#endif /* CONFIG_PRINTK */
2039/*
2040 * kdb_cpu - This function implements the 'cpu' command.
2041 * cpu [<cpunum>]
2042 * Returns:
2043 * KDB_CMD_CPU for success, a kdb diagnostic if error
2044 */
2045static void kdb_cpu_status(void)
2046{
2047 int i, start_cpu, first_print = 1;
2048 char state, prev_state = '?';
2049
2050 kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2051 kdb_printf("Available cpus: ");
2052 for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2053 if (!cpu_online(i)) {
2054 state = 'F'; /* cpu is offline */
2055 } else {
2056 state = ' '; /* cpu is responding to kdb */
2057 if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2058 state = 'I'; /* idle task */
2059 }
2060 if (state != prev_state) {
2061 if (prev_state != '?') {
2062 if (!first_print)
2063 kdb_printf(", ");
2064 first_print = 0;
2065 kdb_printf("%d", start_cpu);
2066 if (start_cpu < i-1)
2067 kdb_printf("-%d", i-1);
2068 if (prev_state != ' ')
2069 kdb_printf("(%c)", prev_state);
2070 }
2071 prev_state = state;
2072 start_cpu = i;
2073 }
2074 }
2075 /* print the trailing cpus, ignoring them if they are all offline */
2076 if (prev_state != 'F') {
2077 if (!first_print)
2078 kdb_printf(", ");
2079 kdb_printf("%d", start_cpu);
2080 if (start_cpu < i-1)
2081 kdb_printf("-%d", i-1);
2082 if (prev_state != ' ')
2083 kdb_printf("(%c)", prev_state);
2084 }
2085 kdb_printf("\n");
2086}
2087
2088static int kdb_cpu(int argc, const char **argv)
2089{
2090 unsigned long cpunum;
2091 int diag;
2092
2093 if (argc == 0) {
2094 kdb_cpu_status();
2095 return 0;
2096 }
2097
2098 if (argc != 1)
2099 return KDB_ARGCOUNT;
2100
2101 diag = kdbgetularg(argv[1], &cpunum);
2102 if (diag)
2103 return diag;
2104
2105 /*
2106 * Validate cpunum
2107 */
2108 if ((cpunum > NR_CPUS) || !cpu_online(cpunum))
2109 return KDB_BADCPUNUM;
2110
2111 dbg_switch_cpu = cpunum;
2112
2113 /*
2114 * Switch to other cpu
2115 */
2116 return KDB_CMD_CPU;
2117}
2118
2119/* The user may not realize that ps/bta with no parameters does not print idle
2120 * or sleeping system daemon processes, so tell them how many were suppressed.
2121 */
2122void kdb_ps_suppressed(void)
2123{
2124 int idle = 0, daemon = 0;
2125 unsigned long mask_I = kdb_task_state_string("I"),
2126 mask_M = kdb_task_state_string("M");
2127 unsigned long cpu;
2128 const struct task_struct *p, *g;
2129 for_each_online_cpu(cpu) {
2130 p = kdb_curr_task(cpu);
2131 if (kdb_task_state(p, mask_I))
2132 ++idle;
2133 }
2134 kdb_do_each_thread(g, p) {
2135 if (kdb_task_state(p, mask_M))
2136 ++daemon;
2137 } kdb_while_each_thread(g, p);
2138 if (idle || daemon) {
2139 if (idle)
2140 kdb_printf("%d idle process%s (state I)%s\n",
2141 idle, idle == 1 ? "" : "es",
2142 daemon ? " and " : "");
2143 if (daemon)
2144 kdb_printf("%d sleeping system daemon (state M) "
2145 "process%s", daemon,
2146 daemon == 1 ? "" : "es");
2147 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2148 }
2149}
2150
2151/*
2152 * kdb_ps - This function implements the 'ps' command which shows a
2153 * list of the active processes.
2154 * ps [DRSTCZEUIMA] All processes, optionally filtered by state
2155 */
2156void kdb_ps1(const struct task_struct *p)
2157{
2158 int cpu;
2159 unsigned long tmp;
2160
2161 if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
2162 return;
2163
2164 cpu = kdb_process_cpu(p);
2165 kdb_printf("0x%p %8d %8d %d %4d %c 0x%p %c%s\n",
2166 (void *)p, p->pid, p->parent->pid,
2167 kdb_task_has_cpu(p), kdb_process_cpu(p),
2168 kdb_task_state_char(p),
2169 (void *)(&p->thread),
2170 p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2171 p->comm);
2172 if (kdb_task_has_cpu(p)) {
2173 if (!KDB_TSK(cpu)) {
2174 kdb_printf(" Error: no saved data for this cpu\n");
2175 } else {
2176 if (KDB_TSK(cpu) != p)
2177 kdb_printf(" Error: does not match running "
2178 "process table (0x%p)\n", KDB_TSK(cpu));
2179 }
2180 }
2181}
2182
2183static int kdb_ps(int argc, const char **argv)
2184{
2185 struct task_struct *g, *p;
2186 unsigned long mask, cpu;
2187
2188 if (argc == 0)
2189 kdb_ps_suppressed();
2190 kdb_printf("%-*s Pid Parent [*] cpu State %-*s Command\n",
2191 (int)(2*sizeof(void *))+2, "Task Addr",
2192 (int)(2*sizeof(void *))+2, "Thread");
2193 mask = kdb_task_state_string(argc ? argv[1] : NULL);
2194 /* Run the active tasks first */
2195 for_each_online_cpu(cpu) {
2196 if (KDB_FLAG(CMD_INTERRUPT))
2197 return 0;
2198 p = kdb_curr_task(cpu);
2199 if (kdb_task_state(p, mask))
2200 kdb_ps1(p);
2201 }
2202 kdb_printf("\n");
2203 /* Now the real tasks */
2204 kdb_do_each_thread(g, p) {
2205 if (KDB_FLAG(CMD_INTERRUPT))
2206 return 0;
2207 if (kdb_task_state(p, mask))
2208 kdb_ps1(p);
2209 } kdb_while_each_thread(g, p);
2210
2211 return 0;
2212}
2213
2214/*
2215 * kdb_pid - This function implements the 'pid' command which switches
2216 * the currently active process.
2217 * pid [<pid> | R]
2218 */
2219static int kdb_pid(int argc, const char **argv)
2220{
2221 struct task_struct *p;
2222 unsigned long val;
2223 int diag;
2224
2225 if (argc > 1)
2226 return KDB_ARGCOUNT;
2227
2228 if (argc) {
2229 if (strcmp(argv[1], "R") == 0) {
2230 p = KDB_TSK(kdb_initial_cpu);
2231 } else {
2232 diag = kdbgetularg(argv[1], &val);
2233 if (diag)
2234 return KDB_BADINT;
2235
2236 p = find_task_by_pid_ns((pid_t)val, &init_pid_ns);
2237 if (!p) {
2238 kdb_printf("No task with pid=%d\n", (pid_t)val);
2239 return 0;
2240 }
2241 }
2242 kdb_set_current_task(p);
2243 }
2244 kdb_printf("KDB current process is %s(pid=%d)\n",
2245 kdb_current_task->comm,
2246 kdb_current_task->pid);
2247
2248 return 0;
2249}
2250
2251/*
2252 * kdb_ll - This function implements the 'll' command which follows a
2253 * linked list and executes an arbitrary command for each
2254 * element.
2255 */
2256static int kdb_ll(int argc, const char **argv)
2257{
2258 int diag;
2259 unsigned long addr;
2260 long offset = 0;
2261 unsigned long va;
2262 unsigned long linkoffset;
2263 int nextarg;
2264 const char *command;
2265
2266 if (argc != 3)
2267 return KDB_ARGCOUNT;
2268
2269 nextarg = 1;
2270 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
2271 if (diag)
2272 return diag;
2273
2274 diag = kdbgetularg(argv[2], &linkoffset);
2275 if (diag)
2276 return diag;
2277
2278 /*
2279 * Using the starting address as
2280 * the first element in the list, and assuming that
2281 * the list ends with a null pointer.
2282 */
2283
2284 va = addr;
2285 command = kdb_strdup(argv[3], GFP_KDB);
2286 if (!command) {
2287 kdb_printf("%s: cannot duplicate command\n", __func__);
2288 return 0;
2289 }
2290 /* Recursive use of kdb_parse, do not use argv after this point */
2291 argv = NULL;
2292
2293 while (va) {
2294 char buf[80];
2295
2296 sprintf(buf, "%s " kdb_machreg_fmt "\n", command, va);
2297 diag = kdb_parse(buf);
2298 if (diag)
2299 return diag;
2300
2301 addr = va + linkoffset;
2302 if (kdb_getword(&va, addr, sizeof(va)))
2303 return 0;
2304 }
2305 kfree(command);
2306
2307 return 0;
2308}
2309
2310static int kdb_kgdb(int argc, const char **argv)
2311{
2312 return KDB_CMD_KGDB;
2313}
2314
2315/*
2316 * kdb_help - This function implements the 'help' and '?' commands.
2317 */
2318static int kdb_help(int argc, const char **argv)
2319{
2320 kdbtab_t *kt;
2321 int i;
2322
2323 kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2324 kdb_printf("-----------------------------"
2325 "-----------------------------\n");
2326 for_each_kdbcmd(kt, i) {
2327 if (kt->cmd_name)
2328 kdb_printf("%-15.15s %-20.20s %s\n", kt->cmd_name,
2329 kt->cmd_usage, kt->cmd_help);
2330 if (KDB_FLAG(CMD_INTERRUPT))
2331 return 0;
2332 }
2333 return 0;
2334}
2335
2336/*
2337 * kdb_kill - This function implements the 'kill' commands.
2338 */
2339static int kdb_kill(int argc, const char **argv)
2340{
2341 long sig, pid;
2342 char *endp;
2343 struct task_struct *p;
2344 struct siginfo info;
2345
2346 if (argc != 2)
2347 return KDB_ARGCOUNT;
2348
2349 sig = simple_strtol(argv[1], &endp, 0);
2350 if (*endp)
2351 return KDB_BADINT;
2352 if (sig >= 0) {
2353 kdb_printf("Invalid signal parameter.<-signal>\n");
2354 return 0;
2355 }
2356 sig = -sig;
2357
2358 pid = simple_strtol(argv[2], &endp, 0);
2359 if (*endp)
2360 return KDB_BADINT;
2361 if (pid <= 0) {
2362 kdb_printf("Process ID must be large than 0.\n");
2363 return 0;
2364 }
2365
2366 /* Find the process. */
2367 p = find_task_by_pid_ns(pid, &init_pid_ns);
2368 if (!p) {
2369 kdb_printf("The specified process isn't found.\n");
2370 return 0;
2371 }
2372 p = p->group_leader;
2373 info.si_signo = sig;
2374 info.si_errno = 0;
2375 info.si_code = SI_USER;
2376 info.si_pid = pid; /* same capabilities as process being signalled */
2377 info.si_uid = 0; /* kdb has root authority */
2378 kdb_send_sig_info(p, &info);
2379 return 0;
2380}
2381
2382struct kdb_tm {
2383 int tm_sec; /* seconds */
2384 int tm_min; /* minutes */
2385 int tm_hour; /* hours */
2386 int tm_mday; /* day of the month */
2387 int tm_mon; /* month */
2388 int tm_year; /* year */
2389};
2390
2391static void kdb_gmtime(struct timespec *tv, struct kdb_tm *tm)
2392{
2393 /* This will work from 1970-2099, 2100 is not a leap year */
2394 static int mon_day[] = { 31, 29, 31, 30, 31, 30, 31,
2395 31, 30, 31, 30, 31 };
2396 memset(tm, 0, sizeof(*tm));
2397 tm->tm_sec = tv->tv_sec % (24 * 60 * 60);
2398 tm->tm_mday = tv->tv_sec / (24 * 60 * 60) +
2399 (2 * 365 + 1); /* shift base from 1970 to 1968 */
2400 tm->tm_min = tm->tm_sec / 60 % 60;
2401 tm->tm_hour = tm->tm_sec / 60 / 60;
2402 tm->tm_sec = tm->tm_sec % 60;
2403 tm->tm_year = 68 + 4*(tm->tm_mday / (4*365+1));
2404 tm->tm_mday %= (4*365+1);
2405 mon_day[1] = 29;
2406 while (tm->tm_mday >= mon_day[tm->tm_mon]) {
2407 tm->tm_mday -= mon_day[tm->tm_mon];
2408 if (++tm->tm_mon == 12) {
2409 tm->tm_mon = 0;
2410 ++tm->tm_year;
2411 mon_day[1] = 28;
2412 }
2413 }
2414 ++tm->tm_mday;
2415}
2416
2417/*
2418 * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2419 * I cannot call that code directly from kdb, it has an unconditional
2420 * cli()/sti() and calls routines that take locks which can stop the debugger.
2421 */
2422static void kdb_sysinfo(struct sysinfo *val)
2423{
2424 struct timespec uptime;
2425 do_posix_clock_monotonic_gettime(&uptime);
2426 memset(val, 0, sizeof(*val));
2427 val->uptime = uptime.tv_sec;
2428 val->loads[0] = avenrun[0];
2429 val->loads[1] = avenrun[1];
2430 val->loads[2] = avenrun[2];
2431 val->procs = nr_threads-1;
2432 si_meminfo(val);
2433
2434 return;
2435}
2436
2437/*
2438 * kdb_summary - This function implements the 'summary' command.
2439 */
2440static int kdb_summary(int argc, const char **argv)
2441{
2442 struct kdb_tm tm;
2443 struct sysinfo val;
2444
2445 if (argc)
2446 return KDB_ARGCOUNT;
2447
2448 kdb_printf("sysname %s\n", init_uts_ns.name.sysname);
2449 kdb_printf("release %s\n", init_uts_ns.name.release);
2450 kdb_printf("version %s\n", init_uts_ns.name.version);
2451 kdb_printf("machine %s\n", init_uts_ns.name.machine);
2452 kdb_printf("nodename %s\n", init_uts_ns.name.nodename);
2453 kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2454 kdb_printf("ccversion %s\n", __stringify(CCVERSION));
2455
2456 kdb_gmtime(&xtime, &tm);
2457 kdb_printf("date %04d-%02d-%02d %02d:%02d:%02d "
2458 "tz_minuteswest %d\n",
2459 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2460 tm.tm_hour, tm.tm_min, tm.tm_sec,
2461 sys_tz.tz_minuteswest);
2462
2463 kdb_sysinfo(&val);
2464 kdb_printf("uptime ");
2465 if (val.uptime > (24*60*60)) {
2466 int days = val.uptime / (24*60*60);
2467 val.uptime %= (24*60*60);
2468 kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2469 }
2470 kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2471
2472 /* lifted from fs/proc/proc_misc.c::loadavg_read_proc() */
2473
2474#define LOAD_INT(x) ((x) >> FSHIFT)
2475#define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
2476 kdb_printf("load avg %ld.%02ld %ld.%02ld %ld.%02ld\n",
2477 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2478 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2479 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2480#undef LOAD_INT
2481#undef LOAD_FRAC
2482 /* Display in kilobytes */
2483#define K(x) ((x) << (PAGE_SHIFT - 10))
2484 kdb_printf("\nMemTotal: %8lu kB\nMemFree: %8lu kB\n"
2485 "Buffers: %8lu kB\n",
2486 val.totalram, val.freeram, val.bufferram);
2487 return 0;
2488}
2489
2490/*
2491 * kdb_per_cpu - This function implements the 'per_cpu' command.
2492 */
2493static int kdb_per_cpu(int argc, const char **argv)
2494{
2495 char buf[256], fmtstr[64];
2496 kdb_symtab_t symtab;
2497 cpumask_t suppress = CPU_MASK_NONE;
2498 int cpu, diag;
2499 unsigned long addr, val, bytesperword = 0, whichcpu = ~0UL;
2500
2501 if (argc < 1 || argc > 3)
2502 return KDB_ARGCOUNT;
2503
2504 snprintf(buf, sizeof(buf), "per_cpu__%s", argv[1]);
2505 if (!kdbgetsymval(buf, &symtab)) {
2506 kdb_printf("%s is not a per_cpu variable\n", argv[1]);
2507 return KDB_BADADDR;
2508 }
2509 if (argc >= 2) {
2510 diag = kdbgetularg(argv[2], &bytesperword);
2511 if (diag)
2512 return diag;
2513 }
2514 if (!bytesperword)
2515 bytesperword = KDB_WORD_SIZE;
2516 else if (bytesperword > KDB_WORD_SIZE)
2517 return KDB_BADWIDTH;
2518 sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2519 if (argc >= 3) {
2520 diag = kdbgetularg(argv[3], &whichcpu);
2521 if (diag)
2522 return diag;
2523 if (!cpu_online(whichcpu)) {
2524 kdb_printf("cpu %ld is not online\n", whichcpu);
2525 return KDB_BADCPUNUM;
2526 }
2527 }
2528
2529 /* Most architectures use __per_cpu_offset[cpu], some use
2530 * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2531 */
2532#ifdef __per_cpu_offset
2533#define KDB_PCU(cpu) __per_cpu_offset(cpu)
2534#else
2535#ifdef CONFIG_SMP
2536#define KDB_PCU(cpu) __per_cpu_offset[cpu]
2537#else
2538#define KDB_PCU(cpu) 0
2539#endif
2540#endif
2541
2542 for_each_online_cpu(cpu) {
2543 if (whichcpu != ~0UL && whichcpu != cpu)
2544 continue;
2545 addr = symtab.sym_start + KDB_PCU(cpu);
2546 diag = kdb_getword(&val, addr, bytesperword);
2547 if (diag) {
2548 kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2549 "read, diag=%d\n", cpu, addr, diag);
2550 continue;
2551 }
2552#ifdef CONFIG_SMP
2553 if (!val) {
2554 cpu_set(cpu, suppress);
2555 continue;
2556 }
2557#endif /* CONFIG_SMP */
2558 kdb_printf("%5d ", cpu);
2559 kdb_md_line(fmtstr, addr,
2560 bytesperword == KDB_WORD_SIZE,
2561 1, bytesperword, 1, 1, 0);
2562 }
2563 if (cpus_weight(suppress) == 0)
2564 return 0;
2565 kdb_printf("Zero suppressed cpu(s):");
2566 for (cpu = first_cpu(suppress); cpu < num_possible_cpus();
2567 cpu = next_cpu(cpu, suppress)) {
2568 kdb_printf(" %d", cpu);
2569 if (cpu == num_possible_cpus() - 1 ||
2570 next_cpu(cpu, suppress) != cpu + 1)
2571 continue;
2572 while (cpu < num_possible_cpus() &&
2573 next_cpu(cpu, suppress) == cpu + 1)
2574 ++cpu;
2575 kdb_printf("-%d", cpu);
2576 }
2577 kdb_printf("\n");
2578
2579#undef KDB_PCU
2580
2581 return 0;
2582}
2583
2584/*
2585 * display help for the use of cmd | grep pattern
2586 */
2587static int kdb_grep_help(int argc, const char **argv)
2588{
2589 kdb_printf("Usage of cmd args | grep pattern:\n");
2590 kdb_printf(" Any command's output may be filtered through an ");
2591 kdb_printf("emulated 'pipe'.\n");
2592 kdb_printf(" 'grep' is just a key word.\n");
2593 kdb_printf(" The pattern may include a very limited set of "
2594 "metacharacters:\n");
2595 kdb_printf(" pattern or ^pattern or pattern$ or ^pattern$\n");
2596 kdb_printf(" And if there are spaces in the pattern, you may "
2597 "quote it:\n");
2598 kdb_printf(" \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2599 " or \"^pat tern$\"\n");
2600 return 0;
2601}
2602
2603/*
2604 * kdb_register_repeat - This function is used to register a kernel
2605 * debugger command.
2606 * Inputs:
2607 * cmd Command name
2608 * func Function to execute the command
2609 * usage A simple usage string showing arguments
2610 * help A simple help string describing command
2611 * repeat Does the command auto repeat on enter?
2612 * Returns:
2613 * zero for success, one if a duplicate command.
2614 */
2615#define kdb_command_extend 50 /* arbitrary */
2616int kdb_register_repeat(char *cmd,
2617 kdb_func_t func,
2618 char *usage,
2619 char *help,
2620 short minlen,
2621 kdb_repeat_t repeat)
2622{
2623 int i;
2624 kdbtab_t *kp;
2625
2626 /*
2627 * Brute force method to determine duplicates
2628 */
2629 for_each_kdbcmd(kp, i) {
2630 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2631 kdb_printf("Duplicate kdb command registered: "
2632 "%s, func %p help %s\n", cmd, func, help);
2633 return 1;
2634 }
2635 }
2636
2637 /*
2638 * Insert command into first available location in table
2639 */
2640 for_each_kdbcmd(kp, i) {
2641 if (kp->cmd_name == NULL)
2642 break;
2643 }
2644
2645 if (i >= kdb_max_commands) {
2646 kdbtab_t *new = kmalloc((kdb_max_commands - KDB_BASE_CMD_MAX +
2647 kdb_command_extend) * sizeof(*new), GFP_KDB);
2648 if (!new) {
2649 kdb_printf("Could not allocate new kdb_command "
2650 "table\n");
2651 return 1;
2652 }
2653 if (kdb_commands) {
2654 memcpy(new, kdb_commands,
2655 kdb_max_commands * sizeof(*new));
2656 kfree(kdb_commands);
2657 }
2658 memset(new + kdb_max_commands, 0,
2659 kdb_command_extend * sizeof(*new));
2660 kdb_commands = new;
2661 kp = kdb_commands + kdb_max_commands;
2662 kdb_max_commands += kdb_command_extend;
2663 }
2664
2665 kp->cmd_name = cmd;
2666 kp->cmd_func = func;
2667 kp->cmd_usage = usage;
2668 kp->cmd_help = help;
2669 kp->cmd_flags = 0;
2670 kp->cmd_minlen = minlen;
2671 kp->cmd_repeat = repeat;
2672
2673 return 0;
2674}
2675
2676/*
2677 * kdb_register - Compatibility register function for commands that do
2678 * not need to specify a repeat state. Equivalent to
2679 * kdb_register_repeat with KDB_REPEAT_NONE.
2680 * Inputs:
2681 * cmd Command name
2682 * func Function to execute the command
2683 * usage A simple usage string showing arguments
2684 * help A simple help string describing command
2685 * Returns:
2686 * zero for success, one if a duplicate command.
2687 */
2688int kdb_register(char *cmd,
2689 kdb_func_t func,
2690 char *usage,
2691 char *help,
2692 short minlen)
2693{
2694 return kdb_register_repeat(cmd, func, usage, help, minlen,
2695 KDB_REPEAT_NONE);
2696}
2697
2698/*
2699 * kdb_unregister - This function is used to unregister a kernel
2700 * debugger command. It is generally called when a module which
2701 * implements kdb commands is unloaded.
2702 * Inputs:
2703 * cmd Command name
2704 * Returns:
2705 * zero for success, one command not registered.
2706 */
2707int kdb_unregister(char *cmd)
2708{
2709 int i;
2710 kdbtab_t *kp;
2711
2712 /*
2713 * find the command.
2714 */
2715 for (i = 0, kp = kdb_commands; i < kdb_max_commands; i++, kp++) {
2716 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2717 kp->cmd_name = NULL;
2718 return 0;
2719 }
2720 }
2721
2722 /* Couldn't find it. */
2723 return 1;
2724}
2725
2726/* Initialize the kdb command table. */
2727static void __init kdb_inittab(void)
2728{
2729 int i;
2730 kdbtab_t *kp;
2731
2732 for_each_kdbcmd(kp, i)
2733 kp->cmd_name = NULL;
2734
2735 kdb_register_repeat("md", kdb_md, "<vaddr>",
2736 "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2737 KDB_REPEAT_NO_ARGS);
2738 kdb_register_repeat("mdr", kdb_md, "<vaddr> <bytes>",
2739 "Display Raw Memory", 0, KDB_REPEAT_NO_ARGS);
2740 kdb_register_repeat("mdp", kdb_md, "<paddr> <bytes>",
2741 "Display Physical Memory", 0, KDB_REPEAT_NO_ARGS);
2742 kdb_register_repeat("mds", kdb_md, "<vaddr>",
2743 "Display Memory Symbolically", 0, KDB_REPEAT_NO_ARGS);
2744 kdb_register_repeat("mm", kdb_mm, "<vaddr> <contents>",
2745 "Modify Memory Contents", 0, KDB_REPEAT_NO_ARGS);
2746 kdb_register_repeat("go", kdb_go, "[<vaddr>]",
2747 "Continue Execution", 1, KDB_REPEAT_NONE);
2748 kdb_register_repeat("rd", kdb_rd, "",
2749 "Display Registers", 0, KDB_REPEAT_NONE);
2750 kdb_register_repeat("rm", kdb_rm, "<reg> <contents>",
2751 "Modify Registers", 0, KDB_REPEAT_NONE);
2752 kdb_register_repeat("ef", kdb_ef, "<vaddr>",
2753 "Display exception frame", 0, KDB_REPEAT_NONE);
2754 kdb_register_repeat("bt", kdb_bt, "[<vaddr>]",
2755 "Stack traceback", 1, KDB_REPEAT_NONE);
2756 kdb_register_repeat("btp", kdb_bt, "<pid>",
2757 "Display stack for process <pid>", 0, KDB_REPEAT_NONE);
2758 kdb_register_repeat("bta", kdb_bt, "[DRSTCZEUIMA]",
2759 "Display stack all processes", 0, KDB_REPEAT_NONE);
2760 kdb_register_repeat("btc", kdb_bt, "",
2761 "Backtrace current process on each cpu", 0, KDB_REPEAT_NONE);
2762 kdb_register_repeat("btt", kdb_bt, "<vaddr>",
2763 "Backtrace process given its struct task address", 0,
2764 KDB_REPEAT_NONE);
2765 kdb_register_repeat("ll", kdb_ll, "<first-element> <linkoffset> <cmd>",
2766 "Execute cmd for each element in linked list", 0, KDB_REPEAT_NONE);
2767 kdb_register_repeat("env", kdb_env, "",
2768 "Show environment variables", 0, KDB_REPEAT_NONE);
2769 kdb_register_repeat("set", kdb_set, "",
2770 "Set environment variables", 0, KDB_REPEAT_NONE);
2771 kdb_register_repeat("help", kdb_help, "",
2772 "Display Help Message", 1, KDB_REPEAT_NONE);
2773 kdb_register_repeat("?", kdb_help, "",
2774 "Display Help Message", 0, KDB_REPEAT_NONE);
2775 kdb_register_repeat("cpu", kdb_cpu, "<cpunum>",
2776 "Switch to new cpu", 0, KDB_REPEAT_NONE);
2777 kdb_register_repeat("kgdb", kdb_kgdb, "",
2778 "Enter kgdb mode", 0, KDB_REPEAT_NONE);
2779 kdb_register_repeat("ps", kdb_ps, "[<flags>|A]",
2780 "Display active task list", 0, KDB_REPEAT_NONE);
2781 kdb_register_repeat("pid", kdb_pid, "<pidnum>",
2782 "Switch to another task", 0, KDB_REPEAT_NONE);
2783 kdb_register_repeat("reboot", kdb_reboot, "",
2784 "Reboot the machine immediately", 0, KDB_REPEAT_NONE);
2785#if defined(CONFIG_MODULES)
2786 kdb_register_repeat("lsmod", kdb_lsmod, "",
2787 "List loaded kernel modules", 0, KDB_REPEAT_NONE);
2788#endif
2789#if defined(CONFIG_MAGIC_SYSRQ)
2790 kdb_register_repeat("sr", kdb_sr, "<key>",
2791 "Magic SysRq key", 0, KDB_REPEAT_NONE);
2792#endif
2793#if defined(CONFIG_PRINTK)
2794 kdb_register_repeat("dmesg", kdb_dmesg, "[lines]",
2795 "Display syslog buffer", 0, KDB_REPEAT_NONE);
2796#endif
2797 kdb_register_repeat("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
2798 "Define a set of commands, down to endefcmd", 0, KDB_REPEAT_NONE);
2799 kdb_register_repeat("kill", kdb_kill, "<-signal> <pid>",
2800 "Send a signal to a process", 0, KDB_REPEAT_NONE);
2801 kdb_register_repeat("summary", kdb_summary, "",
2802 "Summarize the system", 4, KDB_REPEAT_NONE);
2803 kdb_register_repeat("per_cpu", kdb_per_cpu, "",
2804 "Display per_cpu variables", 3, KDB_REPEAT_NONE);
2805 kdb_register_repeat("grephelp", kdb_grep_help, "",
2806 "Display help on | grep", 0, KDB_REPEAT_NONE);
2807}
2808
2809/* Execute any commands defined in kdb_cmds. */
2810static void __init kdb_cmd_init(void)
2811{
2812 int i, diag;
2813 for (i = 0; kdb_cmds[i]; ++i) {
2814 diag = kdb_parse(kdb_cmds[i]);
2815 if (diag)
2816 kdb_printf("kdb command %s failed, kdb diag %d\n",
2817 kdb_cmds[i], diag);
2818 }
2819 if (defcmd_in_progress) {
2820 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2821 kdb_parse("endefcmd");
2822 }
2823}
2824
2825/* Intialize kdb_printf, breakpoint tables and kdb state */
2826void __init kdb_init(int lvl)
2827{
2828 static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2829 int i;
2830
2831 if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2832 return;
2833 for (i = kdb_init_lvl; i < lvl; i++) {
2834 switch (i) {
2835 case KDB_NOT_INITIALIZED:
2836 kdb_inittab(); /* Initialize Command Table */
2837 kdb_initbptab(); /* Initialize Breakpoints */
2838 break;
2839 case KDB_INIT_EARLY:
2840 kdb_cmd_init(); /* Build kdb_cmds tables */
2841 break;
2842 }
2843 }
2844 kdb_init_lvl = lvl;
2845}
diff --git a/kernel/debug/kdb/kdb_private.h b/kernel/debug/kdb/kdb_private.h
new file mode 100644
index 000000000000..69ed2eff3fea
--- /dev/null
+++ b/kernel/debug/kdb/kdb_private.h
@@ -0,0 +1,301 @@
1#ifndef _KDBPRIVATE_H
2#define _KDBPRIVATE_H
3
4/*
5 * Kernel Debugger Architecture Independent Private Headers
6 *
7 * This file is subject to the terms and conditions of the GNU General Public
8 * License. See the file "COPYING" in the main directory of this archive
9 * for more details.
10 *
11 * Copyright (c) 2000-2004 Silicon Graphics, Inc. All Rights Reserved.
12 * Copyright (c) 2009 Wind River Systems, Inc. All Rights Reserved.
13 */
14
15#include <linux/kgdb.h>
16#include "../debug_core.h"
17
18/* Kernel Debugger Error codes. Must not overlap with command codes. */
19#define KDB_NOTFOUND (-1)
20#define KDB_ARGCOUNT (-2)
21#define KDB_BADWIDTH (-3)
22#define KDB_BADRADIX (-4)
23#define KDB_NOTENV (-5)
24#define KDB_NOENVVALUE (-6)
25#define KDB_NOTIMP (-7)
26#define KDB_ENVFULL (-8)
27#define KDB_ENVBUFFULL (-9)
28#define KDB_TOOMANYBPT (-10)
29#define KDB_TOOMANYDBREGS (-11)
30#define KDB_DUPBPT (-12)
31#define KDB_BPTNOTFOUND (-13)
32#define KDB_BADMODE (-14)
33#define KDB_BADINT (-15)
34#define KDB_INVADDRFMT (-16)
35#define KDB_BADREG (-17)
36#define KDB_BADCPUNUM (-18)
37#define KDB_BADLENGTH (-19)
38#define KDB_NOBP (-20)
39#define KDB_BADADDR (-21)
40
41/* Kernel Debugger Command codes. Must not overlap with error codes. */
42#define KDB_CMD_GO (-1001)
43#define KDB_CMD_CPU (-1002)
44#define KDB_CMD_SS (-1003)
45#define KDB_CMD_SSB (-1004)
46#define KDB_CMD_KGDB (-1005)
47#define KDB_CMD_KGDB2 (-1006)
48
49/* Internal debug flags */
50#define KDB_DEBUG_FLAG_BP 0x0002 /* Breakpoint subsystem debug */
51#define KDB_DEBUG_FLAG_BB_SUMM 0x0004 /* Basic block analysis, summary only */
52#define KDB_DEBUG_FLAG_AR 0x0008 /* Activation record, generic */
53#define KDB_DEBUG_FLAG_ARA 0x0010 /* Activation record, arch specific */
54#define KDB_DEBUG_FLAG_BB 0x0020 /* All basic block analysis */
55#define KDB_DEBUG_FLAG_STATE 0x0040 /* State flags */
56#define KDB_DEBUG_FLAG_MASK 0xffff /* All debug flags */
57#define KDB_DEBUG_FLAG_SHIFT 16 /* Shift factor for dbflags */
58
59#define KDB_DEBUG(flag) (kdb_flags & \
60 (KDB_DEBUG_FLAG_##flag << KDB_DEBUG_FLAG_SHIFT))
61#define KDB_DEBUG_STATE(text, value) if (KDB_DEBUG(STATE)) \
62 kdb_print_state(text, value)
63
64#if BITS_PER_LONG == 32
65
66#define KDB_PLATFORM_ENV "BYTESPERWORD=4"
67
68#define kdb_machreg_fmt "0x%lx"
69#define kdb_machreg_fmt0 "0x%08lx"
70#define kdb_bfd_vma_fmt "0x%lx"
71#define kdb_bfd_vma_fmt0 "0x%08lx"
72#define kdb_elfw_addr_fmt "0x%x"
73#define kdb_elfw_addr_fmt0 "0x%08x"
74#define kdb_f_count_fmt "%d"
75
76#elif BITS_PER_LONG == 64
77
78#define KDB_PLATFORM_ENV "BYTESPERWORD=8"
79
80#define kdb_machreg_fmt "0x%lx"
81#define kdb_machreg_fmt0 "0x%016lx"
82#define kdb_bfd_vma_fmt "0x%lx"
83#define kdb_bfd_vma_fmt0 "0x%016lx"
84#define kdb_elfw_addr_fmt "0x%x"
85#define kdb_elfw_addr_fmt0 "0x%016x"
86#define kdb_f_count_fmt "%ld"
87
88#endif
89
90/*
91 * KDB_MAXBPT describes the total number of breakpoints
92 * supported by this architecure.
93 */
94#define KDB_MAXBPT 16
95
96/* Maximum number of arguments to a function */
97#define KDB_MAXARGS 16
98
99typedef enum {
100 KDB_REPEAT_NONE = 0, /* Do not repeat this command */
101 KDB_REPEAT_NO_ARGS, /* Repeat the command without arguments */
102 KDB_REPEAT_WITH_ARGS, /* Repeat the command including its arguments */
103} kdb_repeat_t;
104
105typedef int (*kdb_func_t)(int, const char **);
106
107/* Symbol table format returned by kallsyms. */
108typedef struct __ksymtab {
109 unsigned long value; /* Address of symbol */
110 const char *mod_name; /* Module containing symbol or
111 * "kernel" */
112 unsigned long mod_start;
113 unsigned long mod_end;
114 const char *sec_name; /* Section containing symbol */
115 unsigned long sec_start;
116 unsigned long sec_end;
117 const char *sym_name; /* Full symbol name, including
118 * any version */
119 unsigned long sym_start;
120 unsigned long sym_end;
121 } kdb_symtab_t;
122extern int kallsyms_symbol_next(char *prefix_name, int flag);
123extern int kallsyms_symbol_complete(char *prefix_name, int max_len);
124
125/* Exported Symbols for kernel loadable modules to use. */
126extern int kdb_register(char *, kdb_func_t, char *, char *, short);
127extern int kdb_register_repeat(char *, kdb_func_t, char *, char *,
128 short, kdb_repeat_t);
129extern int kdb_unregister(char *);
130
131extern int kdb_getarea_size(void *, unsigned long, size_t);
132extern int kdb_putarea_size(unsigned long, void *, size_t);
133
134/*
135 * Like get_user and put_user, kdb_getarea and kdb_putarea take variable
136 * names, not pointers. The underlying *_size functions take pointers.
137 */
138#define kdb_getarea(x, addr) kdb_getarea_size(&(x), addr, sizeof((x)))
139#define kdb_putarea(addr, x) kdb_putarea_size(addr, &(x), sizeof((x)))
140
141extern int kdb_getphysword(unsigned long *word,
142 unsigned long addr, size_t size);
143extern int kdb_getword(unsigned long *, unsigned long, size_t);
144extern int kdb_putword(unsigned long, unsigned long, size_t);
145
146extern int kdbgetularg(const char *, unsigned long *);
147extern int kdb_set(int, const char **);
148extern char *kdbgetenv(const char *);
149extern int kdbgetintenv(const char *, int *);
150extern int kdbgetaddrarg(int, const char **, int*, unsigned long *,
151 long *, char **);
152extern int kdbgetsymval(const char *, kdb_symtab_t *);
153extern int kdbnearsym(unsigned long, kdb_symtab_t *);
154extern void kdbnearsym_cleanup(void);
155extern char *kdb_strdup(const char *str, gfp_t type);
156extern void kdb_symbol_print(unsigned long, const kdb_symtab_t *, unsigned int);
157
158/* Routine for debugging the debugger state. */
159extern void kdb_print_state(const char *, int);
160
161extern int kdb_state;
162#define KDB_STATE_KDB 0x00000001 /* Cpu is inside kdb */
163#define KDB_STATE_LEAVING 0x00000002 /* Cpu is leaving kdb */
164#define KDB_STATE_CMD 0x00000004 /* Running a kdb command */
165#define KDB_STATE_KDB_CONTROL 0x00000008 /* This cpu is under
166 * kdb control */
167#define KDB_STATE_HOLD_CPU 0x00000010 /* Hold this cpu inside kdb */
168#define KDB_STATE_DOING_SS 0x00000020 /* Doing ss command */
169#define KDB_STATE_DOING_SSB 0x00000040 /* Doing ssb command,
170 * DOING_SS is also set */
171#define KDB_STATE_SSBPT 0x00000080 /* Install breakpoint
172 * after one ss, independent of
173 * DOING_SS */
174#define KDB_STATE_REENTRY 0x00000100 /* Valid re-entry into kdb */
175#define KDB_STATE_SUPPRESS 0x00000200 /* Suppress error messages */
176#define KDB_STATE_PAGER 0x00000400 /* pager is available */
177#define KDB_STATE_GO_SWITCH 0x00000800 /* go is switching
178 * back to initial cpu */
179#define KDB_STATE_PRINTF_LOCK 0x00001000 /* Holds kdb_printf lock */
180#define KDB_STATE_WAIT_IPI 0x00002000 /* Waiting for kdb_ipi() NMI */
181#define KDB_STATE_RECURSE 0x00004000 /* Recursive entry to kdb */
182#define KDB_STATE_IP_ADJUSTED 0x00008000 /* Restart IP has been
183 * adjusted */
184#define KDB_STATE_GO1 0x00010000 /* go only releases one cpu */
185#define KDB_STATE_KEYBOARD 0x00020000 /* kdb entered via
186 * keyboard on this cpu */
187#define KDB_STATE_KEXEC 0x00040000 /* kexec issued */
188#define KDB_STATE_DOING_KGDB 0x00080000 /* kgdb enter now issued */
189#define KDB_STATE_DOING_KGDB2 0x00100000 /* kgdb enter now issued */
190#define KDB_STATE_KGDB_TRANS 0x00200000 /* Transition to kgdb */
191#define KDB_STATE_ARCH 0xff000000 /* Reserved for arch
192 * specific use */
193
194#define KDB_STATE(flag) (kdb_state & KDB_STATE_##flag)
195#define KDB_STATE_SET(flag) ((void)(kdb_state |= KDB_STATE_##flag))
196#define KDB_STATE_CLEAR(flag) ((void)(kdb_state &= ~KDB_STATE_##flag))
197
198extern int kdb_nextline; /* Current number of lines displayed */
199
200typedef struct _kdb_bp {
201 unsigned long bp_addr; /* Address breakpoint is present at */
202 unsigned int bp_free:1; /* This entry is available */
203 unsigned int bp_enabled:1; /* Breakpoint is active in register */
204 unsigned int bp_type:4; /* Uses hardware register */
205 unsigned int bp_installed:1; /* Breakpoint is installed */
206 unsigned int bp_delay:1; /* Do delayed bp handling */
207 unsigned int bp_delayed:1; /* Delayed breakpoint */
208 unsigned int bph_length; /* HW break length */
209} kdb_bp_t;
210
211#ifdef CONFIG_KGDB_KDB
212extern kdb_bp_t kdb_breakpoints[/* KDB_MAXBPT */];
213
214/* The KDB shell command table */
215typedef struct _kdbtab {
216 char *cmd_name; /* Command name */
217 kdb_func_t cmd_func; /* Function to execute command */
218 char *cmd_usage; /* Usage String for this command */
219 char *cmd_help; /* Help message for this command */
220 short cmd_flags; /* Parsing flags */
221 short cmd_minlen; /* Minimum legal # command
222 * chars required */
223 kdb_repeat_t cmd_repeat; /* Does command auto repeat on enter? */
224} kdbtab_t;
225
226extern int kdb_bt(int, const char **); /* KDB display back trace */
227
228/* KDB breakpoint management functions */
229extern void kdb_initbptab(void);
230extern void kdb_bp_install(struct pt_regs *);
231extern void kdb_bp_remove(void);
232
233typedef enum {
234 KDB_DB_BPT, /* Breakpoint */
235 KDB_DB_SS, /* Single-step trap */
236 KDB_DB_SSB, /* Single step to branch */
237 KDB_DB_SSBPT, /* Single step over breakpoint */
238 KDB_DB_NOBPT /* Spurious breakpoint */
239} kdb_dbtrap_t;
240
241extern int kdb_main_loop(kdb_reason_t, kdb_reason_t,
242 int, kdb_dbtrap_t, struct pt_regs *);
243
244/* Miscellaneous functions and data areas */
245extern int kdb_grepping_flag;
246extern char kdb_grep_string[];
247extern int kdb_grep_leading;
248extern int kdb_grep_trailing;
249extern char *kdb_cmds[];
250extern void kdb_syslog_data(char *syslog_data[]);
251extern unsigned long kdb_task_state_string(const char *);
252extern char kdb_task_state_char (const struct task_struct *);
253extern unsigned long kdb_task_state(const struct task_struct *p,
254 unsigned long mask);
255extern void kdb_ps_suppressed(void);
256extern void kdb_ps1(const struct task_struct *p);
257extern int kdb_parse(const char *cmdstr);
258extern void kdb_print_nameval(const char *name, unsigned long val);
259extern void kdb_send_sig_info(struct task_struct *p, struct siginfo *info);
260extern void kdb_meminfo_proc_show(void);
261extern const char *kdb_walk_kallsyms(loff_t *pos);
262extern char *kdb_getstr(char *, size_t, char *);
263
264/* Defines for kdb_symbol_print */
265#define KDB_SP_SPACEB 0x0001 /* Space before string */
266#define KDB_SP_SPACEA 0x0002 /* Space after string */
267#define KDB_SP_PAREN 0x0004 /* Parenthesis around string */
268#define KDB_SP_VALUE 0x0008 /* Print the value of the address */
269#define KDB_SP_SYMSIZE 0x0010 /* Print the size of the symbol */
270#define KDB_SP_NEWLINE 0x0020 /* Newline after string */
271#define KDB_SP_DEFAULT (KDB_SP_VALUE|KDB_SP_PAREN)
272
273#define KDB_TSK(cpu) kgdb_info[cpu].task
274#define KDB_TSKREGS(cpu) kgdb_info[cpu].debuggerinfo
275
276extern struct task_struct *kdb_curr_task(int);
277
278#define kdb_task_has_cpu(p) (task_curr(p))
279
280/* Simplify coexistence with NPTL */
281#define kdb_do_each_thread(g, p) do_each_thread(g, p)
282#define kdb_while_each_thread(g, p) while_each_thread(g, p)
283
284#define GFP_KDB (in_interrupt() ? GFP_ATOMIC : GFP_KERNEL)
285
286extern void *debug_kmalloc(size_t size, gfp_t flags);
287extern void debug_kfree(void *);
288extern void debug_kusage(void);
289
290extern void kdb_set_current_task(struct task_struct *);
291extern struct task_struct *kdb_current_task;
292#ifdef CONFIG_MODULES
293extern struct list_head *kdb_modules;
294#endif /* CONFIG_MODULES */
295
296extern char kdb_prompt_str[];
297
298#define KDB_WORD_SIZE ((int)sizeof(unsigned long))
299
300#endif /* CONFIG_KGDB_KDB */
301#endif /* !_KDBPRIVATE_H */
diff --git a/kernel/debug/kdb/kdb_support.c b/kernel/debug/kdb/kdb_support.c
new file mode 100644
index 000000000000..45344d5c53dd
--- /dev/null
+++ b/kernel/debug/kdb/kdb_support.c
@@ -0,0 +1,927 @@
1/*
2 * Kernel Debugger Architecture Independent Support Functions
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) 2009 Wind River Systems, Inc. All Rights Reserved.
10 * 03/02/13 added new 2.5 kallsyms <xavier.bru@bull.net>
11 */
12
13#include <stdarg.h>
14#include <linux/types.h>
15#include <linux/sched.h>
16#include <linux/mm.h>
17#include <linux/kallsyms.h>
18#include <linux/stddef.h>
19#include <linux/vmalloc.h>
20#include <linux/ptrace.h>
21#include <linux/module.h>
22#include <linux/highmem.h>
23#include <linux/hardirq.h>
24#include <linux/delay.h>
25#include <linux/uaccess.h>
26#include <linux/kdb.h>
27#include <linux/slab.h>
28#include "kdb_private.h"
29
30/*
31 * kdbgetsymval - Return the address of the given symbol.
32 *
33 * Parameters:
34 * symname Character string containing symbol name
35 * symtab Structure to receive results
36 * Returns:
37 * 0 Symbol not found, symtab zero filled
38 * 1 Symbol mapped to module/symbol/section, data in symtab
39 */
40int kdbgetsymval(const char *symname, kdb_symtab_t *symtab)
41{
42 if (KDB_DEBUG(AR))
43 kdb_printf("kdbgetsymval: symname=%s, symtab=%p\n", symname,
44 symtab);
45 memset(symtab, 0, sizeof(*symtab));
46 symtab->sym_start = kallsyms_lookup_name(symname);
47 if (symtab->sym_start) {
48 if (KDB_DEBUG(AR))
49 kdb_printf("kdbgetsymval: returns 1, "
50 "symtab->sym_start=0x%lx\n",
51 symtab->sym_start);
52 return 1;
53 }
54 if (KDB_DEBUG(AR))
55 kdb_printf("kdbgetsymval: returns 0\n");
56 return 0;
57}
58EXPORT_SYMBOL(kdbgetsymval);
59
60static char *kdb_name_table[100]; /* arbitrary size */
61
62/*
63 * kdbnearsym - Return the name of the symbol with the nearest address
64 * less than 'addr'.
65 *
66 * Parameters:
67 * addr Address to check for symbol near
68 * symtab Structure to receive results
69 * Returns:
70 * 0 No sections contain this address, symtab zero filled
71 * 1 Address mapped to module/symbol/section, data in symtab
72 * Remarks:
73 * 2.6 kallsyms has a "feature" where it unpacks the name into a
74 * string. If that string is reused before the caller expects it
75 * then the caller sees its string change without warning. To
76 * avoid cluttering up the main kdb code with lots of kdb_strdup,
77 * tests and kfree calls, kdbnearsym maintains an LRU list of the
78 * last few unique strings. The list is sized large enough to
79 * hold active strings, no kdb caller of kdbnearsym makes more
80 * than ~20 later calls before using a saved value.
81 */
82int kdbnearsym(unsigned long addr, kdb_symtab_t *symtab)
83{
84 int ret = 0;
85 unsigned long symbolsize;
86 unsigned long offset;
87#define knt1_size 128 /* must be >= kallsyms table size */
88 char *knt1 = NULL;
89
90 if (KDB_DEBUG(AR))
91 kdb_printf("kdbnearsym: addr=0x%lx, symtab=%p\n", addr, symtab);
92 memset(symtab, 0, sizeof(*symtab));
93
94 if (addr < 4096)
95 goto out;
96 knt1 = debug_kmalloc(knt1_size, GFP_ATOMIC);
97 if (!knt1) {
98 kdb_printf("kdbnearsym: addr=0x%lx cannot kmalloc knt1\n",
99 addr);
100 goto out;
101 }
102 symtab->sym_name = kallsyms_lookup(addr, &symbolsize , &offset,
103 (char **)(&symtab->mod_name), knt1);
104 if (offset > 8*1024*1024) {
105 symtab->sym_name = NULL;
106 addr = offset = symbolsize = 0;
107 }
108 symtab->sym_start = addr - offset;
109 symtab->sym_end = symtab->sym_start + symbolsize;
110 ret = symtab->sym_name != NULL && *(symtab->sym_name) != '\0';
111
112 if (ret) {
113 int i;
114 /* Another 2.6 kallsyms "feature". Sometimes the sym_name is
115 * set but the buffer passed into kallsyms_lookup is not used,
116 * so it contains garbage. The caller has to work out which
117 * buffer needs to be saved.
118 *
119 * What was Rusty smoking when he wrote that code?
120 */
121 if (symtab->sym_name != knt1) {
122 strncpy(knt1, symtab->sym_name, knt1_size);
123 knt1[knt1_size-1] = '\0';
124 }
125 for (i = 0; i < ARRAY_SIZE(kdb_name_table); ++i) {
126 if (kdb_name_table[i] &&
127 strcmp(kdb_name_table[i], knt1) == 0)
128 break;
129 }
130 if (i >= ARRAY_SIZE(kdb_name_table)) {
131 debug_kfree(kdb_name_table[0]);
132 memcpy(kdb_name_table, kdb_name_table+1,
133 sizeof(kdb_name_table[0]) *
134 (ARRAY_SIZE(kdb_name_table)-1));
135 } else {
136 debug_kfree(knt1);
137 knt1 = kdb_name_table[i];
138 memcpy(kdb_name_table+i, kdb_name_table+i+1,
139 sizeof(kdb_name_table[0]) *
140 (ARRAY_SIZE(kdb_name_table)-i-1));
141 }
142 i = ARRAY_SIZE(kdb_name_table) - 1;
143 kdb_name_table[i] = knt1;
144 symtab->sym_name = kdb_name_table[i];
145 knt1 = NULL;
146 }
147
148 if (symtab->mod_name == NULL)
149 symtab->mod_name = "kernel";
150 if (KDB_DEBUG(AR))
151 kdb_printf("kdbnearsym: returns %d symtab->sym_start=0x%lx, "
152 "symtab->mod_name=%p, symtab->sym_name=%p (%s)\n", ret,
153 symtab->sym_start, symtab->mod_name, symtab->sym_name,
154 symtab->sym_name);
155
156out:
157 debug_kfree(knt1);
158 return ret;
159}
160
161void kdbnearsym_cleanup(void)
162{
163 int i;
164 for (i = 0; i < ARRAY_SIZE(kdb_name_table); ++i) {
165 if (kdb_name_table[i]) {
166 debug_kfree(kdb_name_table[i]);
167 kdb_name_table[i] = NULL;
168 }
169 }
170}
171
172static char ks_namebuf[KSYM_NAME_LEN+1], ks_namebuf_prev[KSYM_NAME_LEN+1];
173
174/*
175 * kallsyms_symbol_complete
176 *
177 * Parameters:
178 * prefix_name prefix of a symbol name to lookup
179 * max_len maximum length that can be returned
180 * Returns:
181 * Number of symbols which match the given prefix.
182 * Notes:
183 * prefix_name is changed to contain the longest unique prefix that
184 * starts with this prefix (tab completion).
185 */
186int kallsyms_symbol_complete(char *prefix_name, int max_len)
187{
188 loff_t pos = 0;
189 int prefix_len = strlen(prefix_name), prev_len = 0;
190 int i, number = 0;
191 const char *name;
192
193 while ((name = kdb_walk_kallsyms(&pos))) {
194 if (strncmp(name, prefix_name, prefix_len) == 0) {
195 strcpy(ks_namebuf, name);
196 /* Work out the longest name that matches the prefix */
197 if (++number == 1) {
198 prev_len = min_t(int, max_len-1,
199 strlen(ks_namebuf));
200 memcpy(ks_namebuf_prev, ks_namebuf, prev_len);
201 ks_namebuf_prev[prev_len] = '\0';
202 continue;
203 }
204 for (i = 0; i < prev_len; i++) {
205 if (ks_namebuf[i] != ks_namebuf_prev[i]) {
206 prev_len = i;
207 ks_namebuf_prev[i] = '\0';
208 break;
209 }
210 }
211 }
212 }
213 if (prev_len > prefix_len)
214 memcpy(prefix_name, ks_namebuf_prev, prev_len+1);
215 return number;
216}
217
218/*
219 * kallsyms_symbol_next
220 *
221 * Parameters:
222 * prefix_name prefix of a symbol name to lookup
223 * flag 0 means search from the head, 1 means continue search.
224 * Returns:
225 * 1 if a symbol matches the given prefix.
226 * 0 if no string found
227 */
228int kallsyms_symbol_next(char *prefix_name, int flag)
229{
230 int prefix_len = strlen(prefix_name);
231 static loff_t pos;
232 const char *name;
233
234 if (!flag)
235 pos = 0;
236
237 while ((name = kdb_walk_kallsyms(&pos))) {
238 if (strncmp(name, prefix_name, prefix_len) == 0) {
239 strncpy(prefix_name, name, strlen(name)+1);
240 return 1;
241 }
242 }
243 return 0;
244}
245
246/*
247 * kdb_symbol_print - Standard method for printing a symbol name and offset.
248 * Inputs:
249 * addr Address to be printed.
250 * symtab Address of symbol data, if NULL this routine does its
251 * own lookup.
252 * punc Punctuation for string, bit field.
253 * Remarks:
254 * The string and its punctuation is only printed if the address
255 * is inside the kernel, except that the value is always printed
256 * when requested.
257 */
258void kdb_symbol_print(unsigned long addr, const kdb_symtab_t *symtab_p,
259 unsigned int punc)
260{
261 kdb_symtab_t symtab, *symtab_p2;
262 if (symtab_p) {
263 symtab_p2 = (kdb_symtab_t *)symtab_p;
264 } else {
265 symtab_p2 = &symtab;
266 kdbnearsym(addr, symtab_p2);
267 }
268 if (!(symtab_p2->sym_name || (punc & KDB_SP_VALUE)))
269 return;
270 if (punc & KDB_SP_SPACEB)
271 kdb_printf(" ");
272 if (punc & KDB_SP_VALUE)
273 kdb_printf(kdb_machreg_fmt0, addr);
274 if (symtab_p2->sym_name) {
275 if (punc & KDB_SP_VALUE)
276 kdb_printf(" ");
277 if (punc & KDB_SP_PAREN)
278 kdb_printf("(");
279 if (strcmp(symtab_p2->mod_name, "kernel"))
280 kdb_printf("[%s]", symtab_p2->mod_name);
281 kdb_printf("%s", symtab_p2->sym_name);
282 if (addr != symtab_p2->sym_start)
283 kdb_printf("+0x%lx", addr - symtab_p2->sym_start);
284 if (punc & KDB_SP_SYMSIZE)
285 kdb_printf("/0x%lx",
286 symtab_p2->sym_end - symtab_p2->sym_start);
287 if (punc & KDB_SP_PAREN)
288 kdb_printf(")");
289 }
290 if (punc & KDB_SP_SPACEA)
291 kdb_printf(" ");
292 if (punc & KDB_SP_NEWLINE)
293 kdb_printf("\n");
294}
295
296/*
297 * kdb_strdup - kdb equivalent of strdup, for disasm code.
298 * Inputs:
299 * str The string to duplicate.
300 * type Flags to kmalloc for the new string.
301 * Returns:
302 * Address of the new string, NULL if storage could not be allocated.
303 * Remarks:
304 * This is not in lib/string.c because it uses kmalloc which is not
305 * available when string.o is used in boot loaders.
306 */
307char *kdb_strdup(const char *str, gfp_t type)
308{
309 int n = strlen(str)+1;
310 char *s = kmalloc(n, type);
311 if (!s)
312 return NULL;
313 return strcpy(s, str);
314}
315
316/*
317 * kdb_getarea_size - Read an area of data. The kdb equivalent of
318 * copy_from_user, with kdb messages for invalid addresses.
319 * Inputs:
320 * res Pointer to the area to receive the result.
321 * addr Address of the area to copy.
322 * size Size of the area.
323 * Returns:
324 * 0 for success, < 0 for error.
325 */
326int kdb_getarea_size(void *res, unsigned long addr, size_t size)
327{
328 int ret = probe_kernel_read((char *)res, (char *)addr, size);
329 if (ret) {
330 if (!KDB_STATE(SUPPRESS)) {
331 kdb_printf("kdb_getarea: Bad address 0x%lx\n", addr);
332 KDB_STATE_SET(SUPPRESS);
333 }
334 ret = KDB_BADADDR;
335 } else {
336 KDB_STATE_CLEAR(SUPPRESS);
337 }
338 return ret;
339}
340
341/*
342 * kdb_putarea_size - Write an area of data. The kdb equivalent of
343 * copy_to_user, with kdb messages for invalid addresses.
344 * Inputs:
345 * addr Address of the area to write to.
346 * res Pointer to the area holding the data.
347 * size Size of the area.
348 * Returns:
349 * 0 for success, < 0 for error.
350 */
351int kdb_putarea_size(unsigned long addr, void *res, size_t size)
352{
353 int ret = probe_kernel_read((char *)addr, (char *)res, size);
354 if (ret) {
355 if (!KDB_STATE(SUPPRESS)) {
356 kdb_printf("kdb_putarea: Bad address 0x%lx\n", addr);
357 KDB_STATE_SET(SUPPRESS);
358 }
359 ret = KDB_BADADDR;
360 } else {
361 KDB_STATE_CLEAR(SUPPRESS);
362 }
363 return ret;
364}
365
366/*
367 * kdb_getphys - Read data from a physical address. Validate the
368 * address is in range, use kmap_atomic() to get data
369 * similar to kdb_getarea() - but for phys addresses
370 * Inputs:
371 * res Pointer to the word to receive the result
372 * addr Physical address of the area to copy
373 * size Size of the area
374 * Returns:
375 * 0 for success, < 0 for error.
376 */
377static int kdb_getphys(void *res, unsigned long addr, size_t size)
378{
379 unsigned long pfn;
380 void *vaddr;
381 struct page *page;
382
383 pfn = (addr >> PAGE_SHIFT);
384 if (!pfn_valid(pfn))
385 return 1;
386 page = pfn_to_page(pfn);
387 vaddr = kmap_atomic(page, KM_KDB);
388 memcpy(res, vaddr + (addr & (PAGE_SIZE - 1)), size);
389 kunmap_atomic(vaddr, KM_KDB);
390
391 return 0;
392}
393
394/*
395 * kdb_getphysword
396 * Inputs:
397 * word Pointer to the word to receive the result.
398 * addr Address of the area to copy.
399 * size Size of the area.
400 * Returns:
401 * 0 for success, < 0 for error.
402 */
403int kdb_getphysword(unsigned long *word, unsigned long addr, size_t size)
404{
405 int diag;
406 __u8 w1;
407 __u16 w2;
408 __u32 w4;
409 __u64 w8;
410 *word = 0; /* Default value if addr or size is invalid */
411
412 switch (size) {
413 case 1:
414 diag = kdb_getphys(&w1, addr, sizeof(w1));
415 if (!diag)
416 *word = w1;
417 break;
418 case 2:
419 diag = kdb_getphys(&w2, addr, sizeof(w2));
420 if (!diag)
421 *word = w2;
422 break;
423 case 4:
424 diag = kdb_getphys(&w4, addr, sizeof(w4));
425 if (!diag)
426 *word = w4;
427 break;
428 case 8:
429 if (size <= sizeof(*word)) {
430 diag = kdb_getphys(&w8, addr, sizeof(w8));
431 if (!diag)
432 *word = w8;
433 break;
434 }
435 /* drop through */
436 default:
437 diag = KDB_BADWIDTH;
438 kdb_printf("kdb_getphysword: bad width %ld\n", (long) size);
439 }
440 return diag;
441}
442
443/*
444 * kdb_getword - Read a binary value. Unlike kdb_getarea, this treats
445 * data as numbers.
446 * Inputs:
447 * word Pointer to the word to receive the result.
448 * addr Address of the area to copy.
449 * size Size of the area.
450 * Returns:
451 * 0 for success, < 0 for error.
452 */
453int kdb_getword(unsigned long *word, unsigned long addr, size_t size)
454{
455 int diag;
456 __u8 w1;
457 __u16 w2;
458 __u32 w4;
459 __u64 w8;
460 *word = 0; /* Default value if addr or size is invalid */
461 switch (size) {
462 case 1:
463 diag = kdb_getarea(w1, addr);
464 if (!diag)
465 *word = w1;
466 break;
467 case 2:
468 diag = kdb_getarea(w2, addr);
469 if (!diag)
470 *word = w2;
471 break;
472 case 4:
473 diag = kdb_getarea(w4, addr);
474 if (!diag)
475 *word = w4;
476 break;
477 case 8:
478 if (size <= sizeof(*word)) {
479 diag = kdb_getarea(w8, addr);
480 if (!diag)
481 *word = w8;
482 break;
483 }
484 /* drop through */
485 default:
486 diag = KDB_BADWIDTH;
487 kdb_printf("kdb_getword: bad width %ld\n", (long) size);
488 }
489 return diag;
490}
491
492/*
493 * kdb_putword - Write a binary value. Unlike kdb_putarea, this
494 * treats data as numbers.
495 * Inputs:
496 * addr Address of the area to write to..
497 * word The value to set.
498 * size Size of the area.
499 * Returns:
500 * 0 for success, < 0 for error.
501 */
502int kdb_putword(unsigned long addr, unsigned long word, size_t size)
503{
504 int diag;
505 __u8 w1;
506 __u16 w2;
507 __u32 w4;
508 __u64 w8;
509 switch (size) {
510 case 1:
511 w1 = word;
512 diag = kdb_putarea(addr, w1);
513 break;
514 case 2:
515 w2 = word;
516 diag = kdb_putarea(addr, w2);
517 break;
518 case 4:
519 w4 = word;
520 diag = kdb_putarea(addr, w4);
521 break;
522 case 8:
523 if (size <= sizeof(word)) {
524 w8 = word;
525 diag = kdb_putarea(addr, w8);
526 break;
527 }
528 /* drop through */
529 default:
530 diag = KDB_BADWIDTH;
531 kdb_printf("kdb_putword: bad width %ld\n", (long) size);
532 }
533 return diag;
534}
535
536/*
537 * kdb_task_state_string - Convert a string containing any of the
538 * letters DRSTCZEUIMA to a mask for the process state field and
539 * return the value. If no argument is supplied, return the mask
540 * that corresponds to environment variable PS, DRSTCZEU by
541 * default.
542 * Inputs:
543 * s String to convert
544 * Returns:
545 * Mask for process state.
546 * Notes:
547 * The mask folds data from several sources into a single long value, so
548 * be carefull not to overlap the bits. TASK_* bits are in the LSB,
549 * special cases like UNRUNNABLE are in the MSB. As of 2.6.10-rc1 there
550 * is no overlap between TASK_* and EXIT_* but that may not always be
551 * true, so EXIT_* bits are shifted left 16 bits before being stored in
552 * the mask.
553 */
554
555/* unrunnable is < 0 */
556#define UNRUNNABLE (1UL << (8*sizeof(unsigned long) - 1))
557#define RUNNING (1UL << (8*sizeof(unsigned long) - 2))
558#define IDLE (1UL << (8*sizeof(unsigned long) - 3))
559#define DAEMON (1UL << (8*sizeof(unsigned long) - 4))
560
561unsigned long kdb_task_state_string(const char *s)
562{
563 long res = 0;
564 if (!s) {
565 s = kdbgetenv("PS");
566 if (!s)
567 s = "DRSTCZEU"; /* default value for ps */
568 }
569 while (*s) {
570 switch (*s) {
571 case 'D':
572 res |= TASK_UNINTERRUPTIBLE;
573 break;
574 case 'R':
575 res |= RUNNING;
576 break;
577 case 'S':
578 res |= TASK_INTERRUPTIBLE;
579 break;
580 case 'T':
581 res |= TASK_STOPPED;
582 break;
583 case 'C':
584 res |= TASK_TRACED;
585 break;
586 case 'Z':
587 res |= EXIT_ZOMBIE << 16;
588 break;
589 case 'E':
590 res |= EXIT_DEAD << 16;
591 break;
592 case 'U':
593 res |= UNRUNNABLE;
594 break;
595 case 'I':
596 res |= IDLE;
597 break;
598 case 'M':
599 res |= DAEMON;
600 break;
601 case 'A':
602 res = ~0UL;
603 break;
604 default:
605 kdb_printf("%s: unknown flag '%c' ignored\n",
606 __func__, *s);
607 break;
608 }
609 ++s;
610 }
611 return res;
612}
613
614/*
615 * kdb_task_state_char - Return the character that represents the task state.
616 * Inputs:
617 * p struct task for the process
618 * Returns:
619 * One character to represent the task state.
620 */
621char kdb_task_state_char (const struct task_struct *p)
622{
623 int cpu;
624 char state;
625 unsigned long tmp;
626
627 if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
628 return 'E';
629
630 cpu = kdb_process_cpu(p);
631 state = (p->state == 0) ? 'R' :
632 (p->state < 0) ? 'U' :
633 (p->state & TASK_UNINTERRUPTIBLE) ? 'D' :
634 (p->state & TASK_STOPPED) ? 'T' :
635 (p->state & TASK_TRACED) ? 'C' :
636 (p->exit_state & EXIT_ZOMBIE) ? 'Z' :
637 (p->exit_state & EXIT_DEAD) ? 'E' :
638 (p->state & TASK_INTERRUPTIBLE) ? 'S' : '?';
639 if (p->pid == 0) {
640 /* Idle task. Is it really idle, apart from the kdb
641 * interrupt? */
642 if (!kdb_task_has_cpu(p) || kgdb_info[cpu].irq_depth == 1) {
643 if (cpu != kdb_initial_cpu)
644 state = 'I'; /* idle task */
645 }
646 } else if (!p->mm && state == 'S') {
647 state = 'M'; /* sleeping system daemon */
648 }
649 return state;
650}
651
652/*
653 * kdb_task_state - Return true if a process has the desired state
654 * given by the mask.
655 * Inputs:
656 * p struct task for the process
657 * mask mask from kdb_task_state_string to select processes
658 * Returns:
659 * True if the process matches at least one criteria defined by the mask.
660 */
661unsigned long kdb_task_state(const struct task_struct *p, unsigned long mask)
662{
663 char state[] = { kdb_task_state_char(p), '\0' };
664 return (mask & kdb_task_state_string(state)) != 0;
665}
666
667/*
668 * kdb_print_nameval - Print a name and its value, converting the
669 * value to a symbol lookup if possible.
670 * Inputs:
671 * name field name to print
672 * val value of field
673 */
674void kdb_print_nameval(const char *name, unsigned long val)
675{
676 kdb_symtab_t symtab;
677 kdb_printf(" %-11.11s ", name);
678 if (kdbnearsym(val, &symtab))
679 kdb_symbol_print(val, &symtab,
680 KDB_SP_VALUE|KDB_SP_SYMSIZE|KDB_SP_NEWLINE);
681 else
682 kdb_printf("0x%lx\n", val);
683}
684
685/* Last ditch allocator for debugging, so we can still debug even when
686 * the GFP_ATOMIC pool has been exhausted. The algorithms are tuned
687 * for space usage, not for speed. One smallish memory pool, the free
688 * chain is always in ascending address order to allow coalescing,
689 * allocations are done in brute force best fit.
690 */
691
692struct debug_alloc_header {
693 u32 next; /* offset of next header from start of pool */
694 u32 size;
695 void *caller;
696};
697
698/* The memory returned by this allocator must be aligned, which means
699 * so must the header size. Do not assume that sizeof(struct
700 * debug_alloc_header) is a multiple of the alignment, explicitly
701 * calculate the overhead of this header, including the alignment.
702 * The rest of this code must not use sizeof() on any header or
703 * pointer to a header.
704 */
705#define dah_align 8
706#define dah_overhead ALIGN(sizeof(struct debug_alloc_header), dah_align)
707
708static u64 debug_alloc_pool_aligned[256*1024/dah_align]; /* 256K pool */
709static char *debug_alloc_pool = (char *)debug_alloc_pool_aligned;
710static u32 dah_first, dah_first_call = 1, dah_used, dah_used_max;
711
712/* Locking is awkward. The debug code is called from all contexts,
713 * including non maskable interrupts. A normal spinlock is not safe
714 * in NMI context. Try to get the debug allocator lock, if it cannot
715 * be obtained after a second then give up. If the lock could not be
716 * previously obtained on this cpu then only try once.
717 *
718 * sparse has no annotation for "this function _sometimes_ acquires a
719 * lock", so fudge the acquire/release notation.
720 */
721static DEFINE_SPINLOCK(dap_lock);
722static int get_dap_lock(void)
723 __acquires(dap_lock)
724{
725 static int dap_locked = -1;
726 int count;
727 if (dap_locked == smp_processor_id())
728 count = 1;
729 else
730 count = 1000;
731 while (1) {
732 if (spin_trylock(&dap_lock)) {
733 dap_locked = -1;
734 return 1;
735 }
736 if (!count--)
737 break;
738 udelay(1000);
739 }
740 dap_locked = smp_processor_id();
741 __acquire(dap_lock);
742 return 0;
743}
744
745void *debug_kmalloc(size_t size, gfp_t flags)
746{
747 unsigned int rem, h_offset;
748 struct debug_alloc_header *best, *bestprev, *prev, *h;
749 void *p = NULL;
750 if (!get_dap_lock()) {
751 __release(dap_lock); /* we never actually got it */
752 return NULL;
753 }
754 h = (struct debug_alloc_header *)(debug_alloc_pool + dah_first);
755 if (dah_first_call) {
756 h->size = sizeof(debug_alloc_pool_aligned) - dah_overhead;
757 dah_first_call = 0;
758 }
759 size = ALIGN(size, dah_align);
760 prev = best = bestprev = NULL;
761 while (1) {
762 if (h->size >= size && (!best || h->size < best->size)) {
763 best = h;
764 bestprev = prev;
765 if (h->size == size)
766 break;
767 }
768 if (!h->next)
769 break;
770 prev = h;
771 h = (struct debug_alloc_header *)(debug_alloc_pool + h->next);
772 }
773 if (!best)
774 goto out;
775 rem = best->size - size;
776 /* The pool must always contain at least one header */
777 if (best->next == 0 && bestprev == NULL && rem < dah_overhead)
778 goto out;
779 if (rem >= dah_overhead) {
780 best->size = size;
781 h_offset = ((char *)best - debug_alloc_pool) +
782 dah_overhead + best->size;
783 h = (struct debug_alloc_header *)(debug_alloc_pool + h_offset);
784 h->size = rem - dah_overhead;
785 h->next = best->next;
786 } else
787 h_offset = best->next;
788 best->caller = __builtin_return_address(0);
789 dah_used += best->size;
790 dah_used_max = max(dah_used, dah_used_max);
791 if (bestprev)
792 bestprev->next = h_offset;
793 else
794 dah_first = h_offset;
795 p = (char *)best + dah_overhead;
796 memset(p, POISON_INUSE, best->size - 1);
797 *((char *)p + best->size - 1) = POISON_END;
798out:
799 spin_unlock(&dap_lock);
800 return p;
801}
802
803void debug_kfree(void *p)
804{
805 struct debug_alloc_header *h;
806 unsigned int h_offset;
807 if (!p)
808 return;
809 if ((char *)p < debug_alloc_pool ||
810 (char *)p >= debug_alloc_pool + sizeof(debug_alloc_pool_aligned)) {
811 kfree(p);
812 return;
813 }
814 if (!get_dap_lock()) {
815 __release(dap_lock); /* we never actually got it */
816 return; /* memory leak, cannot be helped */
817 }
818 h = (struct debug_alloc_header *)((char *)p - dah_overhead);
819 memset(p, POISON_FREE, h->size - 1);
820 *((char *)p + h->size - 1) = POISON_END;
821 h->caller = NULL;
822 dah_used -= h->size;
823 h_offset = (char *)h - debug_alloc_pool;
824 if (h_offset < dah_first) {
825 h->next = dah_first;
826 dah_first = h_offset;
827 } else {
828 struct debug_alloc_header *prev;
829 unsigned int prev_offset;
830 prev = (struct debug_alloc_header *)(debug_alloc_pool +
831 dah_first);
832 while (1) {
833 if (!prev->next || prev->next > h_offset)
834 break;
835 prev = (struct debug_alloc_header *)
836 (debug_alloc_pool + prev->next);
837 }
838 prev_offset = (char *)prev - debug_alloc_pool;
839 if (prev_offset + dah_overhead + prev->size == h_offset) {
840 prev->size += dah_overhead + h->size;
841 memset(h, POISON_FREE, dah_overhead - 1);
842 *((char *)h + dah_overhead - 1) = POISON_END;
843 h = prev;
844 h_offset = prev_offset;
845 } else {
846 h->next = prev->next;
847 prev->next = h_offset;
848 }
849 }
850 if (h_offset + dah_overhead + h->size == h->next) {
851 struct debug_alloc_header *next;
852 next = (struct debug_alloc_header *)
853 (debug_alloc_pool + h->next);
854 h->size += dah_overhead + next->size;
855 h->next = next->next;
856 memset(next, POISON_FREE, dah_overhead - 1);
857 *((char *)next + dah_overhead - 1) = POISON_END;
858 }
859 spin_unlock(&dap_lock);
860}
861
862void debug_kusage(void)
863{
864 struct debug_alloc_header *h_free, *h_used;
865#ifdef CONFIG_IA64
866 /* FIXME: using dah for ia64 unwind always results in a memory leak.
867 * Fix that memory leak first, then set debug_kusage_one_time = 1 for
868 * all architectures.
869 */
870 static int debug_kusage_one_time;
871#else
872 static int debug_kusage_one_time = 1;
873#endif
874 if (!get_dap_lock()) {
875 __release(dap_lock); /* we never actually got it */
876 return;
877 }
878 h_free = (struct debug_alloc_header *)(debug_alloc_pool + dah_first);
879 if (dah_first == 0 &&
880 (h_free->size == sizeof(debug_alloc_pool_aligned) - dah_overhead ||
881 dah_first_call))
882 goto out;
883 if (!debug_kusage_one_time)
884 goto out;
885 debug_kusage_one_time = 0;
886 kdb_printf("%s: debug_kmalloc memory leak dah_first %d\n",
887 __func__, dah_first);
888 if (dah_first) {
889 h_used = (struct debug_alloc_header *)debug_alloc_pool;
890 kdb_printf("%s: h_used %p size %d\n", __func__, h_used,
891 h_used->size);
892 }
893 do {
894 h_used = (struct debug_alloc_header *)
895 ((char *)h_free + dah_overhead + h_free->size);
896 kdb_printf("%s: h_used %p size %d caller %p\n",
897 __func__, h_used, h_used->size, h_used->caller);
898 h_free = (struct debug_alloc_header *)
899 (debug_alloc_pool + h_free->next);
900 } while (h_free->next);
901 h_used = (struct debug_alloc_header *)
902 ((char *)h_free + dah_overhead + h_free->size);
903 if ((char *)h_used - debug_alloc_pool !=
904 sizeof(debug_alloc_pool_aligned))
905 kdb_printf("%s: h_used %p size %d caller %p\n",
906 __func__, h_used, h_used->size, h_used->caller);
907out:
908 spin_unlock(&dap_lock);
909}
910
911/* Maintain a small stack of kdb_flags to allow recursion without disturbing
912 * the global kdb state.
913 */
914
915static int kdb_flags_stack[4], kdb_flags_index;
916
917void kdb_save_flags(void)
918{
919 BUG_ON(kdb_flags_index >= ARRAY_SIZE(kdb_flags_stack));
920 kdb_flags_stack[kdb_flags_index++] = kdb_flags;
921}
922
923void kdb_restore_flags(void)
924{
925 BUG_ON(kdb_flags_index <= 0);
926 kdb_flags = kdb_flags_stack[--kdb_flags_index];
927}
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-28 16:57:50 -0500