sys/kern/subr_kdb.c

   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$");
  29
  30 #include "opt_kdb.h"
  31 #include "opt_stack.h"
  32
  33 #include <sys/param.h>
  34 #include <sys/systm.h>
  35 #include <sys/cons.h>
  36 #include <sys/kdb.h>
  37 #include <sys/kernel.h>
  38 #include <sys/malloc.h>
  39 #include <sys/pcpu.h>
  40 #include <sys/proc.h>
  41 #include <sys/sbuf.h>
  42 #include <sys/smp.h>
  43 #include <sys/stack.h>
  44 #include <sys/sysctl.h>
  45
  46 #include <machine/kdb.h>
  47 #include <machine/pcb.h>
  48
  49 #ifdef SMP
  50 #include <machine/smp.h>
  51 #endif
  52
  53 u_char __read_frequently kdb_active = 0;
  54 static void *kdb_jmpbufp = NULL;
  55 struct kdb_dbbe *kdb_dbbe = NULL;
  56 static struct pcb kdb_pcb;
  57 struct pcb *kdb_thrctx = NULL;
  58 struct thread *kdb_thread = NULL;
  59 struct trapframe *kdb_frame = NULL;
  60
  61 #ifdef BREAK_TO_DEBUGGER
  62 #define KDB_BREAK_TO_DEBUGGER   1
  63 #else
  64 #define KDB_BREAK_TO_DEBUGGER   0
  65 #endif
  66
  67 #ifdef ALT_BREAK_TO_DEBUGGER
  68 #define KDB_ALT_BREAK_TO_DEBUGGER       1
  69 #else
  70 #define KDB_ALT_BREAK_TO_DEBUGGER       0
  71 #endif
  72
  73 static int      kdb_break_to_debugger = KDB_BREAK_TO_DEBUGGER;
  74 static int      kdb_alt_break_to_debugger = KDB_ALT_BREAK_TO_DEBUGGER;
  75
  76 KDB_BACKEND(null, NULL, NULL, NULL, NULL);
  77 SET_DECLARE(kdb_dbbe_set, struct kdb_dbbe);
  78
  79 static int kdb_sysctl_available(SYSCTL_HANDLER_ARGS);
  80 static int kdb_sysctl_current(SYSCTL_HANDLER_ARGS);
  81 static int kdb_sysctl_enter(SYSCTL_HANDLER_ARGS);
  82 static int kdb_sysctl_panic(SYSCTL_HANDLER_ARGS);
  83 static int kdb_sysctl_trap(SYSCTL_HANDLER_ARGS);
  84 static int kdb_sysctl_trap_code(SYSCTL_HANDLER_ARGS);
  85 static int kdb_sysctl_stack_overflow(SYSCTL_HANDLER_ARGS);
  86
  87 static SYSCTL_NODE(_debug, OID_AUTO, kdb, CTLFLAG_RW, NULL, "KDB nodes");
  88
  89 SYSCTL_PROC(_debug_kdb, OID_AUTO, available, CTLTYPE_STRING | CTLFLAG_RD, NULL,
  90     0, kdb_sysctl_available, "A", "list of available KDB backends");
  91
  92 SYSCTL_PROC(_debug_kdb, OID_AUTO, current, CTLTYPE_STRING | CTLFLAG_RW, NULL,
  93     0, kdb_sysctl_current, "A", "currently selected KDB backend");
  94
  95 SYSCTL_PROC(_debug_kdb, OID_AUTO, enter,
  96     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE, NULL, 0,
  97     kdb_sysctl_enter, "I", "set to enter the debugger");
  98
  99 SYSCTL_PROC(_debug_kdb, OID_AUTO, panic,
 100     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE, NULL, 0,
 101     kdb_sysctl_panic, "I", "set to panic the kernel");
 102
 103 SYSCTL_PROC(_debug_kdb, OID_AUTO, trap,
 104     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE, NULL, 0,
 105     kdb_sysctl_trap, "I", "set to cause a page fault via data access");
 106
 107 SYSCTL_PROC(_debug_kdb, OID_AUTO, trap_code,
 108     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE, NULL, 0,
 109     kdb_sysctl_trap_code, "I", "set to cause a page fault via code access");
 110
 111 SYSCTL_PROC(_debug_kdb, OID_AUTO, stack_overflow,
 112     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE, NULL, 0,
 113     kdb_sysctl_stack_overflow, "I", "set to cause a stack overflow");
 114
 115 SYSCTL_INT(_debug_kdb, OID_AUTO, break_to_debugger,
 116     CTLFLAG_RWTUN | CTLFLAG_SECURE,
 117     &kdb_break_to_debugger, 0, "Enable break to debugger");
 118
 119 SYSCTL_INT(_debug_kdb, OID_AUTO, alt_break_to_debugger,
 120     CTLFLAG_RWTUN | CTLFLAG_SECURE,
 121     &kdb_alt_break_to_debugger, 0, "Enable alternative break to debugger");
 122
 123 /*
 124  * Flag to indicate to debuggers why the debugger was entered.
 125  */
 126 const char * volatile kdb_why = KDB_WHY_UNSET;
 127
 128 static int
 129 kdb_sysctl_available(SYSCTL_HANDLER_ARGS)
 130 {
 131         struct kdb_dbbe **iter;
 132         struct sbuf sbuf;
 133         int error;
 134
 135         sbuf_new_for_sysctl(&sbuf, NULL, 64, req);
 136         SET_FOREACH(iter, kdb_dbbe_set) {
 137                 if ((*iter)->dbbe_active == 0)
 138                         sbuf_printf(&sbuf, "%s ", (*iter)->dbbe_name);
 139         }
 140         error = sbuf_finish(&sbuf);
 141         sbuf_delete(&sbuf);
 142         return (error);
 143 }
 144
 145 static int
 146 kdb_sysctl_current(SYSCTL_HANDLER_ARGS)
 147 {
 148         char buf[16];
 149         int error;
 150
 151         if (kdb_dbbe != NULL)
 152                 strlcpy(buf, kdb_dbbe->dbbe_name, sizeof(buf));
 153         else
 154                 *buf = '\0';
 155         error = sysctl_handle_string(oidp, buf, sizeof(buf), req);
 156         if (error != 0 || req->newptr == NULL)
 157                 return (error);
 158         if (kdb_active)
 159                 return (EBUSY);
 160         return (kdb_dbbe_select(buf));
 161 }
 162
 163 static int
 164 kdb_sysctl_enter(SYSCTL_HANDLER_ARGS)
 165 {
 166         int error, i;
 167
 168         error = sysctl_wire_old_buffer(req, sizeof(int));
 169         if (error == 0) {
 170                 i = 0;
 171                 error = sysctl_handle_int(oidp, &i, 0, req);
 172         }
 173         if (error != 0 || req->newptr == NULL)
 174                 return (error);
 175         if (kdb_active)
 176                 return (EBUSY);
 177         kdb_enter(KDB_WHY_SYSCTL, "sysctl debug.kdb.enter");
 178         return (0);
 179 }
 180
 181 static int
 182 kdb_sysctl_panic(SYSCTL_HANDLER_ARGS)
 183 {
 184         int error, i;
 185
 186         error = sysctl_wire_old_buffer(req, sizeof(int));
 187         if (error == 0) {
 188                 i = 0;
 189                 error = sysctl_handle_int(oidp, &i, 0, req);
 190         }
 191         if (error != 0 || req->newptr == NULL)
 192                 return (error);
 193         panic("kdb_sysctl_panic");
 194         return (0);
 195 }
 196
 197 static int
 198 kdb_sysctl_trap(SYSCTL_HANDLER_ARGS)
 199 {
 200         int error, i;
 201         int *addr = (int *)0x10;
 202
 203         error = sysctl_wire_old_buffer(req, sizeof(int));
 204         if (error == 0) {
 205                 i = 0;
 206                 error = sysctl_handle_int(oidp, &i, 0, req);
 207         }
 208         if (error != 0 || req->newptr == NULL)
 209                 return (error);
 210         return (*addr);
 211 }
 212
 213 static int
 214 kdb_sysctl_trap_code(SYSCTL_HANDLER_ARGS)
 215 {
 216         int error, i;
 217         void (*fp)(u_int, u_int, u_int) = (void *)0xdeadc0de;
 218
 219         error = sysctl_wire_old_buffer(req, sizeof(int));
 220         if (error == 0) {
 221                 i = 0;
 222                 error = sysctl_handle_int(oidp, &i, 0, req);
 223         }
 224         if (error != 0 || req->newptr == NULL)
 225                 return (error);
 226         (*fp)(0x11111111, 0x22222222, 0x33333333);
 227         return (0);
 228 }
 229
 230 static void kdb_stack_overflow(volatile int *x)  __noinline;
 231 static void
 232 kdb_stack_overflow(volatile int *x)
 233 {
 234
 235         if (*x > 10000000)
 236                 return;
 237         kdb_stack_overflow(x);
 238         *x += PCPU_GET(cpuid) / 1000000;
 239 }
 240
 241 static int
 242 kdb_sysctl_stack_overflow(SYSCTL_HANDLER_ARGS)
 243 {
 244         int error, i;
 245         volatile int x;
 246
 247         error = sysctl_wire_old_buffer(req, sizeof(int));
 248         if (error == 0) {
 249                 i = 0;
 250                 error = sysctl_handle_int(oidp, &i, 0, req);
 251         }
 252         if (error != 0 || req->newptr == NULL)
 253                 return (error);
 254         x = 0;
 255         kdb_stack_overflow(&x);
 256         return (0);
 257 }
 258
 259
 260 void
 261 kdb_panic(const char *msg)
 262 {
 263
 264         printf("KDB: panic\n");
 265         panic("%s", msg);
 266 }
 267
 268 void
 269 kdb_reboot(void)
 270 {
 271
 272         printf("KDB: reboot requested\n");
 273         shutdown_nice(0);
 274 }
 275
 276 /*
 277  * Solaris implements a new BREAK which is initiated by a character sequence
 278  * CR ~ ^b which is similar to a familiar pattern used on Sun servers by the
 279  * Remote Console.
 280  *
 281  * Note that this function may be called from almost anywhere, with interrupts
 282  * disabled and with unknown locks held, so it must not access data other than
 283  * its arguments.  Its up to the caller to ensure that the state variable is
 284  * consistent.
 285  */
 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
 399 void
 400 kdb_backtrace(void)
 401 {
 402
 403         if (kdb_dbbe != NULL && kdb_dbbe->dbbe_trace != NULL) {
 404                 printf("KDB: stack backtrace:\n");
 405                 kdb_dbbe->dbbe_trace();
 406         }
 407 #ifdef STACK
 408         else {
 409                 struct stack st;
 410
 411                 printf("KDB: stack backtrace:\n");
 412                 stack_zero(&st);
 413                 stack_save(&st);
 414                 stack_print_ddb(&st);
 415         }
 416 #endif
 417 }
 418
 419 /*
 420  * Similar to kdb_backtrace() except that it prints a backtrace of an
 421  * arbitrary thread rather than the calling thread.
 422  */
 423 void
 424 kdb_backtrace_thread(struct thread *td)
 425 {
 426
 427         if (kdb_dbbe != NULL && kdb_dbbe->dbbe_trace_thread != NULL) {
 428                 printf("KDB: stack backtrace of thread %d:\n", td->td_tid);
 429                 kdb_dbbe->dbbe_trace_thread(td);
 430         }
 431 #ifdef STACK
 432         else {
 433                 struct stack st;
 434
 435                 printf("KDB: stack backtrace of thread %d:\n", td->td_tid);
 436                 stack_zero(&st);
 437                 stack_save_td(&st, td);
 438                 stack_print_ddb(&st);
 439         }
 440 #endif
 441 }
 442
 443 /*
 444  * Set/change the current backend.
 445  */
 446
 447 int
 448 kdb_dbbe_select(const char *name)
 449 {
 450         struct kdb_dbbe *be, **iter;
 451
 452         SET_FOREACH(iter, kdb_dbbe_set) {
 453                 be = *iter;
 454                 if (be->dbbe_active == 0 && strcmp(be->dbbe_name, name) == 0) {
 455                         kdb_dbbe = be;
 456                         return (0);
 457                 }
 458         }
 459         return (EINVAL);
 460 }
 461
 462 /*
 463  * Enter the currently selected debugger. If a message has been provided,
 464  * it is printed first. If the debugger does not support the enter method,
 465  * it is entered by using breakpoint(), which enters the debugger through
 466  * kdb_trap().  The 'why' argument will contain a more mechanically usable
 467  * string than 'msg', and is relied upon by DDB scripting to identify the
 468  * reason for entering the debugger so that the right script can be run.
 469  */
 470 void
 471 kdb_enter(const char *why, const char *msg)
 472 {
 473
 474         if (kdb_dbbe != NULL && kdb_active == 0) {
 475                 if (msg != NULL)
 476                         printf("KDB: enter: %s\n", msg);
 477                 kdb_why = why;
 478                 breakpoint();
 479                 kdb_why = KDB_WHY_UNSET;
 480         }
 481 }
 482
 483 /*
 484  * Initialize the kernel debugger interface.
 485  */
 486
 487 void
 488 kdb_init(void)
 489 {
 490         struct kdb_dbbe *be, **iter;
 491         int cur_pri, pri;
 492
 493         kdb_active = 0;
 494         kdb_dbbe = NULL;
 495         cur_pri = -1;
 496         SET_FOREACH(iter, kdb_dbbe_set) {
 497                 be = *iter;
 498                 pri = (be->dbbe_init != NULL) ? be->dbbe_init() : -1;
 499                 be->dbbe_active = (pri >= 0) ? 0 : -1;
 500                 if (pri > cur_pri) {
 501                         cur_pri = pri;
 502                         kdb_dbbe = be;
 503                 }
 504         }
 505         if (kdb_dbbe != NULL) {
 506                 printf("KDB: debugger backends:");
 507                 SET_FOREACH(iter, kdb_dbbe_set) {
 508                         be = *iter;
 509                         if (be->dbbe_active == 0)
 510                                 printf(" %s", be->dbbe_name);
 511                 }
 512                 printf("\n");
 513                 printf("KDB: current backend: %s\n",
 514                     kdb_dbbe->dbbe_name);
 515         }
 516 }
 517
 518 /*
 519  * Handle contexts.
 520  */
 521
 522 void *
 523 kdb_jmpbuf(jmp_buf new)
 524 {
 525         void *old;
 526
 527         old = kdb_jmpbufp;
 528         kdb_jmpbufp = new;
 529         return (old);
 530 }
 531
 532 void
 533 kdb_reenter(void)
 534 {
 535
 536         if (!kdb_active || kdb_jmpbufp == NULL)
 537                 return;
 538
 539         printf("KDB: reentering\n");
 540         kdb_backtrace();
 541         longjmp(kdb_jmpbufp, 1);
 542         /* NOTREACHED */
 543 }
 544
 545 /*
 546  * Thread related support functions.
 547  */
 548
 549 struct pcb *
 550 kdb_thr_ctx(struct thread *thr)
 551 {
 552 #if defined(SMP) && defined(KDB_STOPPEDPCB)
 553         struct pcpu *pc;
 554 #endif
 555
 556         if (thr == curthread)
 557                 return (&kdb_pcb);
 558
 559 #if defined(SMP) && defined(KDB_STOPPEDPCB)
 560         STAILQ_FOREACH(pc, &cpuhead, pc_allcpu)  {
 561                 if (pc->pc_curthread == thr &&
 562                     CPU_ISSET(pc->pc_cpuid, &stopped_cpus))
 563                         return (KDB_STOPPEDPCB(pc));
 564         }
 565 #endif
 566         return (thr->td_pcb);
 567 }
 568
 569 struct thread *
 570 kdb_thr_first(void)
 571 {
 572         struct proc *p;
 573         struct thread *thr;
 574
 575         p = LIST_FIRST(&allproc);
 576         while (p != NULL) {
 577                 if (p->p_flag & P_INMEM) {
 578                         thr = FIRST_THREAD_IN_PROC(p);
 579                         if (thr != NULL)
 580                                 return (thr);
 581                 }
 582                 p = LIST_NEXT(p, p_list);
 583         }
 584         return (NULL);
 585 }
 586
 587 struct thread *
 588 kdb_thr_from_pid(pid_t pid)
 589 {
 590         struct proc *p;
 591
 592         p = LIST_FIRST(&allproc);
 593         while (p != NULL) {
 594                 if (p->p_flag & P_INMEM && p->p_pid == pid)
 595                         return (FIRST_THREAD_IN_PROC(p));
 596                 p = LIST_NEXT(p, p_list);
 597         }
 598         return (NULL);
 599 }
 600
 601 struct thread *
 602 kdb_thr_lookup(lwpid_t tid)
 603 {
 604         struct thread *thr;
 605
 606         thr = kdb_thr_first();
 607         while (thr != NULL && thr->td_tid != tid)
 608                 thr = kdb_thr_next(thr);
 609         return (thr);
 610 }
 611
 612 struct thread *
 613 kdb_thr_next(struct thread *thr)
 614 {
 615         struct proc *p;
 616
 617         p = thr->td_proc;
 618         thr = TAILQ_NEXT(thr, td_plist);
 619         do {
 620                 if (thr != NULL)
 621                         return (thr);
 622                 p = LIST_NEXT(p, p_list);
 623                 if (p != NULL && (p->p_flag & P_INMEM))
 624                         thr = FIRST_THREAD_IN_PROC(p);
 625         } while (p != NULL);
 626         return (NULL);
 627 }
 628
 629 int
 630 kdb_thr_select(struct thread *thr)
 631 {
 632         if (thr == NULL)
 633                 return (EINVAL);
 634         kdb_thread = thr;
 635         kdb_thrctx = kdb_thr_ctx(thr);
 636         return (0);
 637 }
 638
 639 /*
 640  * Enter the debugger due to a trap.
 641  */
 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 #ifdef SMP
 653         int did_stop_cpus;
 654 #endif
 655
 656         be = kdb_dbbe;
 657         if (be == NULL || be->dbbe_trap == NULL)
 658                 return (0);
 659
 660         /* We reenter the debugger through kdb_reenter(). */
 661         if (kdb_active)
 662                 return (0);
 663
 664         intr = intr_disable();
 665
 666 #ifdef SMP
 667         if (!SCHEDULER_STOPPED()) {
 668                 other_cpus = all_cpus;
 669                 CPU_CLR(PCPU_GET(cpuid), &other_cpus);
 670                 stop_cpus_hard(other_cpus);
 671                 did_stop_cpus = 1;
 672         } else
 673                 did_stop_cpus = 0;
 674 #endif
 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 #ifdef SMP
 703         if (did_stop_cpus)
 704                 restart_cpus(stopped_cpus);
 705 #endif
 706
 707         intr_restore(intr);
 708
 709         return (handled);
 710 }