1/* Set current priority ceiling of pthread_mutex_t.
2 Copyright (C) 2006-2021 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Jakub Jelinek <jakub@redhat.com>, 2006.
5
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
10
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, see
18 <https://www.gnu.org/licenses/>. */
19
20#include <stdbool.h>
21#include <errno.h>
22#include <pthreadP.h>
23#include <atomic.h>
24#include <futex-internal.h>
25#include <shlib-compat.h>
26
27int
28__pthread_mutex_setprioceiling (pthread_mutex_t *mutex, int prioceiling,
29 int *old_ceiling)
30{
31 /* See concurrency notes regarding __kind in struct __pthread_mutex_s
32 in sysdeps/nptl/bits/thread-shared-types.h. */
33 if ((atomic_load_relaxed (&(mutex->__data.__kind))
34 & PTHREAD_MUTEX_PRIO_PROTECT_NP) == 0)
35 return EINVAL;
36
37 /* See __init_sched_fifo_prio. */
38 if (atomic_load_relaxed (&__sched_fifo_min_prio) == -1
39 || atomic_load_relaxed (&__sched_fifo_max_prio) == -1)
40 __init_sched_fifo_prio ();
41
42 if (__glibc_unlikely (prioceiling
43 < atomic_load_relaxed (&__sched_fifo_min_prio))
44 || __glibc_unlikely (prioceiling
45 > atomic_load_relaxed (&__sched_fifo_max_prio))
46 || __glibc_unlikely ((prioceiling
47 & (PTHREAD_MUTEXATTR_PRIO_CEILING_MASK
48 >> PTHREAD_MUTEXATTR_PRIO_CEILING_SHIFT))
49 != prioceiling))
50 return EINVAL;
51
52 /* Check whether we already hold the mutex. */
53 bool locked = false;
54 int kind = PTHREAD_MUTEX_TYPE (mutex);
55 if (mutex->__data.__owner == THREAD_GETMEM (THREAD_SELF, tid))
56 {
57 if (kind == PTHREAD_MUTEX_PP_ERRORCHECK_NP)
58 return EDEADLK;
59
60 if (kind == PTHREAD_MUTEX_PP_RECURSIVE_NP)
61 locked = true;
62 }
63
64 int oldval = mutex->__data.__lock;
65 if (! locked)
66 do
67 {
68 /* Need to lock the mutex, but without obeying the priority
69 protect protocol. */
70 int ceilval = (oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK);
71
72 oldval = atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
73 ceilval | 1, ceilval);
74 if (oldval == ceilval)
75 break;
76
77 do
78 {
79 oldval
80 = atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
81 ceilval | 2,
82 ceilval | 1);
83
84 if ((oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK) != ceilval)
85 break;
86
87 if (oldval != ceilval)
88 futex_wait ((unsigned int *) &mutex->__data.__lock, ceilval | 2,
89 PTHREAD_MUTEX_PSHARED (mutex));
90 }
91 while (atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,
92 ceilval | 2, ceilval)
93 != ceilval);
94
95 if ((oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK) != ceilval)
96 continue;
97 }
98 while (0);
99
100 int oldprio = (oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK)
101 >> PTHREAD_MUTEX_PRIO_CEILING_SHIFT;
102 if (locked)
103 {
104 int ret = __pthread_tpp_change_priority (oldprio, prioceiling);
105 if (ret)
106 return ret;
107 }
108
109 if (old_ceiling != NULL)
110 *old_ceiling = oldprio;
111
112 int newlock = 0;
113 if (locked)
114 newlock = (mutex->__data.__lock & ~PTHREAD_MUTEX_PRIO_CEILING_MASK);
115 mutex->__data.__lock = newlock
116 | (prioceiling << PTHREAD_MUTEX_PRIO_CEILING_SHIFT);
117 atomic_full_barrier ();
118
119 futex_wake ((unsigned int *)&mutex->__data.__lock, INT_MAX,
120 PTHREAD_MUTEX_PSHARED (mutex));
121
122 return 0;
123}
124versioned_symbol (libc, __pthread_mutex_setprioceiling,
125 pthread_mutex_setprioceiling, GLIBC_2_34);
126
127#if OTHER_SHLIB_COMPAT (libpthread, GLIBC_2_4, GLIBC_2_34)
128compat_symbol (libpthread, __pthread_mutex_setprioceiling,
129 pthread_mutex_setprioceiling, GLIBC_2_4);
130#endif
131