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
 262 void
 263 kdb_panic(const char *msg)
 264 {
 265
 266         printf("KDB: panic\n");
 267         panic("%s", msg);
 268 }
 269
 270 void
 271 kdb_reboot(void)
 272 {
 273
 274         printf("KDB: reboot requested\n");
 275         shutdown_nice(0);
 276 }
 277
 278 /*
 279  * Solaris implements a new BREAK which is initiated by a character sequence
 280  * CR ~ ^b which is similar to a familiar pattern used on Sun servers by the
 281  * Remote Console.
 282  *
 283  * Note that this function may be called from almost anywhere, with interrupts
 284  * disabled and with unknown locks held, so it must not access data other than
 285  * its arguments.  Its up to the caller to ensure that the state variable is
 286  * consistent.
 287  */
 288 #define KEY_CR          13      /* CR '\r' */
 289 #define KEY_TILDE       126     /* ~ */
 290 #define KEY_CRTLB       2       /* ^B */
 291 #define KEY_CRTLP       16      /* ^P */
 292 #define KEY_CRTLR       18      /* ^R */
 293
 294 /* States of th KDB "alternate break sequence" detecting state machine. */
 295 enum {
 296         KDB_ALT_BREAK_SEEN_NONE,
 297         KDB_ALT_BREAK_SEEN_CR,
 298         KDB_ALT_BREAK_SEEN_CR_TILDE,
 299 };
 300
 301 int
 302 kdb_break(void)
 303 {
 304
 305         if (!kdb_break_to_debugger)
 306                 return (0);
 307         kdb_enter(KDB_WHY_BREAK, "Break to debugger");
 308         return (KDB_REQ_DEBUGGER);
 309 }
 310
 311 static int
 312 kdb_alt_break_state(int key, int *state)
 313 {
 314         int brk;
 315
 316         /* All states transition to KDB_ALT_BREAK_SEEN_CR on a CR. */
 317         if (key == KEY_CR) {
 318                 *state = KDB_ALT_BREAK_SEEN_CR;
 319                 return (0);
 320         }
 321
 322         brk = 0;
 323         switch (*state) {
 324         case KDB_ALT_BREAK_SEEN_CR:
 325                 *state = KDB_ALT_BREAK_SEEN_NONE;
 326                 if (key == KEY_TILDE)
 327                         *state = KDB_ALT_BREAK_SEEN_CR_TILDE;
 328                 break;
 329         case KDB_ALT_BREAK_SEEN_CR_TILDE:
 330                 *state = KDB_ALT_BREAK_SEEN_NONE;
 331                 if (key == KEY_CRTLB)
 332                         brk = KDB_REQ_DEBUGGER;
 333                 else if (key == KEY_CRTLP)
 334                         brk = KDB_REQ_PANIC;
 335                 else if (key == KEY_CRTLR)
 336                         brk = KDB_REQ_REBOOT;
 337                 break;
 338         case KDB_ALT_BREAK_SEEN_NONE:
 339         default:
 340                 *state = KDB_ALT_BREAK_SEEN_NONE;
 341                 break;
 342         }
 343         return (brk);
 344 }
 345
 346 static int
 347 kdb_alt_break_internal(int key, int *state, int force_gdb)
 348 {
 349         int brk;
 350
 351         if (!kdb_alt_break_to_debugger)
 352                 return (0);
 353         brk = kdb_alt_break_state(key, state);
 354         switch (brk) {
 355         case KDB_REQ_DEBUGGER:
 356                 if (force_gdb)
 357                         kdb_dbbe_select("gdb");
 358                 kdb_enter(KDB_WHY_BREAK, "Break to debugger");
 359                 break;
 360
 361         case KDB_REQ_PANIC:
 362                 if (force_gdb)
 363                         kdb_dbbe_select("gdb");
 364                 kdb_panic("Panic sequence on console");
 365                 break;
 366
 367         case KDB_REQ_REBOOT:
 368                 kdb_reboot();
 369                 break;
 370         }
 371         return (0);
 372 }
 373
 374 int
 375 kdb_alt_break(int key, int *state)
 376 {
 377
 378         return (kdb_alt_break_internal(key, state, 0));
 379 }
 380
 381 /*
 382  * This variation on kdb_alt_break() is used only by dcons, which has its own
 383  * configuration flag to force GDB use regardless of the global KDB
 384  * configuration.
 385  */
 386 int
 387 kdb_alt_break_gdb(int key, int *state)
 388 {
 389
 390         return (kdb_alt_break_internal(key, state, 1));
 391 }
 392
 393 /*
 394  * Print a backtrace of the calling thread. The backtrace is generated by
 395  * the selected debugger, provided it supports backtraces. If no debugger
 396  * is selected or the current debugger does not support backtraces, this
 397  * function silently returns.
 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 int
 447 kdb_dbbe_select(const char *name)
 448 {
 449         struct kdb_dbbe *be, **iter;
 450
 451         SET_FOREACH(iter, kdb_dbbe_set) {
 452                 be = *iter;
 453                 if (be->dbbe_active == 0 && strcmp(be->dbbe_name, name) == 0) {
 454                         kdb_dbbe = be;
 455                         return (0);
 456                 }
 457         }
 458         return (EINVAL);
 459 }
 460
 461 /*
 462  * Enter the currently selected debugger. If a message has been provided,
 463  * it is printed first. If the debugger does not support the enter method,
 464  * it is entered by using breakpoint(), which enters the debugger through
 465  * kdb_trap().  The 'why' argument will contain a more mechanically usable
 466  * string than 'msg', and is relied upon by DDB scripting to identify the
 467  * reason for entering the debugger so that the right script can be run.
 468  */
 469 void
 470 kdb_enter(const char *why, const char *msg)
 471 {
 472
 473         if (kdb_dbbe != NULL && kdb_active == 0) {
 474                 if (msg != NULL)
 475                         printf("KDB: enter: %s\n", msg);
 476                 kdb_why = why;
 477                 breakpoint();
 478                 kdb_why = KDB_WHY_UNSET;
 479         }
 480 }
 481
 482 /*
 483  * Initialize the kernel debugger interface.
 484  */
 485 void
 486 kdb_init(void)
 487 {
 488         struct kdb_dbbe *be, **iter;
 489         int cur_pri, pri;
 490
 491         kdb_active = 0;
 492         kdb_dbbe = NULL;
 493         cur_pri = -1;
 494         SET_FOREACH(iter, kdb_dbbe_set) {
 495                 be = *iter;
 496                 pri = (be->dbbe_init != NULL) ? be->dbbe_init() : -1;
 497                 be->dbbe_active = (pri >= 0) ? 0 : -1;
 498                 if (pri > cur_pri) {
 499                         cur_pri = pri;
 500                         kdb_dbbe = be;
 501                 }
 502         }
 503         if (kdb_dbbe != NULL) {
 504                 printf("KDB: debugger backends:");
 505                 SET_FOREACH(iter, kdb_dbbe_set) {
 506                         be = *iter;
 507                         if (be->dbbe_active == 0)
 508                                 printf(" %s", be->dbbe_name);
 509                 }
 510                 printf("\n");
 511                 printf("KDB: current backend: %s\n",
 512                     kdb_dbbe->dbbe_name);
 513         }
 514 }
 515
 516 /*
 517  * Handle contexts.
 518  */
 519 void *
 520 kdb_jmpbuf(jmp_buf new)
 521 {
 522         void *old;
 523
 524         old = kdb_jmpbufp;
 525         kdb_jmpbufp = new;
 526         return (old);
 527 }
 528
 529 void
 530 kdb_reenter(void)
 531 {
 532
 533         if (!kdb_active || kdb_jmpbufp == NULL)
 534                 return;
 535
 536         printf("KDB: reentering\n");
 537         kdb_backtrace();
 538         longjmp(kdb_jmpbufp, 1);
 539         /* NOTREACHED */
 540 }
 541
 542 void
 543 kdb_reenter_silent(void)
 544 {
 545
 546         if (!kdb_active || kdb_jmpbufp == NULL)
 547                 return;
 548
 549         longjmp(kdb_jmpbufp, 1);
 550         /* NOTREACHED */
 551 }
 552
 553 /*
 554  * Thread-related support functions.
 555  */
 556 struct pcb *
 557 kdb_thr_ctx(struct thread *thr)
 558 {
 559 #if defined(SMP) && defined(KDB_STOPPEDPCB)
 560         struct pcpu *pc;
 561 #endif
 562
 563         if (thr == curthread)
 564                 return (&kdb_pcb);
 565
 566 #if defined(SMP) && defined(KDB_STOPPEDPCB)
 567         STAILQ_FOREACH(pc, &cpuhead, pc_allcpu)  {
 568                 if (pc->pc_curthread == thr &&
 569                     CPU_ISSET(pc->pc_cpuid, &stopped_cpus))
 570                         return (KDB_STOPPEDPCB(pc));
 571         }
 572 #endif
 573         return (thr->td_pcb);
 574 }
 575
 576 struct thread *
 577 kdb_thr_first(void)
 578 {
 579         struct proc *p;
 580         struct thread *thr;
 581
 582         FOREACH_PROC_IN_SYSTEM(p) {
 583                 if (p->p_flag & P_INMEM) {
 584                         thr = FIRST_THREAD_IN_PROC(p);
 585                         if (thr != NULL)
 586                                 return (thr);
 587                 }
 588         }
 589         return (NULL);
 590 }
 591
 592 struct thread *
 593 kdb_thr_from_pid(pid_t pid)
 594 {
 595         struct proc *p;
 596
 597         FOREACH_PROC_IN_SYSTEM(p) {
 598                 if (p->p_flag & P_INMEM && p->p_pid == pid)
 599                         return (FIRST_THREAD_IN_PROC(p));
 600         }
 601         return (NULL);
 602 }
 603
 604 struct thread *
 605 kdb_thr_lookup(lwpid_t tid)
 606 {
 607         struct thread *thr;
 608
 609         thr = kdb_thr_first();
 610         while (thr != NULL && thr->td_tid != tid)
 611                 thr = kdb_thr_next(thr);
 612         return (thr);
 613 }
 614
 615 struct thread *
 616 kdb_thr_next(struct thread *thr)
 617 {
 618         struct proc *p;
 619
 620         p = thr->td_proc;
 621         thr = TAILQ_NEXT(thr, td_plist);
 622         do {
 623                 if (thr != NULL)
 624                         return (thr);
 625                 p = LIST_NEXT(p, p_list);
 626                 if (p != NULL && (p->p_flag & P_INMEM))
 627                         thr = FIRST_THREAD_IN_PROC(p);
 628         } while (p != NULL);
 629         return (NULL);
 630 }
 631
 632 int
 633 kdb_thr_select(struct thread *thr)
 634 {
 635         if (thr == NULL)
 636                 return (EINVAL);
 637         kdb_thread = thr;
 638         kdb_thrctx = kdb_thr_ctx(thr);
 639         return (0);
 640 }
 641
 642 /*
 643  * Enter the debugger due to a trap.
 644  */
 645 int
 646 kdb_trap(int type, int code, struct trapframe *tf)
 647 {
 648 #ifdef SMP
 649         cpuset_t other_cpus;
 650 #endif
 651         struct kdb_dbbe *be;
 652         register_t intr;
 653         int handled;
 654         int did_stop_cpus;
 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         if (!SCHEDULER_STOPPED()) {
 667 #ifdef SMP
 668                 other_cpus = all_cpus;
 669                 CPU_ANDNOT(&other_cpus, &stopped_cpus);
 670                 CPU_CLR(PCPU_GET(cpuid), &other_cpus);
 671                 stop_cpus_hard(other_cpus);
 672 #endif
 673                 curthread->td_stopsched = 1;
 674                 did_stop_cpus = 1;
 675         } else
 676                 did_stop_cpus = 0;
 677
 678         kdb_active++;
 679
 680         kdb_frame = tf;
 681
 682         /* Let MD code do its thing first... */
 683         kdb_cpu_trap(type, code);
 684
 685         makectx(tf, &kdb_pcb);
 686         kdb_thr_select(curthread);
 687
 688         cngrab();
 689
 690         for (;;) {
 691                 handled = be->dbbe_trap(type, code);
 692                 if (be == kdb_dbbe)
 693                         break;
 694                 be = kdb_dbbe;
 695                 if (be == NULL || be->dbbe_trap == NULL)
 696                         break;
 697                 printf("Switching to %s back-end\n", be->dbbe_name);
 698         }
 699
 700         cnungrab();
 701
 702         kdb_active--;
 703
 704         if (did_stop_cpus) {
 705                 curthread->td_stopsched = 0;
 706 #ifdef SMP
 707                 CPU_AND(&other_cpus, &stopped_cpus);
 708                 restart_cpus(other_cpus);
 709 #endif
 710         }
 711
 712         intr_restore(intr);
 713
 714         return (handled);
 715 }