xref: /freebsd/sys/kern/subr_kdb.c (revision ec4deee4e4f2aef1b97d9424f25d04e91fd7dc10)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 2004 The FreeBSD Project
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28 
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31 
32 #include "opt_kdb.h"
33 #include "opt_stack.h"
34 
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/cons.h>
38 #include <sys/kdb.h>
39 #include <sys/kernel.h>
40 #include <sys/malloc.h>
41 #include <sys/lock.h>
42 #include <sys/pcpu.h>
43 #include <sys/proc.h>
44 #include <sys/sbuf.h>
45 #include <sys/smp.h>
46 #include <sys/stack.h>
47 #include <sys/sysctl.h>
48 
49 #include <machine/kdb.h>
50 #include <machine/pcb.h>
51 
52 #ifdef SMP
53 #include <machine/smp.h>
54 #endif
55 
56 u_char __read_frequently kdb_active = 0;
57 static void *kdb_jmpbufp = NULL;
58 struct kdb_dbbe *kdb_dbbe = NULL;
59 static struct pcb kdb_pcb;
60 struct pcb *kdb_thrctx = NULL;
61 struct thread *kdb_thread = NULL;
62 struct trapframe *kdb_frame = NULL;
63 
64 #ifdef BREAK_TO_DEBUGGER
65 #define	KDB_BREAK_TO_DEBUGGER	1
66 #else
67 #define	KDB_BREAK_TO_DEBUGGER	0
68 #endif
69 
70 #ifdef ALT_BREAK_TO_DEBUGGER
71 #define	KDB_ALT_BREAK_TO_DEBUGGER	1
72 #else
73 #define	KDB_ALT_BREAK_TO_DEBUGGER	0
74 #endif
75 
76 static int	kdb_break_to_debugger = KDB_BREAK_TO_DEBUGGER;
77 static int	kdb_alt_break_to_debugger = KDB_ALT_BREAK_TO_DEBUGGER;
78 
79 KDB_BACKEND(null, NULL, NULL, NULL, NULL);
80 
81 static int kdb_sysctl_available(SYSCTL_HANDLER_ARGS);
82 static int kdb_sysctl_current(SYSCTL_HANDLER_ARGS);
83 static int kdb_sysctl_enter(SYSCTL_HANDLER_ARGS);
84 static int kdb_sysctl_panic(SYSCTL_HANDLER_ARGS);
85 static int kdb_sysctl_trap(SYSCTL_HANDLER_ARGS);
86 static int kdb_sysctl_trap_code(SYSCTL_HANDLER_ARGS);
87 static int kdb_sysctl_stack_overflow(SYSCTL_HANDLER_ARGS);
88 
89 static SYSCTL_NODE(_debug, OID_AUTO, kdb, CTLFLAG_RW | CTLFLAG_MPSAFE, NULL,
90     "KDB nodes");
91 
92 SYSCTL_PROC(_debug_kdb, OID_AUTO, available,
93     CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, 0,
94     kdb_sysctl_available, "A",
95     "list of available KDB backends");
96 
97 SYSCTL_PROC(_debug_kdb, OID_AUTO, current,
98     CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_MPSAFE, NULL, 0,
99     kdb_sysctl_current, "A",
100     "currently selected KDB backend");
101 
102 SYSCTL_PROC(_debug_kdb, OID_AUTO, enter,
103     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE | CTLFLAG_MPSAFE, NULL, 0,
104     kdb_sysctl_enter, "I",
105     "set to enter the debugger");
106 
107 SYSCTL_PROC(_debug_kdb, OID_AUTO, panic,
108     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE | CTLFLAG_MPSAFE, NULL, 0,
109     kdb_sysctl_panic, "I",
110     "set to panic the kernel");
111 
112 SYSCTL_PROC(_debug_kdb, OID_AUTO, trap,
113     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE | CTLFLAG_MPSAFE, NULL, 0,
114     kdb_sysctl_trap, "I",
115     "set to cause a page fault via data access");
116 
117 SYSCTL_PROC(_debug_kdb, OID_AUTO, trap_code,
118     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE | CTLFLAG_MPSAFE, NULL, 0,
119     kdb_sysctl_trap_code, "I",
120     "set to cause a page fault via code access");
121 
122 SYSCTL_PROC(_debug_kdb, OID_AUTO, stack_overflow,
123     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE | CTLFLAG_MPSAFE, NULL, 0,
124     kdb_sysctl_stack_overflow, "I",
125     "set to cause a stack overflow");
126 
127 SYSCTL_INT(_debug_kdb, OID_AUTO, break_to_debugger,
128     CTLFLAG_RWTUN | CTLFLAG_SECURE,
129     &kdb_break_to_debugger, 0, "Enable break to debugger");
130 
131 SYSCTL_INT(_debug_kdb, OID_AUTO, alt_break_to_debugger,
132     CTLFLAG_RWTUN | CTLFLAG_SECURE,
133     &kdb_alt_break_to_debugger, 0, "Enable alternative break to debugger");
134 
135 /*
136  * Flag to indicate to debuggers why the debugger was entered.
137  */
138 const char * volatile kdb_why = KDB_WHY_UNSET;
139 
140 static int
141 kdb_sysctl_available(SYSCTL_HANDLER_ARGS)
142 {
143 	struct kdb_dbbe **iter;
144 	struct sbuf sbuf;
145 	int error;
146 
147 	sbuf_new_for_sysctl(&sbuf, NULL, 64, req);
148 	SET_FOREACH(iter, kdb_dbbe_set) {
149 		if ((*iter)->dbbe_active == 0)
150 			sbuf_printf(&sbuf, "%s ", (*iter)->dbbe_name);
151 	}
152 	error = sbuf_finish(&sbuf);
153 	sbuf_delete(&sbuf);
154 	return (error);
155 }
156 
157 static int
158 kdb_sysctl_current(SYSCTL_HANDLER_ARGS)
159 {
160 	char buf[16];
161 	int error;
162 
163 	if (kdb_dbbe != NULL)
164 		strlcpy(buf, kdb_dbbe->dbbe_name, sizeof(buf));
165 	else
166 		*buf = '\0';
167 	error = sysctl_handle_string(oidp, buf, sizeof(buf), req);
168 	if (error != 0 || req->newptr == NULL)
169 		return (error);
170 	if (kdb_active)
171 		return (EBUSY);
172 	return (kdb_dbbe_select(buf));
173 }
174 
175 static int
176 kdb_sysctl_enter(SYSCTL_HANDLER_ARGS)
177 {
178 	int error, i;
179 
180 	error = sysctl_wire_old_buffer(req, sizeof(int));
181 	if (error == 0) {
182 		i = 0;
183 		error = sysctl_handle_int(oidp, &i, 0, req);
184 	}
185 	if (error != 0 || req->newptr == NULL)
186 		return (error);
187 	if (kdb_active)
188 		return (EBUSY);
189 	kdb_enter(KDB_WHY_SYSCTL, "sysctl debug.kdb.enter");
190 	return (0);
191 }
192 
193 static int
194 kdb_sysctl_panic(SYSCTL_HANDLER_ARGS)
195 {
196 	int error, i;
197 
198 	error = sysctl_wire_old_buffer(req, sizeof(int));
199 	if (error == 0) {
200 		i = 0;
201 		error = sysctl_handle_int(oidp, &i, 0, req);
202 	}
203 	if (error != 0 || req->newptr == NULL)
204 		return (error);
205 	panic("kdb_sysctl_panic");
206 	return (0);
207 }
208 
209 static int
210 kdb_sysctl_trap(SYSCTL_HANDLER_ARGS)
211 {
212 	int error, i;
213 	int *addr = (int *)0x10;
214 
215 	error = sysctl_wire_old_buffer(req, sizeof(int));
216 	if (error == 0) {
217 		i = 0;
218 		error = sysctl_handle_int(oidp, &i, 0, req);
219 	}
220 	if (error != 0 || req->newptr == NULL)
221 		return (error);
222 	return (*addr);
223 }
224 
225 static int
226 kdb_sysctl_trap_code(SYSCTL_HANDLER_ARGS)
227 {
228 	int error, i;
229 	void (*fp)(u_int, u_int, u_int) = (void *)0xdeadc0de;
230 
231 	error = sysctl_wire_old_buffer(req, sizeof(int));
232 	if (error == 0) {
233 		i = 0;
234 		error = sysctl_handle_int(oidp, &i, 0, req);
235 	}
236 	if (error != 0 || req->newptr == NULL)
237 		return (error);
238 	(*fp)(0x11111111, 0x22222222, 0x33333333);
239 	return (0);
240 }
241 
242 static void kdb_stack_overflow(volatile int *x)  __noinline;
243 static void
244 kdb_stack_overflow(volatile int *x)
245 {
246 
247 	if (*x > 10000000)
248 		return;
249 	kdb_stack_overflow(x);
250 	*x += PCPU_GET(cpuid) / 1000000;
251 }
252 
253 static int
254 kdb_sysctl_stack_overflow(SYSCTL_HANDLER_ARGS)
255 {
256 	int error, i;
257 	volatile int x;
258 
259 	error = sysctl_wire_old_buffer(req, sizeof(int));
260 	if (error == 0) {
261 		i = 0;
262 		error = sysctl_handle_int(oidp, &i, 0, req);
263 	}
264 	if (error != 0 || req->newptr == NULL)
265 		return (error);
266 	x = 0;
267 	kdb_stack_overflow(&x);
268 	return (0);
269 }
270 
271 void
272 kdb_panic(const char *msg)
273 {
274 
275 	printf("KDB: panic\n");
276 	panic("%s", msg);
277 }
278 
279 void
280 kdb_reboot(void)
281 {
282 
283 	printf("KDB: reboot requested\n");
284 	shutdown_nice(0);
285 }
286 
287 /*
288  * Solaris implements a new BREAK which is initiated by a character sequence
289  * CR ~ ^b which is similar to a familiar pattern used on Sun servers by the
290  * Remote Console.
291  *
292  * Note that this function may be called from almost anywhere, with interrupts
293  * disabled and with unknown locks held, so it must not access data other than
294  * its arguments.  Its up to the caller to ensure that the state variable is
295  * consistent.
296  */
297 #define	KEY_CR		13	/* CR '\r' */
298 #define	KEY_TILDE	126	/* ~ */
299 #define	KEY_CRTLB	2	/* ^B */
300 #define	KEY_CRTLP	16	/* ^P */
301 #define	KEY_CRTLR	18	/* ^R */
302 
303 /* States of th KDB "alternate break sequence" detecting state machine. */
304 enum {
305 	KDB_ALT_BREAK_SEEN_NONE,
306 	KDB_ALT_BREAK_SEEN_CR,
307 	KDB_ALT_BREAK_SEEN_CR_TILDE,
308 };
309 
310 int
311 kdb_break(void)
312 {
313 
314 	if (!kdb_break_to_debugger)
315 		return (0);
316 	kdb_enter(KDB_WHY_BREAK, "Break to debugger");
317 	return (KDB_REQ_DEBUGGER);
318 }
319 
320 static int
321 kdb_alt_break_state(int key, int *state)
322 {
323 	int brk;
324 
325 	/* All states transition to KDB_ALT_BREAK_SEEN_CR on a CR. */
326 	if (key == KEY_CR) {
327 		*state = KDB_ALT_BREAK_SEEN_CR;
328 		return (0);
329 	}
330 
331 	brk = 0;
332 	switch (*state) {
333 	case KDB_ALT_BREAK_SEEN_CR:
334 		*state = KDB_ALT_BREAK_SEEN_NONE;
335 		if (key == KEY_TILDE)
336 			*state = KDB_ALT_BREAK_SEEN_CR_TILDE;
337 		break;
338 	case KDB_ALT_BREAK_SEEN_CR_TILDE:
339 		*state = KDB_ALT_BREAK_SEEN_NONE;
340 		if (key == KEY_CRTLB)
341 			brk = KDB_REQ_DEBUGGER;
342 		else if (key == KEY_CRTLP)
343 			brk = KDB_REQ_PANIC;
344 		else if (key == KEY_CRTLR)
345 			brk = KDB_REQ_REBOOT;
346 		break;
347 	case KDB_ALT_BREAK_SEEN_NONE:
348 	default:
349 		*state = KDB_ALT_BREAK_SEEN_NONE;
350 		break;
351 	}
352 	return (brk);
353 }
354 
355 static int
356 kdb_alt_break_internal(int key, int *state, int force_gdb)
357 {
358 	int brk;
359 
360 	if (!kdb_alt_break_to_debugger)
361 		return (0);
362 	brk = kdb_alt_break_state(key, state);
363 	switch (brk) {
364 	case KDB_REQ_DEBUGGER:
365 		if (force_gdb)
366 			kdb_dbbe_select("gdb");
367 		kdb_enter(KDB_WHY_BREAK, "Break to debugger");
368 		break;
369 
370 	case KDB_REQ_PANIC:
371 		if (force_gdb)
372 			kdb_dbbe_select("gdb");
373 		kdb_panic("Panic sequence on console");
374 		break;
375 
376 	case KDB_REQ_REBOOT:
377 		kdb_reboot();
378 		break;
379 	}
380 	return (0);
381 }
382 
383 int
384 kdb_alt_break(int key, int *state)
385 {
386 
387 	return (kdb_alt_break_internal(key, state, 0));
388 }
389 
390 /*
391  * This variation on kdb_alt_break() is used only by dcons, which has its own
392  * configuration flag to force GDB use regardless of the global KDB
393  * configuration.
394  */
395 int
396 kdb_alt_break_gdb(int key, int *state)
397 {
398 
399 	return (kdb_alt_break_internal(key, state, 1));
400 }
401 
402 /*
403  * Print a backtrace of the calling thread. The backtrace is generated by
404  * the selected debugger, provided it supports backtraces. If no debugger
405  * is selected or the current debugger does not support backtraces, this
406  * function silently returns.
407  */
408 void
409 kdb_backtrace(void)
410 {
411 
412 	if (kdb_dbbe != NULL && kdb_dbbe->dbbe_trace != NULL) {
413 		printf("KDB: stack backtrace:\n");
414 		kdb_dbbe->dbbe_trace();
415 	}
416 #ifdef STACK
417 	else {
418 		struct stack st;
419 
420 		printf("KDB: stack backtrace:\n");
421 		stack_zero(&st);
422 		stack_save(&st);
423 		stack_print_ddb(&st);
424 	}
425 #endif
426 }
427 
428 /*
429  * Similar to kdb_backtrace() except that it prints a backtrace of an
430  * arbitrary thread rather than the calling thread.
431  */
432 void
433 kdb_backtrace_thread(struct thread *td)
434 {
435 
436 	if (kdb_dbbe != NULL && kdb_dbbe->dbbe_trace_thread != NULL) {
437 		printf("KDB: stack backtrace of thread %d:\n", td->td_tid);
438 		kdb_dbbe->dbbe_trace_thread(td);
439 	}
440 #ifdef STACK
441 	else {
442 		struct stack st;
443 
444 		printf("KDB: stack backtrace of thread %d:\n", td->td_tid);
445 		if (stack_save_td(&st, td) == 0)
446 			stack_print_ddb(&st);
447 	}
448 #endif
449 }
450 
451 /*
452  * Set/change the current backend.
453  */
454 int
455 kdb_dbbe_select(const char *name)
456 {
457 	struct kdb_dbbe *be, **iter;
458 
459 	SET_FOREACH(iter, kdb_dbbe_set) {
460 		be = *iter;
461 		if (be->dbbe_active == 0 && strcmp(be->dbbe_name, name) == 0) {
462 			kdb_dbbe = be;
463 			return (0);
464 		}
465 	}
466 	return (EINVAL);
467 }
468 
469 /*
470  * Enter the currently selected debugger. If a message has been provided,
471  * it is printed first. If the debugger does not support the enter method,
472  * it is entered by using breakpoint(), which enters the debugger through
473  * kdb_trap().  The 'why' argument will contain a more mechanically usable
474  * string than 'msg', and is relied upon by DDB scripting to identify the
475  * reason for entering the debugger so that the right script can be run.
476  */
477 void
478 kdb_enter(const char *why, const char *msg)
479 {
480 
481 	if (kdb_dbbe != NULL && kdb_active == 0) {
482 		if (msg != NULL)
483 			printf("KDB: enter: %s\n", msg);
484 		kdb_why = why;
485 		breakpoint();
486 		kdb_why = KDB_WHY_UNSET;
487 	}
488 }
489 
490 /*
491  * Initialize the kernel debugger interface.
492  */
493 void
494 kdb_init(void)
495 {
496 	struct kdb_dbbe *be, **iter;
497 	int cur_pri, pri;
498 
499 	kdb_active = 0;
500 	kdb_dbbe = NULL;
501 	cur_pri = -1;
502 	SET_FOREACH(iter, kdb_dbbe_set) {
503 		be = *iter;
504 		pri = (be->dbbe_init != NULL) ? be->dbbe_init() : -1;
505 		be->dbbe_active = (pri >= 0) ? 0 : -1;
506 		if (pri > cur_pri) {
507 			cur_pri = pri;
508 			kdb_dbbe = be;
509 		}
510 	}
511 	if (kdb_dbbe != NULL) {
512 		printf("KDB: debugger backends:");
513 		SET_FOREACH(iter, kdb_dbbe_set) {
514 			be = *iter;
515 			if (be->dbbe_active == 0)
516 				printf(" %s", be->dbbe_name);
517 		}
518 		printf("\n");
519 		printf("KDB: current backend: %s\n",
520 		    kdb_dbbe->dbbe_name);
521 	}
522 }
523 
524 /*
525  * Handle contexts.
526  */
527 void *
528 kdb_jmpbuf(jmp_buf new)
529 {
530 	void *old;
531 
532 	old = kdb_jmpbufp;
533 	kdb_jmpbufp = new;
534 	return (old);
535 }
536 
537 void
538 kdb_reenter(void)
539 {
540 
541 	if (!kdb_active || kdb_jmpbufp == NULL)
542 		return;
543 
544 	printf("KDB: reentering\n");
545 	kdb_backtrace();
546 	longjmp(kdb_jmpbufp, 1);
547 	/* NOTREACHED */
548 }
549 
550 void
551 kdb_reenter_silent(void)
552 {
553 
554 	if (!kdb_active || kdb_jmpbufp == NULL)
555 		return;
556 
557 	longjmp(kdb_jmpbufp, 1);
558 	/* NOTREACHED */
559 }
560 
561 /*
562  * Thread-related support functions.
563  */
564 struct pcb *
565 kdb_thr_ctx(struct thread *thr)
566 {
567 #if defined(SMP) && defined(KDB_STOPPEDPCB)
568 	struct pcpu *pc;
569 #endif
570 
571 	if (thr == curthread)
572 		return (&kdb_pcb);
573 
574 #if defined(SMP) && defined(KDB_STOPPEDPCB)
575 	STAILQ_FOREACH(pc, &cpuhead, pc_allcpu)  {
576 		if (pc->pc_curthread == thr &&
577 		    CPU_ISSET(pc->pc_cpuid, &stopped_cpus))
578 			return (KDB_STOPPEDPCB(pc));
579 	}
580 #endif
581 	return (thr->td_pcb);
582 }
583 
584 struct thread *
585 kdb_thr_first(void)
586 {
587 	struct proc *p;
588 	struct thread *thr;
589 
590 	FOREACH_PROC_IN_SYSTEM(p) {
591 		if (p->p_flag & P_INMEM) {
592 			thr = FIRST_THREAD_IN_PROC(p);
593 			if (thr != NULL)
594 				return (thr);
595 		}
596 	}
597 	return (NULL);
598 }
599 
600 struct thread *
601 kdb_thr_from_pid(pid_t pid)
602 {
603 	struct proc *p;
604 
605 	FOREACH_PROC_IN_SYSTEM(p) {
606 		if (p->p_flag & P_INMEM && p->p_pid == pid)
607 			return (FIRST_THREAD_IN_PROC(p));
608 	}
609 	return (NULL);
610 }
611 
612 struct thread *
613 kdb_thr_lookup(lwpid_t tid)
614 {
615 	struct thread *thr;
616 
617 	thr = kdb_thr_first();
618 	while (thr != NULL && thr->td_tid != tid)
619 		thr = kdb_thr_next(thr);
620 	return (thr);
621 }
622 
623 struct thread *
624 kdb_thr_next(struct thread *thr)
625 {
626 	struct proc *p;
627 
628 	p = thr->td_proc;
629 	thr = TAILQ_NEXT(thr, td_plist);
630 	do {
631 		if (thr != NULL)
632 			return (thr);
633 		p = LIST_NEXT(p, p_list);
634 		if (p != NULL && (p->p_flag & P_INMEM))
635 			thr = FIRST_THREAD_IN_PROC(p);
636 	} while (p != NULL);
637 	return (NULL);
638 }
639 
640 int
641 kdb_thr_select(struct thread *thr)
642 {
643 	if (thr == NULL)
644 		return (EINVAL);
645 	kdb_thread = thr;
646 	kdb_thrctx = kdb_thr_ctx(thr);
647 	return (0);
648 }
649 
650 /*
651  * Enter the debugger due to a trap.
652  */
653 int
654 kdb_trap(int type, int code, struct trapframe *tf)
655 {
656 #ifdef SMP
657 	cpuset_t other_cpus;
658 #endif
659 	struct kdb_dbbe *be;
660 	register_t intr;
661 	int handled;
662 	int did_stop_cpus;
663 
664 	be = kdb_dbbe;
665 	if (be == NULL || be->dbbe_trap == NULL)
666 		return (0);
667 
668 	/* We reenter the debugger through kdb_reenter(). */
669 	if (kdb_active)
670 		return (0);
671 
672 	intr = intr_disable();
673 
674 	if (!SCHEDULER_STOPPED()) {
675 #ifdef SMP
676 		other_cpus = all_cpus;
677 		CPU_ANDNOT(&other_cpus, &stopped_cpus);
678 		CPU_CLR(PCPU_GET(cpuid), &other_cpus);
679 		stop_cpus_hard(other_cpus);
680 #endif
681 		curthread->td_stopsched = 1;
682 		did_stop_cpus = 1;
683 	} else
684 		did_stop_cpus = 0;
685 
686 	kdb_active++;
687 
688 	kdb_frame = tf;
689 
690 	/* Let MD code do its thing first... */
691 	kdb_cpu_trap(type, code);
692 
693 	makectx(tf, &kdb_pcb);
694 	kdb_thr_select(curthread);
695 
696 	cngrab();
697 
698 	for (;;) {
699 		handled = be->dbbe_trap(type, code);
700 		if (be == kdb_dbbe)
701 			break;
702 		be = kdb_dbbe;
703 		if (be == NULL || be->dbbe_trap == NULL)
704 			break;
705 		printf("Switching to %s back-end\n", be->dbbe_name);
706 	}
707 
708 	cnungrab();
709 
710 	kdb_active--;
711 
712 	if (did_stop_cpus) {
713 		curthread->td_stopsched = 0;
714 #ifdef SMP
715 		CPU_AND(&other_cpus, &stopped_cpus);
716 		restart_cpus(other_cpus);
717 #endif
718 	}
719 
720 	intr_restore(intr);
721 
722 	return (handled);
723 }
724