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