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