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