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