xref: /freebsd/sys/kern/subr_kdb.c (revision a57ca37dd1848cd42844d9082c4a74c2ed57f68a)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause
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/priv.h>
44 #include <sys/proc.h>
45 #include <sys/sbuf.h>
46 #include <sys/smp.h>
47 #include <sys/stack.h>
48 #include <sys/sysctl.h>
49 
50 #include <machine/kdb.h>
51 #include <machine/pcb.h>
52 
53 #ifdef SMP
54 #include <machine/smp.h>
55 #endif
56 
57 #include <security/mac/mac_framework.h>
58 
59 u_char __read_frequently kdb_active = 0;
60 static void *kdb_jmpbufp = NULL;
61 struct kdb_dbbe *kdb_dbbe = NULL;
62 static struct pcb kdb_pcb;
63 struct pcb *kdb_thrctx = NULL;
64 struct thread *kdb_thread = NULL;
65 struct trapframe *kdb_frame = NULL;
66 
67 #ifdef BREAK_TO_DEBUGGER
68 #define	KDB_BREAK_TO_DEBUGGER	1
69 #else
70 #define	KDB_BREAK_TO_DEBUGGER	0
71 #endif
72 
73 #ifdef ALT_BREAK_TO_DEBUGGER
74 #define	KDB_ALT_BREAK_TO_DEBUGGER	1
75 #else
76 #define	KDB_ALT_BREAK_TO_DEBUGGER	0
77 #endif
78 
79 static int	kdb_break_to_debugger = KDB_BREAK_TO_DEBUGGER;
80 static int	kdb_alt_break_to_debugger = KDB_ALT_BREAK_TO_DEBUGGER;
81 static int	kdb_enter_securelevel = 0;
82 
83 KDB_BACKEND(null, NULL, NULL, NULL, NULL);
84 
85 static int kdb_sysctl_available(SYSCTL_HANDLER_ARGS);
86 static int kdb_sysctl_current(SYSCTL_HANDLER_ARGS);
87 static int kdb_sysctl_enter(SYSCTL_HANDLER_ARGS);
88 static int kdb_sysctl_panic(SYSCTL_HANDLER_ARGS);
89 static int kdb_sysctl_panic_str(SYSCTL_HANDLER_ARGS);
90 static int kdb_sysctl_trap(SYSCTL_HANDLER_ARGS);
91 static int kdb_sysctl_trap_code(SYSCTL_HANDLER_ARGS);
92 static int kdb_sysctl_stack_overflow(SYSCTL_HANDLER_ARGS);
93 
94 static SYSCTL_NODE(_debug, OID_AUTO, kdb, CTLFLAG_RW | CTLFLAG_MPSAFE, NULL,
95     "KDB nodes");
96 
97 SYSCTL_PROC(_debug_kdb, OID_AUTO, available,
98     CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, 0,
99     kdb_sysctl_available, "A",
100     "list of available KDB backends");
101 
102 SYSCTL_PROC(_debug_kdb, OID_AUTO, current,
103     CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_MPSAFE, NULL, 0,
104     kdb_sysctl_current, "A",
105     "currently selected KDB backend");
106 
107 SYSCTL_PROC(_debug_kdb, OID_AUTO, enter,
108     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, NULL, 0,
109     kdb_sysctl_enter, "I",
110     "set to enter the debugger");
111 
112 SYSCTL_PROC(_debug_kdb, OID_AUTO, panic,
113     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE | CTLFLAG_MPSAFE, NULL, 0,
114     kdb_sysctl_panic, "I",
115     "set to panic the kernel");
116 
117 SYSCTL_PROC(_debug_kdb, OID_AUTO, panic_str,
118     CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_SECURE | CTLFLAG_MPSAFE, NULL, 0,
119     kdb_sysctl_panic_str, "A",
120     "trigger a kernel panic, using the provided string as the panic message");
121 
122 SYSCTL_PROC(_debug_kdb, OID_AUTO, trap,
123     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE | CTLFLAG_MPSAFE, NULL, 0,
124     kdb_sysctl_trap, "I",
125     "set to cause a page fault via data access");
126 
127 SYSCTL_PROC(_debug_kdb, OID_AUTO, trap_code,
128     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE | CTLFLAG_MPSAFE, NULL, 0,
129     kdb_sysctl_trap_code, "I",
130     "set to cause a page fault via code access");
131 
132 SYSCTL_PROC(_debug_kdb, OID_AUTO, stack_overflow,
133     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE | CTLFLAG_MPSAFE, NULL, 0,
134     kdb_sysctl_stack_overflow, "I",
135     "set to cause a stack overflow");
136 
137 SYSCTL_INT(_debug_kdb, OID_AUTO, break_to_debugger,
138     CTLFLAG_RWTUN,
139     &kdb_break_to_debugger, 0, "Enable break to debugger");
140 
141 SYSCTL_INT(_debug_kdb, OID_AUTO, alt_break_to_debugger,
142     CTLFLAG_RWTUN,
143     &kdb_alt_break_to_debugger, 0, "Enable alternative break to debugger");
144 
145 SYSCTL_INT(_debug_kdb, OID_AUTO, enter_securelevel,
146     CTLFLAG_RWTUN | CTLFLAG_SECURE,
147     &kdb_enter_securelevel, 0,
148     "Maximum securelevel to enter a KDB backend");
149 
150 /*
151  * Flag to indicate to debuggers why the debugger was entered.
152  */
153 const char * volatile kdb_why = KDB_WHY_UNSET;
154 
155 static int
156 kdb_sysctl_available(SYSCTL_HANDLER_ARGS)
157 {
158 	struct kdb_dbbe **iter;
159 	struct sbuf sbuf;
160 	int error;
161 
162 	sbuf_new_for_sysctl(&sbuf, NULL, 64, req);
163 	SET_FOREACH(iter, kdb_dbbe_set) {
164 		if ((*iter)->dbbe_active == 0)
165 			sbuf_printf(&sbuf, "%s ", (*iter)->dbbe_name);
166 	}
167 	error = sbuf_finish(&sbuf);
168 	sbuf_delete(&sbuf);
169 	return (error);
170 }
171 
172 static int
173 kdb_sysctl_current(SYSCTL_HANDLER_ARGS)
174 {
175 	char buf[16];
176 	int error;
177 
178 	if (kdb_dbbe != NULL)
179 		strlcpy(buf, kdb_dbbe->dbbe_name, sizeof(buf));
180 	else
181 		*buf = '\0';
182 	error = sysctl_handle_string(oidp, buf, sizeof(buf), req);
183 	if (error != 0 || req->newptr == NULL)
184 		return (error);
185 	if (kdb_active)
186 		return (EBUSY);
187 	return (kdb_dbbe_select(buf));
188 }
189 
190 static int
191 kdb_sysctl_enter(SYSCTL_HANDLER_ARGS)
192 {
193 	int error, i;
194 
195 	error = sysctl_wire_old_buffer(req, sizeof(int));
196 	if (error == 0) {
197 		i = 0;
198 		error = sysctl_handle_int(oidp, &i, 0, req);
199 	}
200 	if (error != 0 || req->newptr == NULL)
201 		return (error);
202 	if (kdb_active)
203 		return (EBUSY);
204 	kdb_enter(KDB_WHY_SYSCTL, "sysctl debug.kdb.enter");
205 	return (0);
206 }
207 
208 static int
209 kdb_sysctl_panic(SYSCTL_HANDLER_ARGS)
210 {
211 	int error, i;
212 
213 	error = sysctl_wire_old_buffer(req, sizeof(int));
214 	if (error == 0) {
215 		i = 0;
216 		error = sysctl_handle_int(oidp, &i, 0, req);
217 	}
218 	if (error != 0 || req->newptr == NULL)
219 		return (error);
220 	panic("kdb_sysctl_panic");
221 	return (0);
222 }
223 
224 static int
225 kdb_sysctl_panic_str(SYSCTL_HANDLER_ARGS)
226 {
227 	int error;
228 	static char buf[256]; /* static buffer to limit mallocs when panicing */
229 
230 	*buf = '\0';
231 	error = sysctl_handle_string(oidp, buf, sizeof(buf), req);
232 	if (error != 0 || req->newptr == NULL)
233 		return (error);
234 	panic("kdb_sysctl_panic: %s", buf);
235 	return (0);
236 }
237 
238 static int
239 kdb_sysctl_trap(SYSCTL_HANDLER_ARGS)
240 {
241 	int error, i;
242 	int *addr = (int *)0x10;
243 
244 	error = sysctl_wire_old_buffer(req, sizeof(int));
245 	if (error == 0) {
246 		i = 0;
247 		error = sysctl_handle_int(oidp, &i, 0, req);
248 	}
249 	if (error != 0 || req->newptr == NULL)
250 		return (error);
251 	return (*addr);
252 }
253 
254 static int
255 kdb_sysctl_trap_code(SYSCTL_HANDLER_ARGS)
256 {
257 	int error, i;
258 	void (*fp)(u_int, u_int, u_int) = (void *)0xdeadc0de;
259 
260 	error = sysctl_wire_old_buffer(req, sizeof(int));
261 	if (error == 0) {
262 		i = 0;
263 		error = sysctl_handle_int(oidp, &i, 0, req);
264 	}
265 	if (error != 0 || req->newptr == NULL)
266 		return (error);
267 	(*fp)(0x11111111, 0x22222222, 0x33333333);
268 	return (0);
269 }
270 
271 static void kdb_stack_overflow(volatile int *x)  __noinline;
272 static void
273 kdb_stack_overflow(volatile int *x)
274 {
275 
276 	if (*x > 10000000)
277 		return;
278 	kdb_stack_overflow(x);
279 	*x += PCPU_GET(cpuid) / 1000000;
280 }
281 
282 static int
283 kdb_sysctl_stack_overflow(SYSCTL_HANDLER_ARGS)
284 {
285 	int error, i;
286 	volatile int x;
287 
288 	error = sysctl_wire_old_buffer(req, sizeof(int));
289 	if (error == 0) {
290 		i = 0;
291 		error = sysctl_handle_int(oidp, &i, 0, req);
292 	}
293 	if (error != 0 || req->newptr == NULL)
294 		return (error);
295 	x = 0;
296 	kdb_stack_overflow(&x);
297 	return (0);
298 }
299 
300 void
301 kdb_panic(const char *msg)
302 {
303 
304 	kdb_why = KDB_WHY_PANIC;
305 	printf("KDB: panic\n");
306 	panic("%s", msg);
307 }
308 
309 void
310 kdb_reboot(void)
311 {
312 
313 	kdb_why = KDB_WHY_REBOOT;
314 	printf("KDB: reboot requested\n");
315 	shutdown_nice(0);
316 }
317 
318 /*
319  * Solaris implements a new BREAK which is initiated by a character sequence
320  * CR ~ ^b which is similar to a familiar pattern used on Sun servers by the
321  * Remote Console.
322  *
323  * Note that this function may be called from almost anywhere, with interrupts
324  * disabled and with unknown locks held, so it must not access data other than
325  * its arguments.  Its up to the caller to ensure that the state variable is
326  * consistent.
327  */
328 #define	KEY_CR		13	/* CR '\r' */
329 #define	KEY_TILDE	126	/* ~ */
330 #define	KEY_CRTLB	2	/* ^B */
331 #define	KEY_CRTLP	16	/* ^P */
332 #define	KEY_CRTLR	18	/* ^R */
333 
334 /* States of th KDB "alternate break sequence" detecting state machine. */
335 enum {
336 	KDB_ALT_BREAK_SEEN_NONE,
337 	KDB_ALT_BREAK_SEEN_CR,
338 	KDB_ALT_BREAK_SEEN_CR_TILDE,
339 };
340 
341 int
342 kdb_break(void)
343 {
344 
345 	if (!kdb_break_to_debugger)
346 		return (0);
347 	kdb_enter(KDB_WHY_BREAK, "Break to debugger");
348 	return (KDB_REQ_DEBUGGER);
349 }
350 
351 static int
352 kdb_alt_break_state(int key, int *state)
353 {
354 	int brk;
355 
356 	/* All states transition to KDB_ALT_BREAK_SEEN_CR on a CR. */
357 	if (key == KEY_CR) {
358 		*state = KDB_ALT_BREAK_SEEN_CR;
359 		return (0);
360 	}
361 
362 	brk = 0;
363 	switch (*state) {
364 	case KDB_ALT_BREAK_SEEN_CR:
365 		*state = KDB_ALT_BREAK_SEEN_NONE;
366 		if (key == KEY_TILDE)
367 			*state = KDB_ALT_BREAK_SEEN_CR_TILDE;
368 		break;
369 	case KDB_ALT_BREAK_SEEN_CR_TILDE:
370 		*state = KDB_ALT_BREAK_SEEN_NONE;
371 		if (key == KEY_CRTLB)
372 			brk = KDB_REQ_DEBUGGER;
373 		else if (key == KEY_CRTLP)
374 			brk = KDB_REQ_PANIC;
375 		else if (key == KEY_CRTLR)
376 			brk = KDB_REQ_REBOOT;
377 		break;
378 	case KDB_ALT_BREAK_SEEN_NONE:
379 	default:
380 		*state = KDB_ALT_BREAK_SEEN_NONE;
381 		break;
382 	}
383 	return (brk);
384 }
385 
386 static int
387 kdb_alt_break_internal(int key, int *state, int force_gdb)
388 {
389 	int brk;
390 
391 	if (!kdb_alt_break_to_debugger)
392 		return (0);
393 	brk = kdb_alt_break_state(key, state);
394 	switch (brk) {
395 	case KDB_REQ_DEBUGGER:
396 		if (force_gdb)
397 			kdb_dbbe_select("gdb");
398 		kdb_enter(KDB_WHY_BREAK, "Break to debugger");
399 		break;
400 
401 	case KDB_REQ_PANIC:
402 		if (force_gdb)
403 			kdb_dbbe_select("gdb");
404 		kdb_panic("Panic sequence on console");
405 		break;
406 
407 	case KDB_REQ_REBOOT:
408 		kdb_reboot();
409 		break;
410 	}
411 	return (0);
412 }
413 
414 int
415 kdb_alt_break(int key, int *state)
416 {
417 
418 	return (kdb_alt_break_internal(key, state, 0));
419 }
420 
421 /*
422  * This variation on kdb_alt_break() is used only by dcons, which has its own
423  * configuration flag to force GDB use regardless of the global KDB
424  * configuration.
425  */
426 int
427 kdb_alt_break_gdb(int key, int *state)
428 {
429 
430 	return (kdb_alt_break_internal(key, state, 1));
431 }
432 
433 /*
434  * Print a backtrace of the calling thread. The backtrace is generated by
435  * the selected debugger, provided it supports backtraces. If no debugger
436  * is selected or the current debugger does not support backtraces, this
437  * function silently returns.
438  */
439 void
440 kdb_backtrace(void)
441 {
442 
443 	if (kdb_dbbe != NULL && kdb_dbbe->dbbe_trace != NULL) {
444 		printf("KDB: stack backtrace:\n");
445 		kdb_dbbe->dbbe_trace();
446 	}
447 #ifdef STACK
448 	else {
449 		struct stack st;
450 
451 		printf("KDB: stack backtrace:\n");
452 		stack_save(&st);
453 		stack_print_ddb(&st);
454 	}
455 #endif
456 }
457 
458 /*
459  * Similar to kdb_backtrace() except that it prints a backtrace of an
460  * arbitrary thread rather than the calling thread.
461  */
462 void
463 kdb_backtrace_thread(struct thread *td)
464 {
465 
466 	if (kdb_dbbe != NULL && kdb_dbbe->dbbe_trace_thread != NULL) {
467 		printf("KDB: stack backtrace of thread %d:\n", td->td_tid);
468 		kdb_dbbe->dbbe_trace_thread(td);
469 	}
470 #ifdef STACK
471 	else {
472 		struct stack st;
473 
474 		printf("KDB: stack backtrace of thread %d:\n", td->td_tid);
475 		if (stack_save_td(&st, td) == 0)
476 			stack_print_ddb(&st);
477 	}
478 #endif
479 }
480 
481 /*
482  * Set/change the current backend.
483  */
484 int
485 kdb_dbbe_select(const char *name)
486 {
487 	struct kdb_dbbe *be, **iter;
488 	int error;
489 
490 	error = priv_check(curthread, PRIV_KDB_SET_BACKEND);
491 	if (error)
492 		return (error);
493 
494 	SET_FOREACH(iter, kdb_dbbe_set) {
495 		be = *iter;
496 		if (be->dbbe_active == 0 && strcmp(be->dbbe_name, name) == 0) {
497 			kdb_dbbe = be;
498 			return (0);
499 		}
500 	}
501 	return (EINVAL);
502 }
503 
504 static bool
505 kdb_backend_permitted(struct kdb_dbbe *be, struct ucred *cred)
506 {
507 	int error;
508 
509 	error = securelevel_gt(cred, kdb_enter_securelevel);
510 #ifdef MAC
511 	/*
512 	 * Give MAC a chance to weigh in on the policy: if the securelevel is
513 	 * not raised, then MAC may veto the backend, otherwise MAC may
514 	 * explicitly grant access.
515 	 */
516 	if (error == 0) {
517 		error = mac_kdb_check_backend(be);
518 		if (error != 0) {
519 			printf("MAC prevented execution of KDB backend: %s\n",
520 			    be->dbbe_name);
521 			return (false);
522 		}
523 	} else if (mac_kdb_grant_backend(be) == 0) {
524 		error = 0;
525 	}
526 #endif
527 	if (error != 0)
528 		printf("refusing to enter KDB with elevated securelevel\n");
529 	return (error == 0);
530 }
531 
532 /*
533  * Enter the currently selected debugger. If a message has been provided,
534  * it is printed first. If the debugger does not support the enter method,
535  * it is entered by using breakpoint(), which enters the debugger through
536  * kdb_trap().  The 'why' argument will contain a more mechanically usable
537  * string than 'msg', and is relied upon by DDB scripting to identify the
538  * reason for entering the debugger so that the right script can be run.
539  */
540 void
541 kdb_enter(const char *why, const char *msg)
542 {
543 
544 	if (kdb_dbbe != NULL && kdb_active == 0) {
545 		kdb_why = why;
546 		if (msg != NULL)
547 			printf("KDB: enter: %s\n", msg);
548 		breakpoint();
549 		kdb_why = KDB_WHY_UNSET;
550 	}
551 }
552 
553 /*
554  * Initialize the kernel debugger interface.
555  */
556 void
557 kdb_init(void)
558 {
559 	struct kdb_dbbe *be, **iter;
560 	int cur_pri, pri;
561 
562 	kdb_active = 0;
563 	kdb_dbbe = NULL;
564 	cur_pri = -1;
565 	SET_FOREACH(iter, kdb_dbbe_set) {
566 		be = *iter;
567 		pri = (be->dbbe_init != NULL) ? be->dbbe_init() : -1;
568 		be->dbbe_active = (pri >= 0) ? 0 : -1;
569 		if (pri > cur_pri) {
570 			cur_pri = pri;
571 			kdb_dbbe = be;
572 		}
573 	}
574 	if (kdb_dbbe != NULL) {
575 		printf("KDB: debugger backends:");
576 		SET_FOREACH(iter, kdb_dbbe_set) {
577 			be = *iter;
578 			if (be->dbbe_active == 0)
579 				printf(" %s", be->dbbe_name);
580 		}
581 		printf("\n");
582 		printf("KDB: current backend: %s\n",
583 		    kdb_dbbe->dbbe_name);
584 	}
585 }
586 
587 /*
588  * Handle contexts.
589  */
590 void *
591 kdb_jmpbuf(jmp_buf new)
592 {
593 	void *old;
594 
595 	old = kdb_jmpbufp;
596 	kdb_jmpbufp = new;
597 	return (old);
598 }
599 
600 void
601 kdb_reenter(void)
602 {
603 
604 	if (!kdb_active || kdb_jmpbufp == NULL)
605 		return;
606 
607 	printf("KDB: reentering\n");
608 	kdb_backtrace();
609 	longjmp(kdb_jmpbufp, 1);
610 	/* NOTREACHED */
611 }
612 
613 void
614 kdb_reenter_silent(void)
615 {
616 
617 	if (!kdb_active || kdb_jmpbufp == NULL)
618 		return;
619 
620 	longjmp(kdb_jmpbufp, 1);
621 	/* NOTREACHED */
622 }
623 
624 /*
625  * Thread-related support functions.
626  */
627 struct pcb *
628 kdb_thr_ctx(struct thread *thr)
629 {
630 #ifdef SMP
631 	struct pcpu *pc;
632 #endif
633 
634 	if (thr == curthread)
635 		return (&kdb_pcb);
636 
637 #ifdef SMP
638 	STAILQ_FOREACH(pc, &cpuhead, pc_allcpu)  {
639 		if (pc->pc_curthread == thr &&
640 		    CPU_ISSET(pc->pc_cpuid, &stopped_cpus))
641 			return (&stoppcbs[pc->pc_cpuid]);
642 	}
643 #endif
644 	return (thr->td_pcb);
645 }
646 
647 struct thread *
648 kdb_thr_first(void)
649 {
650 	struct proc *p;
651 	struct thread *thr;
652 	u_int i;
653 
654 	/* This function may be called early. */
655 	if (pidhashtbl == NULL)
656 		return (&thread0);
657 
658 	for (i = 0; i <= pidhash; i++) {
659 		LIST_FOREACH(p, &pidhashtbl[i], p_hash) {
660 			thr = FIRST_THREAD_IN_PROC(p);
661 			if (thr != NULL)
662 				return (thr);
663 		}
664 	}
665 	return (NULL);
666 }
667 
668 struct thread *
669 kdb_thr_from_pid(pid_t pid)
670 {
671 	struct proc *p;
672 
673 	LIST_FOREACH(p, PIDHASH(pid), p_hash) {
674 		if (p->p_pid == pid)
675 			return (FIRST_THREAD_IN_PROC(p));
676 	}
677 	return (NULL);
678 }
679 
680 struct thread *
681 kdb_thr_lookup(lwpid_t tid)
682 {
683 	struct thread *thr;
684 
685 	thr = kdb_thr_first();
686 	while (thr != NULL && thr->td_tid != tid)
687 		thr = kdb_thr_next(thr);
688 	return (thr);
689 }
690 
691 struct thread *
692 kdb_thr_next(struct thread *thr)
693 {
694 	struct proc *p;
695 	u_int hash;
696 
697 	p = thr->td_proc;
698 	thr = TAILQ_NEXT(thr, td_plist);
699 	if (thr != NULL)
700 		return (thr);
701 	if (pidhashtbl == NULL)
702 		return (NULL);
703 	hash = p->p_pid & pidhash;
704 	for (;;) {
705 		p = LIST_NEXT(p, p_hash);
706 		while (p == NULL) {
707 			if (++hash > pidhash)
708 				return (NULL);
709 			p = LIST_FIRST(&pidhashtbl[hash]);
710 		}
711 		thr = FIRST_THREAD_IN_PROC(p);
712 		if (thr != NULL)
713 			return (thr);
714 	}
715 }
716 
717 int
718 kdb_thr_select(struct thread *thr)
719 {
720 	if (thr == NULL)
721 		return (EINVAL);
722 	kdb_thread = thr;
723 	kdb_thrctx = kdb_thr_ctx(thr);
724 	return (0);
725 }
726 
727 /*
728  * Enter the debugger due to a trap.
729  */
730 int
731 kdb_trap(int type, int code, struct trapframe *tf)
732 {
733 #ifdef SMP
734 	cpuset_t other_cpus;
735 #endif
736 	struct kdb_dbbe *be;
737 	register_t intr;
738 	int handled;
739 	int did_stop_cpus;
740 
741 	be = kdb_dbbe;
742 	if (be == NULL || be->dbbe_trap == NULL)
743 		return (0);
744 
745 	/* We reenter the debugger through kdb_reenter(). */
746 	if (kdb_active)
747 		return (0);
748 
749 	intr = intr_disable();
750 
751 	if (!SCHEDULER_STOPPED()) {
752 #ifdef SMP
753 		other_cpus = all_cpus;
754 		CPU_ANDNOT(&other_cpus, &other_cpus, &stopped_cpus);
755 		CPU_CLR(PCPU_GET(cpuid), &other_cpus);
756 		stop_cpus_hard(other_cpus);
757 #endif
758 		curthread->td_stopsched = 1;
759 		did_stop_cpus = 1;
760 	} else
761 		did_stop_cpus = 0;
762 
763 	kdb_active++;
764 
765 	kdb_frame = tf;
766 
767 	/* Let MD code do its thing first... */
768 	kdb_cpu_trap(type, code);
769 
770 	makectx(tf, &kdb_pcb);
771 	kdb_thr_select(curthread);
772 
773 	cngrab();
774 
775 	for (;;) {
776 		if (!kdb_backend_permitted(be, curthread->td_ucred)) {
777 			/* Unhandled breakpoint traps are fatal. */
778 			handled = 1;
779 			break;
780 		}
781 		handled = be->dbbe_trap(type, code);
782 		if (be == kdb_dbbe)
783 			break;
784 		be = kdb_dbbe;
785 		if (be == NULL || be->dbbe_trap == NULL)
786 			break;
787 		printf("Switching to %s back-end\n", be->dbbe_name);
788 	}
789 
790 	cnungrab();
791 
792 	kdb_active--;
793 
794 	if (did_stop_cpus) {
795 		curthread->td_stopsched = 0;
796 #ifdef SMP
797 		CPU_AND(&other_cpus, &other_cpus, &stopped_cpus);
798 		restart_cpus(other_cpus);
799 #endif
800 	}
801 
802 	intr_restore(intr);
803 
804 	return (handled);
805 }
806