libc/bionic/pthread_create.cpp

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *  * Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  *  * Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in
  12  *    the documentation and/or other materials provided with the
  13  *    distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  17  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  18  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  19  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  21  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  22  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  23  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  24  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  25  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <pthread.h>
  30
  31 #include <errno.h>
  32 #include <sys/mman.h>
  33
  34 #include "pthread_internal.h"
  35
  36 #include "private/bionic_ssp.h"
  37 #include "private/bionic_tls.h"
  38 #include "private/libc_logging.h"
  39 #include "private/ErrnoRestorer.h"
  40 #include "private/ScopedPthreadMutexLocker.h"
  41
  42 // Used by gdb to track thread creation. See libthread_db.
  43 #ifdef __i386__
  44 extern "C" __attribute__((noinline)) __attribute__((fastcall)) void _thread_created_hook(pid_t) {}
  45 #else
  46 extern "C" __attribute__((noinline)) void _thread_created_hook(pid_t) {}
  47 #endif
  48
  49 // x86 uses segment descriptors rather than a direct pointer to TLS.
  50 #if __i386__
  51 #include <asm/ldt.h>
  52 extern "C" __LIBC_HIDDEN__ void __init_user_desc(struct user_desc*, int, void*);
  53 #endif
  54
  55 static pthread_mutex_t g_pthread_stack_creation_ock = PTHREAD_MUTEX_INITIALIZER;
  56
  57 static pthread_mutex_t g_debugger_notification_lock = PTHREAD_MUTEX_INITIALIZER;
  58
  59 extern "C" int __isthreaded;
  60
  61 // This code is used both by each new pthread and the code that initializes the main thread.
  62 void __init_tls(pthread_internal_t* thread) {
  63   // Zero-initialize all the slots after TLS_SLOT_SELF and TLS_SLOT_THREAD_ID.
  64   for (size_t i = TLS_SLOT_ERRNO; i < BIONIC_TLS_SLOTS; ++i) {
  65     thread->tls[i] = NULL;
  66   }
  67
  68   // Slot 0 must point to itself. The x86 Linux kernel reads the TLS from %fs:0.
  69   thread->tls[TLS_SLOT_SELF] = thread->tls;
  70   thread->tls[TLS_SLOT_THREAD_ID] = thread;
  71   // GCC looks in the TLS for the stack guard on x86, so copy it there from our global.
  72   thread->tls[TLS_SLOT_STACK_GUARD] = (void*) __stack_chk_guard;
  73 }
  74
  75 void __init_alternate_signal_stack(pthread_internal_t* thread) {
  76   // Create and set an alternate signal stack.
  77   stack_t ss;
  78   ss.ss_sp = mmap(NULL, SIGSTKSZ, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
  79   if (ss.ss_sp != MAP_FAILED) {
  80     ss.ss_size = SIGSTKSZ;
  81     ss.ss_flags = 0;
  82     sigaltstack(&ss, NULL);
  83     thread->alternate_signal_stack = ss.ss_sp;
  84   }
  85 }
  86
  87 int __init_thread(pthread_internal_t* thread, bool add_to_thread_list) {
  88   int error = 0;
  89
  90   // Set the scheduling policy/priority of the thread.
  91   if (thread->attr.sched_policy != SCHED_NORMAL) {
  92     sched_param param;
  93     param.sched_priority = thread->attr.sched_priority;
  94     if (sched_setscheduler(thread->tid, thread->attr.sched_policy, &param) == -1) {
  95 #if __LP64__
  96       // For backwards compatibility reasons, we only report failures on 64-bit devices.
  97       error = errno;
  98 #endif
  99       __libc_format_log(ANDROID_LOG_WARN, "libc",
 100                         "pthread_create sched_setscheduler call failed: %s", strerror(errno));
 101     }
 102   }
 103
 104   thread->cleanup_stack = NULL;
 105
 106   if (add_to_thread_list) {
 107     _pthread_internal_add(thread);
 108   }
 109
 110   return error;
 111 }
 112
 113 static void* __create_thread_stack(pthread_internal_t* thread) {
 114   ScopedPthreadMutexLocker lock(&g_pthread_stack_creation_ock);
 115
 116   // Create a new private anonymous map.
 117   int prot = PROT_READ | PROT_WRITE;
 118   int flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE;
 119   void* stack = mmap(NULL, thread->attr.stack_size, prot, flags, -1, 0);
 120   if (stack == MAP_FAILED) {
 121     __libc_format_log(ANDROID_LOG_WARN,
 122                       "libc",
 123                       "pthread_create failed: couldn't allocate %zd-byte stack: %s",
 124                       thread->attr.stack_size, strerror(errno));
 125     return NULL;
 126   }
 127
 128   // Set the guard region at the end of the stack to PROT_NONE.
 129   if (mprotect(stack, thread->attr.guard_size, PROT_NONE) == -1) {
 130     __libc_format_log(ANDROID_LOG_WARN, "libc",
 131                       "pthread_create failed: couldn't mprotect PROT_NONE %zd-byte stack guard region: %s",
 132                       thread->attr.guard_size, strerror(errno));
 133     munmap(stack, thread->attr.stack_size);
 134     return NULL;
 135   }
 136
 137   return stack;
 138 }
 139
 140 static int __pthread_start(void* arg) {
 141   pthread_internal_t* thread = reinterpret_cast<pthread_internal_t*>(arg);
 142
 143   // Wait for our creating thread to release us. This lets it have time to
 144   // notify gdb about this thread before we start doing anything.
 145   // This also provides the memory barrier needed to ensure that all memory
 146   // accesses previously made by the creating thread are visible to us.
 147   pthread_mutex_t* start_mutex = (pthread_mutex_t*) &thread->tls[TLS_SLOT_START_MUTEX];
 148   pthread_mutex_lock(start_mutex);
 149   pthread_mutex_destroy(start_mutex);
 150   thread->tls[TLS_SLOT_START_MUTEX] = NULL;
 151
 152   __init_alternate_signal_stack(thread);
 153
 154   void* result = thread->start_routine(thread->start_routine_arg);
 155   pthread_exit(result);
 156
 157   return 0;
 158 }
 159
 160 // A dummy start routine for pthread_create failures where we've created a thread but aren't
 161 // going to run user code on it. We swap out the user's start routine for this and take advantage
 162 // of the regular thread teardown to free up resources.
 163 static void* __do_nothing(void*) {
 164   return NULL;
 165 }
 166
 167 int pthread_create(pthread_t* thread_out, pthread_attr_t const* attr,
 168                    void* (*start_routine)(void*), void* arg) {
 169   ErrnoRestorer errno_restorer;
 170
 171   // Inform the rest of the C library that at least one thread was created.
 172   __isthreaded = 1;
 173
 174   pthread_internal_t* thread = reinterpret_cast<pthread_internal_t*>(calloc(sizeof(*thread), 1));
 175   if (thread == NULL) {
 176     __libc_format_log(ANDROID_LOG_WARN, "libc", "pthread_create failed: couldn't allocate thread");
 177     return EAGAIN;
 178   }
 179
 180   if (attr == NULL) {
 181     pthread_attr_init(&thread->attr);
 182   } else {
 183     thread->attr = *attr;
 184     attr = NULL; // Prevent misuse below.
 185   }
 186
 187   // Make sure the stack size and guard size are multiples of PAGE_SIZE.
 188   thread->attr.stack_size = (thread->attr.stack_size + (PAGE_SIZE-1)) & ~(PAGE_SIZE-1);
 189   thread->attr.guard_size = (thread->attr.guard_size + (PAGE_SIZE-1)) & ~(PAGE_SIZE-1);
 190
 191   if (thread->attr.stack_base == NULL) {
 192     // The caller didn't provide a stack, so allocate one.
 193     thread->attr.stack_base = __create_thread_stack(thread);
 194     if (thread->attr.stack_base == NULL) {
 195       free(thread);
 196       return EAGAIN;
 197     }
 198   } else {
 199     // The caller did provide a stack, so remember we're not supposed to free it.
 200     thread->attr.flags |= PTHREAD_ATTR_FLAG_USER_ALLOCATED_STACK;
 201   }
 202
 203   // Make room for the TLS area.
 204   // The child stack is the same address, just growing in the opposite direction.
 205   // At offsets >= 0, we have the TLS slots.
 206   // At offsets < 0, we have the child stack.
 207   thread->tls = (void**)((uint8_t*)(thread->attr.stack_base) + thread->attr.stack_size - BIONIC_TLS_SLOTS * sizeof(void*));
 208   void* child_stack = thread->tls;
 209   __init_tls(thread);
 210
 211   // Create a mutex for the thread in TLS to wait on once it starts so we can keep
 212   // it from doing anything until after we notify the debugger about it
 213   //
 214   // This also provides the memory barrier we need to ensure that all
 215   // memory accesses previously performed by this thread are visible to
 216   // the new thread.
 217   pthread_mutex_t* start_mutex = (pthread_mutex_t*) &thread->tls[TLS_SLOT_START_MUTEX];
 218   pthread_mutex_init(start_mutex, NULL);
 219   pthread_mutex_lock(start_mutex);
 220
 221   thread->start_routine = start_routine;
 222   thread->start_routine_arg = arg;
 223
 224   int flags = CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_THREAD | CLONE_SYSVSEM |
 225       CLONE_SETTLS | CLONE_PARENT_SETTID | CLONE_CHILD_CLEARTID;
 226   void* tls = thread->tls;
 227 #if defined(__i386__)
 228   // On x86 (but not x86-64), CLONE_SETTLS takes a pointer to a struct user_desc rather than
 229   // a pointer to the TLS itself.
 230   user_desc tls_descriptor;
 231   __init_user_desc(&tls_descriptor, false, tls);
 232   tls = &tls_descriptor;
 233 #endif
 234   int rc = clone(__pthread_start, child_stack, flags, thread, &(thread->tid), tls, &(thread->tid));
 235   if (rc == -1) {
 236     int clone_errno = errno;
 237     // We don't have to unlock the mutex at all because clone(2) failed so there's no child waiting to
 238     // be unblocked, but we're about to unmap the memory the mutex is stored in, so this serves as a
 239     // reminder that you can't rewrite this function to use a ScopedPthreadMutexLocker.
 240     pthread_mutex_unlock(start_mutex);
 241     if ((thread->attr.flags & PTHREAD_ATTR_FLAG_USER_ALLOCATED_STACK) == 0) {
 242       munmap(thread->attr.stack_base, thread->attr.stack_size);
 243     }
 244     free(thread);
 245     __libc_format_log(ANDROID_LOG_WARN, "libc", "pthread_create failed: clone failed: %s", strerror(errno));
 246     return clone_errno;
 247   }
 248
 249   int init_errno = __init_thread(thread, true);
 250   if (init_errno != 0) {
 251     // Mark the thread detached and replace its start_routine with a no-op.
 252     // Letting the thread run is the easiest way to clean up its resources.
 253     thread->attr.flags |= PTHREAD_ATTR_FLAG_DETACHED;
 254     thread->start_routine = __do_nothing;
 255     pthread_mutex_unlock(start_mutex);
 256     return init_errno;
 257   }
 258
 259   // Notify any debuggers about the new thread.
 260   {
 261     ScopedPthreadMutexLocker debugger_locker(&g_debugger_notification_lock);
 262     _thread_created_hook(thread->tid);
 263   }
 264
 265   // Publish the pthread_t and unlock the mutex to let the new thread start running.
 266   *thread_out = reinterpret_cast<pthread_t>(thread);
 267   pthread_mutex_unlock(start_mutex);
 268
 269   return 0;
 270 }