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