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