1 /*- 2 * Copyright (c) 2004 The FreeBSD Project 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 #include "opt_kdb.h" 31 #include "opt_stack.h" 32 33 #include <sys/param.h> 34 #include <sys/systm.h> 35 #include <sys/kdb.h> 36 #include <sys/kernel.h> 37 #include <sys/malloc.h> 38 #include <sys/pcpu.h> 39 #include <sys/proc.h> 40 #include <sys/smp.h> 41 #include <sys/stack.h> 42 #include <sys/sysctl.h> 43 44 #include <machine/kdb.h> 45 #include <machine/pcb.h> 46 47 #ifdef SMP 48 #include <machine/smp.h> 49 #endif 50 51 int kdb_active = 0; 52 static void *kdb_jmpbufp = NULL; 53 struct kdb_dbbe *kdb_dbbe = NULL; 54 static struct pcb kdb_pcb; 55 struct pcb *kdb_thrctx = NULL; 56 struct thread *kdb_thread = NULL; 57 struct trapframe *kdb_frame = NULL; 58 59 KDB_BACKEND(null, NULL, NULL, NULL); 60 SET_DECLARE(kdb_dbbe_set, struct kdb_dbbe); 61 62 static int kdb_sysctl_available(SYSCTL_HANDLER_ARGS); 63 static int kdb_sysctl_current(SYSCTL_HANDLER_ARGS); 64 static int kdb_sysctl_enter(SYSCTL_HANDLER_ARGS); 65 static int kdb_sysctl_panic(SYSCTL_HANDLER_ARGS); 66 static int kdb_sysctl_trap(SYSCTL_HANDLER_ARGS); 67 static int kdb_sysctl_trap_code(SYSCTL_HANDLER_ARGS); 68 69 SYSCTL_NODE(_debug, OID_AUTO, kdb, CTLFLAG_RW, NULL, "KDB nodes"); 70 71 SYSCTL_PROC(_debug_kdb, OID_AUTO, available, CTLTYPE_STRING | CTLFLAG_RD, NULL, 72 0, kdb_sysctl_available, "A", "list of available KDB backends"); 73 74 SYSCTL_PROC(_debug_kdb, OID_AUTO, current, CTLTYPE_STRING | CTLFLAG_RW, NULL, 75 0, kdb_sysctl_current, "A", "currently selected KDB backend"); 76 77 SYSCTL_PROC(_debug_kdb, OID_AUTO, enter, CTLTYPE_INT | CTLFLAG_RW, NULL, 0, 78 kdb_sysctl_enter, "I", "set to enter the debugger"); 79 80 SYSCTL_PROC(_debug_kdb, OID_AUTO, panic, CTLTYPE_INT | CTLFLAG_RW, NULL, 0, 81 kdb_sysctl_panic, "I", "set to panic the kernel"); 82 83 SYSCTL_PROC(_debug_kdb, OID_AUTO, trap, CTLTYPE_INT | CTLFLAG_RW, NULL, 0, 84 kdb_sysctl_trap, "I", "set to cause a page fault via data access"); 85 86 SYSCTL_PROC(_debug_kdb, OID_AUTO, trap_code, CTLTYPE_INT | CTLFLAG_RW, NULL, 0, 87 kdb_sysctl_trap_code, "I", "set to cause a page fault via code access"); 88 89 /* 90 * Flag indicating whether or not to IPI the other CPUs to stop them on 91 * entering the debugger. Sometimes, this will result in a deadlock as 92 * stop_cpus() waits for the other cpus to stop, so we allow it to be 93 * disabled. In order to maximize the chances of success, use a hard 94 * stop for that. 95 */ 96 #ifdef SMP 97 static int kdb_stop_cpus = 1; 98 SYSCTL_INT(_debug_kdb, OID_AUTO, stop_cpus, CTLFLAG_RW | CTLFLAG_TUN, 99 &kdb_stop_cpus, 0, "stop other CPUs when entering the debugger"); 100 TUNABLE_INT("debug.kdb.stop_cpus", &kdb_stop_cpus); 101 #endif 102 103 /* 104 * Flag to indicate to debuggers why the debugger was entered. 105 */ 106 const char * volatile kdb_why = KDB_WHY_UNSET; 107 108 static int 109 kdb_sysctl_available(SYSCTL_HANDLER_ARGS) 110 { 111 struct kdb_dbbe *be, **iter; 112 char *avail, *p; 113 ssize_t len, sz; 114 int error; 115 116 sz = 0; 117 SET_FOREACH(iter, kdb_dbbe_set) { 118 be = *iter; 119 if (be->dbbe_active == 0) 120 sz += strlen(be->dbbe_name) + 1; 121 } 122 sz++; 123 avail = malloc(sz, M_TEMP, M_WAITOK); 124 p = avail; 125 *p = '\0'; 126 127 SET_FOREACH(iter, kdb_dbbe_set) { 128 be = *iter; 129 if (be->dbbe_active == 0) { 130 len = snprintf(p, sz, "%s ", be->dbbe_name); 131 p += len; 132 sz -= len; 133 } 134 } 135 KASSERT(sz >= 0, ("%s", __func__)); 136 error = sysctl_handle_string(oidp, avail, 0, req); 137 free(avail, M_TEMP); 138 return (error); 139 } 140 141 static int 142 kdb_sysctl_current(SYSCTL_HANDLER_ARGS) 143 { 144 char buf[16]; 145 int error; 146 147 if (kdb_dbbe != NULL) { 148 strncpy(buf, kdb_dbbe->dbbe_name, sizeof(buf)); 149 buf[sizeof(buf) - 1] = '\0'; 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 #ifdef SMP 232 stop_cpus_hard(PCPU_GET(other_cpus)); 233 #endif 234 printf("KDB: panic\n"); 235 panic("%s", msg); 236 } 237 238 void 239 kdb_reboot(void) 240 { 241 242 printf("KDB: reboot requested\n"); 243 shutdown_nice(0); 244 } 245 246 /* 247 * Solaris implements a new BREAK which is initiated by a character sequence 248 * CR ~ ^b which is similar to a familiar pattern used on Sun servers by the 249 * Remote Console. 250 * 251 * Note that this function may be called from almost anywhere, with interrupts 252 * disabled and with unknown locks held, so it must not access data other than 253 * its arguments. Its up to the caller to ensure that the state variable is 254 * consistent. 255 */ 256 257 #define KEY_CR 13 /* CR '\r' */ 258 #define KEY_TILDE 126 /* ~ */ 259 #define KEY_CRTLB 2 /* ^B */ 260 #define KEY_CRTLP 16 /* ^P */ 261 #define KEY_CRTLR 18 /* ^R */ 262 263 int 264 kdb_alt_break(int key, int *state) 265 { 266 int brk; 267 268 brk = 0; 269 switch (*state) { 270 case 0: 271 if (key == KEY_CR) 272 *state = 1; 273 break; 274 case 1: 275 if (key == KEY_TILDE) 276 *state = 2; 277 break; 278 case 2: 279 if (key == KEY_CRTLB) 280 brk = KDB_REQ_DEBUGGER; 281 else if (key == KEY_CRTLP) 282 brk = KDB_REQ_PANIC; 283 else if (key == KEY_CRTLR) 284 brk = KDB_REQ_REBOOT; 285 *state = 0; 286 } 287 return (brk); 288 } 289 290 /* 291 * Print a backtrace of the calling thread. The backtrace is generated by 292 * the selected debugger, provided it supports backtraces. If no debugger 293 * is selected or the current debugger does not support backtraces, this 294 * function silently returns. 295 */ 296 297 void 298 kdb_backtrace(void) 299 { 300 301 if (kdb_dbbe != NULL && kdb_dbbe->dbbe_trace != NULL) { 302 printf("KDB: stack backtrace:\n"); 303 kdb_dbbe->dbbe_trace(); 304 } 305 #ifdef STACK 306 else { 307 struct stack st; 308 309 printf("KDB: stack backtrace:\n"); 310 stack_save(&st); 311 stack_print_ddb(&st); 312 } 313 #endif 314 } 315 316 /* 317 * Set/change the current backend. 318 */ 319 320 int 321 kdb_dbbe_select(const char *name) 322 { 323 struct kdb_dbbe *be, **iter; 324 325 SET_FOREACH(iter, kdb_dbbe_set) { 326 be = *iter; 327 if (be->dbbe_active == 0 && strcmp(be->dbbe_name, name) == 0) { 328 kdb_dbbe = be; 329 return (0); 330 } 331 } 332 return (EINVAL); 333 } 334 335 /* 336 * Enter the currently selected debugger. If a message has been provided, 337 * it is printed first. If the debugger does not support the enter method, 338 * it is entered by using breakpoint(), which enters the debugger through 339 * kdb_trap(). The 'why' argument will contain a more mechanically usable 340 * string than 'msg', and is relied upon by DDB scripting to identify the 341 * reason for entering the debugger so that the right script can be run. 342 */ 343 void 344 kdb_enter(const char *why, const char *msg) 345 { 346 347 if (kdb_dbbe != NULL && kdb_active == 0) { 348 if (msg != NULL) 349 printf("KDB: enter: %s\n", msg); 350 kdb_why = why; 351 breakpoint(); 352 kdb_why = KDB_WHY_UNSET; 353 } 354 } 355 356 /* 357 * Initialize the kernel debugger interface. 358 */ 359 360 void 361 kdb_init(void) 362 { 363 struct kdb_dbbe *be, **iter; 364 int cur_pri, pri; 365 366 kdb_active = 0; 367 kdb_dbbe = NULL; 368 cur_pri = -1; 369 SET_FOREACH(iter, kdb_dbbe_set) { 370 be = *iter; 371 pri = (be->dbbe_init != NULL) ? be->dbbe_init() : -1; 372 be->dbbe_active = (pri >= 0) ? 0 : -1; 373 if (pri > cur_pri) { 374 cur_pri = pri; 375 kdb_dbbe = be; 376 } 377 } 378 if (kdb_dbbe != NULL) { 379 printf("KDB: debugger backends:"); 380 SET_FOREACH(iter, kdb_dbbe_set) { 381 be = *iter; 382 if (be->dbbe_active == 0) 383 printf(" %s", be->dbbe_name); 384 } 385 printf("\n"); 386 printf("KDB: current backend: %s\n", 387 kdb_dbbe->dbbe_name); 388 } 389 } 390 391 /* 392 * Handle contexts. 393 */ 394 395 void * 396 kdb_jmpbuf(jmp_buf new) 397 { 398 void *old; 399 400 old = kdb_jmpbufp; 401 kdb_jmpbufp = new; 402 return (old); 403 } 404 405 void 406 kdb_reenter(void) 407 { 408 409 if (!kdb_active || kdb_jmpbufp == NULL) 410 return; 411 412 longjmp(kdb_jmpbufp, 1); 413 /* NOTREACHED */ 414 } 415 416 /* 417 * Thread related support functions. 418 */ 419 420 struct pcb * 421 kdb_thr_ctx(struct thread *thr) 422 { 423 #if defined(SMP) && defined(KDB_STOPPEDPCB) 424 struct pcpu *pc; 425 #endif 426 427 if (thr == curthread) 428 return (&kdb_pcb); 429 430 #if defined(SMP) && defined(KDB_STOPPEDPCB) 431 SLIST_FOREACH(pc, &cpuhead, pc_allcpu) { 432 if (pc->pc_curthread == thr && (stopped_cpus & pc->pc_cpumask)) 433 return (KDB_STOPPEDPCB(pc)); 434 } 435 #endif 436 return (thr->td_pcb); 437 } 438 439 struct thread * 440 kdb_thr_first(void) 441 { 442 struct proc *p; 443 struct thread *thr; 444 445 p = LIST_FIRST(&allproc); 446 while (p != NULL) { 447 if (p->p_flag & P_INMEM) { 448 thr = FIRST_THREAD_IN_PROC(p); 449 if (thr != NULL) 450 return (thr); 451 } 452 p = LIST_NEXT(p, p_list); 453 } 454 return (NULL); 455 } 456 457 struct thread * 458 kdb_thr_from_pid(pid_t pid) 459 { 460 struct proc *p; 461 462 p = LIST_FIRST(&allproc); 463 while (p != NULL) { 464 if (p->p_flag & P_INMEM && p->p_pid == pid) 465 return (FIRST_THREAD_IN_PROC(p)); 466 p = LIST_NEXT(p, p_list); 467 } 468 return (NULL); 469 } 470 471 struct thread * 472 kdb_thr_lookup(lwpid_t tid) 473 { 474 struct thread *thr; 475 476 thr = kdb_thr_first(); 477 while (thr != NULL && thr->td_tid != tid) 478 thr = kdb_thr_next(thr); 479 return (thr); 480 } 481 482 struct thread * 483 kdb_thr_next(struct thread *thr) 484 { 485 struct proc *p; 486 487 p = thr->td_proc; 488 thr = TAILQ_NEXT(thr, td_plist); 489 do { 490 if (thr != NULL) 491 return (thr); 492 p = LIST_NEXT(p, p_list); 493 if (p != NULL && (p->p_flag & P_INMEM)) 494 thr = FIRST_THREAD_IN_PROC(p); 495 } while (p != NULL); 496 return (NULL); 497 } 498 499 int 500 kdb_thr_select(struct thread *thr) 501 { 502 if (thr == NULL) 503 return (EINVAL); 504 kdb_thread = thr; 505 kdb_thrctx = kdb_thr_ctx(thr); 506 return (0); 507 } 508 509 /* 510 * Enter the debugger due to a trap. 511 */ 512 513 int 514 kdb_trap(int type, int code, struct trapframe *tf) 515 { 516 register_t intr; 517 #ifdef SMP 518 int did_stop_cpus; 519 #endif 520 int handled; 521 522 if (kdb_dbbe == NULL || kdb_dbbe->dbbe_trap == NULL) 523 return (0); 524 525 /* We reenter the debugger through kdb_reenter(). */ 526 if (kdb_active) 527 return (0); 528 529 intr = intr_disable(); 530 531 #ifdef SMP 532 if ((did_stop_cpus = kdb_stop_cpus) != 0) 533 stop_cpus_hard(PCPU_GET(other_cpus)); 534 #endif 535 536 kdb_active++; 537 538 kdb_frame = tf; 539 540 /* Let MD code do its thing first... */ 541 kdb_cpu_trap(type, code); 542 543 makectx(tf, &kdb_pcb); 544 kdb_thr_select(curthread); 545 546 handled = kdb_dbbe->dbbe_trap(type, code); 547 548 kdb_active--; 549 550 #ifdef SMP 551 if (did_stop_cpus) 552 restart_cpus(stopped_cpus); 553 #endif 554 555 intr_restore(intr); 556 557 return (handled); 558 } 559