1/* Copyright (C) 2002-2020 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 <https://www.gnu.org/licenses/>. */
18
19#include <assert.h>
20#include <errno.h>
21#include <limits.h>
22#include <signal.h>
23#include <stdlib.h>
24#include <unistd.h>
25#include <sys/param.h>
26#include <sys/resource.h>
27#include <pthreadP.h>
28#include <atomic.h>
29#include <ldsodefs.h>
30#include <tls.h>
31#include <list.h>
32#include <fork.h>
33#include <version.h>
34#include <shlib-compat.h>
35#include <smp.h>
36#include <lowlevellock.h>
37#include <futex-internal.h>
38#include <kernel-features.h>
39#include <libc-pointer-arith.h>
40#include <pthread-pids.h>
41#include <pthread_mutex_conf.h>
42
43#ifndef TLS_MULTIPLE_THREADS_IN_TCB
44/* Pointer to the corresponding variable in libc. */
45int *__libc_multiple_threads_ptr attribute_hidden;
46#endif
47
48/* Size and alignment of static TLS block. */
49size_t __static_tls_size;
50size_t __static_tls_align_m1;
51
52#ifndef __ASSUME_SET_ROBUST_LIST
53/* Negative if we do not have the system call and we can use it. */
54int __set_robust_list_avail;
55# define set_robust_list_not_avail() \
56 __set_robust_list_avail = -1
57#else
58# define set_robust_list_not_avail() do { } while (0)
59#endif
60
61/* Version of the library, used in libthread_db to detect mismatches. */
62static const char nptl_version[] __attribute_used__ = VERSION;
63
64
65#ifdef SHARED
66static
67#else
68extern
69#endif
70void __nptl_set_robust (struct pthread *);
71
72#ifdef SHARED
73static const struct pthread_functions pthread_functions =
74 {
75 .ptr___pthread_cond_broadcast = __pthread_cond_broadcast,
76 .ptr___pthread_cond_signal = __pthread_cond_signal,
77 .ptr___pthread_cond_wait = __pthread_cond_wait,
78 .ptr___pthread_cond_timedwait = __pthread_cond_timedwait,
79# if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_3_2)
80 .ptr___pthread_cond_broadcast_2_0 = __pthread_cond_broadcast_2_0,
81 .ptr___pthread_cond_signal_2_0 = __pthread_cond_signal_2_0,
82 .ptr___pthread_cond_wait_2_0 = __pthread_cond_wait_2_0,
83 .ptr___pthread_cond_timedwait_2_0 = __pthread_cond_timedwait_2_0,
84# endif
85 .ptr___pthread_exit = __pthread_exit,
86 .ptr_pthread_mutex_destroy = __pthread_mutex_destroy,
87 .ptr_pthread_mutex_init = __pthread_mutex_init,
88 .ptr_pthread_mutex_lock = __pthread_mutex_lock,
89 .ptr_pthread_mutex_unlock = __pthread_mutex_unlock,
90 .ptr___pthread_setcancelstate = __pthread_setcancelstate,
91 .ptr_pthread_setcanceltype = __pthread_setcanceltype,
92 .ptr___pthread_cleanup_upto = __pthread_cleanup_upto,
93 .ptr___pthread_once = __pthread_once,
94 .ptr___pthread_rwlock_rdlock = __pthread_rwlock_rdlock,
95 .ptr___pthread_rwlock_wrlock = __pthread_rwlock_wrlock,
96 .ptr___pthread_rwlock_unlock = __pthread_rwlock_unlock,
97 .ptr___pthread_key_create = __pthread_key_create,
98 .ptr___pthread_getspecific = __pthread_getspecific,
99 .ptr___pthread_setspecific = __pthread_setspecific,
100 .ptr__pthread_cleanup_push_defer = __pthread_cleanup_push_defer,
101 .ptr__pthread_cleanup_pop_restore = __pthread_cleanup_pop_restore,
102 .ptr_nthreads = &__nptl_nthreads,
103 .ptr___pthread_unwind = &__pthread_unwind,
104 .ptr__nptl_deallocate_tsd = __nptl_deallocate_tsd,
105 .ptr__nptl_setxid = __nptl_setxid,
106 .ptr_set_robust = __nptl_set_robust
107 };
108# define ptr_pthread_functions &pthread_functions
109#else
110# define ptr_pthread_functions NULL
111#endif
112
113
114#ifdef SHARED
115static
116#endif
117void
118__nptl_set_robust (struct pthread *self)
119{
120 INTERNAL_SYSCALL_CALL (set_robust_list, &self->robust_head,
121 sizeof (struct robust_list_head));
122}
123
124
125/* For asynchronous cancellation we use a signal. This is the handler. */
126static void
127sigcancel_handler (int sig, siginfo_t *si, void *ctx)
128{
129 /* Safety check. It would be possible to call this function for
130 other signals and send a signal from another process. This is not
131 correct and might even be a security problem. Try to catch as
132 many incorrect invocations as possible. */
133 if (sig != SIGCANCEL
134 || si->si_pid != __getpid()
135 || si->si_code != SI_TKILL)
136 return;
137
138 struct pthread *self = THREAD_SELF;
139
140 int oldval = THREAD_GETMEM (self, cancelhandling);
141 while (1)
142 {
143 /* We are canceled now. When canceled by another thread this flag
144 is already set but if the signal is directly send (internally or
145 from another process) is has to be done here. */
146 int newval = oldval | CANCELING_BITMASK | CANCELED_BITMASK;
147
148 if (oldval == newval || (oldval & EXITING_BITMASK) != 0)
149 /* Already canceled or exiting. */
150 break;
151
152 int curval = THREAD_ATOMIC_CMPXCHG_VAL (self, cancelhandling, newval,
153 oldval);
154 if (curval == oldval)
155 {
156 /* Set the return value. */
157 THREAD_SETMEM (self, result, PTHREAD_CANCELED);
158
159 /* Make sure asynchronous cancellation is still enabled. */
160 if ((newval & CANCELTYPE_BITMASK) != 0)
161 /* Run the registered destructors and terminate the thread. */
162 __do_cancel ();
163
164 break;
165 }
166
167 oldval = curval;
168 }
169}
170
171
172struct xid_command *__xidcmd attribute_hidden;
173
174/* We use the SIGSETXID signal in the setuid, setgid, etc. implementations to
175 tell each thread to call the respective setxid syscall on itself. This is
176 the handler. */
177static void
178sighandler_setxid (int sig, siginfo_t *si, void *ctx)
179{
180 int result;
181
182 /* Safety check. It would be possible to call this function for
183 other signals and send a signal from another process. This is not
184 correct and might even be a security problem. Try to catch as
185 many incorrect invocations as possible. */
186 if (sig != SIGSETXID
187 || si->si_pid != __getpid ()
188 || si->si_code != SI_TKILL)
189 return;
190
191 result = INTERNAL_SYSCALL_NCS (__xidcmd->syscall_no, 3, __xidcmd->id[0],
192 __xidcmd->id[1], __xidcmd->id[2]);
193 int error = 0;
194 if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (result)))
195 error = INTERNAL_SYSCALL_ERRNO (result);
196 __nptl_setxid_error (__xidcmd, error);
197
198 /* Reset the SETXID flag. */
199 struct pthread *self = THREAD_SELF;
200 int flags, newval;
201 do
202 {
203 flags = THREAD_GETMEM (self, cancelhandling);
204 newval = THREAD_ATOMIC_CMPXCHG_VAL (self, cancelhandling,
205 flags & ~SETXID_BITMASK, flags);
206 }
207 while (flags != newval);
208
209 /* And release the futex. */
210 self->setxid_futex = 1;
211 futex_wake (&self->setxid_futex, 1, FUTEX_PRIVATE);
212
213 if (atomic_decrement_val (&__xidcmd->cntr) == 0)
214 futex_wake ((unsigned int *) &__xidcmd->cntr, 1, FUTEX_PRIVATE);
215}
216
217
218/* When using __thread for this, we do it in libc so as not
219 to give libpthread its own TLS segment just for this. */
220extern void **__libc_dl_error_tsd (void) __attribute__ ((const));
221
222
223/* This can be set by the debugger before initialization is complete. */
224static bool __nptl_initial_report_events __attribute_used__;
225
226void
227__pthread_initialize_minimal_internal (void)
228{
229 /* Minimal initialization of the thread descriptor. */
230 struct pthread *pd = THREAD_SELF;
231 __pthread_initialize_pids (pd);
232 THREAD_SETMEM (pd, specific[0], &pd->specific_1stblock[0]);
233 THREAD_SETMEM (pd, user_stack, true);
234
235 /* Initialize the robust mutex data. */
236 {
237#if __PTHREAD_MUTEX_HAVE_PREV
238 pd->robust_prev = &pd->robust_head;
239#endif
240 pd->robust_head.list = &pd->robust_head;
241 pd->robust_head.futex_offset = (offsetof (pthread_mutex_t, __data.__lock)
242 - offsetof (pthread_mutex_t,
243 __data.__list.__next));
244 int res = INTERNAL_SYSCALL_CALL (set_robust_list, &pd->robust_head,
245 sizeof (struct robust_list_head));
246 if (INTERNAL_SYSCALL_ERROR_P (res))
247 set_robust_list_not_avail ();
248 }
249
250 /* Set initial thread's stack block from 0 up to __libc_stack_end.
251 It will be bigger than it actually is, but for unwind.c/pt-longjmp.c
252 purposes this is good enough. */
253 THREAD_SETMEM (pd, stackblock_size, (size_t) __libc_stack_end);
254
255 /* Initialize the list of all running threads with the main thread. */
256 INIT_LIST_HEAD (&__stack_user);
257 list_add (&pd->list, &__stack_user);
258
259 /* Before initializing __stack_user, the debugger could not find us and
260 had to set __nptl_initial_report_events. Propagate its setting. */
261 THREAD_SETMEM (pd, report_events, __nptl_initial_report_events);
262
263 struct sigaction sa;
264 __sigemptyset (&sa.sa_mask);
265
266 /* Install the cancellation signal handler. If for some reason we
267 cannot install the handler we do not abort. Maybe we should, but
268 it is only asynchronous cancellation which is affected. */
269 sa.sa_sigaction = sigcancel_handler;
270 sa.sa_flags = SA_SIGINFO;
271 (void) __libc_sigaction (SIGCANCEL, &sa, NULL);
272
273 /* Install the handle to change the threads' uid/gid. */
274 sa.sa_sigaction = sighandler_setxid;
275 sa.sa_flags = SA_SIGINFO | SA_RESTART;
276 (void) __libc_sigaction (SIGSETXID, &sa, NULL);
277
278 /* The parent process might have left the signals blocked. Just in
279 case, unblock it. We reuse the signal mask in the sigaction
280 structure. It is already cleared. */
281 __sigaddset (&sa.sa_mask, SIGCANCEL);
282 __sigaddset (&sa.sa_mask, SIGSETXID);
283 INTERNAL_SYSCALL_CALL (rt_sigprocmask, SIG_UNBLOCK, &sa.sa_mask,
284 NULL, __NSIG_BYTES);
285
286 /* Get the size of the static and alignment requirements for the TLS
287 block. */
288 size_t static_tls_align;
289 _dl_get_tls_static_info (&__static_tls_size, &static_tls_align);
290
291 /* Make sure the size takes all the alignments into account. */
292 if (STACK_ALIGN > static_tls_align)
293 static_tls_align = STACK_ALIGN;
294 __static_tls_align_m1 = static_tls_align - 1;
295
296 __static_tls_size = roundup (__static_tls_size, static_tls_align);
297
298 /* Determine the default allowed stack size. This is the size used
299 in case the user does not specify one. */
300 struct rlimit limit;
301 if (__getrlimit (RLIMIT_STACK, &limit) != 0
302 || limit.rlim_cur == RLIM_INFINITY)
303 /* The system limit is not usable. Use an architecture-specific
304 default. */
305 limit.rlim_cur = ARCH_STACK_DEFAULT_SIZE;
306 else if (limit.rlim_cur < PTHREAD_STACK_MIN)
307 /* The system limit is unusably small.
308 Use the minimal size acceptable. */
309 limit.rlim_cur = PTHREAD_STACK_MIN;
310
311 /* Make sure it meets the minimum size that allocate_stack
312 (allocatestack.c) will demand, which depends on the page size. */
313 const uintptr_t pagesz = GLRO(dl_pagesize);
314 const size_t minstack = pagesz + __static_tls_size + MINIMAL_REST_STACK;
315 if (limit.rlim_cur < minstack)
316 limit.rlim_cur = minstack;
317
318 /* Round the resource limit up to page size. */
319 limit.rlim_cur = ALIGN_UP (limit.rlim_cur, pagesz);
320 lll_lock (__default_pthread_attr_lock, LLL_PRIVATE);
321 __default_pthread_attr.internal.stacksize = limit.rlim_cur;
322 __default_pthread_attr.internal.guardsize = GLRO (dl_pagesize);
323 lll_unlock (__default_pthread_attr_lock, LLL_PRIVATE);
324
325#ifdef SHARED
326 /* Make __rtld_lock_{,un}lock_recursive use pthread_mutex_{,un}lock,
327 keep the lock count from the ld.so implementation. */
328 GL(dl_rtld_lock_recursive) = (void *) __pthread_mutex_lock;
329 GL(dl_rtld_unlock_recursive) = (void *) __pthread_mutex_unlock;
330 unsigned int rtld_lock_count = GL(dl_load_lock).mutex.__data.__count;
331 GL(dl_load_lock).mutex.__data.__count = 0;
332 while (rtld_lock_count-- > 0)
333 __pthread_mutex_lock (&GL(dl_load_lock).mutex);
334
335 GL(dl_make_stack_executable_hook) = &__make_stacks_executable;
336#endif
337
338 GL(dl_init_static_tls) = &__pthread_init_static_tls;
339
340 GL(dl_wait_lookup_done) = &__wait_lookup_done;
341
342 /* Register the fork generation counter with the libc. */
343#ifndef TLS_MULTIPLE_THREADS_IN_TCB
344 __libc_multiple_threads_ptr =
345#endif
346 __libc_pthread_init (&__fork_generation, __reclaim_stacks,
347 ptr_pthread_functions);
348
349 /* Determine whether the machine is SMP or not. */
350 __is_smp = is_smp_system ();
351
352#if HAVE_TUNABLES
353 __pthread_tunables_init ();
354#endif
355}
356strong_alias (__pthread_initialize_minimal_internal,
357 __pthread_initialize_minimal)
358
359
360/* This function is internal (it has a GLIBC_PRIVATE) version, but it
361 is widely used (either via weak symbol, or dlsym) to obtain the
362 __static_tls_size value. This value is then used to adjust the
363 value of the stack size attribute, so that applications receive the
364 full requested stack size, not diminished by the TCB and static TLS
365 allocation on the stack. Once the TCB is separately allocated,
366 this function should be removed or renamed (if it is still
367 necessary at that point). */
368size_t
369__pthread_get_minstack (const pthread_attr_t *attr)
370{
371 return GLRO(dl_pagesize) + __static_tls_size + PTHREAD_STACK_MIN;
372}
373