1 /* Copyright (C) 2002, 2003, 2005-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, see
17 <http://www.gnu.org/licenses/>. */
18
19 #include <assert.h>
20 #include <errno.h>
21 #include <stdlib.h>
22 #include "pthreadP.h"
23 #include <lowlevellock.h>
24
25
26 int
__pthread_mutex_trylock(pthread_mutex_t * mutex)27 __pthread_mutex_trylock (
28 pthread_mutex_t *mutex)
29 {
30 int oldval;
31 pid_t id = THREAD_GETMEM (THREAD_SELF, tid);
32
33 switch (__builtin_expect (PTHREAD_MUTEX_TYPE (mutex),
34 PTHREAD_MUTEX_TIMED_NP))
35 {
36 /* Recursive mutex. */
37 case PTHREAD_MUTEX_RECURSIVE_NP:
38 /* Check whether we already hold the mutex. */
39 if (mutex->__data.__owner == id)
40 {
41 /* Just bump the counter. */
42 if (__builtin_expect (mutex->__data.__count + 1 == 0, 0))
43 /* Overflow of the counter. */
44 return EAGAIN;
45
46 ++mutex->__data.__count;
47 return 0;
48 }
49
50 if (lll_trylock (mutex->__data.__lock) == 0)
51 {
52 /* Record the ownership. */
53 mutex->__data.__owner = id;
54 mutex->__data.__count = 1;
55 ++mutex->__data.__nusers;
56 return 0;
57 }
58 break;
59
60 case PTHREAD_MUTEX_ERRORCHECK_NP:
61 case PTHREAD_MUTEX_TIMED_NP:
62 case PTHREAD_MUTEX_ADAPTIVE_NP:
63 /* Normal mutex. */
64 if (lll_trylock (mutex->__data.__lock) != 0)
65 break;
66
67 /* Record the ownership. */
68 mutex->__data.__owner = id;
69 ++mutex->__data.__nusers;
70
71 return 0;
72
73 case PTHREAD_MUTEX_ROBUST_RECURSIVE_NP:
74 case PTHREAD_MUTEX_ROBUST_ERRORCHECK_NP:
75 case PTHREAD_MUTEX_ROBUST_NORMAL_NP:
76 case PTHREAD_MUTEX_ROBUST_ADAPTIVE_NP:
77 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
78 &mutex->__data.__list.__next);
79
80 oldval = mutex->__data.__lock;
81 do
82 {
83 again:
84 if ((oldval & FUTEX_OWNER_DIED) != 0)
85 {
86 /* The previous owner died. Try locking the mutex. */
87 int newval = id | (oldval & FUTEX_WAITERS);
88
89 newval
90 = atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
91 newval, oldval);
92
93 if (newval != oldval)
94 {
95 oldval = newval;
96 goto again;
97 }
98
99 /* We got the mutex. */
100 mutex->__data.__count = 1;
101 /* But it is inconsistent unless marked otherwise. */
102 mutex->__data.__owner = PTHREAD_MUTEX_INCONSISTENT;
103
104 ENQUEUE_MUTEX (mutex);
105 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
106
107 /* Note that we deliberately exist here. If we fall
108 through to the end of the function __nusers would be
109 incremented which is not correct because the old
110 owner has to be discounted. */
111 return EOWNERDEAD;
112 }
113
114 /* Check whether we already hold the mutex. */
115 if (__builtin_expect ((oldval & FUTEX_TID_MASK) == id, 0))
116 {
117 int kind = PTHREAD_MUTEX_TYPE (mutex);
118 if (kind == PTHREAD_MUTEX_ROBUST_ERRORCHECK_NP)
119 {
120 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
121 NULL);
122 return EDEADLK;
123 }
124
125 if (kind == PTHREAD_MUTEX_ROBUST_RECURSIVE_NP)
126 {
127 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
128 NULL);
129
130 /* Just bump the counter. */
131 if (__builtin_expect (mutex->__data.__count + 1 == 0, 0))
132 /* Overflow of the counter. */
133 return EAGAIN;
134
135 ++mutex->__data.__count;
136
137 return 0;
138 }
139 }
140
141 oldval = lll_robust_trylock (mutex->__data.__lock, id);
142 if (oldval != 0 && (oldval & FUTEX_OWNER_DIED) == 0)
143 {
144 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
145
146 return EBUSY;
147 }
148
149 if (__builtin_expect (mutex->__data.__owner
150 == PTHREAD_MUTEX_NOTRECOVERABLE, 0))
151 {
152 /* This mutex is now not recoverable. */
153 mutex->__data.__count = 0;
154 if (oldval == id)
155 lll_unlock (mutex->__data.__lock,
156 PTHREAD_ROBUST_MUTEX_PSHARED (mutex));
157 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
158 return ENOTRECOVERABLE;
159 }
160 }
161 while ((oldval & FUTEX_OWNER_DIED) != 0);
162
163 ENQUEUE_MUTEX (mutex);
164 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
165
166 mutex->__data.__owner = id;
167 ++mutex->__data.__nusers;
168 mutex->__data.__count = 1;
169
170 return 0;
171
172 case PTHREAD_MUTEX_PI_RECURSIVE_NP:
173 case PTHREAD_MUTEX_PI_ERRORCHECK_NP:
174 case PTHREAD_MUTEX_PI_NORMAL_NP:
175 case PTHREAD_MUTEX_PI_ADAPTIVE_NP:
176 case PTHREAD_MUTEX_PI_ROBUST_RECURSIVE_NP:
177 case PTHREAD_MUTEX_PI_ROBUST_ERRORCHECK_NP:
178 case PTHREAD_MUTEX_PI_ROBUST_NORMAL_NP:
179 case PTHREAD_MUTEX_PI_ROBUST_ADAPTIVE_NP:
180 {
181 int kind = mutex->__data.__kind & PTHREAD_MUTEX_KIND_MASK_NP;
182 int robust = mutex->__data.__kind & PTHREAD_MUTEX_ROBUST_NORMAL_NP;
183
184 if (robust)
185 /* Note: robust PI futexes are signaled by setting bit 0. */
186 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,
187 (void *) (((uintptr_t) &mutex->__data.__list.__next)
188 | 1));
189
190 oldval = mutex->__data.__lock;
191
192 /* Check whether we already hold the mutex. */
193 if (__builtin_expect ((oldval & FUTEX_TID_MASK) == id, 0))
194 {
195 if (kind == PTHREAD_MUTEX_ERRORCHECK_NP)
196 {
197 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
198 return EDEADLK;
199 }
200
201 if (kind == PTHREAD_MUTEX_RECURSIVE_NP)
202 {
203 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
204
205 /* Just bump the counter. */
206 if (__builtin_expect (mutex->__data.__count + 1 == 0, 0))
207 /* Overflow of the counter. */
208 return EAGAIN;
209
210 ++mutex->__data.__count;
211
212 return 0;
213 }
214 }
215
216 oldval
217 = atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
218 id, 0);
219
220 if (oldval != 0)
221 {
222 if ((oldval & FUTEX_OWNER_DIED) == 0)
223 {
224 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
225
226 return EBUSY;
227 }
228
229 assert (robust);
230
231 /* The mutex owner died. The kernel will now take care of
232 everything. */
233 int private = (robust
234 ? PTHREAD_ROBUST_MUTEX_PSHARED (mutex)
235 : PTHREAD_MUTEX_PSHARED (mutex));
236 INTERNAL_SYSCALL_DECL (__err);
237 #if defined(__UCLIBC_USE_TIME64__) && defined(__NR_futex_time64)
238 int e = INTERNAL_SYSCALL (futex_time64, __err, 4, &mutex->__data.__lock,
239 __lll_private_flag (FUTEX_TRYLOCK_PI,
240 private), 0, 0);
241 #else
242 int e = INTERNAL_SYSCALL (futex, __err, 4, &mutex->__data.__lock,
243 __lll_private_flag (FUTEX_TRYLOCK_PI,
244 private), 0, 0);
245 #endif
246
247 if (INTERNAL_SYSCALL_ERROR_P (e, __err)
248 && INTERNAL_SYSCALL_ERRNO (e, __err) == EWOULDBLOCK)
249 {
250 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
251
252 return EBUSY;
253 }
254
255 oldval = mutex->__data.__lock;
256 }
257
258 if (__builtin_expect (oldval & FUTEX_OWNER_DIED, 0))
259 {
260 atomic_and (&mutex->__data.__lock, ~FUTEX_OWNER_DIED);
261
262 /* We got the mutex. */
263 mutex->__data.__count = 1;
264 /* But it is inconsistent unless marked otherwise. */
265 mutex->__data.__owner = PTHREAD_MUTEX_INCONSISTENT;
266
267 ENQUEUE_MUTEX (mutex);
268 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
269
270 /* Note that we deliberately exit here. If we fall
271 through to the end of the function __nusers would be
272 incremented which is not correct because the old owner
273 has to be discounted. */
274 return EOWNERDEAD;
275 }
276
277 if (robust
278 && __builtin_expect (mutex->__data.__owner
279 == PTHREAD_MUTEX_NOTRECOVERABLE, 0))
280 {
281 /* This mutex is now not recoverable. */
282 mutex->__data.__count = 0;
283
284 INTERNAL_SYSCALL_DECL (__err);
285 #if defined(__UCLIBC_USE_TIME64__) && defined(__NR_futex_time64)
286 INTERNAL_SYSCALL (futex_time64, __err, 4, &mutex->__data.__lock,
287 __lll_private_flag (FUTEX_UNLOCK_PI,
288 PTHREAD_ROBUST_MUTEX_PSHARED (mutex)),
289 0, 0);
290 #else
291 INTERNAL_SYSCALL (futex, __err, 4, &mutex->__data.__lock,
292 __lll_private_flag (FUTEX_UNLOCK_PI,
293 PTHREAD_ROBUST_MUTEX_PSHARED (mutex)),
294 0, 0);
295 #endif
296
297 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
298 return ENOTRECOVERABLE;
299 }
300
301 if (robust)
302 {
303 ENQUEUE_MUTEX_PI (mutex);
304 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
305 }
306
307 mutex->__data.__owner = id;
308 ++mutex->__data.__nusers;
309 mutex->__data.__count = 1;
310
311 return 0;
312 }
313
314 case PTHREAD_MUTEX_PP_RECURSIVE_NP:
315 case PTHREAD_MUTEX_PP_ERRORCHECK_NP:
316 case PTHREAD_MUTEX_PP_NORMAL_NP:
317 case PTHREAD_MUTEX_PP_ADAPTIVE_NP:
318 {
319 int kind = mutex->__data.__kind & PTHREAD_MUTEX_KIND_MASK_NP;
320
321 oldval = mutex->__data.__lock;
322
323 /* Check whether we already hold the mutex. */
324 if (mutex->__data.__owner == id)
325 {
326 if (kind == PTHREAD_MUTEX_ERRORCHECK_NP)
327 return EDEADLK;
328
329 if (kind == PTHREAD_MUTEX_RECURSIVE_NP)
330 {
331 /* Just bump the counter. */
332 if (__builtin_expect (mutex->__data.__count + 1 == 0, 0))
333 /* Overflow of the counter. */
334 return EAGAIN;
335
336 ++mutex->__data.__count;
337
338 return 0;
339 }
340 }
341
342 int oldprio = -1, ceilval;
343 do
344 {
345 int ceiling = (oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK)
346 >> PTHREAD_MUTEX_PRIO_CEILING_SHIFT;
347
348 if (__pthread_current_priority () > ceiling)
349 {
350 if (oldprio != -1)
351 __pthread_tpp_change_priority (oldprio, -1);
352 return EINVAL;
353 }
354
355 int retval = __pthread_tpp_change_priority (oldprio, ceiling);
356 if (retval)
357 return retval;
358
359 ceilval = ceiling << PTHREAD_MUTEX_PRIO_CEILING_SHIFT;
360 oldprio = ceiling;
361
362 oldval
363 = atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
364 ceilval | 1, ceilval);
365
366 if (oldval == ceilval)
367 break;
368 }
369 while ((oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK) != ceilval);
370
371 if (oldval != ceilval)
372 {
373 __pthread_tpp_change_priority (oldprio, -1);
374 break;
375 }
376
377 assert (mutex->__data.__owner == 0);
378 /* Record the ownership. */
379 mutex->__data.__owner = id;
380 ++mutex->__data.__nusers;
381 mutex->__data.__count = 1;
382
383 return 0;
384 }
385 break;
386
387 default:
388 /* Correct code cannot set any other type. */
389 return EINVAL;
390 }
391
392 return EBUSY;
393 }
394 strong_alias (__pthread_mutex_trylock, pthread_mutex_trylock)
395