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_sleepqueue.c

Version: -  FREEBSD  -  FREEBSD11  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  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 John Baldwin <jhb@FreeBSD.org>
    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  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  * 3. Neither the name of the author nor the names of any co-contributors
   14  *    may be used to endorse or promote products derived from this software
   15  *    without specific prior written permission.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   27  * SUCH DAMAGE.
   28  */
   29 
   30 /*
   31  * Implementation of sleep queues used to hold queue of threads blocked on
   32  * a wait channel.  Sleep queues different from turnstiles in that wait
   33  * channels are not owned by anyone, so there is no priority propagation.
   34  * Sleep queues can also provide a timeout and can also be interrupted by
   35  * signals.  That said, there are several similarities between the turnstile
   36  * and sleep queue implementations.  (Note: turnstiles were implemented
   37  * first.)  For example, both use a hash table of the same size where each
   38  * bucket is referred to as a "chain" that contains both a spin lock and
   39  * a linked list of queues.  An individual queue is located by using a hash
   40  * to pick a chain, locking the chain, and then walking the chain searching
   41  * for the queue.  This means that a wait channel object does not need to
   42  * embed it's queue head just as locks do not embed their turnstile queue
   43  * head.  Threads also carry around a sleep queue that they lend to the
   44  * wait channel when blocking.  Just as in turnstiles, the queue includes
   45  * a free list of the sleep queues of other threads blocked on the same
   46  * wait channel in the case of multiple waiters.
   47  *
   48  * Some additional functionality provided by sleep queues include the
   49  * ability to set a timeout.  The timeout is managed using a per-thread
   50  * callout that resumes a thread if it is asleep.  A thread may also
   51  * catch signals while it is asleep (aka an interruptible sleep).  The
   52  * signal code uses sleepq_abort() to interrupt a sleeping thread.  Finally,
   53  * sleep queues also provide some extra assertions.  One is not allowed to
   54  * mix the sleep/wakeup and cv APIs for a given wait channel.  Also, one
   55  * must consistently use the same lock to synchronize with a wait channel,
   56  * though this check is currently only a warning for sleep/wakeup due to
   57  * pre-existing abuse of that API.  The same lock must also be held when
   58  * awakening threads, though that is currently only enforced for condition
   59  * variables.
   60  */
   61 
   62 #include <sys/cdefs.h>
   63 __FBSDID("$FreeBSD$");
   64 
   65 #include "opt_sleepqueue_profiling.h"
   66 #include "opt_ddb.h"
   67 #include "opt_sched.h"
   68 
   69 #include <sys/param.h>
   70 #include <sys/systm.h>
   71 #include <sys/lock.h>
   72 #include <sys/kernel.h>
   73 #include <sys/ktr.h>
   74 #include <sys/mutex.h>
   75 #include <sys/proc.h>
   76 #include <sys/sched.h>
   77 #include <sys/signalvar.h>
   78 #include <sys/sleepqueue.h>
   79 #include <sys/sysctl.h>
   80 
   81 #include <vm/uma.h>
   82 
   83 #ifdef DDB
   84 #include <ddb/ddb.h>
   85 #endif
   86 
   87 /*
   88  * Constants for the hash table of sleep queue chains.  These constants are
   89  * the same ones that 4BSD (and possibly earlier versions of BSD) used.
   90  * Basically, we ignore the lower 8 bits of the address since most wait
   91  * channel pointers are aligned and only look at the next 7 bits for the
   92  * hash.  SC_TABLESIZE must be a power of two for SC_MASK to work properly.
   93  */
   94 #define SC_TABLESIZE    128                     /* Must be power of 2. */
   95 #define SC_MASK         (SC_TABLESIZE - 1)
   96 #define SC_SHIFT        8
   97 #define SC_HASH(wc)     (((uintptr_t)(wc) >> SC_SHIFT) & SC_MASK)
   98 #define SC_LOOKUP(wc)   &sleepq_chains[SC_HASH(wc)]
   99 #define NR_SLEEPQS      2
  100 /*
  101  * There two different lists of sleep queues.  Both lists are connected
  102  * via the sq_hash entries.  The first list is the sleep queue chain list
  103  * that a sleep queue is on when it is attached to a wait channel.  The
  104  * second list is the free list hung off of a sleep queue that is attached
  105  * to a wait channel.
  106  *
  107  * Each sleep queue also contains the wait channel it is attached to, the
  108  * list of threads blocked on that wait channel, flags specific to the
  109  * wait channel, and the lock used to synchronize with a wait channel.
  110  * The flags are used to catch mismatches between the various consumers
  111  * of the sleep queue API (e.g. sleep/wakeup and condition variables).
  112  * The lock pointer is only used when invariants are enabled for various
  113  * debugging checks.
  114  *
  115  * Locking key:
  116  *  c - sleep queue chain lock
  117  */
  118 struct sleepqueue {
  119         TAILQ_HEAD(, thread) sq_blocked[NR_SLEEPQS];    /* (c) Blocked threads. */
  120         LIST_ENTRY(sleepqueue) sq_hash;         /* (c) Chain and free list. */
  121         LIST_HEAD(, sleepqueue) sq_free;        /* (c) Free queues. */
  122         void    *sq_wchan;                      /* (c) Wait channel. */
  123 #ifdef INVARIANTS
  124         int     sq_type;                        /* (c) Queue type. */
  125         struct lock_object *sq_lock;            /* (c) Associated lock. */
  126 #endif
  127 };
  128 
  129 struct sleepqueue_chain {
  130         LIST_HEAD(, sleepqueue) sc_queues;      /* List of sleep queues. */
  131         struct mtx sc_lock;                     /* Spin lock for this chain. */
  132 #ifdef SLEEPQUEUE_PROFILING
  133         u_int   sc_depth;                       /* Length of sc_queues. */
  134         u_int   sc_max_depth;                   /* Max length of sc_queues. */
  135 #endif
  136 };
  137 
  138 #ifdef SLEEPQUEUE_PROFILING
  139 u_int sleepq_max_depth;
  140 SYSCTL_NODE(_debug, OID_AUTO, sleepq, CTLFLAG_RD, 0, "sleepq profiling");
  141 SYSCTL_NODE(_debug_sleepq, OID_AUTO, chains, CTLFLAG_RD, 0,
  142     "sleepq chain stats");
  143 SYSCTL_UINT(_debug_sleepq, OID_AUTO, max_depth, CTLFLAG_RD, &sleepq_max_depth,
  144     0, "maxmimum depth achieved of a single chain");
  145 #endif
  146 static struct sleepqueue_chain sleepq_chains[SC_TABLESIZE];
  147 static uma_zone_t sleepq_zone;
  148 
  149 /*
  150  * Prototypes for non-exported routines.
  151  */
  152 static int      sleepq_catch_signals(void *wchan);
  153 static int      sleepq_check_signals(void);
  154 static int      sleepq_check_timeout(void);
  155 #ifdef INVARIANTS
  156 static void     sleepq_dtor(void *mem, int size, void *arg);
  157 #endif
  158 static int      sleepq_init(void *mem, int size, int flags);
  159 static int      sleepq_resume_thread(struct sleepqueue *sq, struct thread *td,
  160                     int pri);
  161 static void     sleepq_switch(void *wchan);
  162 static void     sleepq_timeout(void *arg);
  163 
  164 /*
  165  * Early initialization of sleep queues that is called from the sleepinit()
  166  * SYSINIT.
  167  */
  168 void
  169 init_sleepqueues(void)
  170 {
  171 #ifdef SLEEPQUEUE_PROFILING
  172         struct sysctl_oid *chain_oid;
  173         char chain_name[10];
  174 #endif
  175         int i;
  176 
  177         for (i = 0; i < SC_TABLESIZE; i++) {
  178                 LIST_INIT(&sleepq_chains[i].sc_queues);
  179                 mtx_init(&sleepq_chains[i].sc_lock, "sleepq chain", NULL,
  180                     MTX_SPIN | MTX_RECURSE);
  181 #ifdef SLEEPQUEUE_PROFILING
  182                 snprintf(chain_name, sizeof(chain_name), "%d", i);
  183                 chain_oid = SYSCTL_ADD_NODE(NULL, 
  184                     SYSCTL_STATIC_CHILDREN(_debug_sleepq_chains), OID_AUTO,
  185                     chain_name, CTLFLAG_RD, NULL, "sleepq chain stats");
  186                 SYSCTL_ADD_UINT(NULL, SYSCTL_CHILDREN(chain_oid), OID_AUTO,
  187                     "depth", CTLFLAG_RD, &sleepq_chains[i].sc_depth, 0, NULL);
  188                 SYSCTL_ADD_UINT(NULL, SYSCTL_CHILDREN(chain_oid), OID_AUTO,
  189                     "max_depth", CTLFLAG_RD, &sleepq_chains[i].sc_max_depth, 0,
  190                     NULL);
  191 #endif
  192         }
  193         sleepq_zone = uma_zcreate("SLEEPQUEUE", sizeof(struct sleepqueue),
  194 #ifdef INVARIANTS
  195             NULL, sleepq_dtor, sleepq_init, NULL, UMA_ALIGN_CACHE, 0);
  196 #else
  197             NULL, NULL, sleepq_init, NULL, UMA_ALIGN_CACHE, 0);
  198 #endif
  199         
  200         thread0.td_sleepqueue = sleepq_alloc();
  201 }
  202 
  203 /*
  204  * Get a sleep queue for a new thread.
  205  */
  206 struct sleepqueue *
  207 sleepq_alloc(void)
  208 {
  209 
  210         return (uma_zalloc(sleepq_zone, M_WAITOK));
  211 }
  212 
  213 /*
  214  * Free a sleep queue when a thread is destroyed.
  215  */
  216 void
  217 sleepq_free(struct sleepqueue *sq)
  218 {
  219 
  220         uma_zfree(sleepq_zone, sq);
  221 }
  222 
  223 /*
  224  * Lock the sleep queue chain associated with the specified wait channel.
  225  */
  226 void
  227 sleepq_lock(void *wchan)
  228 {
  229         struct sleepqueue_chain *sc;
  230 
  231         sc = SC_LOOKUP(wchan);
  232         mtx_lock_spin(&sc->sc_lock);
  233 }
  234 
  235 /*
  236  * Look up the sleep queue associated with a given wait channel in the hash
  237  * table locking the associated sleep queue chain.  If no queue is found in
  238  * the table, NULL is returned.
  239  */
  240 struct sleepqueue *
  241 sleepq_lookup(void *wchan)
  242 {
  243         struct sleepqueue_chain *sc;
  244         struct sleepqueue *sq;
  245 
  246         KASSERT(wchan != NULL, ("%s: invalid NULL wait channel", __func__));
  247         sc = SC_LOOKUP(wchan);
  248         mtx_assert(&sc->sc_lock, MA_OWNED);
  249         LIST_FOREACH(sq, &sc->sc_queues, sq_hash)
  250                 if (sq->sq_wchan == wchan)
  251                         return (sq);
  252         return (NULL);
  253 }
  254 
  255 /*
  256  * Unlock the sleep queue chain associated with a given wait channel.
  257  */
  258 void
  259 sleepq_release(void *wchan)
  260 {
  261         struct sleepqueue_chain *sc;
  262 
  263         sc = SC_LOOKUP(wchan);
  264         mtx_unlock_spin(&sc->sc_lock);
  265 }
  266 
  267 /*
  268  * Places the current thread on the sleep queue for the specified wait
  269  * channel.  If INVARIANTS is enabled, then it associates the passed in
  270  * lock with the sleepq to make sure it is held when that sleep queue is
  271  * woken up.
  272  */
  273 void
  274 sleepq_add(void *wchan, struct lock_object *lock, const char *wmesg, int flags,
  275     int queue)
  276 {
  277         struct sleepqueue_chain *sc;
  278         struct sleepqueue *sq;
  279         struct thread *td;
  280 
  281         td = curthread;
  282         sc = SC_LOOKUP(wchan);
  283         mtx_assert(&sc->sc_lock, MA_OWNED);
  284         MPASS(td->td_sleepqueue != NULL);
  285         MPASS(wchan != NULL);
  286         MPASS((queue >= 0) && (queue < NR_SLEEPQS));
  287 
  288         /* If this thread is not allowed to sleep, die a horrible death. */
  289         KASSERT(!(td->td_pflags & TDP_NOSLEEPING),
  290             ("Trying sleep, but thread marked as sleeping prohibited"));
  291 
  292         /* Look up the sleep queue associated with the wait channel 'wchan'. */
  293         sq = sleepq_lookup(wchan);
  294 
  295         /*
  296          * If the wait channel does not already have a sleep queue, use
  297          * this thread's sleep queue.  Otherwise, insert the current thread
  298          * into the sleep queue already in use by this wait channel.
  299          */
  300         if (sq == NULL) {
  301 #ifdef INVARIANTS
  302                 int i;
  303 
  304                 sq = td->td_sleepqueue;
  305                 for (i = 0; i < NR_SLEEPQS; i++)
  306                         KASSERT(TAILQ_EMPTY(&sq->sq_blocked[i]),
  307                                 ("thread's sleep queue %d is not empty", i));
  308                 KASSERT(LIST_EMPTY(&sq->sq_free),
  309                     ("thread's sleep queue has a non-empty free list"));
  310                 KASSERT(sq->sq_wchan == NULL, ("stale sq_wchan pointer"));
  311                 sq->sq_lock = lock;
  312                 sq->sq_type = flags & SLEEPQ_TYPE;
  313 #endif
  314 #ifdef SLEEPQUEUE_PROFILING
  315                 sc->sc_depth++;
  316                 if (sc->sc_depth > sc->sc_max_depth) {
  317                         sc->sc_max_depth = sc->sc_depth;
  318                         if (sc->sc_max_depth > sleepq_max_depth)
  319                                 sleepq_max_depth = sc->sc_max_depth;
  320                 }
  321 #endif
  322                 sq = td->td_sleepqueue;
  323                 LIST_INSERT_HEAD(&sc->sc_queues, sq, sq_hash);
  324                 sq->sq_wchan = wchan;
  325         } else {
  326                 MPASS(wchan == sq->sq_wchan);
  327                 MPASS(lock == sq->sq_lock);
  328                 MPASS((flags & SLEEPQ_TYPE) == sq->sq_type);
  329                 LIST_INSERT_HEAD(&sq->sq_free, td->td_sleepqueue, sq_hash);
  330         }
  331         thread_lock(td);
  332         TAILQ_INSERT_TAIL(&sq->sq_blocked[queue], td, td_slpq);
  333         td->td_sleepqueue = NULL;
  334         td->td_sqqueue = queue;
  335         td->td_wchan = wchan;
  336         td->td_wmesg = wmesg;
  337         if (flags & SLEEPQ_INTERRUPTIBLE) {
  338                 td->td_flags |= TDF_SINTR;
  339                 td->td_flags &= ~TDF_SLEEPABORT;
  340         }
  341         thread_unlock(td);
  342 }
  343 
  344 /*
  345  * Sets a timeout that will remove the current thread from the specified
  346  * sleep queue after timo ticks if the thread has not already been awakened.
  347  */
  348 void
  349 sleepq_set_timeout(void *wchan, int timo)
  350 {
  351         struct sleepqueue_chain *sc;
  352         struct thread *td;
  353 
  354         td = curthread;
  355         sc = SC_LOOKUP(wchan);
  356         mtx_assert(&sc->sc_lock, MA_OWNED);
  357         MPASS(TD_ON_SLEEPQ(td));
  358         MPASS(td->td_sleepqueue == NULL);
  359         MPASS(wchan != NULL);
  360         callout_reset(&td->td_slpcallout, timo, sleepq_timeout, td);
  361 }
  362 
  363 /*
  364  * Marks the pending sleep of the current thread as interruptible and
  365  * makes an initial check for pending signals before putting a thread
  366  * to sleep. Enters and exits with the thread lock held.  Thread lock
  367  * may have transitioned from the sleepq lock to a run lock.
  368  */
  369 static int
  370 sleepq_catch_signals(void *wchan)
  371 {
  372         struct sleepqueue_chain *sc;
  373         struct sleepqueue *sq;
  374         struct thread *td;
  375         struct proc *p;
  376         struct sigacts *ps;
  377         int sig, ret;
  378 
  379         td = curthread;
  380         p = curproc;
  381         sc = SC_LOOKUP(wchan);
  382         mtx_assert(&sc->sc_lock, MA_OWNED);
  383         MPASS(wchan != NULL);
  384         CTR3(KTR_PROC, "sleepq catching signals: thread %p (pid %ld, %s)",
  385                 (void *)td, (long)p->p_pid, p->p_comm);
  386 
  387         mtx_unlock_spin(&sc->sc_lock);
  388 
  389         /* See if there are any pending signals for this thread. */
  390         PROC_LOCK(p);
  391         ps = p->p_sigacts;
  392         mtx_lock(&ps->ps_mtx);
  393         sig = cursig(td);
  394         if (sig == 0) {
  395                 mtx_unlock(&ps->ps_mtx);
  396                 ret = thread_suspend_check(1);
  397                 MPASS(ret == 0 || ret == EINTR || ret == ERESTART);
  398         } else {
  399                 if (SIGISMEMBER(ps->ps_sigintr, sig))
  400                         ret = EINTR;
  401                 else
  402                         ret = ERESTART;
  403                 mtx_unlock(&ps->ps_mtx);
  404         }
  405         /*
  406          * Lock the per-process spinlock prior to dropping the PROC_LOCK
  407          * to avoid a signal delivery race.  PROC_LOCK, PROC_SLOCK, and
  408          * thread_lock() are currently held in tdsignal().
  409          */
  410         PROC_SLOCK(p);
  411         mtx_lock_spin(&sc->sc_lock);
  412         PROC_UNLOCK(p);
  413         thread_lock(td);
  414         PROC_SUNLOCK(p);
  415         if (ret == 0) {
  416                 if (!(td->td_flags & TDF_INTERRUPT)) {
  417                         sleepq_switch(wchan);
  418                         return (0);
  419                 }
  420                 /* KSE threads tried unblocking us. */
  421                 ret = td->td_intrval;
  422                 MPASS(ret == EINTR || ret == ERESTART || ret == EWOULDBLOCK);
  423         }
  424         /*
  425          * There were pending signals and this thread is still
  426          * on the sleep queue, remove it from the sleep queue.
  427          */
  428         if (TD_ON_SLEEPQ(td)) {
  429                 sq = sleepq_lookup(wchan);
  430                 if (sleepq_resume_thread(sq, td, -1)) {
  431 #ifdef INVARIANTS
  432                         /*
  433                          * This thread hasn't gone to sleep yet, so it
  434                          * should not be swapped out.
  435                          */
  436                         panic("not waking up swapper");
  437 #endif
  438                 }
  439         }
  440         mtx_unlock_spin(&sc->sc_lock);
  441         MPASS(td->td_lock != &sc->sc_lock);
  442         return (ret);
  443 }
  444 
  445 /*
  446  * Switches to another thread if we are still asleep on a sleep queue.
  447  * Returns with thread lock.
  448  */
  449 static void
  450 sleepq_switch(void *wchan)
  451 {
  452         struct sleepqueue_chain *sc;
  453         struct sleepqueue *sq;
  454         struct thread *td;
  455 
  456         td = curthread;
  457         sc = SC_LOOKUP(wchan);
  458         mtx_assert(&sc->sc_lock, MA_OWNED);
  459         THREAD_LOCK_ASSERT(td, MA_OWNED);
  460 
  461         /* 
  462          * If we have a sleep queue, then we've already been woken up, so
  463          * just return.
  464          */
  465         if (td->td_sleepqueue != NULL) {
  466                 mtx_unlock_spin(&sc->sc_lock);
  467                 return;
  468         }
  469 
  470         /*
  471          * If TDF_TIMEOUT is set, then our sleep has been timed out
  472          * already but we are still on the sleep queue, so dequeue the
  473          * thread and return.
  474          */
  475         if (td->td_flags & TDF_TIMEOUT) {
  476                 MPASS(TD_ON_SLEEPQ(td));
  477                 sq = sleepq_lookup(wchan);
  478                 if (sleepq_resume_thread(sq, td, -1)) {
  479 #ifdef INVARIANTS
  480                         /*
  481                          * This thread hasn't gone to sleep yet, so it
  482                          * should not be swapped out.
  483                          */
  484                         panic("not waking up swapper");
  485 #endif
  486                 }
  487                 mtx_unlock_spin(&sc->sc_lock);
  488                 return;         
  489         }
  490 
  491         thread_lock_set(td, &sc->sc_lock);
  492 
  493         MPASS(td->td_sleepqueue == NULL);
  494         sched_sleep(td);
  495         TD_SET_SLEEPING(td);
  496         SCHED_STAT_INC(switch_sleepq);
  497         mi_switch(SW_VOL, NULL);
  498         KASSERT(TD_IS_RUNNING(td), ("running but not TDS_RUNNING"));
  499         CTR3(KTR_PROC, "sleepq resume: thread %p (pid %ld, %s)",
  500             (void *)td, (long)td->td_proc->p_pid, (void *)td->td_proc->p_comm);
  501 }
  502 
  503 /*
  504  * Check to see if we timed out.
  505  */
  506 static int
  507 sleepq_check_timeout(void)
  508 {
  509         struct thread *td;
  510 
  511         td = curthread;
  512         THREAD_LOCK_ASSERT(td, MA_OWNED);
  513 
  514         /*
  515          * If TDF_TIMEOUT is set, we timed out.
  516          */
  517         if (td->td_flags & TDF_TIMEOUT) {
  518                 td->td_flags &= ~TDF_TIMEOUT;
  519                 return (EWOULDBLOCK);
  520         }
  521 
  522         /*
  523          * If TDF_TIMOFAIL is set, the timeout ran after we had
  524          * already been woken up.
  525          */
  526         if (td->td_flags & TDF_TIMOFAIL)
  527                 td->td_flags &= ~TDF_TIMOFAIL;
  528 
  529         /*
  530          * If callout_stop() fails, then the timeout is running on
  531          * another CPU, so synchronize with it to avoid having it
  532          * accidentally wake up a subsequent sleep.
  533          */
  534         else if (callout_stop(&td->td_slpcallout) == 0) {
  535                 td->td_flags |= TDF_TIMEOUT;
  536                 TD_SET_SLEEPING(td);
  537                 SCHED_STAT_INC(switch_sleepqtimo);
  538                 mi_switch(SW_INVOL, NULL);
  539         }
  540         return (0);
  541 }
  542 
  543 /*
  544  * Check to see if we were awoken by a signal.
  545  */
  546 static int
  547 sleepq_check_signals(void)
  548 {
  549         struct thread *td;
  550 
  551         td = curthread;
  552         THREAD_LOCK_ASSERT(td, MA_OWNED);
  553 
  554         /* We are no longer in an interruptible sleep. */
  555         if (td->td_flags & TDF_SINTR)
  556                 td->td_flags &= ~TDF_SINTR;
  557 
  558         if (td->td_flags & TDF_SLEEPABORT) {
  559                 td->td_flags &= ~TDF_SLEEPABORT;
  560                 return (td->td_intrval);
  561         }
  562 
  563         if (td->td_flags & TDF_INTERRUPT)
  564                 return (td->td_intrval);
  565 
  566         return (0);
  567 }
  568 
  569 /*
  570  * Block the current thread until it is awakened from its sleep queue.
  571  */
  572 void
  573 sleepq_wait(void *wchan)
  574 {
  575         struct thread *td;
  576 
  577         td = curthread;
  578         MPASS(!(td->td_flags & TDF_SINTR));
  579         thread_lock(td);
  580         sleepq_switch(wchan);
  581         thread_unlock(td);
  582 }
  583 
  584 /*
  585  * Block the current thread until it is awakened from its sleep queue
  586  * or it is interrupted by a signal.
  587  */
  588 int
  589 sleepq_wait_sig(void *wchan)
  590 {
  591         int rcatch;
  592         int rval;
  593 
  594         rcatch = sleepq_catch_signals(wchan);
  595         rval = sleepq_check_signals();
  596         thread_unlock(curthread);
  597         if (rcatch)
  598                 return (rcatch);
  599         return (rval);
  600 }
  601 
  602 /*
  603  * Block the current thread until it is awakened from its sleep queue
  604  * or it times out while waiting.
  605  */
  606 int
  607 sleepq_timedwait(void *wchan)
  608 {
  609         struct thread *td;
  610         int rval;
  611 
  612         td = curthread;
  613         MPASS(!(td->td_flags & TDF_SINTR));
  614         thread_lock(td);
  615         sleepq_switch(wchan);
  616         rval = sleepq_check_timeout();
  617         thread_unlock(td);
  618 
  619         return (rval);
  620 }
  621 
  622 /*
  623  * Block the current thread until it is awakened from its sleep queue,
  624  * it is interrupted by a signal, or it times out waiting to be awakened.
  625  */
  626 int
  627 sleepq_timedwait_sig(void *wchan)
  628 {
  629         int rcatch, rvalt, rvals;
  630 
  631         rcatch = sleepq_catch_signals(wchan);
  632         rvalt = sleepq_check_timeout();
  633         rvals = sleepq_check_signals();
  634         thread_unlock(curthread);
  635         if (rcatch)
  636                 return (rcatch);
  637         if (rvals)
  638                 return (rvals);
  639         return (rvalt);
  640 }
  641 
  642 /*
  643  * Removes a thread from a sleep queue and makes it
  644  * runnable.
  645  */
  646 static int
  647 sleepq_resume_thread(struct sleepqueue *sq, struct thread *td, int pri)
  648 {
  649         struct sleepqueue_chain *sc;
  650 
  651         MPASS(td != NULL);
  652         MPASS(sq->sq_wchan != NULL);
  653         MPASS(td->td_wchan == sq->sq_wchan);
  654         MPASS(td->td_sqqueue < NR_SLEEPQS && td->td_sqqueue >= 0);
  655         THREAD_LOCK_ASSERT(td, MA_OWNED);
  656         sc = SC_LOOKUP(sq->sq_wchan);
  657         mtx_assert(&sc->sc_lock, MA_OWNED);
  658 
  659         /* Remove the thread from the queue. */
  660         TAILQ_REMOVE(&sq->sq_blocked[td->td_sqqueue], td, td_slpq);
  661 
  662         /*
  663          * Get a sleep queue for this thread.  If this is the last waiter,
  664          * use the queue itself and take it out of the chain, otherwise,
  665          * remove a queue from the free list.
  666          */
  667         if (LIST_EMPTY(&sq->sq_free)) {
  668                 td->td_sleepqueue = sq;
  669 #ifdef INVARIANTS
  670                 sq->sq_wchan = NULL;
  671 #endif
  672 #ifdef SLEEPQUEUE_PROFILING
  673                 sc->sc_depth--;
  674 #endif
  675         } else
  676                 td->td_sleepqueue = LIST_FIRST(&sq->sq_free);
  677         LIST_REMOVE(td->td_sleepqueue, sq_hash);
  678 
  679         td->td_wmesg = NULL;
  680         td->td_wchan = NULL;
  681         td->td_flags &= ~TDF_SINTR;
  682 
  683         /*
  684          * Note that thread td might not be sleeping if it is running
  685          * sleepq_catch_signals() on another CPU or is blocked on
  686          * its proc lock to check signals.  It doesn't hurt to clear
  687          * the sleeping flag if it isn't set though, so we just always
  688          * do it.  However, we can't assert that it is set.
  689          */
  690         CTR3(KTR_PROC, "sleepq_wakeup: thread %p (pid %ld, %s)",
  691             (void *)td, (long)td->td_proc->p_pid, td->td_proc->p_comm);
  692         TD_CLR_SLEEPING(td);
  693 
  694         /* Adjust priority if requested. */
  695         MPASS(pri == -1 || (pri >= PRI_MIN && pri <= PRI_MAX));
  696         if (pri != -1 && td->td_priority > pri)
  697                 sched_prio(td, pri);
  698         return (setrunnable(td));
  699 }
  700 
  701 #ifdef INVARIANTS
  702 /*
  703  * UMA zone item deallocator.
  704  */
  705 static void
  706 sleepq_dtor(void *mem, int size, void *arg)
  707 {
  708         struct sleepqueue *sq;
  709         int i;
  710 
  711         sq = mem;
  712         for (i = 0; i < NR_SLEEPQS; i++)
  713                 MPASS(TAILQ_EMPTY(&sq->sq_blocked[i]));
  714 }
  715 #endif
  716 
  717 /*
  718  * UMA zone item initializer.
  719  */
  720 static int
  721 sleepq_init(void *mem, int size, int flags)
  722 {
  723         struct sleepqueue *sq;
  724         int i;
  725 
  726         bzero(mem, size);
  727         sq = mem;
  728         for (i = 0; i < NR_SLEEPQS; i++)
  729                 TAILQ_INIT(&sq->sq_blocked[i]);
  730         LIST_INIT(&sq->sq_free);
  731         return (0);
  732 }
  733 
  734 /*
  735  * Find the highest priority thread sleeping on a wait channel and resume it.
  736  */
  737 int
  738 sleepq_signal(void *wchan, int flags, int pri, int queue)
  739 {
  740         struct sleepqueue *sq;
  741         struct thread *td, *besttd;
  742         int wakeup_swapper;
  743 
  744         CTR2(KTR_PROC, "sleepq_signal(%p, %d)", wchan, flags);
  745         KASSERT(wchan != NULL, ("%s: invalid NULL wait channel", __func__));
  746         MPASS((queue >= 0) && (queue < NR_SLEEPQS));
  747         sq = sleepq_lookup(wchan);
  748         if (sq == NULL)
  749                 return (0);
  750         KASSERT(sq->sq_type == (flags & SLEEPQ_TYPE),
  751             ("%s: mismatch between sleep/wakeup and cv_*", __func__));
  752 
  753         /*
  754          * Find the highest priority thread on the queue.  If there is a
  755          * tie, use the thread that first appears in the queue as it has
  756          * been sleeping the longest since threads are always added to
  757          * the tail of sleep queues.
  758          */
  759         besttd = NULL;
  760         TAILQ_FOREACH(td, &sq->sq_blocked[queue], td_slpq) {
  761                 if (besttd == NULL || td->td_priority < besttd->td_priority)
  762                         besttd = td;
  763         }
  764         MPASS(besttd != NULL);
  765         thread_lock(besttd);
  766         wakeup_swapper = sleepq_resume_thread(sq, besttd, pri);
  767         thread_unlock(besttd);
  768         return (wakeup_swapper);
  769 }
  770 
  771 /*
  772  * Resume all threads sleeping on a specified wait channel.
  773  */
  774 int
  775 sleepq_broadcast(void *wchan, int flags, int pri, int queue)
  776 {
  777         struct sleepqueue *sq;
  778         struct thread *td, *tdn;
  779         int wakeup_swapper;
  780 
  781         CTR2(KTR_PROC, "sleepq_broadcast(%p, %d)", wchan, flags);
  782         KASSERT(wchan != NULL, ("%s: invalid NULL wait channel", __func__));
  783         MPASS((queue >= 0) && (queue < NR_SLEEPQS));
  784         sq = sleepq_lookup(wchan);
  785         if (sq == NULL) {
  786                 sleepq_release(wchan);
  787                 return (0);
  788         }
  789         KASSERT(sq->sq_type == (flags & SLEEPQ_TYPE),
  790             ("%s: mismatch between sleep/wakeup and cv_*", __func__));
  791 
  792         /* Resume all blocked threads on the sleep queue. */
  793         wakeup_swapper = 0;
  794         TAILQ_FOREACH_SAFE(td, &sq->sq_blocked[queue], td_slpq, tdn) {
  795                 thread_lock(td);
  796                 if (sleepq_resume_thread(sq, td, pri))
  797                         wakeup_swapper = 1;
  798                 thread_unlock(td);
  799         }
  800         sleepq_release(wchan);
  801         return (wakeup_swapper);
  802 }
  803 
  804 /*
  805  * Time sleeping threads out.  When the timeout expires, the thread is
  806  * removed from the sleep queue and made runnable if it is still asleep.
  807  */
  808 static void
  809 sleepq_timeout(void *arg)
  810 {
  811         struct sleepqueue_chain *sc;
  812         struct sleepqueue *sq;
  813         struct thread *td;
  814         void *wchan;
  815         int wakeup_swapper;
  816 
  817         td = arg;
  818         wakeup_swapper = 0;
  819         CTR3(KTR_PROC, "sleepq_timeout: thread %p (pid %ld, %s)",
  820             (void *)td, (long)td->td_proc->p_pid, (void *)td->td_proc->p_comm);
  821 
  822         /*
  823          * First, see if the thread is asleep and get the wait channel if
  824          * it is.
  825          */
  826         thread_lock(td);
  827         if (TD_IS_SLEEPING(td) && TD_ON_SLEEPQ(td)) {
  828                 wchan = td->td_wchan;
  829                 sc = SC_LOOKUP(wchan);
  830                 MPASS(td->td_lock == &sc->sc_lock);
  831                 sq = sleepq_lookup(wchan);
  832                 MPASS(sq != NULL);
  833                 td->td_flags |= TDF_TIMEOUT;
  834                 wakeup_swapper = sleepq_resume_thread(sq, td, -1);
  835                 thread_unlock(td);
  836                 if (wakeup_swapper)
  837                         kick_proc0();
  838                 return;
  839         }
  840 
  841         /*
  842          * If the thread is on the SLEEPQ but isn't sleeping yet, it
  843          * can either be on another CPU in between sleepq_add() and
  844          * one of the sleepq_*wait*() routines or it can be in
  845          * sleepq_catch_signals().
  846          */
  847         if (TD_ON_SLEEPQ(td)) {
  848                 td->td_flags |= TDF_TIMEOUT;
  849                 thread_unlock(td);
  850                 return;
  851         }
  852 
  853         /*
  854          * Now check for the edge cases.  First, if TDF_TIMEOUT is set,
  855          * then the other thread has already yielded to us, so clear
  856          * the flag and resume it.  If TDF_TIMEOUT is not set, then the
  857          * we know that the other thread is not on a sleep queue, but it
  858          * hasn't resumed execution yet.  In that case, set TDF_TIMOFAIL
  859          * to let it know that the timeout has already run and doesn't
  860          * need to be canceled.
  861          */
  862         if (td->td_flags & TDF_TIMEOUT) {
  863                 MPASS(TD_IS_SLEEPING(td));
  864                 td->td_flags &= ~TDF_TIMEOUT;
  865                 TD_CLR_SLEEPING(td);
  866                 wakeup_swapper = setrunnable(td);
  867         } else
  868                 td->td_flags |= TDF_TIMOFAIL;
  869         thread_unlock(td);
  870         if (wakeup_swapper)
  871                 kick_proc0();
  872 }
  873 
  874 /*
  875  * Resumes a specific thread from the sleep queue associated with a specific
  876  * wait channel if it is on that queue.
  877  */
  878 void
  879 sleepq_remove(struct thread *td, void *wchan)
  880 {
  881         struct sleepqueue *sq;
  882         int wakeup_swapper;
  883 
  884         /*
  885          * Look up the sleep queue for this wait channel, then re-check
  886          * that the thread is asleep on that channel, if it is not, then
  887          * bail.
  888          */
  889         MPASS(wchan != NULL);
  890         sleepq_lock(wchan);
  891         sq = sleepq_lookup(wchan);
  892         /*
  893          * We can not lock the thread here as it may be sleeping on a
  894          * different sleepq.  However, holding the sleepq lock for this
  895          * wchan can guarantee that we do not miss a wakeup for this
  896          * channel.  The asserts below will catch any false positives.
  897          */
  898         if (!TD_ON_SLEEPQ(td) || td->td_wchan != wchan) {
  899                 sleepq_release(wchan);
  900                 return;
  901         }
  902         /* Thread is asleep on sleep queue sq, so wake it up. */
  903         thread_lock(td);
  904         MPASS(sq != NULL);
  905         MPASS(td->td_wchan == wchan);
  906         wakeup_swapper = sleepq_resume_thread(sq, td, -1);
  907         thread_unlock(td);
  908         sleepq_release(wchan);
  909         if (wakeup_swapper)
  910                 kick_proc0();
  911 }
  912 
  913 /*
  914  * Abort a thread as if an interrupt had occurred.  Only abort
  915  * interruptible waits (unfortunately it isn't safe to abort others).
  916  */
  917 int
  918 sleepq_abort(struct thread *td, int intrval)
  919 {
  920         struct sleepqueue *sq;
  921         void *wchan;
  922 
  923         THREAD_LOCK_ASSERT(td, MA_OWNED);
  924         MPASS(TD_ON_SLEEPQ(td));
  925         MPASS(td->td_flags & TDF_SINTR);
  926         MPASS(intrval == EINTR || intrval == ERESTART);
  927 
  928         /*
  929          * If the TDF_TIMEOUT flag is set, just leave. A
  930          * timeout is scheduled anyhow.
  931          */
  932         if (td->td_flags & TDF_TIMEOUT)
  933                 return (0);
  934 
  935         CTR3(KTR_PROC, "sleepq_abort: thread %p (pid %ld, %s)",
  936             (void *)td, (long)td->td_proc->p_pid, (void *)td->td_proc->p_comm);
  937         td->td_intrval = intrval;
  938         td->td_flags |= TDF_SLEEPABORT;
  939         /*
  940          * If the thread has not slept yet it will find the signal in
  941          * sleepq_catch_signals() and call sleepq_resume_thread.  Otherwise
  942          * we have to do it here.
  943          */
  944         if (!TD_IS_SLEEPING(td))
  945                 return (0);
  946         wchan = td->td_wchan;
  947         MPASS(wchan != NULL);
  948         sq = sleepq_lookup(wchan);
  949         MPASS(sq != NULL);
  950 
  951         /* Thread is asleep on sleep queue sq, so wake it up. */
  952         return (sleepq_resume_thread(sq, td, -1));
  953 }
  954 
  955 #ifdef DDB
  956 DB_SHOW_COMMAND(sleepq, db_show_sleepqueue)
  957 {
  958         struct sleepqueue_chain *sc;
  959         struct sleepqueue *sq;
  960 #ifdef INVARIANTS
  961         struct lock_object *lock;
  962 #endif
  963         struct thread *td;
  964         void *wchan;
  965         int i;
  966 
  967         if (!have_addr)
  968                 return;
  969 
  970         /*
  971          * First, see if there is an active sleep queue for the wait channel
  972          * indicated by the address.
  973          */
  974         wchan = (void *)addr;
  975         sc = SC_LOOKUP(wchan);
  976         LIST_FOREACH(sq, &sc->sc_queues, sq_hash)
  977                 if (sq->sq_wchan == wchan)
  978                         goto found;
  979 
  980         /*
  981          * Second, see if there is an active sleep queue at the address
  982          * indicated.
  983          */
  984         for (i = 0; i < SC_TABLESIZE; i++)
  985                 LIST_FOREACH(sq, &sleepq_chains[i].sc_queues, sq_hash) {
  986                         if (sq == (struct sleepqueue *)addr)
  987                                 goto found;
  988                 }
  989 
  990         db_printf("Unable to locate a sleep queue via %p\n", (void *)addr);
  991         return;
  992 found:
  993         db_printf("Wait channel: %p\n", sq->sq_wchan);
  994 #ifdef INVARIANTS
  995         db_printf("Queue type: %d\n", sq->sq_type);
  996         if (sq->sq_lock) {
  997                 lock = sq->sq_lock;
  998                 db_printf("Associated Interlock: %p - (%s) %s\n", lock,
  999                     LOCK_CLASS(lock)->lc_name, lock->lo_name);
 1000         }
 1001 #endif
 1002         db_printf("Blocked threads:\n");
 1003         for (i = 0; i < NR_SLEEPQS; i++) {
 1004                 db_printf("\nQueue[%d]:\n", i);
 1005                 if (TAILQ_EMPTY(&sq->sq_blocked[i]))
 1006                         db_printf("\tempty\n");
 1007                 else
 1008                         TAILQ_FOREACH(td, &sq->sq_blocked[0],
 1009                                       td_slpq) {
 1010                                 db_printf("\t%p (tid %d, pid %d, \"%s\")\n", td,
 1011                                           td->td_tid, td->td_proc->p_pid,
 1012                                           td->td_name[i] != '\0' ? td->td_name :
 1013                                           td->td_proc->p_comm);
 1014                         }
 1015         }
 1016 }
 1017 
 1018 /* Alias 'show sleepqueue' to 'show sleepq'. */
 1019 DB_SET(sleepqueue, db_show_sleepqueue, db_show_cmd_set, 0, NULL);
 1020 #endif

Cache object: 056e75e72ce7d8e29fe3d8fc76533296


[ 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.