The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/subr_kdb.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    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: stable/10/sys/kern/subr_kdb.c 325460 2017-11-05 22:34:27Z ngie $");
   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/cons.h>
   36 #include <sys/kdb.h>
   37 #include <sys/kernel.h>
   38 #include <sys/malloc.h>
   39 #include <sys/pcpu.h>
   40 #include <sys/proc.h>
   41 #include <sys/sbuf.h>
   42 #include <sys/smp.h>
   43 #include <sys/stack.h>
   44 #include <sys/sysctl.h>
   45 
   46 #include <machine/kdb.h>
   47 #include <machine/pcb.h>
   48 
   49 #ifdef SMP
   50 #include <machine/smp.h>
   51 #endif
   52 
   53 int kdb_active = 0;
   54 static void *kdb_jmpbufp = NULL;
   55 struct kdb_dbbe *kdb_dbbe = NULL;
   56 static struct pcb kdb_pcb;
   57 struct pcb *kdb_thrctx = NULL;
   58 struct thread *kdb_thread = NULL;
   59 struct trapframe *kdb_frame = NULL;
   60 
   61 #ifdef BREAK_TO_DEBUGGER
   62 #define KDB_BREAK_TO_DEBUGGER   1
   63 #else
   64 #define KDB_BREAK_TO_DEBUGGER   0
   65 #endif
   66 
   67 #ifdef ALT_BREAK_TO_DEBUGGER
   68 #define KDB_ALT_BREAK_TO_DEBUGGER       1
   69 #else
   70 #define KDB_ALT_BREAK_TO_DEBUGGER       0
   71 #endif
   72 
   73 static int      kdb_break_to_debugger = KDB_BREAK_TO_DEBUGGER;
   74 static int      kdb_alt_break_to_debugger = KDB_ALT_BREAK_TO_DEBUGGER;
   75 
   76 KDB_BACKEND(null, NULL, NULL, NULL, NULL);
   77 SET_DECLARE(kdb_dbbe_set, struct kdb_dbbe);
   78 
   79 static int kdb_sysctl_available(SYSCTL_HANDLER_ARGS);
   80 static int kdb_sysctl_current(SYSCTL_HANDLER_ARGS);
   81 static int kdb_sysctl_enter(SYSCTL_HANDLER_ARGS);
   82 static int kdb_sysctl_panic(SYSCTL_HANDLER_ARGS);
   83 static int kdb_sysctl_trap(SYSCTL_HANDLER_ARGS);
   84 static int kdb_sysctl_trap_code(SYSCTL_HANDLER_ARGS);
   85 
   86 static SYSCTL_NODE(_debug, OID_AUTO, kdb, CTLFLAG_RW, NULL, "KDB nodes");
   87 
   88 SYSCTL_PROC(_debug_kdb, OID_AUTO, available, CTLTYPE_STRING | CTLFLAG_RD, NULL,
   89     0, kdb_sysctl_available, "A", "list of available KDB backends");
   90 
   91 SYSCTL_PROC(_debug_kdb, OID_AUTO, current, CTLTYPE_STRING | CTLFLAG_RW, NULL,
   92     0, kdb_sysctl_current, "A", "currently selected KDB backend");
   93 
   94 SYSCTL_PROC(_debug_kdb, OID_AUTO, enter,
   95     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE, NULL, 0,
   96     kdb_sysctl_enter, "I", "set to enter the debugger");
   97 
   98 SYSCTL_PROC(_debug_kdb, OID_AUTO, panic,
   99     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE, NULL, 0,
  100     kdb_sysctl_panic, "I", "set to panic the kernel");
  101 
  102 SYSCTL_PROC(_debug_kdb, OID_AUTO, trap,
  103     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE, NULL, 0,
  104     kdb_sysctl_trap, "I", "set to cause a page fault via data access");
  105 
  106 SYSCTL_PROC(_debug_kdb, OID_AUTO, trap_code,
  107     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE, NULL, 0,
  108     kdb_sysctl_trap_code, "I", "set to cause a page fault via code access");
  109 
  110 SYSCTL_INT(_debug_kdb, OID_AUTO, break_to_debugger,
  111     CTLFLAG_RWTUN | CTLFLAG_SECURE,
  112     &kdb_break_to_debugger, 0, "Enable break to debugger");
  113 TUNABLE_INT("debug.kdb.break_to_debugger", &kdb_break_to_debugger);
  114 
  115 SYSCTL_INT(_debug_kdb, OID_AUTO, alt_break_to_debugger,
  116     CTLFLAG_RWTUN | CTLFLAG_SECURE,
  117     &kdb_alt_break_to_debugger, 0, "Enable alternative break to debugger");
  118 TUNABLE_INT("debug.kdb.alt_break_to_debugger", &kdb_alt_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 /*
  513  * Thread related support functions.
  514  */
  515 
  516 struct pcb *
  517 kdb_thr_ctx(struct thread *thr)
  518 {
  519 #if defined(SMP) && defined(KDB_STOPPEDPCB)
  520         struct pcpu *pc;
  521 #endif
  522 
  523         if (thr == curthread)
  524                 return (&kdb_pcb);
  525 
  526 #if defined(SMP) && defined(KDB_STOPPEDPCB)
  527         STAILQ_FOREACH(pc, &cpuhead, pc_allcpu)  {
  528                 if (pc->pc_curthread == thr &&
  529                     CPU_ISSET(pc->pc_cpuid, &stopped_cpus))
  530                         return (KDB_STOPPEDPCB(pc));
  531         }
  532 #endif
  533         return (thr->td_pcb);
  534 }
  535 
  536 struct thread *
  537 kdb_thr_first(void)
  538 {
  539         struct proc *p;
  540         struct thread *thr;
  541 
  542         p = LIST_FIRST(&allproc);
  543         while (p != NULL) {
  544                 if (p->p_flag & P_INMEM) {
  545                         thr = FIRST_THREAD_IN_PROC(p);
  546                         if (thr != NULL)
  547                                 return (thr);
  548                 }
  549                 p = LIST_NEXT(p, p_list);
  550         }
  551         return (NULL);
  552 }
  553 
  554 struct thread *
  555 kdb_thr_from_pid(pid_t pid)
  556 {
  557         struct proc *p;
  558 
  559         p = LIST_FIRST(&allproc);
  560         while (p != NULL) {
  561                 if (p->p_flag & P_INMEM && p->p_pid == pid)
  562                         return (FIRST_THREAD_IN_PROC(p));
  563                 p = LIST_NEXT(p, p_list);
  564         }
  565         return (NULL);
  566 }
  567 
  568 struct thread *
  569 kdb_thr_lookup(lwpid_t tid)
  570 {
  571         struct thread *thr;
  572 
  573         thr = kdb_thr_first();
  574         while (thr != NULL && thr->td_tid != tid)
  575                 thr = kdb_thr_next(thr);
  576         return (thr);
  577 }
  578 
  579 struct thread *
  580 kdb_thr_next(struct thread *thr)
  581 {
  582         struct proc *p;
  583 
  584         p = thr->td_proc;
  585         thr = TAILQ_NEXT(thr, td_plist);
  586         do {
  587                 if (thr != NULL)
  588                         return (thr);
  589                 p = LIST_NEXT(p, p_list);
  590                 if (p != NULL && (p->p_flag & P_INMEM))
  591                         thr = FIRST_THREAD_IN_PROC(p);
  592         } while (p != NULL);
  593         return (NULL);
  594 }
  595 
  596 int
  597 kdb_thr_select(struct thread *thr)
  598 {
  599         if (thr == NULL)
  600                 return (EINVAL);
  601         kdb_thread = thr;
  602         kdb_thrctx = kdb_thr_ctx(thr);
  603         return (0);
  604 }
  605 
  606 /*
  607  * Enter the debugger due to a trap.
  608  */
  609 
  610 int
  611 kdb_trap(int type, int code, struct trapframe *tf)
  612 {
  613 #ifdef SMP
  614         cpuset_t other_cpus;
  615 #endif
  616         struct kdb_dbbe *be;
  617         register_t intr;
  618         int handled;
  619 #ifdef SMP
  620         int did_stop_cpus;
  621 #endif
  622 
  623         be = kdb_dbbe;
  624         if (be == NULL || be->dbbe_trap == NULL)
  625                 return (0);
  626 
  627         /* We reenter the debugger through kdb_reenter(). */
  628         if (kdb_active)
  629                 return (0);
  630 
  631         intr = intr_disable();
  632 
  633 #ifdef SMP
  634         if (!SCHEDULER_STOPPED()) {
  635                 other_cpus = all_cpus;
  636                 CPU_CLR(PCPU_GET(cpuid), &other_cpus);
  637                 stop_cpus_hard(other_cpus);
  638                 did_stop_cpus = 1;
  639         } else
  640                 did_stop_cpus = 0;
  641 #endif
  642 
  643         kdb_active++;
  644 
  645         kdb_frame = tf;
  646 
  647         /* Let MD code do its thing first... */
  648         kdb_cpu_trap(type, code);
  649 
  650         makectx(tf, &kdb_pcb);
  651         kdb_thr_select(curthread);
  652 
  653         cngrab();
  654 
  655         for (;;) {
  656                 handled = be->dbbe_trap(type, code);
  657                 if (be == kdb_dbbe)
  658                         break;
  659                 be = kdb_dbbe;
  660                 if (be == NULL || be->dbbe_trap == NULL)
  661                         break;
  662                 printf("Switching to %s back-end\n", be->dbbe_name);
  663         }
  664 
  665         cnungrab();
  666 
  667         kdb_active--;
  668 
  669 #ifdef SMP
  670         if (did_stop_cpus)
  671                 restart_cpus(stopped_cpus);
  672 #endif
  673 
  674         intr_restore(intr);
  675 
  676         return (handled);
  677 }

Cache object: 72e5749481dabee08569c0f2da365c05


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.