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 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 #ifdef SMP 631 struct pcpu *pc; 632 #endif 633 634 if (thr == curthread) 635 return (&kdb_pcb); 636 637 #ifdef SMP 638 STAILQ_FOREACH(pc, &cpuhead, pc_allcpu) { 639 if (pc->pc_curthread == thr && 640 CPU_ISSET(pc->pc_cpuid, &stopped_cpus)) 641 return (&stoppcbs[pc->pc_cpuid]); 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 } 806