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                 if (stack_save_td(&st, td) == 0)
 436                         stack_print_ddb(&st);
 437         }
 438 #endif
 439 }
 440
 441 /*
 442  * Set/change the current backend.
 443  */
 444 int
 445 kdb_dbbe_select(const char *name)
 446 {
 447         struct kdb_dbbe *be, **iter;
 448
 449         SET_FOREACH(iter, kdb_dbbe_set) {
 450                 be = *iter;
 451                 if (be->dbbe_active == 0 && strcmp(be->dbbe_name, name) == 0) {
 452                         kdb_dbbe = be;
 453                         return (0);
 454                 }
 455         }
 456         return (EINVAL);
 457 }
 458
 459 /*
 460  * Enter the currently selected debugger. If a message has been provided,
 461  * it is printed first. If the debugger does not support the enter method,
 462  * it is entered by using breakpoint(), which enters the debugger through
 463  * kdb_trap().  The 'why' argument will contain a more mechanically usable
 464  * string than 'msg', and is relied upon by DDB scripting to identify the
 465  * reason for entering the debugger so that the right script can be run.
 466  */
 467 void
 468 kdb_enter(const char *why, const char *msg)
 469 {
 470
 471         if (kdb_dbbe != NULL && kdb_active == 0) {
 472                 if (msg != NULL)
 473                         printf("KDB: enter: %s\n", msg);
 474                 kdb_why = why;
 475                 breakpoint();
 476                 kdb_why = KDB_WHY_UNSET;
 477         }
 478 }
 479
 480 /*
 481  * Initialize the kernel debugger interface.
 482  */
 483 void
 484 kdb_init(void)
 485 {
 486         struct kdb_dbbe *be, **iter;
 487         int cur_pri, pri;
 488
 489         kdb_active = 0;
 490         kdb_dbbe = NULL;
 491         cur_pri = -1;
 492         SET_FOREACH(iter, kdb_dbbe_set) {
 493                 be = *iter;
 494                 pri = (be->dbbe_init != NULL) ? be->dbbe_init() : -1;
 495                 be->dbbe_active = (pri >= 0) ? 0 : -1;
 496                 if (pri > cur_pri) {
 497                         cur_pri = pri;
 498                         kdb_dbbe = be;
 499                 }
 500         }
 501         if (kdb_dbbe != NULL) {
 502                 printf("KDB: debugger backends:");
 503                 SET_FOREACH(iter, kdb_dbbe_set) {
 504                         be = *iter;
 505                         if (be->dbbe_active == 0)
 506                                 printf(" %s", be->dbbe_name);
 507                 }
 508                 printf("\n");
 509                 printf("KDB: current backend: %s\n",
 510                     kdb_dbbe->dbbe_name);
 511         }
 512 }
 513
 514 /*
 515  * Handle contexts.
 516  */
 517 void *
 518 kdb_jmpbuf(jmp_buf new)
 519 {
 520         void *old;
 521
 522         old = kdb_jmpbufp;
 523         kdb_jmpbufp = new;
 524         return (old);
 525 }
 526
 527 void
 528 kdb_reenter(void)
 529 {
 530
 531         if (!kdb_active || kdb_jmpbufp == NULL)
 532                 return;
 533
 534         printf("KDB: reentering\n");
 535         kdb_backtrace();
 536         longjmp(kdb_jmpbufp, 1);
 537         /* NOTREACHED */
 538 }
 539
 540 void
 541 kdb_reenter_silent(void)
 542 {
 543
 544         if (!kdb_active || kdb_jmpbufp == NULL)
 545                 return;
 546
 547         longjmp(kdb_jmpbufp, 1);
 548         /* NOTREACHED */
 549 }
 550
 551 /*
 552  * Thread-related support functions.
 553  */
 554 struct pcb *
 555 kdb_thr_ctx(struct thread *thr)
 556 {
 557 #if defined(SMP) && defined(KDB_STOPPEDPCB)
 558         struct pcpu *pc;
 559 #endif
 560
 561         if (thr == curthread)
 562                 return (&kdb_pcb);
 563
 564 #if defined(SMP) && defined(KDB_STOPPEDPCB)
 565         STAILQ_FOREACH(pc, &cpuhead, pc_allcpu)  {
 566                 if (pc->pc_curthread == thr &&
 567                     CPU_ISSET(pc->pc_cpuid, &stopped_cpus))
 568                         return (KDB_STOPPEDPCB(pc));
 569         }
 570 #endif
 571         return (thr->td_pcb);
 572 }
 573
 574 struct thread *
 575 kdb_thr_first(void)
 576 {
 577         struct proc *p;
 578         struct thread *thr;
 579
 580         FOREACH_PROC_IN_SYSTEM(p) {
 581                 if (p->p_flag & P_INMEM) {
 582                         thr = FIRST_THREAD_IN_PROC(p);
 583                         if (thr != NULL)
 584                                 return (thr);
 585                 }
 586         }
 587         return (NULL);
 588 }
 589
 590 struct thread *
 591 kdb_thr_from_pid(pid_t pid)
 592 {
 593         struct proc *p;
 594
 595         FOREACH_PROC_IN_SYSTEM(p) {
 596                 if (p->p_flag & P_INMEM && p->p_pid == pid)
 597                         return (FIRST_THREAD_IN_PROC(p));
 598         }
 599         return (NULL);
 600 }
 601
 602 struct thread *
 603 kdb_thr_lookup(lwpid_t tid)
 604 {
 605         struct thread *thr;
 606
 607         thr = kdb_thr_first();
 608         while (thr != NULL && thr->td_tid != tid)
 609                 thr = kdb_thr_next(thr);
 610         return (thr);
 611 }
 612
 613 struct thread *
 614 kdb_thr_next(struct thread *thr)
 615 {
 616         struct proc *p;
 617
 618         p = thr->td_proc;
 619         thr = TAILQ_NEXT(thr, td_plist);
 620         do {
 621                 if (thr != NULL)
 622                         return (thr);
 623                 p = LIST_NEXT(p, p_list);
 624                 if (p != NULL && (p->p_flag & P_INMEM))
 625                         thr = FIRST_THREAD_IN_PROC(p);
 626         } while (p != NULL);
 627         return (NULL);
 628 }
 629
 630 int
 631 kdb_thr_select(struct thread *thr)
 632 {
 633         if (thr == NULL)
 634                 return (EINVAL);
 635         kdb_thread = thr;
 636         kdb_thrctx = kdb_thr_ctx(thr);
 637         return (0);
 638 }
 639
 640 /*
 641  * Enter the debugger due to a trap.
 642  */
 643 int
 644 kdb_trap(int type, int code, struct trapframe *tf)
 645 {
 646 #ifdef SMP
 647         cpuset_t other_cpus;
 648 #endif
 649         struct kdb_dbbe *be;
 650         register_t intr;
 651         int handled;
 652         int did_stop_cpus;
 653
 654         be = kdb_dbbe;
 655         if (be == NULL || be->dbbe_trap == NULL)
 656                 return (0);
 657
 658         /* We reenter the debugger through kdb_reenter(). */
 659         if (kdb_active)
 660                 return (0);
 661
 662         intr = intr_disable();
 663
 664         if (!SCHEDULER_STOPPED()) {
 665 #ifdef SMP
 666                 other_cpus = all_cpus;
 667                 CPU_ANDNOT(&other_cpus, &stopped_cpus);
 668                 CPU_CLR(PCPU_GET(cpuid), &other_cpus);
 669                 stop_cpus_hard(other_cpus);
 670 #endif
 671                 curthread->td_stopsched = 1;
 672                 did_stop_cpus = 1;
 673         } else
 674                 did_stop_cpus = 0;
 675
 676         kdb_active++;
 677
 678         kdb_frame = tf;
 679
 680         /* Let MD code do its thing first... */
 681         kdb_cpu_trap(type, code);
 682
 683         makectx(tf, &kdb_pcb);
 684         kdb_thr_select(curthread);
 685
 686         cngrab();
 687
 688         for (;;) {
 689                 handled = be->dbbe_trap(type, code);
 690                 if (be == kdb_dbbe)
 691                         break;
 692                 be = kdb_dbbe;
 693                 if (be == NULL || be->dbbe_trap == NULL)
 694                         break;
 695                 printf("Switching to %s back-end\n", be->dbbe_name);
 696         }
 697
 698         cnungrab();
 699
 700         kdb_active--;
 701
 702         if (did_stop_cpus) {
 703                 curthread->td_stopsched = 0;
 704 #ifdef SMP
 705                 CPU_AND(&other_cpus, &stopped_cpus);
 706                 restart_cpus(other_cpus);
 707 #endif
 708         }
 709
 710         intr_restore(intr);
 711
 712         return (handled);
 713 }