nptl/pthread_mutex_timedlock.c

   1 /* Copyright (C) 2002-2007, 2008 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
   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, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <assert.h>
  21 #include <errno.h>
  22 #include <time.h>
  23 #include "pthreadP.h"
  24 #include <lowlevellock.h>
  25 #include <not-cancel.h>
  26
  27
  28 int
  29 pthread_mutex_timedlock (mutex, abstime)
  30      pthread_mutex_t *mutex;
  31      const struct timespec *abstime;
  32 {
  33   int oldval;
  34   pid_t id = THREAD_GETMEM (THREAD_SELF, tid);
  35   int result = 0;
  36
  37   /* We must not check ABSTIME here.  If the thread does not block
  38      abstime must not be checked for a valid value.  */
  39
  40   switch (__builtin_expect (PTHREAD_MUTEX_TYPE (mutex),
  41                             PTHREAD_MUTEX_TIMED_NP))
  42     {
  43       /* Recursive mutex.  */
  44     case PTHREAD_MUTEX_RECURSIVE_NP:
  45       /* Check whether we already hold the mutex.  */
  46       if (mutex->__data.__owner == id)
  47         {
  48           /* Just bump the counter.  */
  49           if (__builtin_expect (mutex->__data.__count + 1 == 0, 0))
  50             /* Overflow of the counter.  */
  51             return EAGAIN;
  52
  53           ++mutex->__data.__count;
  54
  55           goto out;
  56         }
  57
  58       /* We have to get the mutex.  */
  59       result = lll_timedlock (mutex->__data.__lock, abstime,
  60                               PTHREAD_MUTEX_PSHARED (mutex));
  61
  62       if (result != 0)
  63         goto out;
  64
  65       /* Only locked once so far.  */
  66       mutex->__data.__count = 1;
  67       break;
  68
  69       /* Error checking mutex.  */
  70     case PTHREAD_MUTEX_ERRORCHECK_NP:
  71       /* Check whether we already hold the mutex.  */
  72       if (__builtin_expect (mutex->__data.__owner == id, 0))
  73         return EDEADLK;
  74
  75       /* FALLTHROUGH */
  76
  77     case PTHREAD_MUTEX_TIMED_NP:
  78     simple:
  79       /* Normal mutex.  */
  80       result = lll_timedlock (mutex->__data.__lock, abstime,
  81                               PTHREAD_MUTEX_PSHARED (mutex));
  82       break;
  83
  84     case PTHREAD_MUTEX_ADAPTIVE_NP:
  85       if (! __is_smp)
  86         goto simple;
  87
  88       if (lll_trylock (mutex->__data.__lock) != 0)
  89         {
  90           int cnt = 0;
  91           int max_cnt = MIN (MAX_ADAPTIVE_COUNT,
  92                              mutex->__data.__spins * 2 + 10);
  93           do
  94             {
  95               if (cnt++ >= max_cnt)
  96                 {
  97                   result = lll_timedlock (mutex->__data.__lock, abstime,
  98                                           PTHREAD_MUTEX_PSHARED (mutex));
  99                   break;
 100                 }
 101
 102 #ifdef BUSY_WAIT_NOP
 103               BUSY_WAIT_NOP;
 104 #endif
 105             }
 106           while (lll_trylock (mutex->__data.__lock) != 0);
 107
 108           mutex->__data.__spins += (cnt - mutex->__data.__spins) / 8;
 109         }
 110       break;
 111
 112     case PTHREAD_MUTEX_ROBUST_RECURSIVE_NP:
 113     case PTHREAD_MUTEX_ROBUST_ERRORCHECK_NP:
 114     case PTHREAD_MUTEX_ROBUST_NORMAL_NP:
 115     case PTHREAD_MUTEX_ROBUST_ADAPTIVE_NP:
 116       THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
 117                      &mutex->__data.__list.__next);
 118
 119       oldval = mutex->__data.__lock;
 120       do
 121         {
 122         again:
 123           if ((oldval & FUTEX_OWNER_DIED) != 0)
 124             {
 125               /* The previous owner died.  Try locking the mutex.  */
 126               int newval = id | (oldval & FUTEX_WAITERS);
 127
 128               newval
 129                 = atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
 130                                                        newval, oldval);
 131               if (newval != oldval)
 132                 {
 133                   oldval = newval;
 134                   goto again;
 135                 }
 136
 137               /* We got the mutex.  */
 138               mutex->__data.__count = 1;
 139               /* But it is inconsistent unless marked otherwise.  */
 140               mutex->__data.__owner = PTHREAD_MUTEX_INCONSISTENT;
 141
 142               ENQUEUE_MUTEX (mutex);
 143               THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
 144
 145               /* Note that we deliberately exit here.  If we fall
 146                  through to the end of the function __nusers would be
 147                  incremented which is not correct because the old
 148                  owner has to be discounted.  */
 149               return EOWNERDEAD;
 150             }
 151
 152           /* Check whether we already hold the mutex.  */
 153           if (__builtin_expect ((oldval & FUTEX_TID_MASK) == id, 0))
 154             {
 155               int kind = PTHREAD_MUTEX_TYPE (mutex);
 156               if (kind == PTHREAD_MUTEX_ROBUST_ERRORCHECK_NP)
 157                 {
 158                   THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
 159                                  NULL);
 160                   return EDEADLK;
 161                 }
 162
 163               if (kind == PTHREAD_MUTEX_ROBUST_RECURSIVE_NP)
 164                 {
 165                   THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
 166                                  NULL);
 167
 168                   /* Just bump the counter.  */
 169                   if (__builtin_expect (mutex->__data.__count + 1 == 0, 0))
 170                     /* Overflow of the counter.  */
 171                     return EAGAIN;
 172
 173                   ++mutex->__data.__count;
 174
 175                   return 0;
 176                 }
 177             }
 178
 179           result = lll_robust_timedlock (mutex->__data.__lock, abstime, id,
 180                                          PTHREAD_ROBUST_MUTEX_PSHARED (mutex));
 181
 182           if (__builtin_expect (mutex->__data.__owner
 183                                 == PTHREAD_MUTEX_NOTRECOVERABLE, 0))
 184             {
 185               /* This mutex is now not recoverable.  */
 186               mutex->__data.__count = 0;
 187               lll_unlock (mutex->__data.__lock,
 188                           PTHREAD_ROBUST_MUTEX_PSHARED (mutex));
 189               THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
 190               return ENOTRECOVERABLE;
 191             }
 192
 193           if (result == ETIMEDOUT || result == EINVAL)
 194             goto out;
 195
 196           oldval = result;
 197         }
 198       while ((oldval & FUTEX_OWNER_DIED) != 0);
 199
 200       mutex->__data.__count = 1;
 201       ENQUEUE_MUTEX (mutex);
 202       THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
 203       break;
 204
 205     case PTHREAD_MUTEX_PI_RECURSIVE_NP:
 206     case PTHREAD_MUTEX_PI_ERRORCHECK_NP:
 207     case PTHREAD_MUTEX_PI_NORMAL_NP:
 208     case PTHREAD_MUTEX_PI_ADAPTIVE_NP:
 209     case PTHREAD_MUTEX_PI_ROBUST_RECURSIVE_NP:
 210     case PTHREAD_MUTEX_PI_ROBUST_ERRORCHECK_NP:
 211     case PTHREAD_MUTEX_PI_ROBUST_NORMAL_NP:
 212     case PTHREAD_MUTEX_PI_ROBUST_ADAPTIVE_NP:
 213       {
 214         int kind = mutex->__data.__kind & PTHREAD_MUTEX_KIND_MASK_NP;
 215         int robust = mutex->__data.__kind & PTHREAD_MUTEX_ROBUST_NORMAL_NP;
 216
 217         if (robust)
 218           /* Note: robust PI futexes are signaled by setting bit 0.  */
 219           THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
 220                          (void *) (((uintptr_t) &mutex->__data.__list.__next)
 221                                    | 1));
 222
 223         oldval = mutex->__data.__lock;
 224
 225         /* Check whether we already hold the mutex.  */
 226         if (__builtin_expect ((oldval & FUTEX_TID_MASK) == id, 0))
 227           {
 228             if (kind == PTHREAD_MUTEX_ERRORCHECK_NP)
 229               {
 230                 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
 231                 return EDEADLK;
 232               }
 233
 234             if (kind == PTHREAD_MUTEX_RECURSIVE_NP)
 235               {
 236                 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
 237
 238                 /* Just bump the counter.  */
 239                 if (__builtin_expect (mutex->__data.__count + 1 == 0, 0))
 240                   /* Overflow of the counter.  */
 241                   return EAGAIN;
 242
 243                 ++mutex->__data.__count;
 244
 245                 return 0;
 246               }
 247           }
 248
 249         oldval = atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
 250                                                       id, 0);
 251
 252         if (oldval != 0)
 253           {
 254             /* The mutex is locked.  The kernel will now take care of
 255                everything.  The timeout value must be a relative value.
 256                Convert it.  */
 257             int private = (robust
 258                            ? PTHREAD_ROBUST_MUTEX_PSHARED (mutex)
 259                            : PTHREAD_MUTEX_PSHARED (mutex));
 260             INTERNAL_SYSCALL_DECL (__err);
 261
 262             int e = INTERNAL_SYSCALL (futex, __err, 4, &mutex->__data.__lock,
 263                                       __lll_private_flag (FUTEX_LOCK_PI,
 264                                                           private), 1,
 265                                       abstime);
 266             if (INTERNAL_SYSCALL_ERROR_P (e, __err))
 267               {
 268                 if (INTERNAL_SYSCALL_ERRNO (e, __err) == ETIMEDOUT)
 269                   return ETIMEDOUT;
 270
 271                 if (INTERNAL_SYSCALL_ERRNO (e, __err) == ESRCH
 272                     || INTERNAL_SYSCALL_ERRNO (e, __err) == EDEADLK)
 273                   {
 274                     assert (INTERNAL_SYSCALL_ERRNO (e, __err) != EDEADLK
 275                             || (kind != PTHREAD_MUTEX_ERRORCHECK_NP
 276                                 && kind != PTHREAD_MUTEX_RECURSIVE_NP));
 277                     /* ESRCH can happen only for non-robust PI mutexes where
 278                        the owner of the lock died.  */
 279                     assert (INTERNAL_SYSCALL_ERRNO (e, __err) != ESRCH
 280                             || !robust);
 281
 282                     /* Delay the thread until the timeout is reached.
 283                        Then return ETIMEDOUT.  */
 284                     struct timespec reltime;
 285                     struct timespec now;
 286
 287                     INTERNAL_SYSCALL (clock_gettime, __err, 2, CLOCK_REALTIME,
 288                                       &now);
 289                     reltime.tv_sec = abstime->tv_sec - now.tv_sec;
 290                     reltime.tv_nsec = abstime->tv_nsec - now.tv_nsec;
 291                     if (reltime.tv_nsec < 0)
 292                       {
 293                         reltime.tv_nsec += 1000000000;
 294                         --reltime.tv_sec;
 295                       }
 296                     if (reltime.tv_sec >= 0)
 297                       while (nanosleep_not_cancel (&reltime, &reltime) != 0)
 298                         continue;
 299
 300                     return ETIMEDOUT;
 301                   }
 302
 303                 return INTERNAL_SYSCALL_ERRNO (e, __err);
 304               }
 305
 306             oldval = mutex->__data.__lock;
 307
 308             assert (robust || (oldval & FUTEX_OWNER_DIED) == 0);
 309           }
 310
 311         if (__builtin_expect (oldval & FUTEX_OWNER_DIED, 0))
 312           {
 313             atomic_and (&mutex->__data.__lock, ~FUTEX_OWNER_DIED);
 314
 315             /* We got the mutex.  */
 316             mutex->__data.__count = 1;
 317             /* But it is inconsistent unless marked otherwise.  */
 318             mutex->__data.__owner = PTHREAD_MUTEX_INCONSISTENT;
 319
 320             ENQUEUE_MUTEX_PI (mutex);
 321             THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
 322
 323             /* Note that we deliberately exit here.  If we fall
 324                through to the end of the function __nusers would be
 325                incremented which is not correct because the old owner
 326                has to be discounted.  */
 327             return EOWNERDEAD;
 328           }
 329
 330         if (robust
 331             && __builtin_expect (mutex->__data.__owner
 332                                  == PTHREAD_MUTEX_NOTRECOVERABLE, 0))
 333           {
 334             /* This mutex is now not recoverable.  */
 335             mutex->__data.__count = 0;
 336
 337             INTERNAL_SYSCALL_DECL (__err);
 338             INTERNAL_SYSCALL (futex, __err, 4, &mutex->__data.__lock,
 339                               __lll_private_flag (FUTEX_UNLOCK_PI,
 340                                                   PTHREAD_ROBUST_MUTEX_PSHARED (mutex)),
 341                               0, 0);
 342
 343             THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
 344             return ENOTRECOVERABLE;
 345           }
 346
 347         mutex->__data.__count = 1;
 348         if (robust)
 349           {
 350             ENQUEUE_MUTEX_PI (mutex);
 351             THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
 352           }
 353         }
 354       break;
 355
 356     case PTHREAD_MUTEX_PP_RECURSIVE_NP:
 357     case PTHREAD_MUTEX_PP_ERRORCHECK_NP:
 358     case PTHREAD_MUTEX_PP_NORMAL_NP:
 359     case PTHREAD_MUTEX_PP_ADAPTIVE_NP:
 360       {
 361         int kind = mutex->__data.__kind & PTHREAD_MUTEX_KIND_MASK_NP;
 362
 363         oldval = mutex->__data.__lock;
 364
 365         /* Check whether we already hold the mutex.  */
 366         if (mutex->__data.__owner == id)
 367           {
 368             if (kind == PTHREAD_MUTEX_ERRORCHECK_NP)
 369               return EDEADLK;
 370
 371             if (kind == PTHREAD_MUTEX_RECURSIVE_NP)
 372               {
 373                 /* Just bump the counter.  */
 374                 if (__builtin_expect (mutex->__data.__count + 1 == 0, 0))
 375                   /* Overflow of the counter.  */
 376                   return EAGAIN;
 377
 378                 ++mutex->__data.__count;
 379
 380                 return 0;
 381               }
 382           }
 383
 384         int oldprio = -1, ceilval;
 385         do
 386           {
 387             int ceiling = (oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK)
 388                           >> PTHREAD_MUTEX_PRIO_CEILING_SHIFT;
 389
 390             if (__pthread_current_priority () > ceiling)
 391               {
 392                 result = EINVAL;
 393               failpp:
 394                 if (oldprio != -1)
 395                   __pthread_tpp_change_priority (oldprio, -1);
 396                 return result;
 397               }
 398
 399             result = __pthread_tpp_change_priority (oldprio, ceiling);
 400             if (result)
 401               return result;
 402
 403             ceilval = ceiling << PTHREAD_MUTEX_PRIO_CEILING_SHIFT;
 404             oldprio = ceiling;
 405
 406             oldval
 407               = atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
 408                                                      ceilval | 1, ceilval);
 409
 410             if (oldval == ceilval)
 411               break;
 412
 413             do
 414               {
 415                 oldval
 416                   = atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
 417                                                          ceilval | 2,
 418                                                          ceilval | 1);
 419
 420                 if ((oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK) != ceilval)
 421                   break;
 422
 423                 if (oldval != ceilval)
 424                   {
 425                     /* Reject invalid timeouts.  */
 426                     if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
 427                       {
 428                         result = EINVAL;
 429                         goto failpp;
 430                       }
 431
 432                     struct timeval tv;
 433                     struct timespec rt;
 434
 435                     /* Get the current time.  */
 436                     (void) __gettimeofday (&tv, NULL);
 437
 438                     /* Compute relative timeout.  */
 439                     rt.tv_sec = abstime->tv_sec - tv.tv_sec;
 440                     rt.tv_nsec = abstime->tv_nsec - tv.tv_usec * 1000;
 441                     if (rt.tv_nsec < 0)
 442                       {
 443                         rt.tv_nsec += 1000000000;
 444                         --rt.tv_sec;
 445                       }
 446
 447                     /* Already timed out?  */
 448                     if (rt.tv_sec < 0)
 449                       {
 450                         result = ETIMEDOUT;
 451                         goto failpp;
 452                       }
 453
 454                     lll_futex_timed_wait (&mutex->__data.__lock,
 455                                           ceilval | 2, &rt,
 456                                           PTHREAD_MUTEX_PSHARED (mutex));
 457                   }
 458               }
 459             while (atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
 460                                                         ceilval | 2, ceilval)
 461                    != ceilval);
 462           }
 463         while ((oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK) != ceilval);
 464
 465         assert (mutex->__data.__owner == 0);
 466         mutex->__data.__count = 1;
 467       }
 468       break;
 469
 470     default:
 471       /* Correct code cannot set any other type.  */
 472       return EINVAL;
 473     }
 474
 475   if (result == 0)
 476     {
 477       /* Record the ownership.  */
 478       mutex->__data.__owner = id;
 479       ++mutex->__data.__nusers;
 480     }
 481
 482  out:
 483   return result;
 484 }