sys/kern/subr_kdb.c

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