sysdeps/mach/hurd/htl/pt-hurd-cond-timedwait.c

   1 /* pthread_hurd_cond_timedwait_np.  Hurd-specific wait on a condition.
   2    Copyright (C) 2012-2023 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library;  if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <pthread.h>
  20 #include <assert.h>
  21 #include <hurd/signal.h>
  22 #include <time.h>
  23
  24 #include <pt-internal.h>
  25
  26 extern int __pthread_hurd_cond_timedwait_internal (pthread_cond_t *cond,
  27                                                    pthread_mutex_t *mutex,
  28                                                    const struct timespec
  29                                                    *abstime);
  30
  31 int
  32 __pthread_hurd_cond_timedwait_np (pthread_cond_t *cond,
  33                                   pthread_mutex_t *mutex,
  34                                   const struct timespec *abstime)
  35 {
  36   return __pthread_hurd_cond_timedwait_internal (cond, mutex, abstime);
  37 }
  38
  39 strong_alias (__pthread_hurd_cond_timedwait_np, pthread_hurd_cond_timedwait_np);
  40
  41 int
  42 __pthread_hurd_cond_timedwait_internal (pthread_cond_t *cond,
  43                                         pthread_mutex_t *mutex,
  44                                         const struct timespec *abstime)
  45 {
  46   struct hurd_sigstate *ss = _hurd_self_sigstate ();
  47   struct __pthread *self = _pthread_self ();
  48   error_t err = 0;
  49   int cancel, drain;
  50   clockid_t clock_id = __pthread_default_condattr.__clock;
  51
  52   /* This function will be called by hurd_thread_cancel while we are blocked
  53      We wake up our thread if it's still blocking or about to block, so it will
  54      progress and notice the cancellation flag.  */
  55   void cancel_me (void)
  56   {
  57     int unblock;
  58
  59     __pthread_spin_wait (&cond->__lock);
  60     /* The thread only needs to be awaken if it's blocking or about to block.
  61        If it was already unblocked, it's not queued any more.  */
  62     unblock = self->prevp != NULL;
  63     if (unblock)
  64       __pthread_dequeue (self);
  65     __pthread_spin_unlock (&cond->__lock);
  66
  67     if (unblock)
  68       __pthread_wakeup (self);
  69   }
  70
  71   assert (ss->intr_port == MACH_PORT_NULL);     /* Sanity check for signal bugs. */
  72
  73   if (abstime != NULL && ! valid_nanoseconds (abstime->tv_nsec))
  74     return EINVAL;
  75
  76   err = __pthread_mutex_checklocked (mutex);
  77   if (err)
  78     return err;
  79
  80   /* Atomically enqueue our thread on the condition variable's queue of
  81      waiters, and mark our sigstate to indicate that `cancel_me' must be
  82      called to wake us up.  We must hold the sigstate lock while acquiring
  83      the condition variable's lock and tweaking it, so that
  84      hurd_thread_cancel can never suspend us and then deadlock waiting for
  85      the condition variable's lock.  */
  86
  87   __spin_lock (&ss->lock);
  88   __pthread_spin_wait (&cond->__lock);
  89   cancel = ss->cancel;
  90   if (cancel)
  91     /* We were cancelled before doing anything.  Don't block at all.  */
  92     ss->cancel = 0;
  93   else
  94     {
  95       /* Put us on the queue so that pthread_cond_broadcast will know to wake
  96          us up.  */
  97       __pthread_enqueue (&cond->__queue, self);
  98       if (cond->__attr)
  99         clock_id = cond->__attr->__clock;
 100       /* Tell hurd_thread_cancel how to unblock us.  */
 101       ss->cancel_hook = &cancel_me;
 102     }
 103   __pthread_spin_unlock (&cond->__lock);
 104   __spin_unlock (&ss->lock);
 105
 106   /* Increase the waiter reference count.  Relaxed MO is sufficient because
 107      we only need to synchronize when decrementing the reference count.
 108      We however need to have the mutex held to prevent concurrency with
 109      a pthread_cond_destroy.  */
 110   atomic_fetch_add_relaxed (&cond->__wrefs, 2);
 111
 112   if (cancel)
 113     {
 114       /* Cancelled on entry.  Just leave the mutex locked.  */
 115       mutex = NULL;
 116
 117       __spin_lock (&ss->lock);
 118     }
 119   else
 120     {
 121       /* Release MUTEX before blocking.  */
 122       __pthread_mutex_unlock (mutex);
 123
 124       /* Block the thread.  */
 125       if (abstime != NULL)
 126         err = __pthread_timedblock (self, abstime, clock_id);
 127       else
 128         {
 129           err = 0;
 130           __pthread_block (self);
 131         }
 132
 133       /* As it was done when enqueueing, prevent hurd_thread_cancel from
 134          suspending us while the condition lock is held.  */
 135       __spin_lock (&ss->lock);
 136       __pthread_spin_wait (&cond->__lock);
 137       if (self->prevp == NULL)
 138         /* Another thread removed us from the list of waiters, which means
 139            a wakeup message has been sent.  It was either consumed while
 140            we were blocking, or queued after we timed out and before we
 141            acquired the condition lock, in which case the message queue
 142            must be drained.  */
 143         drain = err ? 1 : 0;
 144       else
 145         {
 146           /* We're still in the list of waiters.  Noone attempted to wake us
 147              up, i.e. we timed out.  */
 148           __pthread_dequeue (self);
 149           drain = 0;
 150         }
 151       __pthread_spin_unlock (&cond->__lock);
 152
 153       if (drain)
 154         __pthread_block (self);
 155     }
 156
 157   /* If destruction is pending (i.e., the wake-request flag is nonzero) and we
 158      are the last waiter (prior value of __wrefs was 1 << 1), then wake any
 159      threads waiting in pthread_cond_destroy.  Release MO to synchronize with
 160      these threads.  Don't bother clearing the wake-up request flag.  */
 161   if ((atomic_fetch_add_release (&cond->__wrefs, -2)) == 3)
 162     __gsync_wake (__mach_task_self (), (vm_offset_t) &cond->__wrefs, 0, 0);
 163
 164   /* Clear the hook, now that we are done blocking.  */
 165   ss->cancel_hook = NULL;
 166   /* Check the cancellation flag; we might have unblocked due to
 167      cancellation rather than a normal pthread_cond_signal or
 168      pthread_cond_broadcast (or we might have just happened to get cancelled
 169      right after waking up).  */
 170   cancel |= ss->cancel;
 171   ss->cancel = 0;
 172   __spin_unlock (&ss->lock);
 173
 174   if (mutex != NULL)
 175     /* Reacquire the mutex and return.  */
 176     __pthread_mutex_lock (mutex);
 177
 178   if (cancel)
 179     return EINTR;
 180   else if (err)
 181     {
 182       assert (err == ETIMEDOUT);
 183       return err;
 184     }
 185
 186   return 0;
 187 }