xref: /freebsd/sys/kern/subr_kdb.c (revision 4ccaa87f695c8b9eb31f2ba9ce4913a045755fe0)
19454b2d8SWarner Losh /*-
28a36da99SPedro F. Giffuni  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
38a36da99SPedro F. Giffuni  *
4cbc17435SMarcel Moolenaar  * Copyright (c) 2004 The FreeBSD Project
5cbc17435SMarcel Moolenaar  * All rights reserved.
6cbc17435SMarcel Moolenaar  *
7cbc17435SMarcel Moolenaar  * Redistribution and use in source and binary forms, with or without
8cbc17435SMarcel Moolenaar  * modification, are permitted provided that the following conditions
9cbc17435SMarcel Moolenaar  * are met:
10cbc17435SMarcel Moolenaar  *
11cbc17435SMarcel Moolenaar  * 1. Redistributions of source code must retain the above copyright
12cbc17435SMarcel Moolenaar  *    notice, this list of conditions and the following disclaimer.
13cbc17435SMarcel Moolenaar  * 2. Redistributions in binary form must reproduce the above copyright
14cbc17435SMarcel Moolenaar  *    notice, this list of conditions and the following disclaimer in the
15cbc17435SMarcel Moolenaar  *    documentation and/or other materials provided with the distribution.
16cbc17435SMarcel Moolenaar  *
17cbc17435SMarcel Moolenaar  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
18cbc17435SMarcel Moolenaar  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19cbc17435SMarcel Moolenaar  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20cbc17435SMarcel Moolenaar  * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
21cbc17435SMarcel Moolenaar  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22cbc17435SMarcel Moolenaar  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23cbc17435SMarcel Moolenaar  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24cbc17435SMarcel Moolenaar  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25cbc17435SMarcel Moolenaar  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26cbc17435SMarcel Moolenaar  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27cbc17435SMarcel Moolenaar  */
28cbc17435SMarcel Moolenaar 
29cbc17435SMarcel Moolenaar #include <sys/cdefs.h>
30cbc17435SMarcel Moolenaar __FBSDID("$FreeBSD$");
31cbc17435SMarcel Moolenaar 
32f0c6706dSPeter Wemm #include "opt_kdb.h"
33088acbb3SAndriy Gapon #include "opt_stack.h"
34f0c6706dSPeter Wemm 
35cbc17435SMarcel Moolenaar #include <sys/param.h>
36cbc17435SMarcel Moolenaar #include <sys/systm.h>
37bf8696b4SAndriy Gapon #include <sys/cons.h>
38cbc17435SMarcel Moolenaar #include <sys/kdb.h>
39cbc17435SMarcel Moolenaar #include <sys/kernel.h>
40cbc17435SMarcel Moolenaar #include <sys/malloc.h>
413f289c3fSJeff Roberson #include <sys/lock.h>
42cbc17435SMarcel Moolenaar #include <sys/pcpu.h>
43cbc17435SMarcel Moolenaar #include <sys/proc.h>
443a5d3671SMatthew D Fleming #include <sys/sbuf.h>
45cbc17435SMarcel Moolenaar #include <sys/smp.h>
46088acbb3SAndriy Gapon #include <sys/stack.h>
47cbc17435SMarcel Moolenaar #include <sys/sysctl.h>
48cbc17435SMarcel Moolenaar 
49cbc17435SMarcel Moolenaar #include <machine/kdb.h>
50cbc17435SMarcel Moolenaar #include <machine/pcb.h>
51cbc17435SMarcel Moolenaar 
5258553b99SJohn Baldwin #ifdef SMP
53fdc9713bSDoug White #include <machine/smp.h>
54fdc9713bSDoug White #endif
55fdc9713bSDoug White 
56614e1868SMateusz Guzik u_char __read_frequently kdb_active = 0;
577cddab63SWarner Losh static void *kdb_jmpbufp = NULL;
58cbc17435SMarcel Moolenaar struct kdb_dbbe *kdb_dbbe = NULL;
597cddab63SWarner Losh static struct pcb kdb_pcb;
60cbc17435SMarcel Moolenaar struct pcb *kdb_thrctx = NULL;
61cbc17435SMarcel Moolenaar struct thread *kdb_thread = NULL;
62cbc17435SMarcel Moolenaar struct trapframe *kdb_frame = NULL;
63cbc17435SMarcel Moolenaar 
644cf75455SRobert Watson #ifdef BREAK_TO_DEBUGGER
654cf75455SRobert Watson #define	KDB_BREAK_TO_DEBUGGER	1
664cf75455SRobert Watson #else
674cf75455SRobert Watson #define	KDB_BREAK_TO_DEBUGGER	0
684cf75455SRobert Watson #endif
694cf75455SRobert Watson 
704cf75455SRobert Watson #ifdef ALT_BREAK_TO_DEBUGGER
714cf75455SRobert Watson #define	KDB_ALT_BREAK_TO_DEBUGGER	1
724cf75455SRobert Watson #else
734cf75455SRobert Watson #define	KDB_ALT_BREAK_TO_DEBUGGER	0
744cf75455SRobert Watson #endif
754cf75455SRobert Watson 
764cf75455SRobert Watson static int	kdb_break_to_debugger = KDB_BREAK_TO_DEBUGGER;
774cf75455SRobert Watson static int	kdb_alt_break_to_debugger = KDB_ALT_BREAK_TO_DEBUGGER;
784cf75455SRobert Watson 
790cc457b0SJohn Baldwin KDB_BACKEND(null, NULL, NULL, NULL, NULL);
80cbc17435SMarcel Moolenaar 
81cbc17435SMarcel Moolenaar static int kdb_sysctl_available(SYSCTL_HANDLER_ARGS);
82cbc17435SMarcel Moolenaar static int kdb_sysctl_current(SYSCTL_HANDLER_ARGS);
83cbc17435SMarcel Moolenaar static int kdb_sysctl_enter(SYSCTL_HANDLER_ARGS);
8440c9966aSPeter Wemm static int kdb_sysctl_panic(SYSCTL_HANDLER_ARGS);
8593644056SWarner Losh static int kdb_sysctl_panic_str(SYSCTL_HANDLER_ARGS);
8640c9966aSPeter Wemm static int kdb_sysctl_trap(SYSCTL_HANDLER_ARGS);
8742ccd54fSYaroslav Tykhiy static int kdb_sysctl_trap_code(SYSCTL_HANDLER_ARGS);
88fd94177cSKonstantin Belousov static int kdb_sysctl_stack_overflow(SYSCTL_HANDLER_ARGS);
89cbc17435SMarcel Moolenaar 
907029da5cSPawel Biernacki static SYSCTL_NODE(_debug, OID_AUTO, kdb, CTLFLAG_RW | CTLFLAG_MPSAFE, NULL,
917029da5cSPawel Biernacki     "KDB nodes");
92cbc17435SMarcel Moolenaar 
937029da5cSPawel Biernacki SYSCTL_PROC(_debug_kdb, OID_AUTO, available,
947029da5cSPawel Biernacki     CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, 0,
957029da5cSPawel Biernacki     kdb_sysctl_available, "A",
967029da5cSPawel Biernacki     "list of available KDB backends");
97cbc17435SMarcel Moolenaar 
987029da5cSPawel Biernacki SYSCTL_PROC(_debug_kdb, OID_AUTO, current,
997029da5cSPawel Biernacki     CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_MPSAFE, NULL, 0,
1007029da5cSPawel Biernacki     kdb_sysctl_current, "A",
1017029da5cSPawel Biernacki     "currently selected KDB backend");
102cbc17435SMarcel Moolenaar 
103ef522f95SDavid E. O'Brien SYSCTL_PROC(_debug_kdb, OID_AUTO, enter,
1047029da5cSPawel Biernacki     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE | CTLFLAG_MPSAFE, NULL, 0,
1057029da5cSPawel Biernacki     kdb_sysctl_enter, "I",
1067029da5cSPawel Biernacki     "set to enter the debugger");
107cbc17435SMarcel Moolenaar 
108ef522f95SDavid E. O'Brien SYSCTL_PROC(_debug_kdb, OID_AUTO, panic,
1097029da5cSPawel Biernacki     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE | CTLFLAG_MPSAFE, NULL, 0,
1107029da5cSPawel Biernacki     kdb_sysctl_panic, "I",
1117029da5cSPawel Biernacki     "set to panic the kernel");
11240c9966aSPeter Wemm 
11393644056SWarner Losh SYSCTL_PROC(_debug_kdb, OID_AUTO, panic_str,
11493644056SWarner Losh     CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_SECURE | CTLFLAG_MPSAFE, NULL, 0,
11593644056SWarner Losh     kdb_sysctl_panic_str, "A",
11640e6e2c2SWarner Losh     "trigger a kernel panic, using the provided string as the panic message");
11793644056SWarner Losh 
118ef522f95SDavid E. O'Brien SYSCTL_PROC(_debug_kdb, OID_AUTO, trap,
1197029da5cSPawel Biernacki     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE | CTLFLAG_MPSAFE, NULL, 0,
1207029da5cSPawel Biernacki     kdb_sysctl_trap, "I",
1217029da5cSPawel Biernacki     "set to cause a page fault via data access");
12242ccd54fSYaroslav Tykhiy 
123ef522f95SDavid E. O'Brien SYSCTL_PROC(_debug_kdb, OID_AUTO, trap_code,
1247029da5cSPawel Biernacki     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE | CTLFLAG_MPSAFE, NULL, 0,
1257029da5cSPawel Biernacki     kdb_sysctl_trap_code, "I",
1267029da5cSPawel Biernacki     "set to cause a page fault via code access");
12740c9966aSPeter Wemm 
128fd94177cSKonstantin Belousov SYSCTL_PROC(_debug_kdb, OID_AUTO, stack_overflow,
1297029da5cSPawel Biernacki     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE | CTLFLAG_MPSAFE, NULL, 0,
1307029da5cSPawel Biernacki     kdb_sysctl_stack_overflow, "I",
1317029da5cSPawel Biernacki     "set to cause a stack overflow");
132fd94177cSKonstantin Belousov 
133ef522f95SDavid E. O'Brien SYSCTL_INT(_debug_kdb, OID_AUTO, break_to_debugger,
134f0188618SHans Petter Selasky     CTLFLAG_RWTUN | CTLFLAG_SECURE,
135ef522f95SDavid E. O'Brien     &kdb_break_to_debugger, 0, "Enable break to debugger");
1364cf75455SRobert Watson 
137ef522f95SDavid E. O'Brien SYSCTL_INT(_debug_kdb, OID_AUTO, alt_break_to_debugger,
138f0188618SHans Petter Selasky     CTLFLAG_RWTUN | CTLFLAG_SECURE,
139ef522f95SDavid E. O'Brien     &kdb_alt_break_to_debugger, 0, "Enable alternative break to debugger");
1404cf75455SRobert Watson 
141d8939d82SRobert Watson /*
1423de213ccSRobert Watson  * Flag to indicate to debuggers why the debugger was entered.
1433de213ccSRobert Watson  */
1443de213ccSRobert Watson const char * volatile kdb_why = KDB_WHY_UNSET;
1453de213ccSRobert Watson 
146cbc17435SMarcel Moolenaar static int
147cbc17435SMarcel Moolenaar kdb_sysctl_available(SYSCTL_HANDLER_ARGS)
148cbc17435SMarcel Moolenaar {
1493a5d3671SMatthew D Fleming 	struct kdb_dbbe **iter;
1503a5d3671SMatthew D Fleming 	struct sbuf sbuf;
151cbc17435SMarcel Moolenaar 	int error;
152cbc17435SMarcel Moolenaar 
1533a5d3671SMatthew D Fleming 	sbuf_new_for_sysctl(&sbuf, NULL, 64, req);
154cbc17435SMarcel Moolenaar 	SET_FOREACH(iter, kdb_dbbe_set) {
1553a5d3671SMatthew D Fleming 		if ((*iter)->dbbe_active == 0)
1563a5d3671SMatthew D Fleming 			sbuf_printf(&sbuf, "%s ", (*iter)->dbbe_name);
157cbc17435SMarcel Moolenaar 	}
1583a5d3671SMatthew D Fleming 	error = sbuf_finish(&sbuf);
1593a5d3671SMatthew D Fleming 	sbuf_delete(&sbuf);
160cbc17435SMarcel Moolenaar 	return (error);
161cbc17435SMarcel Moolenaar }
162cbc17435SMarcel Moolenaar 
163cbc17435SMarcel Moolenaar static int
164cbc17435SMarcel Moolenaar kdb_sysctl_current(SYSCTL_HANDLER_ARGS)
165cbc17435SMarcel Moolenaar {
166cbc17435SMarcel Moolenaar 	char buf[16];
167cbc17435SMarcel Moolenaar 	int error;
168cbc17435SMarcel Moolenaar 
1693a5d3671SMatthew D Fleming 	if (kdb_dbbe != NULL)
1703a5d3671SMatthew D Fleming 		strlcpy(buf, kdb_dbbe->dbbe_name, sizeof(buf));
1713a5d3671SMatthew D Fleming 	else
172a8bfba1aSMarcel Moolenaar 		*buf = '\0';
173cbc17435SMarcel Moolenaar 	error = sysctl_handle_string(oidp, buf, sizeof(buf), req);
174cbc17435SMarcel Moolenaar 	if (error != 0 || req->newptr == NULL)
175cbc17435SMarcel Moolenaar 		return (error);
176cbc17435SMarcel Moolenaar 	if (kdb_active)
177cbc17435SMarcel Moolenaar 		return (EBUSY);
1783bcd2440SMarcel Moolenaar 	return (kdb_dbbe_select(buf));
179cbc17435SMarcel Moolenaar }
180cbc17435SMarcel Moolenaar 
181cbc17435SMarcel Moolenaar static int
182cbc17435SMarcel Moolenaar kdb_sysctl_enter(SYSCTL_HANDLER_ARGS)
183cbc17435SMarcel Moolenaar {
184cbc17435SMarcel Moolenaar 	int error, i;
185cbc17435SMarcel Moolenaar 
186cbc17435SMarcel Moolenaar 	error = sysctl_wire_old_buffer(req, sizeof(int));
187cbc17435SMarcel Moolenaar 	if (error == 0) {
188cbc17435SMarcel Moolenaar 		i = 0;
189cbc17435SMarcel Moolenaar 		error = sysctl_handle_int(oidp, &i, 0, req);
190cbc17435SMarcel Moolenaar 	}
191cbc17435SMarcel Moolenaar 	if (error != 0 || req->newptr == NULL)
192cbc17435SMarcel Moolenaar 		return (error);
193cbc17435SMarcel Moolenaar 	if (kdb_active)
194cbc17435SMarcel Moolenaar 		return (EBUSY);
1953de213ccSRobert Watson 	kdb_enter(KDB_WHY_SYSCTL, "sysctl debug.kdb.enter");
196cbc17435SMarcel Moolenaar 	return (0);
197cbc17435SMarcel Moolenaar }
198cbc17435SMarcel Moolenaar 
19940c9966aSPeter Wemm static int
20040c9966aSPeter Wemm kdb_sysctl_panic(SYSCTL_HANDLER_ARGS)
20140c9966aSPeter Wemm {
20240c9966aSPeter Wemm 	int error, i;
20340c9966aSPeter Wemm 
20440c9966aSPeter Wemm 	error = sysctl_wire_old_buffer(req, sizeof(int));
20540c9966aSPeter Wemm 	if (error == 0) {
20640c9966aSPeter Wemm 		i = 0;
20740c9966aSPeter Wemm 		error = sysctl_handle_int(oidp, &i, 0, req);
20840c9966aSPeter Wemm 	}
20940c9966aSPeter Wemm 	if (error != 0 || req->newptr == NULL)
21040c9966aSPeter Wemm 		return (error);
21140c9966aSPeter Wemm 	panic("kdb_sysctl_panic");
21240c9966aSPeter Wemm 	return (0);
21340c9966aSPeter Wemm }
21440c9966aSPeter Wemm 
21540c9966aSPeter Wemm static int
21693644056SWarner Losh kdb_sysctl_panic_str(SYSCTL_HANDLER_ARGS)
21793644056SWarner Losh {
21893644056SWarner Losh 	int error;
21993644056SWarner Losh 	static char buf[256]; /* static buffer to limit mallocs when panicing */
22093644056SWarner Losh 
22193644056SWarner Losh 	*buf = '\0';
22293644056SWarner Losh 	error = sysctl_handle_string(oidp, buf, sizeof(buf), req);
22393644056SWarner Losh 	if (error != 0 || req->newptr == NULL)
22493644056SWarner Losh 		return (error);
22593644056SWarner Losh 	panic("kdb_sysctl_panic: %s", buf);
22693644056SWarner Losh 	return (0);
22793644056SWarner Losh }
22893644056SWarner Losh 
22993644056SWarner Losh static int
23040c9966aSPeter Wemm kdb_sysctl_trap(SYSCTL_HANDLER_ARGS)
23140c9966aSPeter Wemm {
23240c9966aSPeter Wemm 	int error, i;
23340c9966aSPeter Wemm 	int *addr = (int *)0x10;
23440c9966aSPeter Wemm 
23540c9966aSPeter Wemm 	error = sysctl_wire_old_buffer(req, sizeof(int));
23640c9966aSPeter Wemm 	if (error == 0) {
23740c9966aSPeter Wemm 		i = 0;
23840c9966aSPeter Wemm 		error = sysctl_handle_int(oidp, &i, 0, req);
23940c9966aSPeter Wemm 	}
24040c9966aSPeter Wemm 	if (error != 0 || req->newptr == NULL)
24140c9966aSPeter Wemm 		return (error);
24240c9966aSPeter Wemm 	return (*addr);
24340c9966aSPeter Wemm }
24440c9966aSPeter Wemm 
24542ccd54fSYaroslav Tykhiy static int
24642ccd54fSYaroslav Tykhiy kdb_sysctl_trap_code(SYSCTL_HANDLER_ARGS)
24742ccd54fSYaroslav Tykhiy {
24842ccd54fSYaroslav Tykhiy 	int error, i;
24942ccd54fSYaroslav Tykhiy 	void (*fp)(u_int, u_int, u_int) = (void *)0xdeadc0de;
25042ccd54fSYaroslav Tykhiy 
25142ccd54fSYaroslav Tykhiy 	error = sysctl_wire_old_buffer(req, sizeof(int));
25242ccd54fSYaroslav Tykhiy 	if (error == 0) {
25342ccd54fSYaroslav Tykhiy 		i = 0;
25442ccd54fSYaroslav Tykhiy 		error = sysctl_handle_int(oidp, &i, 0, req);
25542ccd54fSYaroslav Tykhiy 	}
25642ccd54fSYaroslav Tykhiy 	if (error != 0 || req->newptr == NULL)
25742ccd54fSYaroslav Tykhiy 		return (error);
25842ccd54fSYaroslav Tykhiy 	(*fp)(0x11111111, 0x22222222, 0x33333333);
25942ccd54fSYaroslav Tykhiy 	return (0);
26042ccd54fSYaroslav Tykhiy }
26142ccd54fSYaroslav Tykhiy 
262fd94177cSKonstantin Belousov static void kdb_stack_overflow(volatile int *x)  __noinline;
263fd94177cSKonstantin Belousov static void
264fd94177cSKonstantin Belousov kdb_stack_overflow(volatile int *x)
265fd94177cSKonstantin Belousov {
266fd94177cSKonstantin Belousov 
267fd94177cSKonstantin Belousov 	if (*x > 10000000)
268fd94177cSKonstantin Belousov 		return;
269fd94177cSKonstantin Belousov 	kdb_stack_overflow(x);
270fd94177cSKonstantin Belousov 	*x += PCPU_GET(cpuid) / 1000000;
271fd94177cSKonstantin Belousov }
272fd94177cSKonstantin Belousov 
273fd94177cSKonstantin Belousov static int
274fd94177cSKonstantin Belousov kdb_sysctl_stack_overflow(SYSCTL_HANDLER_ARGS)
275fd94177cSKonstantin Belousov {
276fd94177cSKonstantin Belousov 	int error, i;
277fd94177cSKonstantin Belousov 	volatile int x;
278fd94177cSKonstantin Belousov 
279fd94177cSKonstantin Belousov 	error = sysctl_wire_old_buffer(req, sizeof(int));
280fd94177cSKonstantin Belousov 	if (error == 0) {
281fd94177cSKonstantin Belousov 		i = 0;
282fd94177cSKonstantin Belousov 		error = sysctl_handle_int(oidp, &i, 0, req);
283fd94177cSKonstantin Belousov 	}
284fd94177cSKonstantin Belousov 	if (error != 0 || req->newptr == NULL)
285fd94177cSKonstantin Belousov 		return (error);
286fd94177cSKonstantin Belousov 	x = 0;
287fd94177cSKonstantin Belousov 	kdb_stack_overflow(&x);
288fd94177cSKonstantin Belousov 	return (0);
289fd94177cSKonstantin Belousov }
290fd94177cSKonstantin Belousov 
29143d7128cSPeter Wemm void
29243d7128cSPeter Wemm kdb_panic(const char *msg)
29343d7128cSPeter Wemm {
294a38f1f26SAttilio Rao 
29543d7128cSPeter Wemm 	printf("KDB: panic\n");
2961bdfff22SAndriy Gapon 	panic("%s", msg);
29743d7128cSPeter Wemm }
29843d7128cSPeter Wemm 
29943d7128cSPeter Wemm void
30043d7128cSPeter Wemm kdb_reboot(void)
30143d7128cSPeter Wemm {
30243d7128cSPeter Wemm 
30343d7128cSPeter Wemm 	printf("KDB: reboot requested\n");
30443d7128cSPeter Wemm 	shutdown_nice(0);
30543d7128cSPeter Wemm }
30643d7128cSPeter Wemm 
307cbc17435SMarcel Moolenaar /*
308cbc17435SMarcel Moolenaar  * Solaris implements a new BREAK which is initiated by a character sequence
309cbc17435SMarcel Moolenaar  * CR ~ ^b which is similar to a familiar pattern used on Sun servers by the
310cbc17435SMarcel Moolenaar  * Remote Console.
311cbc17435SMarcel Moolenaar  *
312cbc17435SMarcel Moolenaar  * Note that this function may be called from almost anywhere, with interrupts
313cbc17435SMarcel Moolenaar  * disabled and with unknown locks held, so it must not access data other than
314cbc17435SMarcel Moolenaar  * its arguments.  Its up to the caller to ensure that the state variable is
315cbc17435SMarcel Moolenaar  * consistent.
316cbc17435SMarcel Moolenaar  */
317cbc17435SMarcel Moolenaar #define	KEY_CR		13	/* CR '\r' */
318cbc17435SMarcel Moolenaar #define	KEY_TILDE	126	/* ~ */
319cbc17435SMarcel Moolenaar #define	KEY_CRTLB	2	/* ^B */
32043d7128cSPeter Wemm #define	KEY_CRTLP	16	/* ^P */
32143d7128cSPeter Wemm #define	KEY_CRTLR	18	/* ^R */
322cbc17435SMarcel Moolenaar 
32349f5aeafSAttilio Rao /* States of th KDB "alternate break sequence" detecting state machine. */
32449f5aeafSAttilio Rao enum {
32549f5aeafSAttilio Rao 	KDB_ALT_BREAK_SEEN_NONE,
32649f5aeafSAttilio Rao 	KDB_ALT_BREAK_SEEN_CR,
32749f5aeafSAttilio Rao 	KDB_ALT_BREAK_SEEN_CR_TILDE,
32849f5aeafSAttilio Rao };
32949f5aeafSAttilio Rao 
330cbc17435SMarcel Moolenaar int
3314cf75455SRobert Watson kdb_break(void)
3324cf75455SRobert Watson {
3334cf75455SRobert Watson 
3344cf75455SRobert Watson 	if (!kdb_break_to_debugger)
3354cf75455SRobert Watson 		return (0);
3364cf75455SRobert Watson 	kdb_enter(KDB_WHY_BREAK, "Break to debugger");
3374cf75455SRobert Watson 	return (KDB_REQ_DEBUGGER);
3384cf75455SRobert Watson }
3394cf75455SRobert Watson 
3404cf75455SRobert Watson static int
3414cf75455SRobert Watson kdb_alt_break_state(int key, int *state)
342cbc17435SMarcel Moolenaar {
343cbc17435SMarcel Moolenaar 	int brk;
344cbc17435SMarcel Moolenaar 
34549f5aeafSAttilio Rao 	/* All states transition to KDB_ALT_BREAK_SEEN_CR on a CR. */
34649f5aeafSAttilio Rao 	if (key == KEY_CR) {
34749f5aeafSAttilio Rao 		*state = KDB_ALT_BREAK_SEEN_CR;
34849f5aeafSAttilio Rao 		return (0);
34949f5aeafSAttilio Rao 	}
35049f5aeafSAttilio Rao 
351cbc17435SMarcel Moolenaar 	brk = 0;
35243d7128cSPeter Wemm 	switch (*state) {
35349f5aeafSAttilio Rao 	case KDB_ALT_BREAK_SEEN_CR:
35449f5aeafSAttilio Rao 		*state = KDB_ALT_BREAK_SEEN_NONE;
35543d7128cSPeter Wemm 		if (key == KEY_TILDE)
35649f5aeafSAttilio Rao 			*state = KDB_ALT_BREAK_SEEN_CR_TILDE;
357cbc17435SMarcel Moolenaar 		break;
35849f5aeafSAttilio Rao 	case KDB_ALT_BREAK_SEEN_CR_TILDE:
35949f5aeafSAttilio Rao 		*state = KDB_ALT_BREAK_SEEN_NONE;
36043d7128cSPeter Wemm 		if (key == KEY_CRTLB)
36143d7128cSPeter Wemm 			brk = KDB_REQ_DEBUGGER;
36243d7128cSPeter Wemm 		else if (key == KEY_CRTLP)
36343d7128cSPeter Wemm 			brk = KDB_REQ_PANIC;
36443d7128cSPeter Wemm 		else if (key == KEY_CRTLR)
36543d7128cSPeter Wemm 			brk = KDB_REQ_REBOOT;
36649f5aeafSAttilio Rao 		break;
36749f5aeafSAttilio Rao 	case KDB_ALT_BREAK_SEEN_NONE:
36849f5aeafSAttilio Rao 	default:
36949f5aeafSAttilio Rao 		*state = KDB_ALT_BREAK_SEEN_NONE;
37049f5aeafSAttilio Rao 		break;
371cbc17435SMarcel Moolenaar 	}
372cbc17435SMarcel Moolenaar 	return (brk);
373cbc17435SMarcel Moolenaar }
374cbc17435SMarcel Moolenaar 
3754cf75455SRobert Watson static int
3764cf75455SRobert Watson kdb_alt_break_internal(int key, int *state, int force_gdb)
3774cf75455SRobert Watson {
3784cf75455SRobert Watson 	int brk;
3794cf75455SRobert Watson 
3804cf75455SRobert Watson 	if (!kdb_alt_break_to_debugger)
3814cf75455SRobert Watson 		return (0);
3824cf75455SRobert Watson 	brk = kdb_alt_break_state(key, state);
3834cf75455SRobert Watson 	switch (brk) {
3844cf75455SRobert Watson 	case KDB_REQ_DEBUGGER:
3854cf75455SRobert Watson 		if (force_gdb)
3864cf75455SRobert Watson 			kdb_dbbe_select("gdb");
3874cf75455SRobert Watson 		kdb_enter(KDB_WHY_BREAK, "Break to debugger");
3884cf75455SRobert Watson 		break;
3894cf75455SRobert Watson 
3904cf75455SRobert Watson 	case KDB_REQ_PANIC:
3914cf75455SRobert Watson 		if (force_gdb)
3924cf75455SRobert Watson 			kdb_dbbe_select("gdb");
3934cf75455SRobert Watson 		kdb_panic("Panic sequence on console");
3944cf75455SRobert Watson 		break;
3954cf75455SRobert Watson 
3964cf75455SRobert Watson 	case KDB_REQ_REBOOT:
3974cf75455SRobert Watson 		kdb_reboot();
3984cf75455SRobert Watson 		break;
3994cf75455SRobert Watson 	}
4004cf75455SRobert Watson 	return (0);
4014cf75455SRobert Watson }
4024cf75455SRobert Watson 
4034cf75455SRobert Watson int
4044cf75455SRobert Watson kdb_alt_break(int key, int *state)
4054cf75455SRobert Watson {
4064cf75455SRobert Watson 
4074cf75455SRobert Watson 	return (kdb_alt_break_internal(key, state, 0));
4084cf75455SRobert Watson }
4094cf75455SRobert Watson 
4104cf75455SRobert Watson /*
4114cf75455SRobert Watson  * This variation on kdb_alt_break() is used only by dcons, which has its own
4124cf75455SRobert Watson  * configuration flag to force GDB use regardless of the global KDB
4134cf75455SRobert Watson  * configuration.
4144cf75455SRobert Watson  */
4154cf75455SRobert Watson int
4164cf75455SRobert Watson kdb_alt_break_gdb(int key, int *state)
4174cf75455SRobert Watson {
4184cf75455SRobert Watson 
4194cf75455SRobert Watson 	return (kdb_alt_break_internal(key, state, 1));
4204cf75455SRobert Watson }
4214cf75455SRobert Watson 
422cbc17435SMarcel Moolenaar /*
423cbc17435SMarcel Moolenaar  * Print a backtrace of the calling thread. The backtrace is generated by
424cbc17435SMarcel Moolenaar  * the selected debugger, provided it supports backtraces. If no debugger
425cbc17435SMarcel Moolenaar  * is selected or the current debugger does not support backtraces, this
426cbc17435SMarcel Moolenaar  * function silently returns.
427cbc17435SMarcel Moolenaar  */
428cbc17435SMarcel Moolenaar void
4297cddab63SWarner Losh kdb_backtrace(void)
430cbc17435SMarcel Moolenaar {
431cbc17435SMarcel Moolenaar 
432cbc17435SMarcel Moolenaar 	if (kdb_dbbe != NULL && kdb_dbbe->dbbe_trace != NULL) {
433cbc17435SMarcel Moolenaar 		printf("KDB: stack backtrace:\n");
434cbc17435SMarcel Moolenaar 		kdb_dbbe->dbbe_trace();
435cbc17435SMarcel Moolenaar 	}
436088acbb3SAndriy Gapon #ifdef STACK
437088acbb3SAndriy Gapon 	else {
438088acbb3SAndriy Gapon 		struct stack st;
439088acbb3SAndriy Gapon 
440088acbb3SAndriy Gapon 		printf("KDB: stack backtrace:\n");
4410cc457b0SJohn Baldwin 		stack_zero(&st);
442088acbb3SAndriy Gapon 		stack_save(&st);
44361548876SAndriy Gapon 		stack_print_ddb(&st);
444088acbb3SAndriy Gapon 	}
445088acbb3SAndriy Gapon #endif
446cbc17435SMarcel Moolenaar }
447cbc17435SMarcel Moolenaar 
448cbc17435SMarcel Moolenaar /*
4490cc457b0SJohn Baldwin  * Similar to kdb_backtrace() except that it prints a backtrace of an
4500cc457b0SJohn Baldwin  * arbitrary thread rather than the calling thread.
4510cc457b0SJohn Baldwin  */
4520cc457b0SJohn Baldwin void
4530cc457b0SJohn Baldwin kdb_backtrace_thread(struct thread *td)
4540cc457b0SJohn Baldwin {
4550cc457b0SJohn Baldwin 
4560cc457b0SJohn Baldwin 	if (kdb_dbbe != NULL && kdb_dbbe->dbbe_trace_thread != NULL) {
4570cc457b0SJohn Baldwin 		printf("KDB: stack backtrace of thread %d:\n", td->td_tid);
4580cc457b0SJohn Baldwin 		kdb_dbbe->dbbe_trace_thread(td);
4590cc457b0SJohn Baldwin 	}
4600cc457b0SJohn Baldwin #ifdef STACK
4610cc457b0SJohn Baldwin 	else {
4620cc457b0SJohn Baldwin 		struct stack st;
4630cc457b0SJohn Baldwin 
4640cc457b0SJohn Baldwin 		printf("KDB: stack backtrace of thread %d:\n", td->td_tid);
4651c29da02SMark Johnston 		if (stack_save_td(&st, td) == 0)
4660cc457b0SJohn Baldwin 			stack_print_ddb(&st);
4670cc457b0SJohn Baldwin 	}
4680cc457b0SJohn Baldwin #endif
4690cc457b0SJohn Baldwin }
4700cc457b0SJohn Baldwin 
4710cc457b0SJohn Baldwin /*
4723bcd2440SMarcel Moolenaar  * Set/change the current backend.
4733bcd2440SMarcel Moolenaar  */
4743bcd2440SMarcel Moolenaar int
4753bcd2440SMarcel Moolenaar kdb_dbbe_select(const char *name)
4763bcd2440SMarcel Moolenaar {
4773bcd2440SMarcel Moolenaar 	struct kdb_dbbe *be, **iter;
4783bcd2440SMarcel Moolenaar 
4793bcd2440SMarcel Moolenaar 	SET_FOREACH(iter, kdb_dbbe_set) {
4803bcd2440SMarcel Moolenaar 		be = *iter;
4813bcd2440SMarcel Moolenaar 		if (be->dbbe_active == 0 && strcmp(be->dbbe_name, name) == 0) {
4823bcd2440SMarcel Moolenaar 			kdb_dbbe = be;
4833bcd2440SMarcel Moolenaar 			return (0);
4843bcd2440SMarcel Moolenaar 		}
4853bcd2440SMarcel Moolenaar 	}
4863bcd2440SMarcel Moolenaar 	return (EINVAL);
4873bcd2440SMarcel Moolenaar }
4883bcd2440SMarcel Moolenaar 
4893bcd2440SMarcel Moolenaar /*
490cbc17435SMarcel Moolenaar  * Enter the currently selected debugger. If a message has been provided,
491cbc17435SMarcel Moolenaar  * it is printed first. If the debugger does not support the enter method,
492cbc17435SMarcel Moolenaar  * it is entered by using breakpoint(), which enters the debugger through
4933de213ccSRobert Watson  * kdb_trap().  The 'why' argument will contain a more mechanically usable
4943de213ccSRobert Watson  * string than 'msg', and is relied upon by DDB scripting to identify the
4953de213ccSRobert Watson  * reason for entering the debugger so that the right script can be run.
496cbc17435SMarcel Moolenaar  */
497cbc17435SMarcel Moolenaar void
4983de213ccSRobert Watson kdb_enter(const char *why, const char *msg)
499cbc17435SMarcel Moolenaar {
500cbc17435SMarcel Moolenaar 
501cbc17435SMarcel Moolenaar 	if (kdb_dbbe != NULL && kdb_active == 0) {
502cbc17435SMarcel Moolenaar 		if (msg != NULL)
503cbc17435SMarcel Moolenaar 			printf("KDB: enter: %s\n", msg);
5043de213ccSRobert Watson 		kdb_why = why;
505cbc17435SMarcel Moolenaar 		breakpoint();
5063de213ccSRobert Watson 		kdb_why = KDB_WHY_UNSET;
507cbc17435SMarcel Moolenaar 	}
508cbc17435SMarcel Moolenaar }
509cbc17435SMarcel Moolenaar 
510cbc17435SMarcel Moolenaar /*
511cbc17435SMarcel Moolenaar  * Initialize the kernel debugger interface.
512cbc17435SMarcel Moolenaar  */
513cbc17435SMarcel Moolenaar void
5147cddab63SWarner Losh kdb_init(void)
515cbc17435SMarcel Moolenaar {
516cbc17435SMarcel Moolenaar 	struct kdb_dbbe *be, **iter;
517cbc17435SMarcel Moolenaar 	int cur_pri, pri;
518cbc17435SMarcel Moolenaar 
519cbc17435SMarcel Moolenaar 	kdb_active = 0;
520cbc17435SMarcel Moolenaar 	kdb_dbbe = NULL;
521cbc17435SMarcel Moolenaar 	cur_pri = -1;
522cbc17435SMarcel Moolenaar 	SET_FOREACH(iter, kdb_dbbe_set) {
523cbc17435SMarcel Moolenaar 		be = *iter;
524cbc17435SMarcel Moolenaar 		pri = (be->dbbe_init != NULL) ? be->dbbe_init() : -1;
525cbc17435SMarcel Moolenaar 		be->dbbe_active = (pri >= 0) ? 0 : -1;
526cbc17435SMarcel Moolenaar 		if (pri > cur_pri) {
527cbc17435SMarcel Moolenaar 			cur_pri = pri;
528cbc17435SMarcel Moolenaar 			kdb_dbbe = be;
529cbc17435SMarcel Moolenaar 		}
530cbc17435SMarcel Moolenaar 	}
531cbc17435SMarcel Moolenaar 	if (kdb_dbbe != NULL) {
532cbc17435SMarcel Moolenaar 		printf("KDB: debugger backends:");
533cbc17435SMarcel Moolenaar 		SET_FOREACH(iter, kdb_dbbe_set) {
534cbc17435SMarcel Moolenaar 			be = *iter;
535cbc17435SMarcel Moolenaar 			if (be->dbbe_active == 0)
536cbc17435SMarcel Moolenaar 				printf(" %s", be->dbbe_name);
537cbc17435SMarcel Moolenaar 		}
538cbc17435SMarcel Moolenaar 		printf("\n");
539cbc17435SMarcel Moolenaar 		printf("KDB: current backend: %s\n",
540cbc17435SMarcel Moolenaar 		    kdb_dbbe->dbbe_name);
541cbc17435SMarcel Moolenaar 	}
542cbc17435SMarcel Moolenaar }
543cbc17435SMarcel Moolenaar 
544cbc17435SMarcel Moolenaar /*
545cbc17435SMarcel Moolenaar  * Handle contexts.
546cbc17435SMarcel Moolenaar  */
547cbc17435SMarcel Moolenaar void *
548cbc17435SMarcel Moolenaar kdb_jmpbuf(jmp_buf new)
549cbc17435SMarcel Moolenaar {
550cbc17435SMarcel Moolenaar 	void *old;
551cbc17435SMarcel Moolenaar 
552cbc17435SMarcel Moolenaar 	old = kdb_jmpbufp;
553cbc17435SMarcel Moolenaar 	kdb_jmpbufp = new;
554cbc17435SMarcel Moolenaar 	return (old);
555cbc17435SMarcel Moolenaar }
556cbc17435SMarcel Moolenaar 
557cbc17435SMarcel Moolenaar void
558cbc17435SMarcel Moolenaar kdb_reenter(void)
559cbc17435SMarcel Moolenaar {
560cbc17435SMarcel Moolenaar 
561cbc17435SMarcel Moolenaar 	if (!kdb_active || kdb_jmpbufp == NULL)
562cbc17435SMarcel Moolenaar 		return;
563cbc17435SMarcel Moolenaar 
564c2a44591SKonstantin Belousov 	printf("KDB: reentering\n");
565c2a44591SKonstantin Belousov 	kdb_backtrace();
566cbc17435SMarcel Moolenaar 	longjmp(kdb_jmpbufp, 1);
567cbc17435SMarcel Moolenaar 	/* NOTREACHED */
568cbc17435SMarcel Moolenaar }
569cbc17435SMarcel Moolenaar 
570212ff84fSEdward Tomasz Napierala void
571212ff84fSEdward Tomasz Napierala kdb_reenter_silent(void)
572212ff84fSEdward Tomasz Napierala {
573212ff84fSEdward Tomasz Napierala 
574212ff84fSEdward Tomasz Napierala 	if (!kdb_active || kdb_jmpbufp == NULL)
575212ff84fSEdward Tomasz Napierala 		return;
576212ff84fSEdward Tomasz Napierala 
577212ff84fSEdward Tomasz Napierala 	longjmp(kdb_jmpbufp, 1);
578212ff84fSEdward Tomasz Napierala 	/* NOTREACHED */
579212ff84fSEdward Tomasz Napierala }
580212ff84fSEdward Tomasz Napierala 
581cbc17435SMarcel Moolenaar /*
5822c9ec075SAlexey Dokuchaev  * Thread-related support functions.
583cbc17435SMarcel Moolenaar  */
584cbc17435SMarcel Moolenaar struct pcb *
585cbc17435SMarcel Moolenaar kdb_thr_ctx(struct thread *thr)
586fdc9713bSDoug White {
587bfcdefd8SMarcel Moolenaar #if defined(SMP) && defined(KDB_STOPPEDPCB)
588fdc9713bSDoug White 	struct pcpu *pc;
58958553b99SJohn Baldwin #endif
590fdc9713bSDoug White 
591fdc9713bSDoug White 	if (thr == curthread)
5926b1e0d75SJohn Baldwin 		return (&kdb_pcb);
593fdc9713bSDoug White 
594bfcdefd8SMarcel Moolenaar #if defined(SMP) && defined(KDB_STOPPEDPCB)
595d098f930SNathan Whitehorn 	STAILQ_FOREACH(pc, &cpuhead, pc_allcpu)  {
59671a19bdcSAttilio Rao 		if (pc->pc_curthread == thr &&
597a38f1f26SAttilio Rao 		    CPU_ISSET(pc->pc_cpuid, &stopped_cpus))
598bfcdefd8SMarcel Moolenaar 			return (KDB_STOPPEDPCB(pc));
599fdc9713bSDoug White 	}
60058553b99SJohn Baldwin #endif
6016b1e0d75SJohn Baldwin 	return (thr->td_pcb);
602fdc9713bSDoug White }
603cbc17435SMarcel Moolenaar 
604cbc17435SMarcel Moolenaar struct thread *
605cbc17435SMarcel Moolenaar kdb_thr_first(void)
606cbc17435SMarcel Moolenaar {
607cbc17435SMarcel Moolenaar 	struct proc *p;
608cbc17435SMarcel Moolenaar 	struct thread *thr;
6099acce1c9SJohn Baldwin 	u_int i;
610cbc17435SMarcel Moolenaar 
611*4ccaa87fSMitchell Horne 	/* This function may be called early. */
612*4ccaa87fSMitchell Horne 	if (pidhashtbl == NULL)
613*4ccaa87fSMitchell Horne 		return (&thread0);
614*4ccaa87fSMitchell Horne 
6159acce1c9SJohn Baldwin 	for (i = 0; i <= pidhash; i++) {
6169acce1c9SJohn Baldwin 		LIST_FOREACH(p, &pidhashtbl[i], p_hash) {
617cbc17435SMarcel Moolenaar 			thr = FIRST_THREAD_IN_PROC(p);
618cbc17435SMarcel Moolenaar 			if (thr != NULL)
619cbc17435SMarcel Moolenaar 				return (thr);
620cbc17435SMarcel Moolenaar 		}
621cbc17435SMarcel Moolenaar 	}
622cbc17435SMarcel Moolenaar 	return (NULL);
623cbc17435SMarcel Moolenaar }
624cbc17435SMarcel Moolenaar 
625cbc17435SMarcel Moolenaar struct thread *
6263d4f3136SMarcel Moolenaar kdb_thr_from_pid(pid_t pid)
6273d4f3136SMarcel Moolenaar {
6283d4f3136SMarcel Moolenaar 	struct proc *p;
6293d4f3136SMarcel Moolenaar 
6309acce1c9SJohn Baldwin 	LIST_FOREACH(p, PIDHASH(pid), p_hash) {
631825d2341SJohn Baldwin 		if (p->p_pid == pid)
6323d4f3136SMarcel Moolenaar 			return (FIRST_THREAD_IN_PROC(p));
6333d4f3136SMarcel Moolenaar 	}
6343d4f3136SMarcel Moolenaar 	return (NULL);
6353d4f3136SMarcel Moolenaar }
6363d4f3136SMarcel Moolenaar 
6373d4f3136SMarcel Moolenaar struct thread *
6383d4f3136SMarcel Moolenaar kdb_thr_lookup(lwpid_t tid)
639cbc17435SMarcel Moolenaar {
640cbc17435SMarcel Moolenaar 	struct thread *thr;
641cbc17435SMarcel Moolenaar 
642cbc17435SMarcel Moolenaar 	thr = kdb_thr_first();
643cbc17435SMarcel Moolenaar 	while (thr != NULL && thr->td_tid != tid)
644cbc17435SMarcel Moolenaar 		thr = kdb_thr_next(thr);
645cbc17435SMarcel Moolenaar 	return (thr);
646cbc17435SMarcel Moolenaar }
647cbc17435SMarcel Moolenaar 
648cbc17435SMarcel Moolenaar struct thread *
649cbc17435SMarcel Moolenaar kdb_thr_next(struct thread *thr)
650cbc17435SMarcel Moolenaar {
651cbc17435SMarcel Moolenaar 	struct proc *p;
6529acce1c9SJohn Baldwin 	u_int hash;
653cbc17435SMarcel Moolenaar 
654cbc17435SMarcel Moolenaar 	p = thr->td_proc;
655cbc17435SMarcel Moolenaar 	thr = TAILQ_NEXT(thr, td_plist);
656cbc17435SMarcel Moolenaar 	if (thr != NULL)
657cbc17435SMarcel Moolenaar 		return (thr);
658*4ccaa87fSMitchell Horne 	if (pidhashtbl == NULL)
659*4ccaa87fSMitchell Horne 		return (NULL);
6609acce1c9SJohn Baldwin 	hash = p->p_pid & pidhash;
6619acce1c9SJohn Baldwin 	for (;;) {
6629acce1c9SJohn Baldwin 		p = LIST_NEXT(p, p_hash);
6639acce1c9SJohn Baldwin 		while (p == NULL) {
6649acce1c9SJohn Baldwin 			if (++hash > pidhash)
665cbc17435SMarcel Moolenaar 				return (NULL);
6669acce1c9SJohn Baldwin 			p = LIST_FIRST(&pidhashtbl[hash]);
6679acce1c9SJohn Baldwin 		}
668825d2341SJohn Baldwin 		thr = FIRST_THREAD_IN_PROC(p);
669825d2341SJohn Baldwin 		if (thr != NULL)
670825d2341SJohn Baldwin 			return (thr);
6719acce1c9SJohn Baldwin 	}
672cbc17435SMarcel Moolenaar }
673cbc17435SMarcel Moolenaar 
674cbc17435SMarcel Moolenaar int
675cbc17435SMarcel Moolenaar kdb_thr_select(struct thread *thr)
676cbc17435SMarcel Moolenaar {
677cbc17435SMarcel Moolenaar 	if (thr == NULL)
678cbc17435SMarcel Moolenaar 		return (EINVAL);
679cbc17435SMarcel Moolenaar 	kdb_thread = thr;
680cbc17435SMarcel Moolenaar 	kdb_thrctx = kdb_thr_ctx(thr);
681cbc17435SMarcel Moolenaar 	return (0);
682cbc17435SMarcel Moolenaar }
683cbc17435SMarcel Moolenaar 
684cbc17435SMarcel Moolenaar /*
685cbc17435SMarcel Moolenaar  * Enter the debugger due to a trap.
686cbc17435SMarcel Moolenaar  */
687cbc17435SMarcel Moolenaar int
688cbc17435SMarcel Moolenaar kdb_trap(int type, int code, struct trapframe *tf)
689cbc17435SMarcel Moolenaar {
690d8939d82SRobert Watson #ifdef SMP
691a38f1f26SAttilio Rao 	cpuset_t other_cpus;
692d8939d82SRobert Watson #endif
693c0757dafSAttilio Rao 	struct kdb_dbbe *be;
694c0757dafSAttilio Rao 	register_t intr;
6955991a4f8SMarcel Moolenaar 	int handled;
69635370593SAndriy Gapon 	int did_stop_cpus;
697cbc17435SMarcel Moolenaar 
6983a5d3671SMatthew D Fleming 	be = kdb_dbbe;
6993a5d3671SMatthew D Fleming 	if (be == NULL || be->dbbe_trap == NULL)
700cbc17435SMarcel Moolenaar 		return (0);
701cbc17435SMarcel Moolenaar 
702cbc17435SMarcel Moolenaar 	/* We reenter the debugger through kdb_reenter(). */
703cbc17435SMarcel Moolenaar 	if (kdb_active)
704cbc17435SMarcel Moolenaar 		return (0);
705cbc17435SMarcel Moolenaar 
7062fae8f5aSMarcel Moolenaar 	intr = intr_disable();
707cbc17435SMarcel Moolenaar 
70835370593SAndriy Gapon 	if (!SCHEDULER_STOPPED()) {
709fcbb889fSEric van Gyzen #ifdef SMP
710a38f1f26SAttilio Rao 		other_cpus = all_cpus;
7119825eadfSRyan Libby 		CPU_ANDNOT(&other_cpus, &stopped_cpus);
712a38f1f26SAttilio Rao 		CPU_CLR(PCPU_GET(cpuid), &other_cpus);
713a38f1f26SAttilio Rao 		stop_cpus_hard(other_cpus);
714fcbb889fSEric van Gyzen #endif
715fcbb889fSEric van Gyzen 		curthread->td_stopsched = 1;
71635370593SAndriy Gapon 		did_stop_cpus = 1;
71735370593SAndriy Gapon 	} else
71835370593SAndriy Gapon 		did_stop_cpus = 0;
719cbc17435SMarcel Moolenaar 
72039eb1d12SMarcel Moolenaar 	kdb_active++;
72139eb1d12SMarcel Moolenaar 
722e6aa7232SMarcel Moolenaar 	kdb_frame = tf;
723e6aa7232SMarcel Moolenaar 
724cbc17435SMarcel Moolenaar 	/* Let MD code do its thing first... */
725cbc17435SMarcel Moolenaar 	kdb_cpu_trap(type, code);
726cbc17435SMarcel Moolenaar 
727ddf41225SMarcel Moolenaar 	makectx(tf, &kdb_pcb);
728ddf41225SMarcel Moolenaar 	kdb_thr_select(curthread);
729ddf41225SMarcel Moolenaar 
730bf8696b4SAndriy Gapon 	cngrab();
731bf8696b4SAndriy Gapon 
7323a5d3671SMatthew D Fleming 	for (;;) {
7333a5d3671SMatthew D Fleming 		handled = be->dbbe_trap(type, code);
7343a5d3671SMatthew D Fleming 		if (be == kdb_dbbe)
7353a5d3671SMatthew D Fleming 			break;
7363a5d3671SMatthew D Fleming 		be = kdb_dbbe;
7373a5d3671SMatthew D Fleming 		if (be == NULL || be->dbbe_trap == NULL)
7383a5d3671SMatthew D Fleming 			break;
7393a5d3671SMatthew D Fleming 		printf("Switching to %s back-end\n", be->dbbe_name);
7403a5d3671SMatthew D Fleming 	}
741cbc17435SMarcel Moolenaar 
742bf8696b4SAndriy Gapon 	cnungrab();
743bf8696b4SAndriy Gapon 
74439eb1d12SMarcel Moolenaar 	kdb_active--;
74539eb1d12SMarcel Moolenaar 
74616b51429SEric van Gyzen 	if (did_stop_cpus) {
747fcbb889fSEric van Gyzen 		curthread->td_stopsched = 0;
748fcbb889fSEric van Gyzen #ifdef SMP
7495b3e8b07SWojciech Macek 		CPU_AND(&other_cpus, &stopped_cpus);
7505b3e8b07SWojciech Macek 		restart_cpus(other_cpus);
751cbc17435SMarcel Moolenaar #endif
752fcbb889fSEric van Gyzen 	}
753cbc17435SMarcel Moolenaar 
7542fae8f5aSMarcel Moolenaar 	intr_restore(intr);
755cbc17435SMarcel Moolenaar 
756cbc17435SMarcel Moolenaar 	return (handled);
757cbc17435SMarcel Moolenaar }
758