1 /* Copyright (C) 2002, 2003, 2005-2008, 2009 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
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.
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.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <http://www.gnu.org/licenses/>. */
23 #include <lowlevellock.h>
27 __pthread_mutex_unlock_full (pthread_mutex_t *mutex, int decr)
28 __attribute_noinline__;
31 internal_function attribute_hidden
32 __pthread_mutex_unlock_usercnt (mutex, decr)
33 pthread_mutex_t *mutex;
36 int type = PTHREAD_MUTEX_TYPE (mutex);
37 if (__builtin_expect (type & ~PTHREAD_MUTEX_KIND_MASK_NP, 0))
38 return __pthread_mutex_unlock_full (mutex, decr);
40 if (__builtin_expect (type, PTHREAD_MUTEX_TIMED_NP)
41 == PTHREAD_MUTEX_TIMED_NP)
43 /* Always reset the owner field. */
45 mutex->__data.__owner = 0;
48 --mutex->__data.__nusers;
51 lll_unlock (mutex->__data.__lock, PTHREAD_MUTEX_PSHARED (mutex));
54 else if (__builtin_expect (type == PTHREAD_MUTEX_RECURSIVE_NP, 1))
56 /* Recursive mutex. */
57 if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
60 if (--mutex->__data.__count != 0)
61 /* We still hold the mutex. */
65 else if (__builtin_expect (type == PTHREAD_MUTEX_ADAPTIVE_NP, 1))
69 /* Error checking mutex. */
70 assert (type == PTHREAD_MUTEX_ERRORCHECK_NP);
71 if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid)
72 || ! lll_islocked (mutex->__data.__lock))
81 __pthread_mutex_unlock_full (pthread_mutex_t *mutex, int decr)
85 switch (PTHREAD_MUTEX_TYPE (mutex))
87 case PTHREAD_MUTEX_ROBUST_RECURSIVE_NP:
88 /* Recursive mutex. */
89 if ((mutex->__data.__lock & FUTEX_TID_MASK)
90 == THREAD_GETMEM (THREAD_SELF, tid)
91 && __builtin_expect (mutex->__data.__owner
92 == PTHREAD_MUTEX_INCONSISTENT, 0))
94 if (--mutex->__data.__count != 0)
95 /* We still hold the mutex. */
96 return ENOTRECOVERABLE;
101 if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
104 if (--mutex->__data.__count != 0)
105 /* We still hold the mutex. */
110 case PTHREAD_MUTEX_ROBUST_ERRORCHECK_NP:
111 case PTHREAD_MUTEX_ROBUST_NORMAL_NP:
112 case PTHREAD_MUTEX_ROBUST_ADAPTIVE_NP:
113 if ((mutex->__data.__lock & FUTEX_TID_MASK)
114 != THREAD_GETMEM (THREAD_SELF, tid)
115 || ! lll_islocked (mutex->__data.__lock))
118 /* If the previous owner died and the caller did not succeed in
119 making the state consistent, mark the mutex as unrecoverable
120 and make all waiters. */
121 if (__builtin_expect (mutex->__data.__owner
122 == PTHREAD_MUTEX_INCONSISTENT, 0))
124 newowner = PTHREAD_MUTEX_NOTRECOVERABLE;
127 /* Remove mutex from the list. */
128 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
129 &mutex->__data.__list.__next);
130 DEQUEUE_MUTEX (mutex);
132 mutex->__data.__owner = newowner;
135 --mutex->__data.__nusers;
138 lll_robust_unlock (mutex->__data.__lock,
139 PTHREAD_ROBUST_MUTEX_PSHARED (mutex));
141 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
144 case PTHREAD_MUTEX_PI_RECURSIVE_NP:
145 /* Recursive mutex. */
146 if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
149 if (--mutex->__data.__count != 0)
150 /* We still hold the mutex. */
152 goto continue_pi_non_robust;
154 case PTHREAD_MUTEX_PI_ROBUST_RECURSIVE_NP:
155 /* Recursive mutex. */
156 if ((mutex->__data.__lock & FUTEX_TID_MASK)
157 == THREAD_GETMEM (THREAD_SELF, tid)
158 && __builtin_expect (mutex->__data.__owner
159 == PTHREAD_MUTEX_INCONSISTENT, 0))
161 if (--mutex->__data.__count != 0)
162 /* We still hold the mutex. */
163 return ENOTRECOVERABLE;
165 goto pi_notrecoverable;
168 if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
171 if (--mutex->__data.__count != 0)
172 /* We still hold the mutex. */
175 goto continue_pi_robust;
177 case PTHREAD_MUTEX_PI_ERRORCHECK_NP:
178 case PTHREAD_MUTEX_PI_NORMAL_NP:
179 case PTHREAD_MUTEX_PI_ADAPTIVE_NP:
180 case PTHREAD_MUTEX_PI_ROBUST_ERRORCHECK_NP:
181 case PTHREAD_MUTEX_PI_ROBUST_NORMAL_NP:
182 case PTHREAD_MUTEX_PI_ROBUST_ADAPTIVE_NP:
183 if ((mutex->__data.__lock & FUTEX_TID_MASK)
184 != THREAD_GETMEM (THREAD_SELF, tid)
185 || ! lll_islocked (mutex->__data.__lock))
188 /* If the previous owner died and the caller did not succeed in
189 making the state consistent, mark the mutex as unrecoverable
190 and make all waiters. */
191 if ((mutex->__data.__kind & PTHREAD_MUTEX_ROBUST_NORMAL_NP) != 0
192 && __builtin_expect (mutex->__data.__owner
193 == PTHREAD_MUTEX_INCONSISTENT, 0))
195 newowner = PTHREAD_MUTEX_NOTRECOVERABLE;
197 if ((mutex->__data.__kind & PTHREAD_MUTEX_ROBUST_NORMAL_NP) != 0)
200 /* Remove mutex from the list.
201 Note: robust PI futexes are signaled by setting bit 0. */
202 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
203 (void *) (((uintptr_t) &mutex->__data.__list.__next)
205 DEQUEUE_MUTEX (mutex);
208 continue_pi_non_robust:
209 mutex->__data.__owner = newowner;
212 --mutex->__data.__nusers;
215 if ((mutex->__data.__lock & FUTEX_WAITERS) != 0
216 || atomic_compare_and_exchange_bool_rel (&mutex->__data.__lock, 0,
217 THREAD_GETMEM (THREAD_SELF,
220 int robust = mutex->__data.__kind & PTHREAD_MUTEX_ROBUST_NORMAL_NP;
221 int private = (robust
222 ? PTHREAD_ROBUST_MUTEX_PSHARED (mutex)
223 : PTHREAD_MUTEX_PSHARED (mutex));
224 INTERNAL_SYSCALL_DECL (__err);
225 INTERNAL_SYSCALL (futex, __err, 2, &mutex->__data.__lock,
226 __lll_private_flag (FUTEX_UNLOCK_PI, private));
229 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
232 case PTHREAD_MUTEX_PP_RECURSIVE_NP:
233 /* Recursive mutex. */
234 if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid))
237 if (--mutex->__data.__count != 0)
238 /* We still hold the mutex. */
242 case PTHREAD_MUTEX_PP_ERRORCHECK_NP:
243 /* Error checking mutex. */
244 if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid)
245 || (mutex->__data.__lock & ~ PTHREAD_MUTEX_PRIO_CEILING_MASK) == 0)
249 case PTHREAD_MUTEX_PP_NORMAL_NP:
250 case PTHREAD_MUTEX_PP_ADAPTIVE_NP:
251 /* Always reset the owner field. */
253 mutex->__data.__owner = 0;
257 --mutex->__data.__nusers;
263 oldval = mutex->__data.__lock;
264 newval = oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK;
266 while (atomic_compare_and_exchange_bool_rel (&mutex->__data.__lock,
269 if ((oldval & ~PTHREAD_MUTEX_PRIO_CEILING_MASK) > 1)
270 lll_futex_wake (&mutex->__data.__lock, 1,
271 PTHREAD_MUTEX_PSHARED (mutex));
273 int oldprio = newval >> PTHREAD_MUTEX_PRIO_CEILING_SHIFT;
274 return __pthread_tpp_change_priority (oldprio, -1);
277 /* Correct code cannot set any other type. */
286 __pthread_mutex_unlock (mutex)
287 pthread_mutex_t *mutex;
289 return __pthread_mutex_unlock_usercnt (mutex, 1);
291 strong_alias (__pthread_mutex_unlock, pthread_mutex_unlock)
292 strong_alias (__pthread_mutex_unlock, __pthread_mutex_unlock_internal)