sys/kern/subr_kdb.c

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