lib/libthread_xu/thread/thr_init.c

   1 /*
   2  * Copyright (c) 2003 Daniel M. Eischen <deischen@freebsd.org>
   3  * Copyright (c) 1995-1998 John Birrell <jb@cimlogic.com.au>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. All advertising materials mentioning features or use of this software
  15  *    must display the following acknowledgement:
  16  *      This product includes software developed by John Birrell.
  17  * 4. Neither the name of the author nor the names of any co-contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include "namespace.h"
  35 #include <sys/param.h>
  36 #include <sys/signalvar.h>
  37
  38 #include <sys/ioctl.h>
  39 #include <sys/sysctl.h>
  40 #include <sys/time.h>
  41 #include <sys/ttycom.h>
  42 #include <sys/mman.h>
  43
  44 #include <fcntl.h>
  45 #include <paths.h>
  46 #include <pthread.h>
  47 #include <signal.h>
  48 #include <stdlib.h>
  49 #include <string.h>
  50 #include <unistd.h>
  51 #include "un-namespace.h"
  52
  53 #include "libc_private.h"
  54 #include "thr_private.h"
  55
  56 /* thr_attr.c */
  57 STATIC_LIB_REQUIRE(_pthread_attr_init);
  58 /* thr_barrier.c */
  59 STATIC_LIB_REQUIRE(_pthread_barrier_init);
  60 /* thr_barrierattr.c */
  61 STATIC_LIB_REQUIRE(_pthread_barrierattr_init);
  62 /* thr_cancel.c */
  63 STATIC_LIB_REQUIRE(_pthread_cancel);
  64 /* thr_clean.c */
  65 STATIC_LIB_REQUIRE(_pthread_cleanup_push);
  66 /* thr_concurrency.c */
  67 STATIC_LIB_REQUIRE(_pthread_getconcurrency);
  68 STATIC_LIB_REQUIRE(_pthread_setconcurrency);
  69 /* thr_cond.c */
  70 STATIC_LIB_REQUIRE(_pthread_cond_init);
  71 /* thr_condattr.c */
  72 STATIC_LIB_REQUIRE(_pthread_condattr_init);
  73 /* thr_create.c */
  74 STATIC_LIB_REQUIRE(_pthread_create);
  75 /* thr_detach.c */
  76 STATIC_LIB_REQUIRE(_pthread_detach);
  77 /* thr_equal.c */
  78 STATIC_LIB_REQUIRE(_pthread_equal);
  79 /* thr_exit.c */
  80 STATIC_LIB_REQUIRE(_pthread_exit);
  81 /* thr_fork.c */
  82 STATIC_LIB_REQUIRE(_pthread_atfork);
  83 STATIC_LIB_REQUIRE(_fork);
  84 /* thr_getprio.c */
  85 STATIC_LIB_REQUIRE(_pthread_getprio);
  86 /* thr_getschedparam.c */
  87 STATIC_LIB_REQUIRE(_pthread_getschedparam);
  88 /* thr_info.c */
  89 STATIC_LIB_REQUIRE(_pthread_set_name_np);
  90 /* thr_join.c */
  91 STATIC_LIB_REQUIRE(_pthread_join);
  92 /* thr_kill.c */
  93 STATIC_LIB_REQUIRE(_pthread_kill);
  94 /* thr_main_np.c */
  95 STATIC_LIB_REQUIRE(_pthread_main_np);
  96 /* thr_multi_np.c */
  97 STATIC_LIB_REQUIRE(_pthread_multi_np);
  98 /* thr_mutex.c */
  99 STATIC_LIB_REQUIRE(_pthread_mutex_init);
 100 /* thr_mutex_prioceiling.c */
 101 STATIC_LIB_REQUIRE(_pthread_mutexattr_getprioceiling);
 102 /* thr_mutex_protocol.c */
 103 STATIC_LIB_REQUIRE(_pthread_mutexattr_getprotocol);
 104 /* thr_mutexattr.c */
 105 STATIC_LIB_REQUIRE(_pthread_mutexattr_init);
 106 /* thr_once.c */
 107 STATIC_LIB_REQUIRE(_pthread_once);
 108 /* thr_pspinlock.c */
 109 STATIC_LIB_REQUIRE(_pthread_spin_init);
 110 /* thr_resume_np.c */
 111 STATIC_LIB_REQUIRE(_pthread_resume_np);
 112 /* thr_rwlock.c */
 113 STATIC_LIB_REQUIRE(_pthread_rwlock_init);
 114 /* thr_rwlockattr.c */
 115 STATIC_LIB_REQUIRE(_pthread_rwlockattr_init);
 116 /* thr_self.c */
 117 STATIC_LIB_REQUIRE(_pthread_self);
 118 /* thr_sem.c */
 119 STATIC_LIB_REQUIRE(_sem_init);
 120 /* thr_setprio.c */
 121 STATIC_LIB_REQUIRE(_pthread_setprio);
 122 /* thr_setschedparam.c */
 123 STATIC_LIB_REQUIRE(_pthread_setschedparam);
 124 /* thr_sig.c */
 125 STATIC_LIB_REQUIRE(_sigwait);
 126 /* thr_single_np.c */
 127 STATIC_LIB_REQUIRE(_pthread_single_np);
 128 /* thr_spec.c */
 129 STATIC_LIB_REQUIRE(_pthread_key_create);
 130 /* thr_spinlock.c */
 131 STATIC_LIB_REQUIRE(_spinlock);
 132 /* thr_suspend_np.c */
 133 STATIC_LIB_REQUIRE(_pthread_suspend_np);
 134 /* thr_switch_np.c */
 135 STATIC_LIB_REQUIRE(_pthread_switch_add_np);
 136 /* thr_symbols.c */
 137 STATIC_LIB_REQUIRE(_thread_state_running);
 138 /* thr_syscalls.c */
 139 STATIC_LIB_REQUIRE(__wait4);
 140 /* thr_yield.c */
 141 STATIC_LIB_REQUIRE(_pthread_yield);
 142
 143 char            *_usrstack;
 144 struct pthread  *_thr_initial;
 145 int             _thread_scope_system;
 146
 147 pid_t           _thr_pid;
 148 size_t          _thr_guard_default;
 149 size_t          _thr_stack_default =    THR_STACK_DEFAULT;
 150 size_t          _thr_stack_initial =    THR_STACK_INITIAL;
 151 int             _thr_page_size;
 152
 153 static void     init_private(void);
 154 static void     init_main_thread(struct pthread *thread);
 155 static int      init_once = 0;
 156
 157 void    _thread_init(void) __attribute__ ((constructor));
 158 void
 159 _thread_init(void)
 160 {
 161         _libpthread_init(NULL);
 162 }
 163
 164 /*
 165  * Threaded process initialization.
 166  *
 167  * This is only called under two conditions:
 168  *
 169  *   1) Some thread routines have detected that the library hasn't yet
 170  *      been initialized (_thr_initial == NULL && curthread == NULL), or
 171  *
 172  *   2) An explicit call to reinitialize after a fork (indicated
 173  *      by curthread != NULL)
 174  */
 175 void
 176 _libpthread_init(struct pthread *curthread)
 177 {
 178         int fd, first = 0;
 179         sigset_t sigset, oldset;
 180
 181         /* Check if this function has already been called: */
 182         if ((_thr_initial != NULL) && (curthread == NULL))
 183                 /* Only initialize the threaded application once. */
 184                 return;
 185
 186         /*
 187          * Check for the special case of this process running as
 188          * or in place of init as pid = 1:
 189          */
 190         if ((_thr_pid = getpid()) == 1) {
 191                 /*
 192                  * Setup a new session for this process which is
 193                  * assumed to be running as root.
 194                  */
 195                 if (setsid() == -1)
 196                         PANIC("Can't set session ID");
 197                 if (revoke(_PATH_CONSOLE) != 0)
 198                         PANIC("Can't revoke console");
 199                 if ((fd = __sys_open(_PATH_CONSOLE, O_RDWR)) < 0)
 200                         PANIC("Can't open console");
 201                 if (setlogin("root") == -1)
 202                         PANIC("Can't set login to root");
 203                 if (__sys_ioctl(fd, TIOCSCTTY, NULL) == -1)
 204                         PANIC("Can't set controlling terminal");
 205         }
 206
 207         /* Initialize pthread private data. */
 208         init_private();
 209
 210         /* Set the initial thread. */
 211         if (curthread == NULL) {
 212                 first = 1;
 213                 /* Create and initialize the initial thread. */
 214                 curthread = _thr_alloc(NULL);
 215                 if (curthread == NULL)
 216                         PANIC("Can't allocate initial thread");
 217                 init_main_thread(curthread);
 218         }
 219         /*
 220          * Add the thread to the thread list queue.
 221          */
 222         THR_LIST_ADD(curthread);
 223         _thread_active_threads = 1;
 224
 225         /* Setup the thread specific data */
 226         tls_set_tcb(curthread->tcb);
 227
 228         if (first) {
 229                 SIGFILLSET(sigset);
 230                 __sys_sigprocmask(SIG_SETMASK, &sigset, &oldset);
 231                 _thr_signal_init();
 232                 _thr_initial = curthread;
 233                 SIGDELSET(oldset, SIGCANCEL);
 234                 __sys_sigprocmask(SIG_SETMASK, &oldset, NULL);
 235                 if (td_eventismember(&_thread_event_mask, TD_CREATE))
 236                         _thr_report_creation(curthread, curthread);
 237         }
 238 }
 239
 240 /*
 241  * This function and pthread_create() do a lot of the same things.
 242  * It'd be nice to consolidate the common stuff in one place.
 243  */
 244 static void
 245 init_main_thread(struct pthread *thread)
 246 {
 247         /* Setup the thread attributes. */
 248         thread->tid = _thr_get_tid();
 249         thread->attr = _pthread_attr_default;
 250         /*
 251          * Set up the thread stack.
 252          *
 253          * Create a red zone below the main stack.  All other stacks
 254          * are constrained to a maximum size by the parameters
 255          * passed to mmap(), but this stack is only limited by
 256          * resource limits, so this stack needs an explicitly mapped
 257          * red zone to protect the thread stack that is just beyond.
 258          */
 259         if (mmap(_usrstack - _thr_stack_initial -
 260                 _thr_guard_default, _thr_guard_default,
 261                 0, MAP_ANON | MAP_TRYFIXED, -1, 0) == MAP_FAILED) {
 262                 PANIC("Cannot allocate red zone for initial thread");
 263         }
 264
 265         /*
 266          * Mark the stack as an application supplied stack so that it
 267          * isn't deallocated.
 268          *
 269          * XXX - I'm not sure it would hurt anything to deallocate
 270          *       the main thread stack because deallocation doesn't
 271          *       actually free() it; it just puts it in the free
 272          *       stack queue for later reuse.
 273          */
 274         thread->attr.stackaddr_attr = _usrstack - _thr_stack_initial;
 275         thread->attr.stacksize_attr = _thr_stack_initial;
 276         thread->attr.guardsize_attr = _thr_guard_default;
 277         thread->attr.flags |= THR_STACK_USER;
 278
 279         /*
 280          * Write a magic value to the thread structure
 281          * to help identify valid ones:
 282          */
 283         thread->magic = THR_MAGIC;
 284
 285         thread->cancelflags = PTHREAD_CANCEL_ENABLE | PTHREAD_CANCEL_DEFERRED;
 286         thread->name = strdup("initial thread");
 287
 288         /* Default the priority of the initial thread: */
 289         thread->base_priority = THR_DEFAULT_PRIORITY;
 290         thread->active_priority = THR_DEFAULT_PRIORITY;
 291         thread->inherited_priority = 0;
 292
 293         /* Initialize the mutex queue: */
 294         TAILQ_INIT(&thread->mutexq);
 295
 296         thread->state = PS_RUNNING;
 297         thread->uniqueid = 0;
 298
 299         /* Others cleared to zero by thr_alloc() */
 300 }
 301
 302 static void
 303 init_private(void)
 304 {
 305         size_t len;
 306         int mib[2];
 307
 308         _thr_umtx_init(&_mutex_static_lock);
 309         _thr_umtx_init(&_cond_static_lock);
 310         _thr_umtx_init(&_rwlock_static_lock);
 311         _thr_umtx_init(&_keytable_lock);
 312         _thr_umtx_init(&_thr_atfork_lock);
 313         _thr_umtx_init(&_thr_event_lock);
 314         _thr_spinlock_init();
 315         _thr_list_init();
 316
 317         /*
 318          * Avoid reinitializing some things if they don't need to be,
 319          * e.g. after a fork().
 320          */
 321         if (init_once == 0) {
 322                 /* Find the stack top */
 323                 mib[0] = CTL_KERN;
 324                 mib[1] = KERN_USRSTACK;
 325                 len = sizeof (_usrstack);
 326                 if (sysctl(mib, 2, &_usrstack, &len, NULL, 0) == -1)
 327                         PANIC("Cannot get kern.usrstack from sysctl");
 328                 _thr_page_size = getpagesize();
 329                 _thr_guard_default = _thr_page_size;
 330                 _pthread_attr_default.guardsize_attr = _thr_guard_default;
 331
 332                 TAILQ_INIT(&_thr_atfork_list);
 333 #ifdef SYSTEM_SCOPE_ONLY
 334                 _thread_scope_system = 1;
 335 #else
 336                 if (getenv("LIBPTHREAD_SYSTEM_SCOPE") != NULL)
 337                         _thread_scope_system = 1;
 338                 else if (getenv("LIBPTHREAD_PROCESS_SCOPE") != NULL)
 339                         _thread_scope_system = -1;
 340 #endif
 341         }
 342         init_once = 1;
 343 }