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