Avoid confusing compiler with dynamically impossible statically invalid dereference...
[glibc.git] / nptl / nptl-init.c
blob1ad41c5bb39ca6592d629590c9421f78f5ba2925
1 /* Copyright (C) 2002-2015 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/>. */
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 <kernel-features.h>
38 #include <libc-internal.h>
40 #ifndef TLS_MULTIPLE_THREADS_IN_TCB
41 /* Pointer to the corresponding variable in libc. */
42 int *__libc_multiple_threads_ptr attribute_hidden;
43 #endif
45 /* Size and alignment of static TLS block. */
46 size_t __static_tls_size;
47 size_t __static_tls_align_m1;
49 #ifndef __ASSUME_SET_ROBUST_LIST
50 /* Negative if we do not have the system call and we can use it. */
51 int __set_robust_list_avail;
52 # define set_robust_list_not_avail() \
53 __set_robust_list_avail = -1
54 #else
55 # define set_robust_list_not_avail() do { } while (0)
56 #endif
58 #ifndef __ASSUME_FUTEX_CLOCK_REALTIME
59 /* Nonzero if we do not have FUTEX_CLOCK_REALTIME. */
60 int __have_futex_clock_realtime;
61 # define __set_futex_clock_realtime() \
62 __have_futex_clock_realtime = 1
63 #else
64 #define __set_futex_clock_realtime() do { } while (0)
65 #endif
67 /* Version of the library, used in libthread_db to detect mismatches. */
68 static const char nptl_version[] __attribute_used__ = VERSION;
71 #ifndef SHARED
72 extern void __libc_setup_tls (size_t tcbsize, size_t tcbalign);
73 #endif
75 #ifdef SHARED
76 static
77 #else
78 extern
79 #endif
80 void __nptl_set_robust (struct pthread *);
82 #ifdef SHARED
83 static void nptl_freeres (void);
86 static const struct pthread_functions pthread_functions =
88 .ptr_pthread_attr_destroy = __pthread_attr_destroy,
89 # if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_1)
90 .ptr___pthread_attr_init_2_0 = __pthread_attr_init_2_0,
91 # endif
92 .ptr___pthread_attr_init_2_1 = __pthread_attr_init_2_1,
93 .ptr_pthread_attr_getdetachstate = __pthread_attr_getdetachstate,
94 .ptr_pthread_attr_setdetachstate = __pthread_attr_setdetachstate,
95 .ptr_pthread_attr_getinheritsched = __pthread_attr_getinheritsched,
96 .ptr_pthread_attr_setinheritsched = __pthread_attr_setinheritsched,
97 .ptr_pthread_attr_getschedparam = __pthread_attr_getschedparam,
98 .ptr_pthread_attr_setschedparam = __pthread_attr_setschedparam,
99 .ptr_pthread_attr_getschedpolicy = __pthread_attr_getschedpolicy,
100 .ptr_pthread_attr_setschedpolicy = __pthread_attr_setschedpolicy,
101 .ptr_pthread_attr_getscope = __pthread_attr_getscope,
102 .ptr_pthread_attr_setscope = __pthread_attr_setscope,
103 .ptr_pthread_condattr_destroy = __pthread_condattr_destroy,
104 .ptr_pthread_condattr_init = __pthread_condattr_init,
105 .ptr___pthread_cond_broadcast = __pthread_cond_broadcast,
106 .ptr___pthread_cond_destroy = __pthread_cond_destroy,
107 .ptr___pthread_cond_init = __pthread_cond_init,
108 .ptr___pthread_cond_signal = __pthread_cond_signal,
109 .ptr___pthread_cond_wait = __pthread_cond_wait,
110 .ptr___pthread_cond_timedwait = __pthread_cond_timedwait,
111 # if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_3_2)
112 .ptr___pthread_cond_broadcast_2_0 = __pthread_cond_broadcast_2_0,
113 .ptr___pthread_cond_destroy_2_0 = __pthread_cond_destroy_2_0,
114 .ptr___pthread_cond_init_2_0 = __pthread_cond_init_2_0,
115 .ptr___pthread_cond_signal_2_0 = __pthread_cond_signal_2_0,
116 .ptr___pthread_cond_wait_2_0 = __pthread_cond_wait_2_0,
117 .ptr___pthread_cond_timedwait_2_0 = __pthread_cond_timedwait_2_0,
118 # endif
119 .ptr_pthread_equal = __pthread_equal,
120 .ptr___pthread_exit = __pthread_exit,
121 .ptr_pthread_getschedparam = __pthread_getschedparam,
122 .ptr_pthread_setschedparam = __pthread_setschedparam,
123 .ptr_pthread_mutex_destroy = __pthread_mutex_destroy,
124 .ptr_pthread_mutex_init = __pthread_mutex_init,
125 .ptr_pthread_mutex_lock = __pthread_mutex_lock,
126 .ptr_pthread_mutex_unlock = __pthread_mutex_unlock,
127 .ptr_pthread_self = __pthread_self,
128 .ptr_pthread_setcancelstate = __pthread_setcancelstate,
129 .ptr_pthread_setcanceltype = __pthread_setcanceltype,
130 .ptr___pthread_cleanup_upto = __pthread_cleanup_upto,
131 .ptr___pthread_once = __pthread_once,
132 .ptr___pthread_rwlock_rdlock = __pthread_rwlock_rdlock,
133 .ptr___pthread_rwlock_wrlock = __pthread_rwlock_wrlock,
134 .ptr___pthread_rwlock_unlock = __pthread_rwlock_unlock,
135 .ptr___pthread_key_create = __pthread_key_create,
136 .ptr___pthread_getspecific = __pthread_getspecific,
137 .ptr___pthread_setspecific = __pthread_setspecific,
138 .ptr__pthread_cleanup_push_defer = __pthread_cleanup_push_defer,
139 .ptr__pthread_cleanup_pop_restore = __pthread_cleanup_pop_restore,
140 .ptr_nthreads = &__nptl_nthreads,
141 .ptr___pthread_unwind = &__pthread_unwind,
142 .ptr__nptl_deallocate_tsd = __nptl_deallocate_tsd,
143 # ifdef SIGSETXID
144 .ptr__nptl_setxid = __nptl_setxid,
145 # endif
146 /* For now only the stack cache needs to be freed. */
147 .ptr_freeres = nptl_freeres,
148 .ptr_set_robust = __nptl_set_robust
150 # define ptr_pthread_functions &pthread_functions
151 #else
152 # define ptr_pthread_functions NULL
153 #endif
156 #ifdef SHARED
157 /* This function is called indirectly from the freeres code in libc. */
158 static void
159 __libc_freeres_fn_section
160 nptl_freeres (void)
162 __unwind_freeres ();
163 __free_stacks (0);
167 static
168 #endif
169 void
170 __nptl_set_robust (struct pthread *self)
172 #ifdef __NR_set_robust_list
173 INTERNAL_SYSCALL_DECL (err);
174 INTERNAL_SYSCALL (set_robust_list, err, 2, &self->robust_head,
175 sizeof (struct robust_list_head));
176 #endif
180 #ifdef SIGCANCEL
181 /* For asynchronous cancellation we use a signal. This is the handler. */
182 static void
183 sigcancel_handler (int sig, siginfo_t *si, void *ctx)
185 /* Determine the process ID. It might be negative if the thread is
186 in the middle of a fork() call. */
187 pid_t pid = THREAD_GETMEM (THREAD_SELF, pid);
188 if (__glibc_unlikely (pid < 0))
189 pid = -pid;
191 /* Safety check. It would be possible to call this function for
192 other signals and send a signal from another process. This is not
193 correct and might even be a security problem. Try to catch as
194 many incorrect invocations as possible. */
195 if (sig != SIGCANCEL
196 || si->si_pid != pid
197 || si->si_code != SI_TKILL)
198 return;
200 struct pthread *self = THREAD_SELF;
202 int oldval = THREAD_GETMEM (self, cancelhandling);
203 while (1)
205 /* We are canceled now. When canceled by another thread this flag
206 is already set but if the signal is directly send (internally or
207 from another process) is has to be done here. */
208 int newval = oldval | CANCELING_BITMASK | CANCELED_BITMASK;
210 if (oldval == newval || (oldval & EXITING_BITMASK) != 0)
211 /* Already canceled or exiting. */
212 break;
214 int curval = THREAD_ATOMIC_CMPXCHG_VAL (self, cancelhandling, newval,
215 oldval);
216 if (curval == oldval)
218 /* Set the return value. */
219 THREAD_SETMEM (self, result, PTHREAD_CANCELED);
221 /* Make sure asynchronous cancellation is still enabled. */
222 if ((newval & CANCELTYPE_BITMASK) != 0)
223 /* Run the registered destructors and terminate the thread. */
224 __do_cancel ();
226 break;
229 oldval = curval;
232 #endif
235 #ifdef SIGSETXID
236 struct xid_command *__xidcmd attribute_hidden;
238 /* We use the SIGSETXID signal in the setuid, setgid, etc. implementations to
239 tell each thread to call the respective setxid syscall on itself. This is
240 the handler. */
241 static void
242 sighandler_setxid (int sig, siginfo_t *si, void *ctx)
244 /* Determine the process ID. It might be negative if the thread is
245 in the middle of a fork() call. */
246 pid_t pid = THREAD_GETMEM (THREAD_SELF, pid);
247 int result;
248 if (__glibc_unlikely (pid < 0))
249 pid = -pid;
251 /* Safety check. It would be possible to call this function for
252 other signals and send a signal from another process. This is not
253 correct and might even be a security problem. Try to catch as
254 many incorrect invocations as possible. */
255 if (sig != SIGSETXID
256 || si->si_pid != pid
257 || si->si_code != SI_TKILL)
258 return;
260 INTERNAL_SYSCALL_DECL (err);
261 result = INTERNAL_SYSCALL_NCS (__xidcmd->syscall_no, err, 3, __xidcmd->id[0],
262 __xidcmd->id[1], __xidcmd->id[2]);
263 int error = 0;
264 if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (result, err)))
265 error = INTERNAL_SYSCALL_ERRNO (result, err);
266 __nptl_setxid_error (__xidcmd, error);
268 /* Reset the SETXID flag. */
269 struct pthread *self = THREAD_SELF;
270 int flags, newval;
273 flags = THREAD_GETMEM (self, cancelhandling);
274 newval = THREAD_ATOMIC_CMPXCHG_VAL (self, cancelhandling,
275 flags & ~SETXID_BITMASK, flags);
277 while (flags != newval);
279 /* And release the futex. */
280 self->setxid_futex = 1;
281 lll_futex_wake (&self->setxid_futex, 1, LLL_PRIVATE);
283 if (atomic_decrement_val (&__xidcmd->cntr) == 0)
284 lll_futex_wake (&__xidcmd->cntr, 1, LLL_PRIVATE);
286 #endif
289 /* When using __thread for this, we do it in libc so as not
290 to give libpthread its own TLS segment just for this. */
291 extern void **__libc_dl_error_tsd (void) __attribute__ ((const));
294 /* This can be set by the debugger before initialization is complete. */
295 static bool __nptl_initial_report_events __attribute_used__;
297 void
298 __pthread_initialize_minimal_internal (void)
300 #ifndef SHARED
301 /* Unlike in the dynamically linked case the dynamic linker has not
302 taken care of initializing the TLS data structures. */
303 __libc_setup_tls (TLS_TCB_SIZE, TLS_TCB_ALIGN);
305 /* We must prevent gcc from being clever and move any of the
306 following code ahead of the __libc_setup_tls call. This function
307 will initialize the thread register which is subsequently
308 used. */
309 __asm __volatile ("");
310 #endif
312 /* Minimal initialization of the thread descriptor. */
313 struct pthread *pd = THREAD_SELF;
314 #ifdef __NR_set_tid_address
315 INTERNAL_SYSCALL_DECL (err);
316 pd->pid = pd->tid = INTERNAL_SYSCALL (set_tid_address, err, 1, &pd->tid);
317 #endif
318 THREAD_SETMEM (pd, specific[0], &pd->specific_1stblock[0]);
319 THREAD_SETMEM (pd, user_stack, true);
320 if (LLL_LOCK_INITIALIZER != 0)
321 THREAD_SETMEM (pd, lock, LLL_LOCK_INITIALIZER);
322 #if HP_TIMING_AVAIL
323 THREAD_SETMEM (pd, cpuclock_offset, GL(dl_cpuclock_offset));
324 #endif
326 /* Initialize the robust mutex data. */
327 #ifdef __PTHREAD_MUTEX_HAVE_PREV
328 pd->robust_prev = &pd->robust_head;
329 #endif
330 pd->robust_head.list = &pd->robust_head;
331 #ifdef __NR_set_robust_list
332 pd->robust_head.futex_offset = (offsetof (pthread_mutex_t, __data.__lock)
333 - offsetof (pthread_mutex_t,
334 __data.__list.__next));
335 int res = INTERNAL_SYSCALL (set_robust_list, err, 2, &pd->robust_head,
336 sizeof (struct robust_list_head));
337 if (INTERNAL_SYSCALL_ERROR_P (res, err))
338 #endif
339 set_robust_list_not_avail ();
341 #ifdef __NR_futex
342 # ifndef __ASSUME_PRIVATE_FUTEX
343 /* Private futexes are always used (at least internally) so that
344 doing the test once this early is beneficial. */
346 int word = 0;
347 word = INTERNAL_SYSCALL (futex, err, 3, &word,
348 FUTEX_WAKE | FUTEX_PRIVATE_FLAG, 1);
349 if (!INTERNAL_SYSCALL_ERROR_P (word, err))
350 THREAD_SETMEM (pd, header.private_futex, FUTEX_PRIVATE_FLAG);
353 /* Private futexes have been introduced earlier than the
354 FUTEX_CLOCK_REALTIME flag. We don't have to run the test if we
355 know the former are not supported. This also means we know the
356 kernel will return ENOSYS for unknown operations. */
357 if (THREAD_GETMEM (pd, header.private_futex) != 0)
358 # endif
359 # ifndef __ASSUME_FUTEX_CLOCK_REALTIME
361 int word = 0;
362 /* NB: the syscall actually takes six parameters. The last is the
363 bit mask. But since we will not actually wait at all the value
364 is irrelevant. Given that passing six parameters is difficult
365 on some architectures we just pass whatever random value the
366 calling convention calls for to the kernel. It causes no harm. */
367 word = INTERNAL_SYSCALL (futex, err, 5, &word,
368 FUTEX_WAIT_BITSET | FUTEX_CLOCK_REALTIME
369 | FUTEX_PRIVATE_FLAG, 1, NULL, 0);
370 assert (INTERNAL_SYSCALL_ERROR_P (word, err));
371 if (INTERNAL_SYSCALL_ERRNO (word, err) != ENOSYS)
372 __set_futex_clock_realtime ();
374 # endif
375 #endif
377 /* Set initial thread's stack block from 0 up to __libc_stack_end.
378 It will be bigger than it actually is, but for unwind.c/pt-longjmp.c
379 purposes this is good enough. */
380 THREAD_SETMEM (pd, stackblock_size, (size_t) __libc_stack_end);
382 /* Initialize the list of all running threads with the main thread. */
383 INIT_LIST_HEAD (&__stack_user);
384 list_add (&pd->list, &__stack_user);
386 /* Before initializing __stack_user, the debugger could not find us and
387 had to set __nptl_initial_report_events. Propagate its setting. */
388 THREAD_SETMEM (pd, report_events, __nptl_initial_report_events);
390 #if defined SIGCANCEL || defined SIGSETXID
391 struct sigaction sa;
392 __sigemptyset (&sa.sa_mask);
394 # ifdef SIGCANCEL
395 /* Install the cancellation signal handler. If for some reason we
396 cannot install the handler we do not abort. Maybe we should, but
397 it is only asynchronous cancellation which is affected. */
398 sa.sa_sigaction = sigcancel_handler;
399 sa.sa_flags = SA_SIGINFO;
400 (void) __libc_sigaction (SIGCANCEL, &sa, NULL);
401 # endif
403 # ifdef SIGSETXID
404 /* Install the handle to change the threads' uid/gid. */
405 sa.sa_sigaction = sighandler_setxid;
406 sa.sa_flags = SA_SIGINFO | SA_RESTART;
407 (void) __libc_sigaction (SIGSETXID, &sa, NULL);
408 # endif
410 /* The parent process might have left the signals blocked. Just in
411 case, unblock it. We reuse the signal mask in the sigaction
412 structure. It is already cleared. */
413 # ifdef SIGCANCEL
414 __sigaddset (&sa.sa_mask, SIGCANCEL);
415 # endif
416 # ifdef SIGSETXID
417 __sigaddset (&sa.sa_mask, SIGSETXID);
418 # endif
419 (void) INTERNAL_SYSCALL (rt_sigprocmask, err, 4, SIG_UNBLOCK, &sa.sa_mask,
420 NULL, _NSIG / 8);
421 #endif
423 /* Get the size of the static and alignment requirements for the TLS
424 block. */
425 size_t static_tls_align;
426 _dl_get_tls_static_info (&__static_tls_size, &static_tls_align);
428 /* Make sure the size takes all the alignments into account. */
429 if (STACK_ALIGN > static_tls_align)
430 static_tls_align = STACK_ALIGN;
431 __static_tls_align_m1 = static_tls_align - 1;
433 __static_tls_size = roundup (__static_tls_size, static_tls_align);
435 /* Determine the default allowed stack size. This is the size used
436 in case the user does not specify one. */
437 struct rlimit limit;
438 if (__getrlimit (RLIMIT_STACK, &limit) != 0
439 || limit.rlim_cur == RLIM_INFINITY)
440 /* The system limit is not usable. Use an architecture-specific
441 default. */
442 limit.rlim_cur = ARCH_STACK_DEFAULT_SIZE;
443 else if (limit.rlim_cur < PTHREAD_STACK_MIN)
444 /* The system limit is unusably small.
445 Use the minimal size acceptable. */
446 limit.rlim_cur = PTHREAD_STACK_MIN;
448 /* Make sure it meets the minimum size that allocate_stack
449 (allocatestack.c) will demand, which depends on the page size. */
450 const uintptr_t pagesz = GLRO(dl_pagesize);
451 const size_t minstack = pagesz + __static_tls_size + MINIMAL_REST_STACK;
452 if (limit.rlim_cur < minstack)
453 limit.rlim_cur = minstack;
455 /* Round the resource limit up to page size. */
456 limit.rlim_cur = ALIGN_UP (limit.rlim_cur, pagesz);
457 lll_lock (__default_pthread_attr_lock, LLL_PRIVATE);
458 __default_pthread_attr.stacksize = limit.rlim_cur;
459 __default_pthread_attr.guardsize = GLRO (dl_pagesize);
460 lll_unlock (__default_pthread_attr_lock, LLL_PRIVATE);
462 #ifdef SHARED
463 /* Transfer the old value from the dynamic linker's internal location. */
464 *__libc_dl_error_tsd () = *(*GL(dl_error_catch_tsd)) ();
465 GL(dl_error_catch_tsd) = &__libc_dl_error_tsd;
467 /* Make __rtld_lock_{,un}lock_recursive use pthread_mutex_{,un}lock,
468 keep the lock count from the ld.so implementation. */
469 GL(dl_rtld_lock_recursive) = (void *) __pthread_mutex_lock;
470 GL(dl_rtld_unlock_recursive) = (void *) __pthread_mutex_unlock;
471 unsigned int rtld_lock_count = GL(dl_load_lock).mutex.__data.__count;
472 GL(dl_load_lock).mutex.__data.__count = 0;
473 while (rtld_lock_count-- > 0)
474 __pthread_mutex_lock (&GL(dl_load_lock).mutex);
476 GL(dl_make_stack_executable_hook) = &__make_stacks_executable;
477 #endif
479 GL(dl_init_static_tls) = &__pthread_init_static_tls;
481 GL(dl_wait_lookup_done) = &__wait_lookup_done;
483 /* Register the fork generation counter with the libc. */
484 #ifndef TLS_MULTIPLE_THREADS_IN_TCB
485 __libc_multiple_threads_ptr =
486 #endif
487 __libc_pthread_init (&__fork_generation, __reclaim_stacks,
488 ptr_pthread_functions);
490 /* Determine whether the machine is SMP or not. */
491 __is_smp = is_smp_system ();
493 strong_alias (__pthread_initialize_minimal_internal,
494 __pthread_initialize_minimal)
497 size_t
498 __pthread_get_minstack (const pthread_attr_t *attr)
500 struct pthread_attr *iattr = (struct pthread_attr *) attr;
502 return (GLRO(dl_pagesize) + __static_tls_size + PTHREAD_STACK_MIN
503 + iattr->guardsize);