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