nptl/lowlevellock.c

   1 /* low level locking for pthread library.  Generic futex-using version.
   2    Copyright (C) 2003-2015 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Paul Mackerras <paulus@au.ibm.com>, 2003.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #include <errno.h>
  21 #include <sysdep.h>
  22 #include <lowlevellock.h>
  23 #include <sys/time.h>
  24 #include <atomic.h>
  25
  26 void
  27 __lll_lock_wait_private (int *futex)
  28 {
  29   if (*futex == 2)
  30     lll_futex_wait (futex, 2, LLL_PRIVATE); /* Wait if *futex == 2.  */
  31
  32   while (atomic_exchange_acq (futex, 2) != 0)
  33     lll_futex_wait (futex, 2, LLL_PRIVATE); /* Wait if *futex == 2.  */
  34 }
  35
  36
  37 /* These functions don't get included in libc.so  */
  38 #if IS_IN (libpthread)
  39 void
  40 __lll_lock_wait (int *futex, int private)
  41 {
  42   if (*futex == 2)
  43     lll_futex_wait (futex, 2, private); /* Wait if *futex == 2.  */
  44
  45   while (atomic_exchange_acq (futex, 2) != 0)
  46     lll_futex_wait (futex, 2, private); /* Wait if *futex == 2.  */
  47 }
  48
  49
  50 int
  51 __lll_timedlock_wait (int *futex, const struct timespec *abstime, int private)
  52 {
  53   /* Reject invalid timeouts.  */
  54   if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
  55     return EINVAL;
  56
  57   /* Try locking.  */
  58   while (atomic_exchange_acq (futex, 2) != 0)
  59     {
  60       struct timeval tv;
  61
  62       /* Get the current time.  */
  63       (void) __gettimeofday (&tv, NULL);
  64
  65       /* Compute relative timeout.  */
  66       struct timespec rt;
  67       rt.tv_sec = abstime->tv_sec - tv.tv_sec;
  68       rt.tv_nsec = abstime->tv_nsec - tv.tv_usec * 1000;
  69       if (rt.tv_nsec < 0)
  70         {
  71           rt.tv_nsec += 1000000000;
  72           --rt.tv_sec;
  73         }
  74
  75       if (rt.tv_sec < 0)
  76         return ETIMEDOUT;
  77
  78       /* If *futex == 2, wait until woken or timeout.  */
  79       lll_futex_timed_wait (futex, 2, &rt, private);
  80     }
  81
  82   return 0;
  83 }
  84
  85
  86 /* The kernel notifies a process which uses CLONE_CHILD_CLEARTID via futex
  87    wake-up when the clone terminates.  The memory location contains the
  88    thread ID while the clone is running and is reset to zero by the kernel
  89    afterwards.  The kernel up to version 3.16.3 does not use the private futex
  90    operations for futex wake-up when the clone terminates.  */
  91 int
  92 __lll_timedwait_tid (int *tidp, const struct timespec *abstime)
  93 {
  94   int tid;
  95
  96   if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
  97     return EINVAL;
  98
  99   /* Repeat until thread terminated.  */
 100   while ((tid = *tidp) != 0)
 101     {
 102       struct timeval tv;
 103       struct timespec rt;
 104
 105       /* Get the current time.  */
 106       (void) __gettimeofday (&tv, NULL);
 107
 108       /* Compute relative timeout.  */
 109       rt.tv_sec = abstime->tv_sec - tv.tv_sec;
 110       rt.tv_nsec = abstime->tv_nsec - tv.tv_usec * 1000;
 111       if (rt.tv_nsec < 0)
 112         {
 113           rt.tv_nsec += 1000000000;
 114           --rt.tv_sec;
 115         }
 116
 117       /* Already timed out?  */
 118       if (rt.tv_sec < 0)
 119         return ETIMEDOUT;
 120
 121       /* If *tidp == tid, wait until thread terminates or the wait times out.
 122          The kernel up to version 3.16.3 does not use the private futex
 123          operations for futex wake-up when the clone terminates.
 124       */
 125       if (lll_futex_timed_wait (tidp, tid, &rt, LLL_SHARED) == -ETIMEDOUT)
 126         return ETIMEDOUT;
 127     }
 128
 129   return 0;
 130 }
 131 #endif