nptl/pthread_mutex_timedlock.c

   1 /* Copyright (C) 2002,2003,2004,2005,2006,2007 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             INTERNAL_SYSCALL_DECL (__err);
 258
 259             int e = INTERNAL_SYSCALL (futex, __err, 4, &mutex->__data.__lock,
 260                                       FUTEX_LOCK_PI, 1, abstime);
 261             if (INTERNAL_SYSCALL_ERROR_P (e, __err))
 262               {
 263                 if (INTERNAL_SYSCALL_ERRNO (e, __err) == ETIMEDOUT)
 264                   return ETIMEDOUT;
 265
 266                 if (INTERNAL_SYSCALL_ERRNO (e, __err) == ESRCH
 267                     || INTERNAL_SYSCALL_ERRNO (e, __err) == EDEADLK)
 268                   {
 269                     assert (INTERNAL_SYSCALL_ERRNO (e, __err) != EDEADLK
 270                             || (kind != PTHREAD_MUTEX_ERRORCHECK_NP
 271                                 && kind != PTHREAD_MUTEX_RECURSIVE_NP));
 272                     /* ESRCH can happen only for non-robust PI mutexes where
 273                        the owner of the lock died.  */
 274                     assert (INTERNAL_SYSCALL_ERRNO (e, __err) != ESRCH
 275                             || !robust);
 276
 277                     /* Delay the thread until the timeout is reached.
 278                        Then return ETIMEDOUT.  */
 279                     struct timespec reltime;
 280                     struct timespec now;
 281
 282                     INTERNAL_SYSCALL (clock_gettime, __err, 2, CLOCK_REALTIME,
 283                                       &now);
 284                     reltime.tv_sec = abstime->tv_sec - now.tv_sec;
 285                     reltime.tv_nsec = abstime->tv_nsec - now.tv_nsec;
 286                     if (reltime.tv_nsec < 0)
 287                       {
 288                         reltime.tv_nsec += 1000000000;
 289                         --reltime.tv_sec;
 290                       }
 291                     if (reltime.tv_sec >= 0)
 292                       while (nanosleep_not_cancel (&reltime, &reltime) != 0)
 293                         continue;
 294
 295                     return ETIMEDOUT;
 296                   }
 297
 298                 return INTERNAL_SYSCALL_ERRNO (e, __err);
 299               }
 300
 301             oldval = mutex->__data.__lock;
 302
 303             assert (robust || (oldval & FUTEX_OWNER_DIED) == 0);
 304           }
 305
 306         if (__builtin_expect (oldval & FUTEX_OWNER_DIED, 0))
 307           {
 308             atomic_and (&mutex->__data.__lock, ~FUTEX_OWNER_DIED);
 309
 310             /* We got the mutex.  */
 311             mutex->__data.__count = 1;
 312             /* But it is inconsistent unless marked otherwise.  */
 313             mutex->__data.__owner = PTHREAD_MUTEX_INCONSISTENT;
 314
 315             ENQUEUE_MUTEX_PI (mutex);
 316             THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
 317
 318             /* Note that we deliberately exit here.  If we fall
 319                through to the end of the function __nusers would be
 320                incremented which is not correct because the old owner
 321                has to be discounted.  */
 322             return EOWNERDEAD;
 323           }
 324
 325         if (robust
 326             && __builtin_expect (mutex->__data.__owner
 327                                  == PTHREAD_MUTEX_NOTRECOVERABLE, 0))
 328           {
 329             /* This mutex is now not recoverable.  */
 330             mutex->__data.__count = 0;
 331
 332             INTERNAL_SYSCALL_DECL (__err);
 333             INTERNAL_SYSCALL (futex, __err, 4, &mutex->__data.__lock,
 334                               FUTEX_UNLOCK_PI, 0, 0);
 335
 336             THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
 337             return ENOTRECOVERABLE;
 338           }
 339
 340         mutex->__data.__count = 1;
 341         if (robust)
 342           {
 343             ENQUEUE_MUTEX_PI (mutex);
 344             THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
 345           }
 346         }
 347       break;
 348
 349     case PTHREAD_MUTEX_PP_RECURSIVE_NP:
 350     case PTHREAD_MUTEX_PP_ERRORCHECK_NP:
 351     case PTHREAD_MUTEX_PP_NORMAL_NP:
 352     case PTHREAD_MUTEX_PP_ADAPTIVE_NP:
 353       {
 354         int kind = mutex->__data.__kind & PTHREAD_MUTEX_KIND_MASK_NP;
 355
 356         oldval = mutex->__data.__lock;
 357
 358         /* Check whether we already hold the mutex.  */
 359         if (mutex->__data.__owner == id)
 360           {
 361             if (kind == PTHREAD_MUTEX_ERRORCHECK_NP)
 362               return EDEADLK;
 363
 364             if (kind == PTHREAD_MUTEX_RECURSIVE_NP)
 365               {
 366                 /* Just bump the counter.  */
 367                 if (__builtin_expect (mutex->__data.__count + 1 == 0, 0))
 368                   /* Overflow of the counter.  */
 369                   return EAGAIN;
 370
 371                 ++mutex->__data.__count;
 372
 373                 return 0;
 374               }
 375           }
 376
 377         int oldprio = -1, ceilval;
 378         do
 379           {
 380             int ceiling = (oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK)
 381                           >> PTHREAD_MUTEX_PRIO_CEILING_SHIFT;
 382
 383             if (__pthread_current_priority () > ceiling)
 384               {
 385                 result = EINVAL;
 386               failpp:
 387                 if (oldprio != -1)
 388                   __pthread_tpp_change_priority (oldprio, -1);
 389                 return result;
 390               }
 391
 392             result = __pthread_tpp_change_priority (oldprio, ceiling);
 393             if (result)
 394               return result;
 395
 396             ceilval = ceiling << PTHREAD_MUTEX_PRIO_CEILING_SHIFT;
 397             oldprio = ceiling;
 398
 399             oldval
 400               = atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
 401                                                      ceilval | 1, ceilval);
 402
 403             if (oldval == ceilval)
 404               break;
 405
 406             do
 407               {
 408                 oldval
 409                   = atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
 410                                                          ceilval | 2,
 411                                                          ceilval | 1);
 412
 413                 if ((oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK) != ceilval)
 414                   break;
 415
 416                 if (oldval != ceilval)
 417                   {
 418                     /* Reject invalid timeouts.  */
 419                     if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
 420                       {
 421                         result = EINVAL;
 422                         goto failpp;
 423                       }
 424
 425                     struct timeval tv;
 426                     struct timespec rt;
 427
 428                     /* Get the current time.  */
 429                     (void) __gettimeofday (&tv, NULL);
 430
 431                     /* Compute relative timeout.  */
 432                     rt.tv_sec = abstime->tv_sec - tv.tv_sec;
 433                     rt.tv_nsec = abstime->tv_nsec - tv.tv_usec * 1000;
 434                     if (rt.tv_nsec < 0)
 435                       {
 436                         rt.tv_nsec += 1000000000;
 437                         --rt.tv_sec;
 438                       }
 439
 440                     /* Already timed out?  */
 441                     if (rt.tv_sec < 0)
 442                       {
 443                         result = ETIMEDOUT;
 444                         goto failpp;
 445                       }
 446
 447                     lll_futex_timed_wait (&mutex->__data.__lock,
 448                                           ceilval | 2, &rt,
 449                                           PTHREAD_MUTEX_PSHARED (mutex));
 450                   }
 451               }
 452             while (atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
 453                                                         ceilval | 2, ceilval)
 454                    != ceilval);
 455           }
 456         while ((oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK) != ceilval);
 457
 458         assert (mutex->__data.__owner == 0);
 459         mutex->__data.__count = 1;
 460       }
 461       break;
 462
 463     default:
 464       /* Correct code cannot set any other type.  */
 465       return EINVAL;
 466     }
 467
 468   if (result == 0)
 469     {
 470       /* Record the ownership.  */
 471       mutex->__data.__owner = id;
 472       ++mutex->__data.__nusers;
 473     }
 474
 475  out:
 476   return result;
 477 }