nptl/pthread_mutex_unlock.c

   1 /* Copyright (C) 2002, 2003, 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 <errno.h>
  21 #include <stdlib.h>
  22 #include "pthreadP.h"
  23 #include <lowlevellock.h>
  24
  25
  26 int
  27 internal_function attribute_hidden
  28 __pthread_mutex_unlock_usercnt (mutex, decr)
  29      pthread_mutex_t *mutex;
  30      int decr;
  31 {
  32   int newowner = 0;
  33
  34   switch (__builtin_expect (PTHREAD_MUTEX_TYPE (mutex),
  35                             PTHREAD_MUTEX_TIMED_NP))
  36     {
  37     case PTHREAD_MUTEX_RECURSIVE_NP:
  38       /* Recursive mutex.  */
  39       if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
  40         return EPERM;
  41
  42       if (--mutex->__data.__count != 0)
  43         /* We still hold the mutex.  */
  44         return 0;
  45       goto normal;
  46
  47     case PTHREAD_MUTEX_ERRORCHECK_NP:
  48       /* Error checking mutex.  */
  49       if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid)
  50           || ! lll_mutex_islocked (mutex->__data.__lock))
  51         return EPERM;
  52       /* FALLTHROUGH */
  53
  54     case PTHREAD_MUTEX_TIMED_NP:
  55     case PTHREAD_MUTEX_ADAPTIVE_NP:
  56       /* Always reset the owner field.  */
  57     normal:
  58       mutex->__data.__owner = 0;
  59       if (decr)
  60         /* One less user.  */
  61         --mutex->__data.__nusers;
  62
  63       /* Unlock.  */
  64       lll_mutex_unlock (mutex->__data.__lock);
  65       break;
  66
  67     case PTHREAD_MUTEX_ROBUST_RECURSIVE_NP:
  68       /* Recursive mutex.  */
  69       if ((mutex->__data.__lock & FUTEX_TID_MASK)
  70           == THREAD_GETMEM (THREAD_SELF, tid)
  71           && __builtin_expect (mutex->__data.__owner
  72                                == PTHREAD_MUTEX_INCONSISTENT, 0))
  73         {
  74           if (--mutex->__data.__count != 0)
  75             /* We still hold the mutex.  */
  76             return ENOTRECOVERABLE;
  77
  78           goto notrecoverable;
  79         }
  80
  81       if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
  82         return EPERM;
  83
  84       if (--mutex->__data.__count != 0)
  85         /* We still hold the mutex.  */
  86         return 0;
  87
  88       goto robust;
  89
  90     case PTHREAD_MUTEX_ROBUST_ERRORCHECK_NP:
  91     case PTHREAD_MUTEX_ROBUST_NORMAL_NP:
  92     case PTHREAD_MUTEX_ROBUST_ADAPTIVE_NP:
  93       if ((mutex->__data.__lock & FUTEX_TID_MASK)
  94           != THREAD_GETMEM (THREAD_SELF, tid)
  95           || ! lll_mutex_islocked (mutex->__data.__lock))
  96         return EPERM;
  97
  98       /* If the previous owner died and the caller did not succeed in
  99          making the state consistent, mark the mutex as unrecoverable
 100          and make all waiters.  */
 101       if (__builtin_expect (mutex->__data.__owner
 102                             == PTHREAD_MUTEX_INCONSISTENT, 0))
 103       notrecoverable:
 104         newowner = PTHREAD_MUTEX_NOTRECOVERABLE;
 105
 106     robust:
 107       /* Remove mutex from the list.  */
 108       THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
 109                      &mutex->__data.__list.__next);
 110       DEQUEUE_MUTEX (mutex);
 111
 112       mutex->__data.__owner = newowner;
 113       if (decr)
 114         /* One less user.  */
 115         --mutex->__data.__nusers;
 116
 117       /* Unlock.  */
 118       lll_robust_mutex_unlock (mutex->__data.__lock);
 119
 120       THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
 121       break;
 122
 123     case PTHREAD_MUTEX_PI_RECURSIVE_NP:
 124       /* Recursive mutex.  */
 125       if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
 126         return EPERM;
 127
 128       if (--mutex->__data.__count != 0)
 129         /* We still hold the mutex.  */
 130         return 0;
 131       goto continue_pi;
 132
 133     case PTHREAD_MUTEX_PI_ROBUST_RECURSIVE_NP:
 134       /* Recursive mutex.  */
 135       if ((mutex->__data.__lock & FUTEX_TID_MASK)
 136           == THREAD_GETMEM (THREAD_SELF, tid)
 137           && __builtin_expect (mutex->__data.__owner
 138                                == PTHREAD_MUTEX_INCONSISTENT, 0))
 139         {
 140           if (--mutex->__data.__count != 0)
 141             /* We still hold the mutex.  */
 142             return ENOTRECOVERABLE;
 143
 144           goto pi_notrecoverable;
 145         }
 146
 147       if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
 148         return EPERM;
 149
 150       if (--mutex->__data.__count != 0)
 151         /* We still hold the mutex.  */
 152         return 0;
 153
 154       goto continue_pi;
 155
 156     case PTHREAD_MUTEX_PI_ERRORCHECK_NP:
 157     case PTHREAD_MUTEX_PI_NORMAL_NP:
 158     case PTHREAD_MUTEX_PI_ADAPTIVE_NP:
 159     case PTHREAD_MUTEX_PI_ROBUST_ERRORCHECK_NP:
 160     case PTHREAD_MUTEX_PI_ROBUST_NORMAL_NP:
 161     case PTHREAD_MUTEX_PI_ROBUST_ADAPTIVE_NP:
 162       if ((mutex->__data.__lock & FUTEX_TID_MASK)
 163           != THREAD_GETMEM (THREAD_SELF, tid)
 164           || ! lll_mutex_islocked (mutex->__data.__lock))
 165         return EPERM;
 166
 167       /* If the previous owner died and the caller did not succeed in
 168          making the state consistent, mark the mutex as unrecoverable
 169          and make all waiters.  */
 170       if ((mutex->__data.__kind & PTHREAD_MUTEX_ROBUST_NORMAL_NP) != 0
 171           && __builtin_expect (mutex->__data.__owner
 172                                == PTHREAD_MUTEX_INCONSISTENT, 0))
 173       pi_notrecoverable:
 174        newowner = PTHREAD_MUTEX_NOTRECOVERABLE;
 175
 176     continue_pi:
 177       if ((mutex->__data.__kind & PTHREAD_MUTEX_ROBUST_NORMAL_NP) != 0)
 178         {
 179           /* Remove mutex from the list.
 180              Note: robust PI futexes are signaled by setting bit 0.  */
 181           THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
 182                          (void *) (((uintptr_t) &mutex->__data.__list.__next)
 183                                    | 1));
 184           DEQUEUE_MUTEX (mutex);
 185         }
 186
 187       mutex->__data.__owner = newowner;
 188       if (decr)
 189         /* One less user.  */
 190         --mutex->__data.__nusers;
 191
 192       /* Unlock.  */
 193       if ((mutex->__data.__lock & FUTEX_WAITERS) != 0
 194           || atomic_compare_and_exchange_bool_acq (&mutex->__data.__lock, 0,
 195                                                    THREAD_GETMEM (THREAD_SELF,
 196                                                                   tid)))
 197         {
 198           INTERNAL_SYSCALL_DECL (__err);
 199           INTERNAL_SYSCALL (futex, __err, 2, &mutex->__data.__lock,
 200                             FUTEX_UNLOCK_PI);
 201         }
 202
 203       THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
 204       break;
 205
 206     case PTHREAD_MUTEX_PP_RECURSIVE_NP:
 207       /* Recursive mutex.  */
 208       if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
 209         return EPERM;
 210
 211       if (--mutex->__data.__count != 0)
 212         /* We still hold the mutex.  */
 213         return 0;
 214       goto pp;
 215
 216     case PTHREAD_MUTEX_PP_ERRORCHECK_NP:
 217       /* Error checking mutex.  */
 218       if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid)
 219           || (mutex->__data.__lock & ~ PTHREAD_MUTEX_PRIO_CEILING_MASK) == 0)
 220         return EPERM;
 221       /* FALLTHROUGH */
 222
 223     case PTHREAD_MUTEX_PP_NORMAL_NP:
 224     case PTHREAD_MUTEX_PP_ADAPTIVE_NP:
 225       /* Always reset the owner field.  */
 226     pp:
 227       mutex->__data.__owner = 0;
 228
 229       if (decr)
 230         /* One less user.  */
 231         --mutex->__data.__nusers;
 232
 233       /* Unlock.  */
 234       int newval, oldval;
 235       do
 236         {
 237           oldval = mutex->__data.__lock;
 238           newval = oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK;
 239         }
 240       while (atomic_compare_and_exchange_bool_acq (&mutex->__data.__lock,
 241                                                    newval, oldval));
 242
 243       if ((oldval & ~PTHREAD_MUTEX_PRIO_CEILING_MASK) > 1)
 244         lll_futex_wake (&mutex->__data.__lock, 1,
 245                         // XYZ check mutex flag
 246                         LLL_SHARED);
 247
 248       int oldprio = newval >> PTHREAD_MUTEX_PRIO_CEILING_SHIFT;
 249       return __pthread_tpp_change_priority (oldprio, -1);
 250
 251     default:
 252       /* Correct code cannot set any other type.  */
 253       return EINVAL;
 254     }
 255
 256   return 0;
 257 }
 258
 259
 260 int
 261 __pthread_mutex_unlock (mutex)
 262      pthread_mutex_t *mutex;
 263 {
 264   return __pthread_mutex_unlock_usercnt (mutex, 1);
 265 }
 266 strong_alias (__pthread_mutex_unlock, pthread_mutex_unlock)
 267 strong_alias (__pthread_mutex_unlock, __pthread_mutex_unlock_internal)