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