1 /* Copyright (C) 2002-2017 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/>. */
22 #include <sys/param.h>
26 #include <lowlevellock.h>
27 #include <not-cancel.h>
29 #include <stap-probe.h>
31 #ifndef lll_timedlock_elision
32 #define lll_timedlock_elision(a,dummy,b,c) lll_timedlock(a, b, c)
35 #ifndef lll_trylock_elision
36 #define lll_trylock_elision(a,t) lll_trylock(a)
40 #define FORCE_ELISION(m, s)
44 pthread_mutex_timedlock (pthread_mutex_t
*mutex
,
45 const struct timespec
*abstime
)
48 pid_t id
= THREAD_GETMEM (THREAD_SELF
, tid
);
51 LIBC_PROBE (mutex_timedlock_entry
, 2, mutex
, abstime
);
53 /* We must not check ABSTIME here. If the thread does not block
54 abstime must not be checked for a valid value. */
56 switch (__builtin_expect (PTHREAD_MUTEX_TYPE_ELISION (mutex
),
57 PTHREAD_MUTEX_TIMED_NP
))
59 /* Recursive mutex. */
60 case PTHREAD_MUTEX_RECURSIVE_NP
|PTHREAD_MUTEX_ELISION_NP
:
61 case PTHREAD_MUTEX_RECURSIVE_NP
:
62 /* Check whether we already hold the mutex. */
63 if (mutex
->__data
.__owner
== id
)
65 /* Just bump the counter. */
66 if (__glibc_unlikely (mutex
->__data
.__count
+ 1 == 0))
67 /* Overflow of the counter. */
70 ++mutex
->__data
.__count
;
75 /* We have to get the mutex. */
76 result
= lll_timedlock (mutex
->__data
.__lock
, abstime
,
77 PTHREAD_MUTEX_PSHARED (mutex
));
82 /* Only locked once so far. */
83 mutex
->__data
.__count
= 1;
86 /* Error checking mutex. */
87 case PTHREAD_MUTEX_ERRORCHECK_NP
:
88 /* Check whether we already hold the mutex. */
89 if (__glibc_unlikely (mutex
->__data
.__owner
== id
))
92 /* Don't do lock elision on an error checking mutex. */
95 case PTHREAD_MUTEX_TIMED_NP
:
96 FORCE_ELISION (mutex
, goto elision
);
99 result
= lll_timedlock (mutex
->__data
.__lock
, abstime
,
100 PTHREAD_MUTEX_PSHARED (mutex
));
103 case PTHREAD_MUTEX_TIMED_ELISION_NP
:
104 elision
: __attribute__((unused
))
105 /* Don't record ownership */
106 return lll_timedlock_elision (mutex
->__data
.__lock
,
107 mutex
->__data
.__spins
,
109 PTHREAD_MUTEX_PSHARED (mutex
));
112 case PTHREAD_MUTEX_ADAPTIVE_NP
:
116 if (lll_trylock (mutex
->__data
.__lock
) != 0)
119 int max_cnt
= MIN (MAX_ADAPTIVE_COUNT
,
120 mutex
->__data
.__spins
* 2 + 10);
123 if (cnt
++ >= max_cnt
)
125 result
= lll_timedlock (mutex
->__data
.__lock
, abstime
,
126 PTHREAD_MUTEX_PSHARED (mutex
));
131 while (lll_trylock (mutex
->__data
.__lock
) != 0);
133 mutex
->__data
.__spins
+= (cnt
- mutex
->__data
.__spins
) / 8;
137 case PTHREAD_MUTEX_ROBUST_RECURSIVE_NP
:
138 case PTHREAD_MUTEX_ROBUST_ERRORCHECK_NP
:
139 case PTHREAD_MUTEX_ROBUST_NORMAL_NP
:
140 case PTHREAD_MUTEX_ROBUST_ADAPTIVE_NP
:
141 THREAD_SETMEM (THREAD_SELF
, robust_head
.list_op_pending
,
142 &mutex
->__data
.__list
.__next
);
144 oldval
= mutex
->__data
.__lock
;
145 /* This is set to FUTEX_WAITERS iff we might have shared the
146 FUTEX_WAITERS flag with other threads, and therefore need to keep it
147 set to avoid lost wake-ups. We have the same requirement in the
148 simple mutex algorithm. */
149 unsigned int assume_other_futex_waiters
= 0;
153 if ((oldval
& FUTEX_OWNER_DIED
) != 0)
155 /* The previous owner died. Try locking the mutex. */
156 int newval
= id
| (oldval
& FUTEX_WAITERS
)
157 | assume_other_futex_waiters
;
160 = atomic_compare_and_exchange_val_acq (&mutex
->__data
.__lock
,
162 if (newval
!= oldval
)
168 /* We got the mutex. */
169 mutex
->__data
.__count
= 1;
170 /* But it is inconsistent unless marked otherwise. */
171 mutex
->__data
.__owner
= PTHREAD_MUTEX_INCONSISTENT
;
173 ENQUEUE_MUTEX (mutex
);
174 THREAD_SETMEM (THREAD_SELF
, robust_head
.list_op_pending
, NULL
);
176 /* Note that we deliberately exit here. If we fall
177 through to the end of the function __nusers would be
178 incremented which is not correct because the old
179 owner has to be discounted. */
183 /* Check whether we already hold the mutex. */
184 if (__glibc_unlikely ((oldval
& FUTEX_TID_MASK
) == id
))
186 int kind
= PTHREAD_MUTEX_TYPE (mutex
);
187 if (kind
== PTHREAD_MUTEX_ROBUST_ERRORCHECK_NP
)
189 THREAD_SETMEM (THREAD_SELF
, robust_head
.list_op_pending
,
194 if (kind
== PTHREAD_MUTEX_ROBUST_RECURSIVE_NP
)
196 THREAD_SETMEM (THREAD_SELF
, robust_head
.list_op_pending
,
199 /* Just bump the counter. */
200 if (__glibc_unlikely (mutex
->__data
.__count
+ 1 == 0))
201 /* Overflow of the counter. */
204 ++mutex
->__data
.__count
;
206 LIBC_PROBE (mutex_timedlock_acquired
, 1, mutex
);
212 result
= lll_robust_timedlock (mutex
->__data
.__lock
, abstime
,
213 id
| assume_other_futex_waiters
,
214 PTHREAD_ROBUST_MUTEX_PSHARED (mutex
));
215 /* See above. We set FUTEX_WAITERS and might have shared this flag
216 with other threads; thus, we need to preserve it. */
217 assume_other_futex_waiters
= FUTEX_WAITERS
;
219 if (__builtin_expect (mutex
->__data
.__owner
220 == PTHREAD_MUTEX_NOTRECOVERABLE
, 0))
222 /* This mutex is now not recoverable. */
223 mutex
->__data
.__count
= 0;
224 lll_unlock (mutex
->__data
.__lock
,
225 PTHREAD_ROBUST_MUTEX_PSHARED (mutex
));
226 THREAD_SETMEM (THREAD_SELF
, robust_head
.list_op_pending
, NULL
);
227 return ENOTRECOVERABLE
;
230 if (result
== ETIMEDOUT
|| result
== EINVAL
)
235 while ((oldval
& FUTEX_OWNER_DIED
) != 0);
237 mutex
->__data
.__count
= 1;
238 ENQUEUE_MUTEX (mutex
);
239 THREAD_SETMEM (THREAD_SELF
, robust_head
.list_op_pending
, NULL
);
242 /* The PI support requires the Linux futex system call. If that's not
243 available, pthread_mutex_init should never have allowed the type to
244 be set. So it will get the default case for an invalid type. */
246 case PTHREAD_MUTEX_PI_RECURSIVE_NP
:
247 case PTHREAD_MUTEX_PI_ERRORCHECK_NP
:
248 case PTHREAD_MUTEX_PI_NORMAL_NP
:
249 case PTHREAD_MUTEX_PI_ADAPTIVE_NP
:
250 case PTHREAD_MUTEX_PI_ROBUST_RECURSIVE_NP
:
251 case PTHREAD_MUTEX_PI_ROBUST_ERRORCHECK_NP
:
252 case PTHREAD_MUTEX_PI_ROBUST_NORMAL_NP
:
253 case PTHREAD_MUTEX_PI_ROBUST_ADAPTIVE_NP
:
255 int kind
= mutex
->__data
.__kind
& PTHREAD_MUTEX_KIND_MASK_NP
;
256 int robust
= mutex
->__data
.__kind
& PTHREAD_MUTEX_ROBUST_NORMAL_NP
;
259 /* Note: robust PI futexes are signaled by setting bit 0. */
260 THREAD_SETMEM (THREAD_SELF
, robust_head
.list_op_pending
,
261 (void *) (((uintptr_t) &mutex
->__data
.__list
.__next
)
264 oldval
= mutex
->__data
.__lock
;
266 /* Check whether we already hold the mutex. */
267 if (__glibc_unlikely ((oldval
& FUTEX_TID_MASK
) == id
))
269 if (kind
== PTHREAD_MUTEX_ERRORCHECK_NP
)
271 THREAD_SETMEM (THREAD_SELF
, robust_head
.list_op_pending
, NULL
);
275 if (kind
== PTHREAD_MUTEX_RECURSIVE_NP
)
277 THREAD_SETMEM (THREAD_SELF
, robust_head
.list_op_pending
, NULL
);
279 /* Just bump the counter. */
280 if (__glibc_unlikely (mutex
->__data
.__count
+ 1 == 0))
281 /* Overflow of the counter. */
284 ++mutex
->__data
.__count
;
286 LIBC_PROBE (mutex_timedlock_acquired
, 1, mutex
);
292 oldval
= atomic_compare_and_exchange_val_acq (&mutex
->__data
.__lock
,
297 /* The mutex is locked. The kernel will now take care of
298 everything. The timeout value must be a relative value.
300 int private = (robust
301 ? PTHREAD_ROBUST_MUTEX_PSHARED (mutex
)
302 : PTHREAD_MUTEX_PSHARED (mutex
));
303 INTERNAL_SYSCALL_DECL (__err
);
305 int e
= INTERNAL_SYSCALL (futex
, __err
, 4, &mutex
->__data
.__lock
,
306 __lll_private_flag (FUTEX_LOCK_PI
,
309 if (INTERNAL_SYSCALL_ERROR_P (e
, __err
))
311 if (INTERNAL_SYSCALL_ERRNO (e
, __err
) == ETIMEDOUT
)
314 if (INTERNAL_SYSCALL_ERRNO (e
, __err
) == ESRCH
315 || INTERNAL_SYSCALL_ERRNO (e
, __err
) == EDEADLK
)
317 assert (INTERNAL_SYSCALL_ERRNO (e
, __err
) != EDEADLK
318 || (kind
!= PTHREAD_MUTEX_ERRORCHECK_NP
319 && kind
!= PTHREAD_MUTEX_RECURSIVE_NP
));
320 /* ESRCH can happen only for non-robust PI mutexes where
321 the owner of the lock died. */
322 assert (INTERNAL_SYSCALL_ERRNO (e
, __err
) != ESRCH
325 /* Delay the thread until the timeout is reached.
326 Then return ETIMEDOUT. */
327 struct timespec reltime
;
330 INTERNAL_SYSCALL (clock_gettime
, __err
, 2, CLOCK_REALTIME
,
332 reltime
.tv_sec
= abstime
->tv_sec
- now
.tv_sec
;
333 reltime
.tv_nsec
= abstime
->tv_nsec
- now
.tv_nsec
;
334 if (reltime
.tv_nsec
< 0)
336 reltime
.tv_nsec
+= 1000000000;
339 if (reltime
.tv_sec
>= 0)
340 while (nanosleep_not_cancel (&reltime
, &reltime
) != 0)
346 return INTERNAL_SYSCALL_ERRNO (e
, __err
);
349 oldval
= mutex
->__data
.__lock
;
351 assert (robust
|| (oldval
& FUTEX_OWNER_DIED
) == 0);
354 if (__glibc_unlikely (oldval
& FUTEX_OWNER_DIED
))
356 atomic_and (&mutex
->__data
.__lock
, ~FUTEX_OWNER_DIED
);
358 /* We got the mutex. */
359 mutex
->__data
.__count
= 1;
360 /* But it is inconsistent unless marked otherwise. */
361 mutex
->__data
.__owner
= PTHREAD_MUTEX_INCONSISTENT
;
363 ENQUEUE_MUTEX_PI (mutex
);
364 THREAD_SETMEM (THREAD_SELF
, robust_head
.list_op_pending
, NULL
);
366 /* Note that we deliberately exit here. If we fall
367 through to the end of the function __nusers would be
368 incremented which is not correct because the old owner
369 has to be discounted. */
374 && __builtin_expect (mutex
->__data
.__owner
375 == PTHREAD_MUTEX_NOTRECOVERABLE
, 0))
377 /* This mutex is now not recoverable. */
378 mutex
->__data
.__count
= 0;
380 INTERNAL_SYSCALL_DECL (__err
);
381 INTERNAL_SYSCALL (futex
, __err
, 4, &mutex
->__data
.__lock
,
382 __lll_private_flag (FUTEX_UNLOCK_PI
,
383 PTHREAD_ROBUST_MUTEX_PSHARED (mutex
)),
386 THREAD_SETMEM (THREAD_SELF
, robust_head
.list_op_pending
, NULL
);
387 return ENOTRECOVERABLE
;
390 mutex
->__data
.__count
= 1;
393 ENQUEUE_MUTEX_PI (mutex
);
394 THREAD_SETMEM (THREAD_SELF
, robust_head
.list_op_pending
, NULL
);
398 #endif /* __NR_futex. */
400 case PTHREAD_MUTEX_PP_RECURSIVE_NP
:
401 case PTHREAD_MUTEX_PP_ERRORCHECK_NP
:
402 case PTHREAD_MUTEX_PP_NORMAL_NP
:
403 case PTHREAD_MUTEX_PP_ADAPTIVE_NP
:
405 int kind
= mutex
->__data
.__kind
& PTHREAD_MUTEX_KIND_MASK_NP
;
407 oldval
= mutex
->__data
.__lock
;
409 /* Check whether we already hold the mutex. */
410 if (mutex
->__data
.__owner
== id
)
412 if (kind
== PTHREAD_MUTEX_ERRORCHECK_NP
)
415 if (kind
== PTHREAD_MUTEX_RECURSIVE_NP
)
417 /* Just bump the counter. */
418 if (__glibc_unlikely (mutex
->__data
.__count
+ 1 == 0))
419 /* Overflow of the counter. */
422 ++mutex
->__data
.__count
;
424 LIBC_PROBE (mutex_timedlock_acquired
, 1, mutex
);
430 int oldprio
= -1, ceilval
;
433 int ceiling
= (oldval
& PTHREAD_MUTEX_PRIO_CEILING_MASK
)
434 >> PTHREAD_MUTEX_PRIO_CEILING_SHIFT
;
436 if (__pthread_current_priority () > ceiling
)
441 __pthread_tpp_change_priority (oldprio
, -1);
445 result
= __pthread_tpp_change_priority (oldprio
, ceiling
);
449 ceilval
= ceiling
<< PTHREAD_MUTEX_PRIO_CEILING_SHIFT
;
453 = atomic_compare_and_exchange_val_acq (&mutex
->__data
.__lock
,
454 ceilval
| 1, ceilval
);
456 if (oldval
== ceilval
)
462 = atomic_compare_and_exchange_val_acq (&mutex
->__data
.__lock
,
466 if ((oldval
& PTHREAD_MUTEX_PRIO_CEILING_MASK
) != ceilval
)
469 if (oldval
!= ceilval
)
471 /* Reject invalid timeouts. */
472 if (abstime
->tv_nsec
< 0 || abstime
->tv_nsec
>= 1000000000)
481 /* Get the current time. */
482 (void) __gettimeofday (&tv
, NULL
);
484 /* Compute relative timeout. */
485 rt
.tv_sec
= abstime
->tv_sec
- tv
.tv_sec
;
486 rt
.tv_nsec
= abstime
->tv_nsec
- tv
.tv_usec
* 1000;
489 rt
.tv_nsec
+= 1000000000;
493 /* Already timed out? */
500 lll_futex_timed_wait (&mutex
->__data
.__lock
,
502 PTHREAD_MUTEX_PSHARED (mutex
));
505 while (atomic_compare_and_exchange_val_acq (&mutex
->__data
.__lock
,
506 ceilval
| 2, ceilval
)
509 while ((oldval
& PTHREAD_MUTEX_PRIO_CEILING_MASK
) != ceilval
);
511 assert (mutex
->__data
.__owner
== 0);
512 mutex
->__data
.__count
= 1;
517 /* Correct code cannot set any other type. */
523 /* Record the ownership. */
524 mutex
->__data
.__owner
= id
;
525 ++mutex
->__data
.__nusers
;
527 LIBC_PROBE (mutex_timedlock_acquired
, 1, mutex
);