2 * Copyright (c) 2004 The FreeBSD Project
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
32 #include <sys/param.h>
33 #include <sys/systm.h>
35 #include <sys/kernel.h>
36 #include <sys/malloc.h>
40 #include <sys/sysctl.h>
42 #include <machine/kdb.h>
43 #include <machine/pcb.h>
46 #include <machine/smp.h>
50 void *kdb_jmpbufp
= NULL
;
51 struct kdb_dbbe
*kdb_dbbe
= NULL
;
53 struct pcb
*kdb_thrctx
= NULL
;
54 struct thread
*kdb_thread
= NULL
;
55 struct trapframe
*kdb_frame
= NULL
;
57 KDB_BACKEND(null
, NULL
, NULL
, NULL
);
58 SET_DECLARE(kdb_dbbe_set
, struct kdb_dbbe
);
60 static int kdb_sysctl_available(SYSCTL_HANDLER_ARGS
);
61 static int kdb_sysctl_current(SYSCTL_HANDLER_ARGS
);
62 static int kdb_sysctl_enter(SYSCTL_HANDLER_ARGS
);
63 static int kdb_sysctl_panic(SYSCTL_HANDLER_ARGS
);
64 static int kdb_sysctl_trap(SYSCTL_HANDLER_ARGS
);
65 static int kdb_sysctl_trap_code(SYSCTL_HANDLER_ARGS
);
67 SYSCTL_NODE(_debug
, OID_AUTO
, kdb
, CTLFLAG_RW
, NULL
, "KDB nodes");
69 SYSCTL_PROC(_debug_kdb
, OID_AUTO
, available
, CTLTYPE_STRING
| CTLFLAG_RD
, 0, 0,
70 kdb_sysctl_available
, "A", "list of available KDB backends");
72 SYSCTL_PROC(_debug_kdb
, OID_AUTO
, current
, CTLTYPE_STRING
| CTLFLAG_RW
, 0, 0,
73 kdb_sysctl_current
, "A", "currently selected KDB backend");
75 SYSCTL_PROC(_debug_kdb
, OID_AUTO
, enter
, CTLTYPE_INT
| CTLFLAG_RW
, 0, 0,
76 kdb_sysctl_enter
, "I", "set to enter the debugger");
78 SYSCTL_PROC(_debug_kdb
, OID_AUTO
, panic
, CTLTYPE_INT
| CTLFLAG_RW
, 0, 0,
79 kdb_sysctl_panic
, "I", "set to panic the kernel");
81 SYSCTL_PROC(_debug_kdb
, OID_AUTO
, trap
, CTLTYPE_INT
| CTLFLAG_RW
, 0, 0,
82 kdb_sysctl_trap
, "I", "set to cause a page fault via data access");
84 SYSCTL_PROC(_debug_kdb
, OID_AUTO
, trap_code
, CTLTYPE_INT
| CTLFLAG_RW
, 0, 0,
85 kdb_sysctl_trap_code
, "I", "set to cause a page fault via code access");
88 * Flag indicating whether or not to IPI the other CPUs to stop them on
89 * entering the debugger. Sometimes, this will result in a deadlock as
90 * stop_cpus() waits for the other cpus to stop, so we allow it to be
94 static int kdb_stop_cpus
= 1;
95 SYSCTL_INT(_debug_kdb
, OID_AUTO
, stop_cpus
, CTLTYPE_INT
| CTLFLAG_RW
,
96 &kdb_stop_cpus
, 0, "stop other CPUs when entering the debugger");
97 TUNABLE_INT("debug.kdb.stop_cpus", &kdb_stop_cpus
);
101 * Flag to indicate to debuggers why the debugger was entered.
103 const char * volatile kdb_why
= KDB_WHY_UNSET
;
106 kdb_sysctl_available(SYSCTL_HANDLER_ARGS
)
108 struct kdb_dbbe
*be
, **iter
;
114 SET_FOREACH(iter
, kdb_dbbe_set
) {
116 if (be
->dbbe_active
== 0)
117 sz
+= strlen(be
->dbbe_name
) + 1;
120 avail
= malloc(sz
, M_TEMP
, M_WAITOK
);
124 SET_FOREACH(iter
, kdb_dbbe_set
) {
126 if (be
->dbbe_active
== 0) {
127 len
= snprintf(p
, sz
, "%s ", be
->dbbe_name
);
132 KASSERT(sz
>= 0, ("%s", __func__
));
133 error
= sysctl_handle_string(oidp
, avail
, 0, req
);
139 kdb_sysctl_current(SYSCTL_HANDLER_ARGS
)
144 if (kdb_dbbe
!= NULL
) {
145 strncpy(buf
, kdb_dbbe
->dbbe_name
, sizeof(buf
));
146 buf
[sizeof(buf
) - 1] = '\0';
149 error
= sysctl_handle_string(oidp
, buf
, sizeof(buf
), req
);
150 if (error
!= 0 || req
->newptr
== NULL
)
154 return (kdb_dbbe_select(buf
));
158 kdb_sysctl_enter(SYSCTL_HANDLER_ARGS
)
162 error
= sysctl_wire_old_buffer(req
, sizeof(int));
165 error
= sysctl_handle_int(oidp
, &i
, 0, req
);
167 if (error
!= 0 || req
->newptr
== NULL
)
171 kdb_enter(KDB_WHY_SYSCTL
, "sysctl debug.kdb.enter");
176 kdb_sysctl_panic(SYSCTL_HANDLER_ARGS
)
180 error
= sysctl_wire_old_buffer(req
, sizeof(int));
183 error
= sysctl_handle_int(oidp
, &i
, 0, req
);
185 if (error
!= 0 || req
->newptr
== NULL
)
187 panic("kdb_sysctl_panic");
192 kdb_sysctl_trap(SYSCTL_HANDLER_ARGS
)
195 int *addr
= (int *)0x10;
197 error
= sysctl_wire_old_buffer(req
, sizeof(int));
200 error
= sysctl_handle_int(oidp
, &i
, 0, req
);
202 if (error
!= 0 || req
->newptr
== NULL
)
208 kdb_sysctl_trap_code(SYSCTL_HANDLER_ARGS
)
211 void (*fp
)(u_int
, u_int
, u_int
) = (void *)0xdeadc0de;
213 error
= sysctl_wire_old_buffer(req
, sizeof(int));
216 error
= sysctl_handle_int(oidp
, &i
, 0, req
);
218 if (error
!= 0 || req
->newptr
== NULL
)
220 (*fp
)(0x11111111, 0x22222222, 0x33333333);
225 kdb_panic(const char *msg
)
229 stop_cpus(PCPU_GET(other_cpus
));
231 printf("KDB: panic\n");
239 printf("KDB: reboot requested\n");
244 * Solaris implements a new BREAK which is initiated by a character sequence
245 * CR ~ ^b which is similar to a familiar pattern used on Sun servers by the
248 * Note that this function may be called from almost anywhere, with interrupts
249 * disabled and with unknown locks held, so it must not access data other than
250 * its arguments. Its up to the caller to ensure that the state variable is
254 #define KEY_CR 13 /* CR '\r' */
255 #define KEY_TILDE 126 /* ~ */
256 #define KEY_CRTLB 2 /* ^B */
257 #define KEY_CRTLP 16 /* ^P */
258 #define KEY_CRTLR 18 /* ^R */
261 kdb_alt_break(int key
, int *state
)
272 if (key
== KEY_TILDE
)
276 if (key
== KEY_CRTLB
)
277 brk
= KDB_REQ_DEBUGGER
;
278 else if (key
== KEY_CRTLP
)
280 else if (key
== KEY_CRTLR
)
281 brk
= KDB_REQ_REBOOT
;
288 * Print a backtrace of the calling thread. The backtrace is generated by
289 * the selected debugger, provided it supports backtraces. If no debugger
290 * is selected or the current debugger does not support backtraces, this
291 * function silently returns.
298 if (kdb_dbbe
!= NULL
&& kdb_dbbe
->dbbe_trace
!= NULL
) {
299 printf("KDB: stack backtrace:\n");
300 kdb_dbbe
->dbbe_trace();
305 * Set/change the current backend.
309 kdb_dbbe_select(const char *name
)
311 struct kdb_dbbe
*be
, **iter
;
313 SET_FOREACH(iter
, kdb_dbbe_set
) {
315 if (be
->dbbe_active
== 0 && strcmp(be
->dbbe_name
, name
) == 0) {
324 * Enter the currently selected debugger. If a message has been provided,
325 * it is printed first. If the debugger does not support the enter method,
326 * it is entered by using breakpoint(), which enters the debugger through
327 * kdb_trap(). The 'why' argument will contain a more mechanically usable
328 * string than 'msg', and is relied upon by DDB scripting to identify the
329 * reason for entering the debugger so that the right script can be run.
332 kdb_enter(const char *why
, const char *msg
)
335 if (kdb_dbbe
!= NULL
&& kdb_active
== 0) {
337 printf("KDB: enter: %s\n", msg
);
340 kdb_why
= KDB_WHY_UNSET
;
345 * Initialize the kernel debugger interface.
351 struct kdb_dbbe
*be
, **iter
;
357 SET_FOREACH(iter
, kdb_dbbe_set
) {
359 pri
= (be
->dbbe_init
!= NULL
) ? be
->dbbe_init() : -1;
360 be
->dbbe_active
= (pri
>= 0) ? 0 : -1;
366 if (kdb_dbbe
!= NULL
) {
367 printf("KDB: debugger backends:");
368 SET_FOREACH(iter
, kdb_dbbe_set
) {
370 if (be
->dbbe_active
== 0)
371 printf(" %s", be
->dbbe_name
);
374 printf("KDB: current backend: %s\n",
375 kdb_dbbe
->dbbe_name
);
384 kdb_jmpbuf(jmp_buf new)
397 if (!kdb_active
|| kdb_jmpbufp
== NULL
)
400 longjmp(kdb_jmpbufp
, 1);
405 * Thread related support functions.
409 kdb_thr_ctx(struct thread
*thr
)
411 #if defined(SMP) && defined(KDB_STOPPEDPCB)
415 if (thr
== curthread
)
418 #if defined(SMP) && defined(KDB_STOPPEDPCB)
419 SLIST_FOREACH(pc
, &cpuhead
, pc_allcpu
) {
420 if (pc
->pc_curthread
== thr
&& (stopped_cpus
& pc
->pc_cpumask
))
421 return (KDB_STOPPEDPCB(pc
));
424 return (thr
->td_pcb
);
433 p
= LIST_FIRST(&allproc
);
435 if (p
->p_flag
& P_INMEM
) {
436 thr
= FIRST_THREAD_IN_PROC(p
);
440 p
= LIST_NEXT(p
, p_list
);
446 kdb_thr_from_pid(pid_t pid
)
450 p
= LIST_FIRST(&allproc
);
452 if (p
->p_flag
& P_INMEM
&& p
->p_pid
== pid
)
453 return (FIRST_THREAD_IN_PROC(p
));
454 p
= LIST_NEXT(p
, p_list
);
460 kdb_thr_lookup(lwpid_t tid
)
464 thr
= kdb_thr_first();
465 while (thr
!= NULL
&& thr
->td_tid
!= tid
)
466 thr
= kdb_thr_next(thr
);
471 kdb_thr_next(struct thread
*thr
)
476 thr
= TAILQ_NEXT(thr
, td_plist
);
480 p
= LIST_NEXT(p
, p_list
);
481 if (p
!= NULL
&& (p
->p_flag
& P_INMEM
))
482 thr
= FIRST_THREAD_IN_PROC(p
);
488 kdb_thr_select(struct thread
*thr
)
493 kdb_thrctx
= kdb_thr_ctx(thr
);
498 * Enter the debugger due to a trap.
502 kdb_trap(int type
, int code
, struct trapframe
*tf
)
510 if (kdb_dbbe
== NULL
|| kdb_dbbe
->dbbe_trap
== NULL
)
513 /* We reenter the debugger through kdb_reenter(). */
517 intr
= intr_disable();
520 if ((did_stop_cpus
= kdb_stop_cpus
) != 0)
521 stop_cpus(PCPU_GET(other_cpus
));
528 /* Let MD code do its thing first... */
529 kdb_cpu_trap(type
, code
);
531 makectx(tf
, &kdb_pcb
);
532 kdb_thr_select(curthread
);
534 handled
= kdb_dbbe
->dbbe_trap(type
, code
);
540 restart_cpus(stopped_cpus
);