.
[glibc/history.git] / nptl / init.c
blobd445de0795390d9472ce82c0b312d666b951cf8d
1 /* Copyright (C) 2002,2003,2004,2005,2006,2007 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, write to the Free
17 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18 02111-1307 USA. */
20 #include <assert.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 <fork.h>
32 #include <version.h>
33 #include <shlib-compat.h>
34 #include <smp.h>
35 #include <lowlevellock.h>
36 #include <kernel-features.h>
39 /* Size and alignment of static TLS block. */
40 size_t __static_tls_size;
41 size_t __static_tls_align_m1;
43 #ifndef __ASSUME_SET_ROBUST_LIST
44 /* Negative if we do not have the system call and we can use it. */
45 int __set_robust_list_avail;
46 # define set_robust_list_not_avail() \
47 __set_robust_list_avail = -1
48 #else
49 # define set_robust_list_not_avail() do { } while (0)
50 #endif
52 /* Version of the library, used in libthread_db to detect mismatches. */
53 static const char nptl_version[] __attribute_used__ = VERSION;
56 #ifndef SHARED
57 extern void __libc_setup_tls (size_t tcbsize, size_t tcbalign);
58 #endif
61 #ifdef SHARED
62 static const struct pthread_functions pthread_functions =
64 .ptr_pthread_attr_destroy = __pthread_attr_destroy,
65 # if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_1)
66 .ptr___pthread_attr_init_2_0 = __pthread_attr_init_2_0,
67 # endif
68 .ptr___pthread_attr_init_2_1 = __pthread_attr_init_2_1,
69 .ptr_pthread_attr_getdetachstate = __pthread_attr_getdetachstate,
70 .ptr_pthread_attr_setdetachstate = __pthread_attr_setdetachstate,
71 .ptr_pthread_attr_getinheritsched = __pthread_attr_getinheritsched,
72 .ptr_pthread_attr_setinheritsched = __pthread_attr_setinheritsched,
73 .ptr_pthread_attr_getschedparam = __pthread_attr_getschedparam,
74 .ptr_pthread_attr_setschedparam = __pthread_attr_setschedparam,
75 .ptr_pthread_attr_getschedpolicy = __pthread_attr_getschedpolicy,
76 .ptr_pthread_attr_setschedpolicy = __pthread_attr_setschedpolicy,
77 .ptr_pthread_attr_getscope = __pthread_attr_getscope,
78 .ptr_pthread_attr_setscope = __pthread_attr_setscope,
79 .ptr_pthread_condattr_destroy = __pthread_condattr_destroy,
80 .ptr_pthread_condattr_init = __pthread_condattr_init,
81 .ptr___pthread_cond_broadcast = __pthread_cond_broadcast,
82 .ptr___pthread_cond_destroy = __pthread_cond_destroy,
83 .ptr___pthread_cond_init = __pthread_cond_init,
84 .ptr___pthread_cond_signal = __pthread_cond_signal,
85 .ptr___pthread_cond_wait = __pthread_cond_wait,
86 .ptr___pthread_cond_timedwait = __pthread_cond_timedwait,
87 # if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_3_2)
88 .ptr___pthread_cond_broadcast_2_0 = __pthread_cond_broadcast_2_0,
89 .ptr___pthread_cond_destroy_2_0 = __pthread_cond_destroy_2_0,
90 .ptr___pthread_cond_init_2_0 = __pthread_cond_init_2_0,
91 .ptr___pthread_cond_signal_2_0 = __pthread_cond_signal_2_0,
92 .ptr___pthread_cond_wait_2_0 = __pthread_cond_wait_2_0,
93 .ptr___pthread_cond_timedwait_2_0 = __pthread_cond_timedwait_2_0,
94 # endif
95 .ptr_pthread_equal = __pthread_equal,
96 .ptr___pthread_exit = __pthread_exit,
97 .ptr_pthread_getschedparam = __pthread_getschedparam,
98 .ptr_pthread_setschedparam = __pthread_setschedparam,
99 .ptr_pthread_mutex_destroy = INTUSE(__pthread_mutex_destroy),
100 .ptr_pthread_mutex_init = INTUSE(__pthread_mutex_init),
101 .ptr_pthread_mutex_lock = INTUSE(__pthread_mutex_lock),
102 .ptr_pthread_mutex_unlock = INTUSE(__pthread_mutex_unlock),
103 .ptr_pthread_self = __pthread_self,
104 .ptr_pthread_setcancelstate = __pthread_setcancelstate,
105 .ptr_pthread_setcanceltype = __pthread_setcanceltype,
106 .ptr___pthread_cleanup_upto = __pthread_cleanup_upto,
107 .ptr___pthread_once = __pthread_once_internal,
108 .ptr___pthread_rwlock_rdlock = __pthread_rwlock_rdlock_internal,
109 .ptr___pthread_rwlock_wrlock = __pthread_rwlock_wrlock_internal,
110 .ptr___pthread_rwlock_unlock = __pthread_rwlock_unlock_internal,
111 .ptr___pthread_key_create = __pthread_key_create_internal,
112 .ptr___pthread_getspecific = __pthread_getspecific_internal,
113 .ptr___pthread_setspecific = __pthread_setspecific_internal,
114 .ptr__pthread_cleanup_push_defer = __pthread_cleanup_push_defer,
115 .ptr__pthread_cleanup_pop_restore = __pthread_cleanup_pop_restore,
116 .ptr_nthreads = &__nptl_nthreads,
117 .ptr___pthread_unwind = &__pthread_unwind,
118 .ptr__nptl_deallocate_tsd = __nptl_deallocate_tsd,
119 .ptr__nptl_setxid = __nptl_setxid,
120 /* For now only the stack cache needs to be freed. */
121 .ptr_freeres = __free_stack_cache
123 # define ptr_pthread_functions &pthread_functions
124 #else
125 # define ptr_pthread_functions NULL
126 #endif
129 /* For asynchronous cancellation we use a signal. This is the handler. */
130 static void
131 sigcancel_handler (int sig, siginfo_t *si, void *ctx)
133 #ifdef __ASSUME_CORRECT_SI_PID
134 /* Determine the process ID. It might be negative if the thread is
135 in the middle of a fork() call. */
136 pid_t pid = THREAD_GETMEM (THREAD_SELF, pid);
137 if (__builtin_expect (pid < 0, 0))
138 pid = -pid;
139 #endif
141 /* Safety check. It would be possible to call this function for
142 other signals and send a signal from another process. This is not
143 correct and might even be a security problem. Try to catch as
144 many incorrect invocations as possible. */
145 if (sig != SIGCANCEL
146 #ifdef __ASSUME_CORRECT_SI_PID
147 /* Kernels before 2.5.75 stored the thread ID and not the process
148 ID in si_pid so we skip this test. */
149 || si->si_pid != pid
150 #endif
151 || si->si_code != SI_TKILL)
152 return;
154 struct pthread *self = THREAD_SELF;
156 int oldval = THREAD_GETMEM (self, cancelhandling);
157 while (1)
159 /* We are canceled now. When canceled by another thread this flag
160 is already set but if the signal is directly send (internally or
161 from another process) is has to be done here. */
162 int newval = oldval | CANCELING_BITMASK | CANCELED_BITMASK;
164 if (oldval == newval || (oldval & EXITING_BITMASK) != 0)
165 /* Already canceled or exiting. */
166 break;
168 int curval = THREAD_ATOMIC_CMPXCHG_VAL (self, cancelhandling, newval,
169 oldval);
170 if (curval == oldval)
172 /* Set the return value. */
173 THREAD_SETMEM (self, result, PTHREAD_CANCELED);
175 /* Make sure asynchronous cancellation is still enabled. */
176 if ((newval & CANCELTYPE_BITMASK) != 0)
177 /* Run the registered destructors and terminate the thread. */
178 __do_cancel ();
180 break;
183 oldval = curval;
188 struct xid_command *__xidcmd attribute_hidden;
190 /* For asynchronous cancellation we use a signal. This is the handler. */
191 static void
192 sighandler_setxid (int sig, siginfo_t *si, void *ctx)
194 #ifdef __ASSUME_CORRECT_SI_PID
195 /* Determine the process ID. It might be negative if the thread is
196 in the middle of a fork() call. */
197 pid_t pid = THREAD_GETMEM (THREAD_SELF, pid);
198 if (__builtin_expect (pid < 0, 0))
199 pid = -pid;
200 #endif
202 /* Safety check. It would be possible to call this function for
203 other signals and send a signal from another process. This is not
204 correct and might even be a security problem. Try to catch as
205 many incorrect invocations as possible. */
206 if (sig != SIGSETXID
207 #ifdef __ASSUME_CORRECT_SI_PID
208 /* Kernels before 2.5.75 stored the thread ID and not the process
209 ID in si_pid so we skip this test. */
210 || si->si_pid != pid
211 #endif
212 || si->si_code != SI_TKILL)
213 return;
215 INTERNAL_SYSCALL_DECL (err);
216 INTERNAL_SYSCALL_NCS (__xidcmd->syscall_no, err, 3, __xidcmd->id[0],
217 __xidcmd->id[1], __xidcmd->id[2]);
219 if (atomic_decrement_val (&__xidcmd->cntr) == 0)
220 lll_futex_wake (&__xidcmd->cntr, 1, LLL_PRIVATE);
222 /* Reset the SETXID flag. */
223 struct pthread *self = THREAD_SELF;
224 int flags = THREAD_GETMEM (self, cancelhandling);
225 THREAD_SETMEM (self, cancelhandling, flags & ~SETXID_BITMASK);
227 /* And release the futex. */
228 self->setxid_futex = 1;
229 lll_futex_wake (&self->setxid_futex, 1, LLL_PRIVATE);
233 /* When using __thread for this, we do it in libc so as not
234 to give libpthread its own TLS segment just for this. */
235 extern void **__libc_dl_error_tsd (void) __attribute__ ((const));
238 /* This can be set by the debugger before initialization is complete. */
239 static bool __nptl_initial_report_events;
241 void
242 __pthread_initialize_minimal_internal (void)
244 #ifndef SHARED
245 /* Unlike in the dynamically linked case the dynamic linker has not
246 taken care of initializing the TLS data structures. */
247 __libc_setup_tls (TLS_TCB_SIZE, TLS_TCB_ALIGN);
249 /* We must prevent gcc from being clever and move any of the
250 following code ahead of the __libc_setup_tls call. This function
251 will initialize the thread register which is subsequently
252 used. */
253 __asm __volatile ("");
254 #endif
256 /* Minimal initialization of the thread descriptor. */
257 struct pthread *pd = THREAD_SELF;
258 INTERNAL_SYSCALL_DECL (err);
259 pd->pid = pd->tid = INTERNAL_SYSCALL (set_tid_address, err, 1, &pd->tid);
260 THREAD_SETMEM (pd, specific[0], &pd->specific_1stblock[0]);
261 THREAD_SETMEM (pd, user_stack, true);
262 if (LLL_LOCK_INITIALIZER != 0)
263 THREAD_SETMEM (pd, lock, LLL_LOCK_INITIALIZER);
264 #if HP_TIMING_AVAIL
265 THREAD_SETMEM (pd, cpuclock_offset, GL(dl_cpuclock_offset));
266 #endif
268 /* Initialize the robust mutex data. */
269 #ifdef __PTHREAD_MUTEX_HAVE_PREV
270 pd->robust_prev = &pd->robust_head;
271 #endif
272 pd->robust_head.list = &pd->robust_head;
273 #ifdef __NR_set_robust_list
274 pd->robust_head.futex_offset = (offsetof (pthread_mutex_t, __data.__lock)
275 - offsetof (pthread_mutex_t,
276 __data.__list.__next));
277 int res = INTERNAL_SYSCALL (set_robust_list, err, 2, &pd->robust_head,
278 sizeof (struct robust_list_head));
279 if (INTERNAL_SYSCALL_ERROR_P (res, err))
280 #endif
281 set_robust_list_not_avail ();
283 #ifndef __ASSUME_PRIVATE_FUTEX
284 /* Private futexes are always used (at least internally) so that
285 doing the test once this early is beneficial. */
287 int word = 0;
288 word = INTERNAL_SYSCALL (futex, err, 3, &word,
289 FUTEX_WAKE | FUTEX_PRIVATE_FLAG, 1);
290 if (!INTERNAL_SYSCALL_ERROR_P (word, err))
291 THREAD_SETMEM (pd, header.private_futex, FUTEX_PRIVATE_FLAG);
293 #endif
295 /* Set initial thread's stack block from 0 up to __libc_stack_end.
296 It will be bigger than it actually is, but for unwind.c/pt-longjmp.c
297 purposes this is good enough. */
298 THREAD_SETMEM (pd, stackblock_size, (size_t) __libc_stack_end);
300 /* Initialize the list of all running threads with the main thread. */
301 INIT_LIST_HEAD (&__stack_user);
302 list_add (&pd->list, &__stack_user);
304 /* Before initializing __stack_user, the debugger could not find us and
305 had to set __nptl_initial_report_events. Propagate its setting. */
306 THREAD_SETMEM (pd, report_events, __nptl_initial_report_events);
308 /* Install the cancellation signal handler. If for some reason we
309 cannot install the handler we do not abort. Maybe we should, but
310 it is only asynchronous cancellation which is affected. */
311 struct sigaction sa;
312 sa.sa_sigaction = sigcancel_handler;
313 sa.sa_flags = SA_SIGINFO;
314 __sigemptyset (&sa.sa_mask);
316 (void) __libc_sigaction (SIGCANCEL, &sa, NULL);
318 /* Install the handle to change the threads' uid/gid. */
319 sa.sa_sigaction = sighandler_setxid;
320 sa.sa_flags = SA_SIGINFO | SA_RESTART;
322 (void) __libc_sigaction (SIGSETXID, &sa, NULL);
324 /* The parent process might have left the signals blocked. Just in
325 case, unblock it. We reuse the signal mask in the sigaction
326 structure. It is already cleared. */
327 __sigaddset (&sa.sa_mask, SIGCANCEL);
328 __sigaddset (&sa.sa_mask, SIGSETXID);
329 (void) INTERNAL_SYSCALL (rt_sigprocmask, err, 4, SIG_UNBLOCK, &sa.sa_mask,
330 NULL, _NSIG / 8);
332 /* Get the size of the static and alignment requirements for the TLS
333 block. */
334 size_t static_tls_align;
335 _dl_get_tls_static_info (&__static_tls_size, &static_tls_align);
337 /* Make sure the size takes all the alignments into account. */
338 if (STACK_ALIGN > static_tls_align)
339 static_tls_align = STACK_ALIGN;
340 __static_tls_align_m1 = static_tls_align - 1;
342 __static_tls_size = roundup (__static_tls_size, static_tls_align);
344 /* Determine the default allowed stack size. This is the size used
345 in case the user does not specify one. */
346 struct rlimit limit;
347 if (getrlimit (RLIMIT_STACK, &limit) != 0
348 || limit.rlim_cur == RLIM_INFINITY)
349 /* The system limit is not usable. Use an architecture-specific
350 default. */
351 limit.rlim_cur = ARCH_STACK_DEFAULT_SIZE;
352 else if (limit.rlim_cur < PTHREAD_STACK_MIN)
353 /* The system limit is unusably small.
354 Use the minimal size acceptable. */
355 limit.rlim_cur = PTHREAD_STACK_MIN;
357 /* Make sure it meets the minimum size that allocate_stack
358 (allocatestack.c) will demand, which depends on the page size. */
359 const uintptr_t pagesz = __sysconf (_SC_PAGESIZE);
360 const size_t minstack = pagesz + __static_tls_size + MINIMAL_REST_STACK;
361 if (limit.rlim_cur < minstack)
362 limit.rlim_cur = minstack;
364 /* Round the resource limit up to page size. */
365 limit.rlim_cur = (limit.rlim_cur + pagesz - 1) & -pagesz;
366 __default_stacksize = limit.rlim_cur;
368 #ifdef SHARED
369 /* Transfer the old value from the dynamic linker's internal location. */
370 *__libc_dl_error_tsd () = *(*GL(dl_error_catch_tsd)) ();
371 GL(dl_error_catch_tsd) = &__libc_dl_error_tsd;
373 /* Make __rtld_lock_{,un}lock_recursive use pthread_mutex_{,un}lock,
374 keep the lock count from the ld.so implementation. */
375 GL(dl_rtld_lock_recursive) = (void *) INTUSE (__pthread_mutex_lock);
376 GL(dl_rtld_unlock_recursive) = (void *) INTUSE (__pthread_mutex_unlock);
377 unsigned int rtld_lock_count = GL(dl_load_lock).mutex.__data.__count;
378 GL(dl_load_lock).mutex.__data.__count = 0;
379 while (rtld_lock_count-- > 0)
380 INTUSE (__pthread_mutex_lock) (&GL(dl_load_lock).mutex);
382 GL(dl_make_stack_executable_hook) = &__make_stacks_executable;
383 #endif
385 GL(dl_init_static_tls) = &__pthread_init_static_tls;
387 GL(dl_wait_lookup_done) = &__wait_lookup_done;
389 /* Register the fork generation counter with the libc. */
390 #ifndef TLS_MULTIPLE_THREADS_IN_TCB
391 __libc_multiple_threads_ptr =
392 #endif
393 __libc_pthread_init (&__fork_generation, __reclaim_stacks,
394 ptr_pthread_functions);
396 /* Determine whether the machine is SMP or not. */
397 __is_smp = is_smp_system ();
399 strong_alias (__pthread_initialize_minimal_internal,
400 __pthread_initialize_minimal)