1 /* Copyright (C) 2002-2023 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, see
16 <https://www.gnu.org/licenses/>. */
17
18 #include <assert.h>
19 #include <errno.h>
20 #include <stdbool.h>
21 #include <string.h>
22 #include <kernel-features.h>
23 #include "pthreadP.h"
24 #include <atomic.h>
25 #include <pthread-offsets.h>
26 #include <futex-internal.h>
27 #include <shlib-compat.h>
28
29 #include <stap-probe.h>
30
31 static const struct pthread_mutexattr default_mutexattr =
32 {
33 /* Default is a normal mutex, not shared between processes. */
34 .mutexkind = PTHREAD_MUTEX_NORMAL
35 };
36
37
38 static bool
39 prio_inherit_missing (void)
40 {
41 static int tpi_supported;
42 if (__glibc_unlikely (atomic_load_relaxed (&tpi_supported) == 0))
43 {
44 int e = futex_unlock_pi (&(unsigned int){0}, 0);
45 atomic_store_relaxed (&tpi_supported, e == ENOSYS ? -1 : 1);
46 }
47 return __glibc_unlikely (tpi_supported < 0);
48 }
49
50 int
51 ___pthread_mutex_init (pthread_mutex_t *mutex,
52 const pthread_mutexattr_t *mutexattr)
53 {
54 const struct pthread_mutexattr *imutexattr;
55
56 ASSERT_TYPE_SIZE (pthread_mutex_t, __SIZEOF_PTHREAD_MUTEX_T);
57
58 /* __kind is the only field where its offset should be checked to
59 avoid ABI breakage with static initializers. */
60 ASSERT_PTHREAD_INTERNAL_OFFSET (pthread_mutex_t, __data.__kind,
61 __PTHREAD_MUTEX_KIND_OFFSET);
62 ASSERT_PTHREAD_INTERNAL_MEMBER_SIZE (pthread_mutex_t, __data.__kind, int);
63
64 imutexattr = ((const struct pthread_mutexattr *) mutexattr
65 ?: &default_mutexattr);
66
67 /* Sanity checks. */
68 switch (__builtin_expect (imutexattr->mutexkind
69 & PTHREAD_MUTEXATTR_PROTOCOL_MASK,
70 PTHREAD_PRIO_NONE
71 << PTHREAD_MUTEXATTR_PROTOCOL_SHIFT))
72 {
73 case PTHREAD_PRIO_NONE << PTHREAD_MUTEXATTR_PROTOCOL_SHIFT:
74 break;
75
76 case PTHREAD_PRIO_INHERIT << PTHREAD_MUTEXATTR_PROTOCOL_SHIFT:
77 if (__glibc_unlikely (prio_inherit_missing ()))
78 return ENOTSUP;
79 break;
80
81 default:
82 /* XXX: For now we don't support robust priority protected mutexes. */
83 if (imutexattr->mutexkind & PTHREAD_MUTEXATTR_FLAG_ROBUST)
84 return ENOTSUP;
85 break;
86 }
87
88 /* Clear the whole variable. */
89 memset (mutex, '\0', __SIZEOF_PTHREAD_MUTEX_T);
90
91 /* Copy the values from the attribute. */
92 int mutex_kind = imutexattr->mutexkind & ~PTHREAD_MUTEXATTR_FLAG_BITS;
93
94 if ((imutexattr->mutexkind & PTHREAD_MUTEXATTR_FLAG_ROBUST) != 0)
95 {
96 #ifndef __ASSUME_SET_ROBUST_LIST
97 if ((imutexattr->mutexkind & PTHREAD_MUTEXATTR_FLAG_PSHARED) != 0
98 && !__nptl_set_robust_list_avail)
99 return ENOTSUP;
100 #endif
101
102 mutex_kind |= PTHREAD_MUTEX_ROBUST_NORMAL_NP;
103 }
104
105 switch (imutexattr->mutexkind & PTHREAD_MUTEXATTR_PROTOCOL_MASK)
106 {
107 case PTHREAD_PRIO_INHERIT << PTHREAD_MUTEXATTR_PROTOCOL_SHIFT:
108 mutex_kind |= PTHREAD_MUTEX_PRIO_INHERIT_NP;
109 break;
110
111 case PTHREAD_PRIO_PROTECT << PTHREAD_MUTEXATTR_PROTOCOL_SHIFT:
112 mutex_kind |= PTHREAD_MUTEX_PRIO_PROTECT_NP;
113
114 int ceiling = (imutexattr->mutexkind
115 & PTHREAD_MUTEXATTR_PRIO_CEILING_MASK)
116 >> PTHREAD_MUTEXATTR_PRIO_CEILING_SHIFT;
117 if (! ceiling)
118 {
119 /* See __init_sched_fifo_prio. */
120 if (atomic_load_relaxed (&__sched_fifo_min_prio) == -1)
121 __init_sched_fifo_prio ();
122 if (ceiling < atomic_load_relaxed (&__sched_fifo_min_prio))
123 ceiling = atomic_load_relaxed (&__sched_fifo_min_prio);
124 }
125 mutex->__data.__lock = ceiling << PTHREAD_MUTEX_PRIO_CEILING_SHIFT;
126 break;
127
128 default:
129 break;
130 }
131
132 /* The kernel when waking robust mutexes on exit never uses
133 FUTEX_PRIVATE_FLAG FUTEX_WAKE. */
134 if ((imutexattr->mutexkind & (PTHREAD_MUTEXATTR_FLAG_PSHARED
135 | PTHREAD_MUTEXATTR_FLAG_ROBUST)) != 0)
136 mutex_kind |= PTHREAD_MUTEX_PSHARED_BIT;
137
138 /* See concurrency notes regarding __kind in struct __pthread_mutex_s
139 in sysdeps/nptl/bits/thread-shared-types.h. */
140 atomic_store_relaxed (&(mutex->__data.__kind), mutex_kind);
141
142 /* Default values: mutex not used yet. */
143 // mutex->__count = 0; already done by memset
144 // mutex->__owner = 0; already done by memset
145 // mutex->__nusers = 0; already done by memset
146 // mutex->__spins = 0; already done by memset
147 // mutex->__next = NULL; already done by memset
148
149 LIBC_PROBE (mutex_init, 1, mutex);
150
151 return 0;
152 }
153 versioned_symbol (libpthread, ___pthread_mutex_init, pthread_mutex_init,
154 GLIBC_2_0);
155 libc_hidden_ver (___pthread_mutex_init, __pthread_mutex_init)
156 #ifndef SHARED
157 strong_alias (___pthread_mutex_init, __pthread_mutex_init)
158 #endif
159
160 #if OTHER_SHLIB_COMPAT (libpthread, GLIBC_2_0, GLIBC_2_34)
161 compat_symbol (libpthread, ___pthread_mutex_init, __pthread_mutex_init,
162 GLIBC_2_0);
163 #endif