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 #define KEY_CR 13 /* CR '\r' */ 254 #define KEY_TILDE 126 /* ~ */ 255 #define KEY_CRTLB 2 /* ^B */ 256 #define KEY_CRTLP 16 /* ^P */ 257 #define KEY_CRTLR 18 /* ^R */ 258 259 /* States of th KDB "alternate break sequence" detecting state machine. */ 260 enum { 261 KDB_ALT_BREAK_SEEN_NONE, 262 KDB_ALT_BREAK_SEEN_CR, 263 KDB_ALT_BREAK_SEEN_CR_TILDE, 264 }; 265 266 int 267 kdb_break(void) 268 { 269 270 if (!kdb_break_to_debugger) 271 return (0); 272 kdb_enter(KDB_WHY_BREAK, "Break to debugger"); 273 return (KDB_REQ_DEBUGGER); 274 } 275 276 static int 277 kdb_alt_break_state(int key, int *state) 278 { 279 int brk; 280 281 /* All states transition to KDB_ALT_BREAK_SEEN_CR on a CR. */ 282 if (key == KEY_CR) { 283 *state = KDB_ALT_BREAK_SEEN_CR; 284 return (0); 285 } 286 287 brk = 0; 288 switch (*state) { 289 case KDB_ALT_BREAK_SEEN_CR: 290 *state = KDB_ALT_BREAK_SEEN_NONE; 291 if (key == KEY_TILDE) 292 *state = KDB_ALT_BREAK_SEEN_CR_TILDE; 293 break; 294 case KDB_ALT_BREAK_SEEN_CR_TILDE: 295 *state = KDB_ALT_BREAK_SEEN_NONE; 296 if (key == KEY_CRTLB) 297 brk = KDB_REQ_DEBUGGER; 298 else if (key == KEY_CRTLP) 299 brk = KDB_REQ_PANIC; 300 else if (key == KEY_CRTLR) 301 brk = KDB_REQ_REBOOT; 302 break; 303 case KDB_ALT_BREAK_SEEN_NONE: 304 default: 305 *state = KDB_ALT_BREAK_SEEN_NONE; 306 break; 307 } 308 return (brk); 309 } 310 311 static int 312 kdb_alt_break_internal(int key, int *state, int force_gdb) 313 { 314 int brk; 315 316 if (!kdb_alt_break_to_debugger) 317 return (0); 318 brk = kdb_alt_break_state(key, state); 319 switch (brk) { 320 case KDB_REQ_DEBUGGER: 321 if (force_gdb) 322 kdb_dbbe_select("gdb"); 323 kdb_enter(KDB_WHY_BREAK, "Break to debugger"); 324 break; 325 326 case KDB_REQ_PANIC: 327 if (force_gdb) 328 kdb_dbbe_select("gdb"); 329 kdb_panic("Panic sequence on console"); 330 break; 331 332 case KDB_REQ_REBOOT: 333 kdb_reboot(); 334 break; 335 } 336 return (0); 337 } 338 339 int 340 kdb_alt_break(int key, int *state) 341 { 342 343 return (kdb_alt_break_internal(key, state, 0)); 344 } 345 346 /* 347 * This variation on kdb_alt_break() is used only by dcons, which has its own 348 * configuration flag to force GDB use regardless of the global KDB 349 * configuration. 350 */ 351 int 352 kdb_alt_break_gdb(int key, int *state) 353 { 354 355 return (kdb_alt_break_internal(key, state, 1)); 356 } 357 358 /* 359 * Print a backtrace of the calling thread. The backtrace is generated by 360 * the selected debugger, provided it supports backtraces. If no debugger 361 * is selected or the current debugger does not support backtraces, this 362 * function silently returns. 363 */ 364 void 365 kdb_backtrace(void) 366 { 367 368 if (kdb_dbbe != NULL && kdb_dbbe->dbbe_trace != NULL) { 369 printf("KDB: stack backtrace:\n"); 370 kdb_dbbe->dbbe_trace(); 371 } 372 #ifdef STACK 373 else { 374 struct stack st; 375 376 printf("KDB: stack backtrace:\n"); 377 stack_zero(&st); 378 stack_save(&st); 379 stack_print_ddb(&st); 380 } 381 #endif 382 } 383 384 /* 385 * Similar to kdb_backtrace() except that it prints a backtrace of an 386 * arbitrary thread rather than the calling thread. 387 */ 388 void 389 kdb_backtrace_thread(struct thread *td) 390 { 391 392 if (kdb_dbbe != NULL && kdb_dbbe->dbbe_trace_thread != NULL) { 393 printf("KDB: stack backtrace of thread %d:\n", td->td_tid); 394 kdb_dbbe->dbbe_trace_thread(td); 395 } 396 #ifdef STACK 397 else { 398 struct stack st; 399 400 printf("KDB: stack backtrace of thread %d:\n", td->td_tid); 401 stack_zero(&st); 402 stack_save_td(&st, td); 403 stack_print_ddb(&st); 404 } 405 #endif 406 } 407 408 /* 409 * Set/change the current backend. 410 */ 411 int 412 kdb_dbbe_select(const char *name) 413 { 414 struct kdb_dbbe *be, **iter; 415 416 SET_FOREACH(iter, kdb_dbbe_set) { 417 be = *iter; 418 if (be->dbbe_active == 0 && strcmp(be->dbbe_name, name) == 0) { 419 kdb_dbbe = be; 420 return (0); 421 } 422 } 423 return (EINVAL); 424 } 425 426 /* 427 * Enter the currently selected debugger. If a message has been provided, 428 * it is printed first. If the debugger does not support the enter method, 429 * it is entered by using breakpoint(), which enters the debugger through 430 * kdb_trap(). The 'why' argument will contain a more mechanically usable 431 * string than 'msg', and is relied upon by DDB scripting to identify the 432 * reason for entering the debugger so that the right script can be run. 433 */ 434 void 435 kdb_enter(const char *why, const char *msg) 436 { 437 438 if (kdb_dbbe != NULL && kdb_active == 0) { 439 if (msg != NULL) 440 printf("KDB: enter: %s\n", msg); 441 kdb_why = why; 442 breakpoint(); 443 kdb_why = KDB_WHY_UNSET; 444 } 445 } 446 447 /* 448 * Initialize the kernel debugger interface. 449 */ 450 void 451 kdb_init(void) 452 { 453 struct kdb_dbbe *be, **iter; 454 int cur_pri, pri; 455 456 kdb_active = 0; 457 kdb_dbbe = NULL; 458 cur_pri = -1; 459 SET_FOREACH(iter, kdb_dbbe_set) { 460 be = *iter; 461 pri = (be->dbbe_init != NULL) ? be->dbbe_init() : -1; 462 be->dbbe_active = (pri >= 0) ? 0 : -1; 463 if (pri > cur_pri) { 464 cur_pri = pri; 465 kdb_dbbe = be; 466 } 467 } 468 if (kdb_dbbe != NULL) { 469 printf("KDB: debugger backends:"); 470 SET_FOREACH(iter, kdb_dbbe_set) { 471 be = *iter; 472 if (be->dbbe_active == 0) 473 printf(" %s", be->dbbe_name); 474 } 475 printf("\n"); 476 printf("KDB: current backend: %s\n", 477 kdb_dbbe->dbbe_name); 478 } 479 } 480 481 /* 482 * Handle contexts. 483 */ 484 void * 485 kdb_jmpbuf(jmp_buf new) 486 { 487 void *old; 488 489 old = kdb_jmpbufp; 490 kdb_jmpbufp = new; 491 return (old); 492 } 493 494 void 495 kdb_reenter(void) 496 { 497 498 if (!kdb_active || kdb_jmpbufp == NULL) 499 return; 500 501 printf("KDB: reentering\n"); 502 kdb_backtrace(); 503 longjmp(kdb_jmpbufp, 1); 504 /* NOTREACHED */ 505 } 506 507 void 508 kdb_reenter_silent(void) 509 { 510 511 if (!kdb_active || kdb_jmpbufp == NULL) 512 return; 513 514 longjmp(kdb_jmpbufp, 1); 515 /* NOTREACHED */ 516 } 517 518 /* 519 * Thread-related support functions. 520 */ 521 struct pcb * 522 kdb_thr_ctx(struct thread *thr) 523 { 524 #if defined(SMP) && defined(KDB_STOPPEDPCB) 525 struct pcpu *pc; 526 #endif 527 528 if (thr == curthread) 529 return (&kdb_pcb); 530 531 #if defined(SMP) && defined(KDB_STOPPEDPCB) 532 STAILQ_FOREACH(pc, &cpuhead, pc_allcpu) { 533 if (pc->pc_curthread == thr && 534 CPU_ISSET(pc->pc_cpuid, &stopped_cpus)) 535 return (KDB_STOPPEDPCB(pc)); 536 } 537 #endif 538 return (thr->td_pcb); 539 } 540 541 struct thread * 542 kdb_thr_first(void) 543 { 544 struct proc *p; 545 struct thread *thr; 546 547 p = LIST_FIRST(&allproc); 548 while (p != NULL) { 549 if (p->p_flag & P_INMEM) { 550 thr = FIRST_THREAD_IN_PROC(p); 551 if (thr != NULL) 552 return (thr); 553 } 554 p = LIST_NEXT(p, p_list); 555 } 556 return (NULL); 557 } 558 559 struct thread * 560 kdb_thr_from_pid(pid_t pid) 561 { 562 struct proc *p; 563 564 p = LIST_FIRST(&allproc); 565 while (p != NULL) { 566 if (p->p_flag & P_INMEM && p->p_pid == pid) 567 return (FIRST_THREAD_IN_PROC(p)); 568 p = LIST_NEXT(p, p_list); 569 } 570 return (NULL); 571 } 572 573 struct thread * 574 kdb_thr_lookup(lwpid_t tid) 575 { 576 struct thread *thr; 577 578 thr = kdb_thr_first(); 579 while (thr != NULL && thr->td_tid != tid) 580 thr = kdb_thr_next(thr); 581 return (thr); 582 } 583 584 struct thread * 585 kdb_thr_next(struct thread *thr) 586 { 587 struct proc *p; 588 589 p = thr->td_proc; 590 thr = TAILQ_NEXT(thr, td_plist); 591 do { 592 if (thr != NULL) 593 return (thr); 594 p = LIST_NEXT(p, p_list); 595 if (p != NULL && (p->p_flag & P_INMEM)) 596 thr = FIRST_THREAD_IN_PROC(p); 597 } while (p != NULL); 598 return (NULL); 599 } 600 601 int 602 kdb_thr_select(struct thread *thr) 603 { 604 if (thr == NULL) 605 return (EINVAL); 606 kdb_thread = thr; 607 kdb_thrctx = kdb_thr_ctx(thr); 608 return (0); 609 } 610 611 /* 612 * Enter the debugger due to a trap. 613 */ 614 int 615 kdb_trap(int type, int code, struct trapframe *tf) 616 { 617 #ifdef SMP 618 cpuset_t other_cpus; 619 #endif 620 struct kdb_dbbe *be; 621 register_t intr; 622 int handled; 623 #ifdef SMP 624 int did_stop_cpus; 625 #endif 626 627 be = kdb_dbbe; 628 if (be == NULL || be->dbbe_trap == NULL) 629 return (0); 630 631 /* We reenter the debugger through kdb_reenter(). */ 632 if (kdb_active) 633 return (0); 634 635 intr = intr_disable(); 636 637 #ifdef SMP 638 if (!SCHEDULER_STOPPED()) { 639 other_cpus = all_cpus; 640 CPU_CLR(PCPU_GET(cpuid), &other_cpus); 641 stop_cpus_hard(other_cpus); 642 did_stop_cpus = 1; 643 } else 644 did_stop_cpus = 0; 645 #endif 646 647 kdb_active++; 648 649 kdb_frame = tf; 650 651 /* Let MD code do its thing first... */ 652 kdb_cpu_trap(type, code); 653 654 makectx(tf, &kdb_pcb); 655 kdb_thr_select(curthread); 656 657 cngrab(); 658 659 for (;;) { 660 handled = be->dbbe_trap(type, code); 661 if (be == kdb_dbbe) 662 break; 663 be = kdb_dbbe; 664 if (be == NULL || be->dbbe_trap == NULL) 665 break; 666 printf("Switching to %s back-end\n", be->dbbe_name); 667 } 668 669 cnungrab(); 670 671 kdb_active--; 672 673 #ifdef SMP 674 if (did_stop_cpus) 675 restart_cpus(stopped_cpus); 676 #endif 677 678 intr_restore(intr); 679 680 return (handled); 681 } 682