1 /* $NetBSD: pthread_int.h,v 1.111 2023/05/25 14:30:03 riastradh Exp $ */
2
3 /*-
4 * Copyright (c) 2001, 2002, 2003, 2006, 2007, 2008, 2020
5 * The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Nathan J. Williams and Andrew Doran.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 #ifndef _LIB_PTHREAD_INT_H
34 #define _LIB_PTHREAD_INT_H
35
36 #include <sys/tls.h>
37
38 /* #define PTHREAD__DEBUG */
39
40 #include "pthread_types.h"
41 #include "pthread_queue.h"
42 #include "pthread_md.h"
43
44 #include <sys/atomic.h>
45 #include <sys/rbtree.h>
46 #include <sys/param.h>
47
48 #include <limits.h>
49 #include <lwp.h>
50 #include <signal.h>
51 #include <stdbool.h>
52
53 #ifdef __GNUC__
54 #define PTHREAD_HIDE __attribute__ ((visibility("hidden")))
55 #else
56 #define PTHREAD_HIDE /* nothing */
57 #endif
58
59 #define PTHREAD__UNPARK_MAX 128
60
61 /*
62 * The size of this structure needs to be no larger than struct
63 * __pthread_cleanup_store, defined in pthread.h.
64 */
65 struct pt_clean_t {
66 PTQ_ENTRY(pt_clean_t) ptc_next;
67 void (*ptc_cleanup)(void *);
68 void *ptc_arg;
69 };
70
71 /* Private data for pthread_attr_t */
72 struct pthread_attr_private {
73 char ptap_name[PTHREAD_MAX_NAMELEN_NP];
74 void *ptap_namearg;
75 void *ptap_stackaddr;
76 size_t ptap_stacksize;
77 size_t ptap_guardsize;
78 struct sched_param ptap_sp;
79 int ptap_policy;
80 };
81
82 struct pthread_lock_ops {
83 void (*plo_init)(__cpu_simple_lock_t *);
84 int (*plo_try)(__cpu_simple_lock_t *);
85 void (*plo_unlock)(__cpu_simple_lock_t *);
86 void (*plo_lock)(__cpu_simple_lock_t *);
87 };
88
89 struct __pthread_st {
90 pthread_t pt_self; /* Must be first. */
91 #if defined(__HAVE_TLS_VARIANT_I) || defined(__HAVE_TLS_VARIANT_II)
92 struct tls_tcb *pt_tls; /* Thread Local Storage area */
93 #endif
94 unsigned int pt_magic; /* Magic number */
95 int pt_state; /* running, blocked, etc. */
96 int pt_flags; /* see PT_FLAG_* below */
97 int pt_cancel; /* Deferred cancellation */
98 int pt_errno; /* Thread-specific errno. */
99 stack_t pt_stack; /* Our stack */
100 bool pt_stack_allocated;
101 size_t pt_guardsize;
102 void *pt_exitval; /* Read by pthread_join() */
103 char *pt_name; /* Thread's name, set by the app. */
104 struct pthread_lock_ops pt_lockops;/* Cached to avoid PIC overhead */
105 void *(*pt_func)(void *);/* Function to call at start. */
106 void *pt_arg; /* Argument to pass at start. */
107
108 /* Stack of cancellation cleanup handlers and their arguments */
109 PTQ_HEAD(, pt_clean_t) pt_cleanup_stack;
110
111 /* LWP ID and entry on the list of all threads. */
112 lwpid_t pt_lid;
113 PTQ_ENTRY(__pthread_st) pt_deadq;
114
115 /*
116 * rbtree node and entry on the list of all threads. pt_alltree in
117 * its own cacheline, so pthread__find() is not needlessly impacted
118 * by threads going about their normal business. pt_allq is
119 * adjusted at the same time as pt_alltree.
120 */
121 rb_node_t pt_alltree __aligned(COHERENCY_UNIT);
122 PTQ_ENTRY(__pthread_st) pt_allq;
123
124 /* Lock on state also gets its own line. */
125 pthread_mutex_t pt_lock __aligned(COHERENCY_UNIT);
126
127 /*
128 * General synchronization data. We try to align, as threads
129 * on other CPUs will access this data frequently.
130 */
131 int pt_dummy1 __aligned(COHERENCY_UNIT);
132 struct lwpctl *pt_lwpctl; /* Kernel/user comms area */
133 volatile int pt_rwlocked; /* Handed rwlock successfully */
134 void * volatile pt_sleepobj; /* Object slept on */
135 PTQ_ENTRY(__pthread_st) pt_sleep;
136
137 /* Thread-specific data. Large so it sits close to the end. */
138 int pt_havespecific __aligned(COHERENCY_UNIT);
139 struct pt_specific {
140 void *pts_value;
141 PTQ_ENTRY(pt_specific) pts_next;
142 } pt_specific[];
143 };
144
145 /* Thread states */
146 #define PT_STATE_RUNNING 1
147 #define PT_STATE_ZOMBIE 5
148 #define PT_STATE_DEAD 6
149
150 /* Flag values */
151
152 #define PT_FLAG_DETACHED 0x0001
153 #define PT_FLAG_CS_DISABLED 0x0004 /* Cancellation disabled */
154 #define PT_FLAG_CS_ASYNC 0x0008 /* Cancellation is async */
155 #define PT_FLAG_CS_PENDING 0x0010
156 #define PT_FLAG_SCOPE_SYSTEM 0x0040
157 #define PT_FLAG_EXPLICIT_SCHED 0x0080
158 #define PT_FLAG_SUSPENDED 0x0100 /* In the suspended queue */
159
160 #define PT_MAGIC 0x11110001
161 #define PT_DEAD 0xDEAD0001
162
163 #define PT_ATTR_MAGIC 0x22220002
164 #define PT_ATTR_DEAD 0xDEAD0002
165
166 extern size_t pthread__stacksize;
167 extern size_t pthread__guardsize;
168 extern size_t pthread__pagesize;
169 extern int pthread__nspins;
170 extern int pthread__concurrency;
171 extern int pthread__osrev;
172 extern size_t pthread__unpark_max;
173 extern int pthread_keys_max;
174
175 extern int __uselibcstub;
176
177 struct pthread__waiter {
178 struct pthread__waiter *volatile next;
179 lwpid_t volatile lid;
180 };
181
182 /* Flag to be used in a ucontext_t's uc_flags indicating that
183 * the saved register state is "user" state only, not full
184 * trap state.
185 */
186 #define _UC_USER_BIT 30
187 #define _UC_USER (1LU << _UC_USER_BIT)
188
189 /* Utility functions */
190 void pthread__unpark_all(pthread_queue_t *, pthread_t, pthread_mutex_t *)
191 PTHREAD_HIDE;
192 void pthread__unpark(pthread_queue_t *, pthread_t, pthread_mutex_t *)
193 PTHREAD_HIDE;
194 int pthread__park(pthread_t, pthread_mutex_t *, pthread_queue_t *,
195 const struct timespec *, int) PTHREAD_HIDE;
196 pthread_mutex_t *pthread__hashlock(volatile const void *) PTHREAD_HIDE;
197
198 /* Internal locking primitives */
199 void pthread__lockprim_init(void) PTHREAD_HIDE;
200 void pthread_lockinit(pthread_spin_t *) PTHREAD_HIDE;
201
202 static inline void pthread__spinlock(pthread_t, pthread_spin_t *)
203 __attribute__((__always_inline__));
204 static inline void
pthread__spinlock(pthread_t self,pthread_spin_t * lock)205 pthread__spinlock(pthread_t self, pthread_spin_t *lock)
206 {
207 if (__predict_true((*self->pt_lockops.plo_try)(lock)))
208 return;
209 (*self->pt_lockops.plo_lock)(lock);
210 }
211
212 static inline int pthread__spintrylock(pthread_t, pthread_spin_t *)
213 __attribute__((__always_inline__));
214 static inline int
pthread__spintrylock(pthread_t self,pthread_spin_t * lock)215 pthread__spintrylock(pthread_t self, pthread_spin_t *lock)
216 {
217 return (*self->pt_lockops.plo_try)(lock);
218 }
219
220 static inline void pthread__spinunlock(pthread_t, pthread_spin_t *)
221 __attribute__((__always_inline__));
222 static inline void
pthread__spinunlock(pthread_t self,pthread_spin_t * lock)223 pthread__spinunlock(pthread_t self, pthread_spin_t *lock)
224 {
225 (*self->pt_lockops.plo_unlock)(lock);
226 }
227
228 extern const struct pthread_lock_ops *pthread__lock_ops;
229
230 int pthread__simple_locked_p(__cpu_simple_lock_t *) PTHREAD_HIDE;
231 #define pthread__simple_lock_init(alp) (*pthread__lock_ops->plo_init)(alp)
232 #define pthread__simple_lock_try(alp) (*pthread__lock_ops->plo_try)(alp)
233 #define pthread__simple_unlock(alp) (*pthread__lock_ops->plo_unlock)(alp)
234
235 void pthread__testcancel(pthread_t) PTHREAD_HIDE;
236 int pthread__find(pthread_t) PTHREAD_HIDE;
237
238 #ifndef PTHREAD_MD_INIT
239 #define PTHREAD_MD_INIT
240 #endif
241
242 #ifndef _INITCONTEXT_U_MD
243 #define _INITCONTEXT_U_MD(ucp)
244 #endif
245
246 #define _INITCONTEXT_U(ucp) do { \
247 (ucp)->uc_flags = _UC_CPU | _UC_STACK; \
248 _INITCONTEXT_U_MD(ucp) \
249 } while (0)
250
251
252 #if !defined(__HAVE_TLS_VARIANT_I) && !defined(__HAVE_TLS_VARIANT_II)
253 #error Either __HAVE_TLS_VARIANT_I or __HAVE_TLS_VARIANT_II must be defined
254 #endif
255
256 #ifdef _PTHREAD_GETTCB_EXT
257 struct tls_tcb *_PTHREAD_GETTCB_EXT(void);
258 #endif
259
260 static inline pthread_t __constfunc
pthread__self(void)261 pthread__self(void)
262 {
263 #if defined(_PTHREAD_GETTCB_EXT)
264 struct tls_tcb * const tcb = _PTHREAD_GETTCB_EXT();
265 #elif defined(__HAVE___LWP_GETTCB_FAST)
266 struct tls_tcb * const tcb = __lwp_gettcb_fast();
267 #else
268 struct tls_tcb * const tcb = __lwp_getprivate_fast();
269 #endif
270 return (pthread_t)tcb->tcb_pthread;
271 }
272
273 #define pthread__abort() \
274 pthread__assertfunc(__FILE__, __LINE__, __func__, "unreachable")
275
276 #define pthread__assert(e) do { \
277 if (__predict_false(!(e))) \
278 pthread__assertfunc(__FILE__, __LINE__, __func__, #e); \
279 } while (0)
280
281 #define pthread__error(err, msg, e) do { \
282 if (__predict_false(!(e))) { \
283 pthread__errorfunc(__FILE__, __LINE__, __func__, msg); \
284 return (err); \
285 } \
286 } while (0)
287
288 void *pthread_tsd_init(size_t *) PTHREAD_HIDE;
289 void pthread__destroy_tsd(pthread_t) PTHREAD_HIDE;
290 void pthread__copy_tsd(pthread_t) PTHREAD_HIDE;
291
292 __dead void pthread__assertfunc(const char *, int, const char *, const char *)
293 PTHREAD_HIDE;
294 void pthread__errorfunc(const char *, int, const char *, const char *, ...)
295 __printflike(4, 5) PTHREAD_HIDE;
296 char *pthread__getenv(const char *) PTHREAD_HIDE;
297 __dead void pthread__cancelled(void) PTHREAD_HIDE;
298 void pthread__mutex_deferwake(pthread_t, pthread_mutex_t *,
299 struct pthread__waiter *) PTHREAD_HIDE;
300 int pthread__checkpri(int) PTHREAD_HIDE;
301 int pthread__add_specific(pthread_t, pthread_key_t, const void *) PTHREAD_HIDE;
302
303 #ifndef pthread__smt_pause
304 #define pthread__smt_pause() __nothing
305 #endif
306 #ifndef pthread__smt_wait
307 #define pthread__smt_wait() __nothing
308 #endif
309 #ifndef pthread__smt_wake
310 #define pthread__smt_wake() __nothing
311 #endif
312
313 /*
314 * Bits in the owner field of the lock that indicate lock state. If the
315 * WRITE_LOCKED bit is clear, then the owner field is actually a count of
316 * the number of readers.
317 */
318 #define RW_HAS_WAITERS 0x01 /* lock has waiters */
319 #define RW_WRITE_WANTED 0x02 /* >= 1 waiter is a writer */
320 #define RW_WRITE_LOCKED 0x04 /* lock is currently write locked */
321 #define RW_UNUSED 0x08 /* currently unused */
322
323 #define RW_FLAGMASK 0x0f
324
325 #define RW_READ_COUNT_SHIFT 4
326 #define RW_READ_INCR (1 << RW_READ_COUNT_SHIFT)
327 #define RW_THREAD ((uintptr_t)-RW_READ_INCR)
328
329 #endif /* _LIB_PTHREAD_INT_H */
330