Update.
[glibc.git] / nptl / init.c
blob86745af8d1db5dc440619b7af444eb747e24c8a2
1 /* Copyright (C) 2002, 2003, 2004 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>
38 #ifndef __NR_set_tid_address
39 /* XXX For the time being... Once we can rely on the kernel headers
40 having the definition remove these lines. */
41 #if defined __s390__
42 # define __NR_set_tid_address 252
43 #elif defined __ia64__
44 # define __NR_set_tid_address 1233
45 #elif defined __i386__
46 # define __NR_set_tid_address 258
47 #elif defined __x86_64__
48 # define __NR_set_tid_address 218
49 #elif defined __powerpc__
50 # define __NR_set_tid_address 232
51 #elif defined __sparc__
52 # define __NR_set_tid_address 166
53 #else
54 # error "define __NR_set_tid_address"
55 #endif
56 #endif
59 /* Size and alignment of static TLS block. */
60 size_t __static_tls_size;
61 size_t __static_tls_align_m1;
63 /* Version of the library, used in libthread_db to detect mismatches. */
64 static const char nptl_version[] __attribute_used__ = VERSION;
67 #if defined USE_TLS && !defined SHARED
68 extern void __libc_setup_tls (size_t tcbsize, size_t tcbalign);
69 #endif
72 #ifdef SHARED
73 static const struct pthread_functions pthread_functions =
75 .ptr_pthread_attr_destroy = __pthread_attr_destroy,
76 # if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_1)
77 .ptr___pthread_attr_init_2_0 = __pthread_attr_init_2_0,
78 # endif
79 .ptr___pthread_attr_init_2_1 = __pthread_attr_init_2_1,
80 .ptr_pthread_attr_getdetachstate = __pthread_attr_getdetachstate,
81 .ptr_pthread_attr_setdetachstate = __pthread_attr_setdetachstate,
82 .ptr_pthread_attr_getinheritsched = __pthread_attr_getinheritsched,
83 .ptr_pthread_attr_setinheritsched = __pthread_attr_setinheritsched,
84 .ptr_pthread_attr_getschedparam = __pthread_attr_getschedparam,
85 .ptr_pthread_attr_setschedparam = __pthread_attr_setschedparam,
86 .ptr_pthread_attr_getschedpolicy = __pthread_attr_getschedpolicy,
87 .ptr_pthread_attr_setschedpolicy = __pthread_attr_setschedpolicy,
88 .ptr_pthread_attr_getscope = __pthread_attr_getscope,
89 .ptr_pthread_attr_setscope = __pthread_attr_setscope,
90 .ptr_pthread_condattr_destroy = __pthread_condattr_destroy,
91 .ptr_pthread_condattr_init = __pthread_condattr_init,
92 .ptr___pthread_cond_broadcast = __pthread_cond_broadcast,
93 .ptr___pthread_cond_destroy = __pthread_cond_destroy,
94 .ptr___pthread_cond_init = __pthread_cond_init,
95 .ptr___pthread_cond_signal = __pthread_cond_signal,
96 .ptr___pthread_cond_wait = __pthread_cond_wait,
97 .ptr___pthread_cond_timedwait = __pthread_cond_timedwait,
98 # if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_3_2)
99 .ptr___pthread_cond_broadcast_2_0 = __pthread_cond_broadcast_2_0,
100 .ptr___pthread_cond_destroy_2_0 = __pthread_cond_destroy_2_0,
101 .ptr___pthread_cond_init_2_0 = __pthread_cond_init_2_0,
102 .ptr___pthread_cond_signal_2_0 = __pthread_cond_signal_2_0,
103 .ptr___pthread_cond_wait_2_0 = __pthread_cond_wait_2_0,
104 .ptr___pthread_cond_timedwait_2_0 = __pthread_cond_timedwait_2_0,
105 # endif
106 .ptr_pthread_equal = __pthread_equal,
107 .ptr___pthread_exit = __pthread_exit,
108 .ptr_pthread_getschedparam = __pthread_getschedparam,
109 .ptr_pthread_setschedparam = __pthread_setschedparam,
110 .ptr_pthread_mutex_destroy = INTUSE(__pthread_mutex_destroy),
111 .ptr_pthread_mutex_init = INTUSE(__pthread_mutex_init),
112 .ptr_pthread_mutex_lock = INTUSE(__pthread_mutex_lock),
113 .ptr_pthread_mutex_unlock = INTUSE(__pthread_mutex_unlock),
114 .ptr_pthread_self = __pthread_self,
115 .ptr_pthread_setcancelstate = __pthread_setcancelstate,
116 .ptr_pthread_setcanceltype = __pthread_setcanceltype,
117 .ptr___pthread_cleanup_upto = __pthread_cleanup_upto,
118 .ptr___pthread_once = __pthread_once_internal,
119 .ptr___pthread_rwlock_rdlock = __pthread_rwlock_rdlock_internal,
120 .ptr___pthread_rwlock_wrlock = __pthread_rwlock_wrlock_internal,
121 .ptr___pthread_rwlock_unlock = __pthread_rwlock_unlock_internal,
122 .ptr___pthread_key_create = __pthread_key_create_internal,
123 .ptr___pthread_getspecific = __pthread_getspecific_internal,
124 .ptr___pthread_setspecific = __pthread_setspecific_internal,
125 .ptr__pthread_cleanup_push_defer = __pthread_cleanup_push_defer,
126 .ptr__pthread_cleanup_pop_restore = __pthread_cleanup_pop_restore,
127 .ptr_nthreads = &__nptl_nthreads,
128 .ptr___pthread_unwind = &__pthread_unwind,
129 .ptr__nptl_deallocate_tsd = __nptl_deallocate_tsd,
130 .ptr__nptl_setxid = __nptl_setxid
132 # define ptr_pthread_functions &pthread_functions
133 #else
134 # define ptr_pthread_functions NULL
135 #endif
138 /* For asynchronous cancellation we use a signal. This is the handler. */
139 static void
140 sigcancel_handler (int sig, siginfo_t *si, void *ctx)
142 /* Safety check. It would be possible to call this function for
143 other signals and send a signal from another process. This is not
144 correct and might even be a security problem. Try to catch as
145 many incorrect invocations as possible. */
146 if (sig != SIGCANCEL
147 #ifdef __ASSUME_CORRECT_SI_PID
148 /* Kernels before 2.5.75 stored the thread ID and not the process
149 ID in si_pid so we skip this test. */
150 || si->si_pid != THREAD_GETMEM (THREAD_SELF, pid)
151 #endif
152 || si->si_code != SI_TKILL)
153 return;
155 struct pthread *self = THREAD_SELF;
157 int oldval = THREAD_GETMEM (self, cancelhandling);
158 while (1)
160 /* We are canceled now. When canceled by another thread this flag
161 is already set but if the signal is directly send (internally or
162 from another process) is has to be done here. */
163 int newval = oldval | CANCELING_BITMASK | CANCELED_BITMASK;
165 if (oldval == newval || (oldval & EXITING_BITMASK) != 0)
166 /* Already canceled or exiting. */
167 break;
169 int curval = THREAD_ATOMIC_CMPXCHG_VAL (self, cancelhandling, newval,
170 oldval);
171 if (curval == oldval)
173 /* Set the return value. */
174 THREAD_SETMEM (self, result, PTHREAD_CANCELED);
176 /* Make sure asynchronous cancellation is still enabled. */
177 if ((newval & CANCELTYPE_BITMASK) != 0)
178 /* Run the registered destructors and terminate the thread. */
179 __do_cancel ();
181 break;
184 oldval = curval;
189 struct xid_command *__xidcmd attribute_hidden;
191 /* For asynchronous cancellation we use a signal. This is the handler. */
192 static void
193 sighandler_setxid (int sig, siginfo_t *si, void *ctx)
195 /* Safety check. It would be possible to call this function for
196 other signals and send a signal from another process. This is not
197 correct and might even be a security problem. Try to catch as
198 many incorrect invocations as possible. */
199 if (sig != SIGSETXID
200 #ifdef __ASSUME_CORRECT_SI_PID
201 /* Kernels before 2.5.75 stored the thread ID and not the process
202 ID in si_pid so we skip this test. */
203 || si->si_pid != THREAD_GETMEM (THREAD_SELF, pid)
204 #endif
205 || si->si_code != SI_TKILL)
206 return;
208 INTERNAL_SYSCALL_DECL (err);
209 INTERNAL_SYSCALL_NCS (__xidcmd->syscall_no, err, 3, __xidcmd->id[0],
210 __xidcmd->id[1], __xidcmd->id[2]);
212 if (atomic_decrement_val (&__xidcmd->cntr) == 0)
213 lll_futex_wake (&__xidcmd->cntr, 1);
217 /* When using __thread for this, we do it in libc so as not
218 to give libpthread its own TLS segment just for this. */
219 extern void **__libc_dl_error_tsd (void) __attribute__ ((const));
222 void
223 __pthread_initialize_minimal_internal (void)
225 #ifndef SHARED
226 /* Unlike in the dynamically linked case the dynamic linker has not
227 taken care of initializing the TLS data structures. */
228 __libc_setup_tls (TLS_TCB_SIZE, TLS_TCB_ALIGN);
230 /* We must prevent gcc from being clever and move any of the
231 following code ahead of the __libc_setup_tls call. This function
232 will initialize the thread register which is subsequently
233 used. */
234 __asm __volatile ("");
235 #endif
237 /* Minimal initialization of the thread descriptor. */
238 struct pthread *pd = THREAD_SELF;
239 INTERNAL_SYSCALL_DECL (err);
240 pd->pid = pd->tid = INTERNAL_SYSCALL (set_tid_address, err, 1, &pd->tid);
241 THREAD_SETMEM (pd, specific[0], &pd->specific_1stblock[0]);
242 THREAD_SETMEM (pd, user_stack, true);
243 if (LLL_LOCK_INITIALIZER != 0)
244 THREAD_SETMEM (pd, lock, LLL_LOCK_INITIALIZER);
245 #if HP_TIMING_AVAIL
246 THREAD_SETMEM (pd, cpuclock_offset, GL(dl_cpuclock_offset));
247 #endif
249 /* Set initial thread's stack block from 0 up to __libc_stack_end.
250 It will be bigger than it actually is, but for unwind.c/pt-longjmp.c
251 purposes this is good enough. */
252 THREAD_SETMEM (pd, stackblock_size, (size_t) __libc_stack_end);
254 /* Initialize the list of all running threads with the main thread. */
255 INIT_LIST_HEAD (&__stack_user);
256 list_add (&pd->list, &__stack_user);
259 /* Install the cancellation signal handler. If for some reason we
260 cannot install the handler we do not abort. Maybe we should, but
261 it is only asynchronous cancellation which is affected. */
262 struct sigaction sa;
263 sa.sa_sigaction = sigcancel_handler;
264 sa.sa_flags = SA_SIGINFO;
265 __sigemptyset (&sa.sa_mask);
267 (void) __libc_sigaction (SIGCANCEL, &sa, NULL);
269 /* Install the handle to change the threads' uid/gid. */
270 sa.sa_sigaction = sighandler_setxid;
271 sa.sa_flags = SA_SIGINFO | SA_RESTART;
273 (void) __libc_sigaction (SIGSETXID, &sa, NULL);
275 /* The parent process might have left the signals blocked. Just in
276 case, unblock it. We reuse the signal mask in the sigaction
277 structure. It is already cleared. */
278 __sigaddset (&sa.sa_mask, SIGCANCEL);
279 __sigaddset (&sa.sa_mask, SIGSETXID);
280 (void) INTERNAL_SYSCALL (rt_sigprocmask, err, 4, SIG_UNBLOCK, &sa.sa_mask,
281 NULL, _NSIG / 8);
284 /* Determine the default allowed stack size. This is the size used
285 in case the user does not specify one. */
286 struct rlimit limit;
287 if (getrlimit (RLIMIT_STACK, &limit) != 0
288 || limit.rlim_cur == RLIM_INFINITY)
289 /* The system limit is not usable. Use an architecture-specific
290 default. */
291 __default_stacksize = ARCH_STACK_DEFAULT_SIZE;
292 else if (limit.rlim_cur < PTHREAD_STACK_MIN)
293 /* The system limit is unusably small.
294 Use the minimal size acceptable. */
295 __default_stacksize = PTHREAD_STACK_MIN;
296 else
298 /* Round the resource limit up to page size. */
299 const uintptr_t pagesz = __sysconf (_SC_PAGESIZE);
300 __default_stacksize = (limit.rlim_cur + pagesz - 1) & -pagesz;
303 /* Get the size of the static and alignment requirements for the TLS
304 block. */
305 size_t static_tls_align;
306 _dl_get_tls_static_info (&__static_tls_size, &static_tls_align);
308 /* Make sure the size takes all the alignments into account. */
309 if (STACK_ALIGN > static_tls_align)
310 static_tls_align = STACK_ALIGN;
311 __static_tls_align_m1 = static_tls_align - 1;
313 __static_tls_size = roundup (__static_tls_size, static_tls_align);
315 #ifdef SHARED
316 /* Transfer the old value from the dynamic linker's internal location. */
317 *__libc_dl_error_tsd () = *(*GL(dl_error_catch_tsd)) ();
318 GL(dl_error_catch_tsd) = &__libc_dl_error_tsd;
320 /* Make __rtld_lock_{,un}lock_recursive use pthread_mutex_{,un}lock,
321 keep the lock count from the ld.so implementation. */
322 GL(dl_rtld_lock_recursive) = (void *) INTUSE (__pthread_mutex_lock);
323 GL(dl_rtld_unlock_recursive) = (void *) INTUSE (__pthread_mutex_unlock);
324 unsigned int rtld_lock_count = GL(dl_load_lock).mutex.__data.__count;
325 GL(dl_load_lock).mutex.__data.__count = 0;
326 while (rtld_lock_count-- > 0)
327 INTUSE (__pthread_mutex_lock) (&GL(dl_load_lock).mutex);
329 GL(dl_make_stack_executable_hook) = &__make_stacks_executable;
330 #endif
332 GL(dl_init_static_tls) = &__pthread_init_static_tls;
334 /* Register the fork generation counter with the libc. */
335 #ifndef TLS_MULTIPLE_THREADS_IN_TCB
336 __libc_multiple_threads_ptr =
337 #endif
338 __libc_pthread_init (&__fork_generation, __reclaim_stacks,
339 ptr_pthread_functions);
341 /* Determine whether the machine is SMP or not. */
342 __is_smp = is_smp_system ();
344 strong_alias (__pthread_initialize_minimal_internal,
345 __pthread_initialize_minimal)