nptl/init.c

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