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