14b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes/*
24b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes * Copyright (C) 2008 The Android Open Source Project
34b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes * All rights reserved.
44b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes *
54b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes * Redistribution and use in source and binary forms, with or without
64b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes * modification, are permitted provided that the following conditions
74b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes * are met:
84b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes *  * Redistributions of source code must retain the above copyright
94b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes *    notice, this list of conditions and the following disclaimer.
104b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes *  * Redistributions in binary form must reproduce the above copyright
114b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes *    notice, this list of conditions and the following disclaimer in
124b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes *    the documentation and/or other materials provided with the
134b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes *    distribution.
144b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes *
154b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
164b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
174b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
184b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
194b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
204b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
214b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
224b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
234b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
244b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
254b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
264b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes * SUCH DAMAGE.
274b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes */
284b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
294b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes#include <pthread.h>
304b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
314b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes#include <errno.h>
3205fc1d7050d5451aea08dc5f504d2670287b2d43Elliott Hughes#include <string.h>
334b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes#include <sys/mman.h>
347086ad6919feb2415c6027163f5c63323bcca27cElliott Hughes#include <unistd.h>
354b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
364b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes#include "pthread_internal.h"
374b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
3803eebcb6e8762e668a0d3af6bb303cccb88c5b81Christopher Ferris#include "private/bionic_macros.h"
398cf1b305670123aed7638d984ca39bfd22388440Yabin Cui#include "private/bionic_prctl.h"
404b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes#include "private/bionic_ssp.h"
414b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes#include "private/bionic_tls.h"
428f2a5a0b40fc82126c691d5c30131d908772aab7Elliott Hughes#include "private/libc_logging.h"
434b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes#include "private/ErrnoRestorer.h"
444b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes#include "private/ScopedPthreadMutexLocker.h"
454b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
460d236aa3f1e6d31b0c729448ae9d3ed1cad23fb4Elliott Hughes// x86 uses segment descriptors rather than a direct pointer to TLS.
470d236aa3f1e6d31b0c729448ae9d3ed1cad23fb4Elliott Hughes#if __i386__
480d236aa3f1e6d31b0c729448ae9d3ed1cad23fb4Elliott Hughes#include <asm/ldt.h>
490d236aa3f1e6d31b0c729448ae9d3ed1cad23fb4Elliott Hughesextern "C" __LIBC_HIDDEN__ void __init_user_desc(struct user_desc*, int, void*);
500d236aa3f1e6d31b0c729448ae9d3ed1cad23fb4Elliott Hughes#endif
510d236aa3f1e6d31b0c729448ae9d3ed1cad23fb4Elliott Hughes
52f2cea021ab2c6d7d7feeb40cca098aa132605876Elliott Hughesextern "C" int __isthreaded;
53f2cea021ab2c6d7d7feeb40cca098aa132605876Elliott Hughes
5470b24b1cc2a1a4436b1fea3f8b76616fdcb27224Elliott Hughes// This code is used both by each new pthread and the code that initializes the main thread.
55af8aebebb52d73ea38c604525a6a5857618861cfElliott Hughesvoid __init_tls(pthread_internal_t* thread) {
564b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  // Slot 0 must point to itself. The x86 Linux kernel reads the TLS from %fs:0.
5740eabe24e4e3ae8ebe437f1f4e43cf39cbba2e9eElliott Hughes  thread->tls[TLS_SLOT_SELF] = thread->tls;
5840eabe24e4e3ae8ebe437f1f4e43cf39cbba2e9eElliott Hughes  thread->tls[TLS_SLOT_THREAD_ID] = thread;
594b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  // GCC looks in the TLS for the stack guard on x86, so copy it there from our global.
608b5df3920f2843c9cdf04160517c1e8b77c992f5Elliott Hughes  thread->tls[TLS_SLOT_STACK_GUARD] = reinterpret_cast<void*>(__stack_chk_guard);
6170b24b1cc2a1a4436b1fea3f8b76616fdcb27224Elliott Hughes}
624b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
6370b24b1cc2a1a4436b1fea3f8b76616fdcb27224Elliott Hughesvoid __init_alternate_signal_stack(pthread_internal_t* thread) {
6484114c8dd5b17efecf7988f263ce431208d7be5aElliott Hughes  // Create and set an alternate signal stack.
65ef115003012f61cf5539fdfeb201b98e4a92f610Yabin Cui  void* stack_base = mmap(NULL, SIGNAL_STACK_SIZE, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
66ef115003012f61cf5539fdfeb201b98e4a92f610Yabin Cui  if (stack_base != MAP_FAILED) {
67ef115003012f61cf5539fdfeb201b98e4a92f610Yabin Cui
68ef115003012f61cf5539fdfeb201b98e4a92f610Yabin Cui    // Create a guard page to catch stack overflows in signal handlers.
69ef115003012f61cf5539fdfeb201b98e4a92f610Yabin Cui    if (mprotect(stack_base, PAGE_SIZE, PROT_NONE) == -1) {
70ef115003012f61cf5539fdfeb201b98e4a92f610Yabin Cui      munmap(stack_base, SIGNAL_STACK_SIZE);
71ef115003012f61cf5539fdfeb201b98e4a92f610Yabin Cui      return;
72ef115003012f61cf5539fdfeb201b98e4a92f610Yabin Cui    }
73ef115003012f61cf5539fdfeb201b98e4a92f610Yabin Cui    stack_t ss;
74ef115003012f61cf5539fdfeb201b98e4a92f610Yabin Cui    ss.ss_sp = reinterpret_cast<uint8_t*>(stack_base) + PAGE_SIZE;
75ef115003012f61cf5539fdfeb201b98e4a92f610Yabin Cui    ss.ss_size = SIGNAL_STACK_SIZE - PAGE_SIZE;
7684114c8dd5b17efecf7988f263ce431208d7be5aElliott Hughes    ss.ss_flags = 0;
7784114c8dd5b17efecf7988f263ce431208d7be5aElliott Hughes    sigaltstack(&ss, NULL);
78ef115003012f61cf5539fdfeb201b98e4a92f610Yabin Cui    thread->alternate_signal_stack = stack_base;
798cf1b305670123aed7638d984ca39bfd22388440Yabin Cui
808cf1b305670123aed7638d984ca39bfd22388440Yabin Cui    // We can only use const static allocated string for mapped region name, as Android kernel
818cf1b305670123aed7638d984ca39bfd22388440Yabin Cui    // uses the string pointer directly when dumping /proc/pid/maps.
82a3125fd1396a09a7fc4872dc4653f342150a3debElliott Hughes    prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, ss.ss_sp, ss.ss_size, "thread signal stack");
83eeb6b57e750220edc0b489fae11837bc73fa7a45Elliott Hughes    prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, stack_base, PAGE_SIZE, "thread signal stack guard page");
8484114c8dd5b17efecf7988f263ce431208d7be5aElliott Hughes  }
854b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes}
864b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
87673b15e4ee2c6d99b150aedddc0f389e29f98e1bYabin Cuiint __init_thread(pthread_internal_t* thread) {
884b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  int error = 0;
894b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
9058cf31b50699ed9f523de38c8e943f3bbd1ced9eYabin Cui  if (__predict_true((thread->attr.flags & PTHREAD_ATTR_FLAG_DETACHED) == 0)) {
9158cf31b50699ed9f523de38c8e943f3bbd1ced9eYabin Cui    atomic_init(&thread->join_state, THREAD_NOT_JOINED);
9258cf31b50699ed9f523de38c8e943f3bbd1ced9eYabin Cui  } else {
9358cf31b50699ed9f523de38c8e943f3bbd1ced9eYabin Cui    atomic_init(&thread->join_state, THREAD_DETACHED);
9458cf31b50699ed9f523de38c8e943f3bbd1ced9eYabin Cui  }
9558cf31b50699ed9f523de38c8e943f3bbd1ced9eYabin Cui
964b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  // Set the scheduling policy/priority of the thread.
974b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  if (thread->attr.sched_policy != SCHED_NORMAL) {
98c3f114037dbf028896310609fd28cf2b3da99c4dElliott Hughes    sched_param param;
994b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes    param.sched_priority = thread->attr.sched_priority;
10040eabe24e4e3ae8ebe437f1f4e43cf39cbba2e9eElliott Hughes    if (sched_setscheduler(thread->tid, thread->attr.sched_policy, &param) == -1) {
10198624c374646a050556bdc402b55b792fefa7e55Elliott Hughes#if __LP64__
10298624c374646a050556bdc402b55b792fefa7e55Elliott Hughes      // For backwards compatibility reasons, we only report failures on 64-bit devices.
10398624c374646a050556bdc402b55b792fefa7e55Elliott Hughes      error = errno;
10498624c374646a050556bdc402b55b792fefa7e55Elliott Hughes#endif
105b95cf0d23a1db3b7c37bd98b0c86196796c9b029Elliott Hughes      __libc_format_log(ANDROID_LOG_WARN, "libc",
106b95cf0d23a1db3b7c37bd98b0c86196796c9b029Elliott Hughes                        "pthread_create sched_setscheduler call failed: %s", strerror(errno));
1074b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes    }
1084b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  }
1094b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
1104b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  thread->cleanup_stack = NULL;
1114b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
1124b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  return error;
1134b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes}
1144b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
115ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cuistatic void* __create_thread_mapped_space(size_t mmap_size, size_t stack_guard_size) {
1164b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  // Create a new private anonymous map.
1174b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  int prot = PROT_READ | PROT_WRITE;
1184b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  int flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE;
119ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui  void* space = mmap(NULL, mmap_size, prot, flags, -1, 0);
120ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui  if (space == MAP_FAILED) {
121b95cf0d23a1db3b7c37bd98b0c86196796c9b029Elliott Hughes    __libc_format_log(ANDROID_LOG_WARN,
122b95cf0d23a1db3b7c37bd98b0c86196796c9b029Elliott Hughes                      "libc",
123ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui                      "pthread_create failed: couldn't allocate %zu-bytes mapped space: %s",
124ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui                      mmap_size, strerror(errno));
1254b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes    return NULL;
1264b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  }
1274b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
128ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui  // Stack is at the lower end of mapped space, stack guard region is at the lower end of stack.
129ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui  // Set the stack guard region to PROT_NONE, so we can detect thread stack overflow.
130ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui  if (mprotect(space, stack_guard_size, PROT_NONE) == -1) {
131b95cf0d23a1db3b7c37bd98b0c86196796c9b029Elliott Hughes    __libc_format_log(ANDROID_LOG_WARN, "libc",
132ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui                      "pthread_create failed: couldn't mprotect PROT_NONE %zu-byte stack guard region: %s",
133ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui                      stack_guard_size, strerror(errno));
134ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui    munmap(space, mmap_size);
1354b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes    return NULL;
1364b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  }
137eeb6b57e750220edc0b489fae11837bc73fa7a45Elliott Hughes  prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, space, stack_guard_size, "thread stack guard page");
1384b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
139ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui  return space;
1404b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes}
1414b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
1428cf1b305670123aed7638d984ca39bfd22388440Yabin Cuistatic int __allocate_thread(pthread_attr_t* attr, pthread_internal_t** threadp, void** child_stack) {
143ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui  size_t mmap_size;
1446a7aaf46759db32c6ed0eb953a4a230dc96af0d9Yabin Cui  uint8_t* stack_top;
1456a7aaf46759db32c6ed0eb953a4a230dc96af0d9Yabin Cui
1468cf1b305670123aed7638d984ca39bfd22388440Yabin Cui  if (attr->stack_base == NULL) {
1478cf1b305670123aed7638d984ca39bfd22388440Yabin Cui    // The caller didn't provide a stack, so allocate one.
1488cf1b305670123aed7638d984ca39bfd22388440Yabin Cui    // Make sure the stack size and guard size are multiples of PAGE_SIZE.
149ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui    mmap_size = BIONIC_ALIGN(attr->stack_size + sizeof(pthread_internal_t), PAGE_SIZE);
1508cf1b305670123aed7638d984ca39bfd22388440Yabin Cui    attr->guard_size = BIONIC_ALIGN(attr->guard_size, PAGE_SIZE);
151ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui    attr->stack_base = __create_thread_mapped_space(mmap_size, attr->guard_size);
1528cf1b305670123aed7638d984ca39bfd22388440Yabin Cui    if (attr->stack_base == NULL) {
1538cf1b305670123aed7638d984ca39bfd22388440Yabin Cui      return EAGAIN;
1548cf1b305670123aed7638d984ca39bfd22388440Yabin Cui    }
155ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui    stack_top = reinterpret_cast<uint8_t*>(attr->stack_base) + mmap_size;
1568cf1b305670123aed7638d984ca39bfd22388440Yabin Cui  } else {
157ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui    // Remember the mmap size is zero and we don't need to free it.
158ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui    mmap_size = 0;
1596a7aaf46759db32c6ed0eb953a4a230dc96af0d9Yabin Cui    stack_top = reinterpret_cast<uint8_t*>(attr->stack_base) + attr->stack_size;
1608cf1b305670123aed7638d984ca39bfd22388440Yabin Cui  }
1618cf1b305670123aed7638d984ca39bfd22388440Yabin Cui
162ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui  // Mapped space(or user allocated stack) is used for:
163a2db50d5d7fa67b297eddd1c0549f08ea4b6a950Yabin Cui  //   pthread_internal_t
164ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui  //   thread stack (including guard page)
165a2db50d5d7fa67b297eddd1c0549f08ea4b6a950Yabin Cui
166a2db50d5d7fa67b297eddd1c0549f08ea4b6a950Yabin Cui  // To safely access the pthread_internal_t and thread stack, we need to find a 16-byte aligned boundary.
167a2db50d5d7fa67b297eddd1c0549f08ea4b6a950Yabin Cui  stack_top = reinterpret_cast<uint8_t*>(
168a2db50d5d7fa67b297eddd1c0549f08ea4b6a950Yabin Cui                (reinterpret_cast<uintptr_t>(stack_top) - sizeof(pthread_internal_t)) & ~0xf);
169a2db50d5d7fa67b297eddd1c0549f08ea4b6a950Yabin Cui
1708cf1b305670123aed7638d984ca39bfd22388440Yabin Cui  pthread_internal_t* thread = reinterpret_cast<pthread_internal_t*>(stack_top);
171304348af197f30b3bf0e0764b97eb9699a376c68Yabin Cui  if (mmap_size == 0) {
172304348af197f30b3bf0e0764b97eb9699a376c68Yabin Cui    // If thread was not allocated by mmap(), it may not have been cleared to zero.
173304348af197f30b3bf0e0764b97eb9699a376c68Yabin Cui    // So assume the worst and zero it.
174304348af197f30b3bf0e0764b97eb9699a376c68Yabin Cui    memset(thread, 0, sizeof(pthread_internal_t));
175304348af197f30b3bf0e0764b97eb9699a376c68Yabin Cui  }
176917d390510e442b9b030d54992ebf41cc1e7f853Yabin Cui  attr->stack_size = stack_top - reinterpret_cast<uint8_t*>(attr->stack_base);
1778cf1b305670123aed7638d984ca39bfd22388440Yabin Cui
178ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui  thread->mmap_size = mmap_size;
1798cf1b305670123aed7638d984ca39bfd22388440Yabin Cui  thread->attr = *attr;
1808cf1b305670123aed7638d984ca39bfd22388440Yabin Cui  __init_tls(thread);
1818cf1b305670123aed7638d984ca39bfd22388440Yabin Cui
1828cf1b305670123aed7638d984ca39bfd22388440Yabin Cui  *threadp = thread;
1838cf1b305670123aed7638d984ca39bfd22388440Yabin Cui  *child_stack = stack_top;
1848cf1b305670123aed7638d984ca39bfd22388440Yabin Cui  return 0;
1858cf1b305670123aed7638d984ca39bfd22388440Yabin Cui}
1868cf1b305670123aed7638d984ca39bfd22388440Yabin Cui
187e48b68570d872ef7ece1d873c0ea298ea76393f3Elliott Hughesstatic int __pthread_start(void* arg) {
188e48b68570d872ef7ece1d873c0ea298ea76393f3Elliott Hughes  pthread_internal_t* thread = reinterpret_cast<pthread_internal_t*>(arg);
189e48b68570d872ef7ece1d873c0ea298ea76393f3Elliott Hughes
190e48b68570d872ef7ece1d873c0ea298ea76393f3Elliott Hughes  // Wait for our creating thread to release us. This lets it have time to
191e48b68570d872ef7ece1d873c0ea298ea76393f3Elliott Hughes  // notify gdb about this thread before we start doing anything.
192e48b68570d872ef7ece1d873c0ea298ea76393f3Elliott Hughes  // This also provides the memory barrier needed to ensure that all memory
193e48b68570d872ef7ece1d873c0ea298ea76393f3Elliott Hughes  // accesses previously made by the creating thread are visible to us.
194d26e780df66b9add4cf7e7ebb2f6c6749d1c5050Yabin Cui  thread->startup_handshake_lock.lock();
195e48b68570d872ef7ece1d873c0ea298ea76393f3Elliott Hughes
196e48b68570d872ef7ece1d873c0ea298ea76393f3Elliott Hughes  __init_alternate_signal_stack(thread);
197e48b68570d872ef7ece1d873c0ea298ea76393f3Elliott Hughes
198e48b68570d872ef7ece1d873c0ea298ea76393f3Elliott Hughes  void* result = thread->start_routine(thread->start_routine_arg);
199e48b68570d872ef7ece1d873c0ea298ea76393f3Elliott Hughes  pthread_exit(result);
200e48b68570d872ef7ece1d873c0ea298ea76393f3Elliott Hughes
201e48b68570d872ef7ece1d873c0ea298ea76393f3Elliott Hughes  return 0;
202e48b68570d872ef7ece1d873c0ea298ea76393f3Elliott Hughes}
203e48b68570d872ef7ece1d873c0ea298ea76393f3Elliott Hughes
204cef3faec0ea40fdfe58e425fd0be64f00de6a26dElliott Hughes// A dummy start routine for pthread_create failures where we've created a thread but aren't
205cef3faec0ea40fdfe58e425fd0be64f00de6a26dElliott Hughes// going to run user code on it. We swap out the user's start routine for this and take advantage
206cef3faec0ea40fdfe58e425fd0be64f00de6a26dElliott Hughes// of the regular thread teardown to free up resources.
207cef3faec0ea40fdfe58e425fd0be64f00de6a26dElliott Hughesstatic void* __do_nothing(void*) {
208cef3faec0ea40fdfe58e425fd0be64f00de6a26dElliott Hughes  return NULL;
209cef3faec0ea40fdfe58e425fd0be64f00de6a26dElliott Hughes}
210cef3faec0ea40fdfe58e425fd0be64f00de6a26dElliott Hughes
2114b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughesint pthread_create(pthread_t* thread_out, pthread_attr_t const* attr,
2124b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes                   void* (*start_routine)(void*), void* arg) {
2134b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  ErrnoRestorer errno_restorer;
2144b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
215f2cea021ab2c6d7d7feeb40cca098aa132605876Elliott Hughes  // Inform the rest of the C library that at least one thread was created.
2164b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  __isthreaded = 1;
2174b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
2188cf1b305670123aed7638d984ca39bfd22388440Yabin Cui  pthread_attr_t thread_attr;
2194b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  if (attr == NULL) {
2208cf1b305670123aed7638d984ca39bfd22388440Yabin Cui    pthread_attr_init(&thread_attr);
2214b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  } else {
2228cf1b305670123aed7638d984ca39bfd22388440Yabin Cui    thread_attr = *attr;
2234b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes    attr = NULL; // Prevent misuse below.
2244b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  }
2254b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
2268cf1b305670123aed7638d984ca39bfd22388440Yabin Cui  pthread_internal_t* thread = NULL;
2278cf1b305670123aed7638d984ca39bfd22388440Yabin Cui  void* child_stack = NULL;
2288cf1b305670123aed7638d984ca39bfd22388440Yabin Cui  int result = __allocate_thread(&thread_attr, &thread, &child_stack);
2298cf1b305670123aed7638d984ca39bfd22388440Yabin Cui  if (result != 0) {
2308cf1b305670123aed7638d984ca39bfd22388440Yabin Cui    return result;
2314b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  }
2324b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
233d26e780df66b9add4cf7e7ebb2f6c6749d1c5050Yabin Cui  // Create a lock for the thread to wait on once it starts so we can keep
2344b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  // it from doing anything until after we notify the debugger about it
2354b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  //
2364b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  // This also provides the memory barrier we need to ensure that all
2374b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  // memory accesses previously performed by this thread are visible to
2384b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  // the new thread.
239d26e780df66b9add4cf7e7ebb2f6c6749d1c5050Yabin Cui  thread->startup_handshake_lock.init(false);
240d26e780df66b9add4cf7e7ebb2f6c6749d1c5050Yabin Cui  thread->startup_handshake_lock.lock();
2414b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
24270b24b1cc2a1a4436b1fea3f8b76616fdcb27224Elliott Hughes  thread->start_routine = start_routine;
24370b24b1cc2a1a4436b1fea3f8b76616fdcb27224Elliott Hughes  thread->start_routine_arg = arg;
2444b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
2457086ad6919feb2415c6027163f5c63323bcca27cElliott Hughes  thread->set_cached_pid(getpid());
2467086ad6919feb2415c6027163f5c63323bcca27cElliott Hughes
247877ec6d90418ff1d6597147d355a2229fdffae7eElliott Hughes  int flags = CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_THREAD | CLONE_SYSVSEM |
248877ec6d90418ff1d6597147d355a2229fdffae7eElliott Hughes      CLONE_SETTLS | CLONE_PARENT_SETTID | CLONE_CHILD_CLEARTID;
2498cf1b305670123aed7638d984ca39bfd22388440Yabin Cui  void* tls = reinterpret_cast<void*>(thread->tls);
25080906141f79be8be63fc915bfab467029b442ca1Elliott Hughes#if defined(__i386__)
25180906141f79be8be63fc915bfab467029b442ca1Elliott Hughes  // On x86 (but not x86-64), CLONE_SETTLS takes a pointer to a struct user_desc rather than
2520d236aa3f1e6d31b0c729448ae9d3ed1cad23fb4Elliott Hughes  // a pointer to the TLS itself.
2530d236aa3f1e6d31b0c729448ae9d3ed1cad23fb4Elliott Hughes  user_desc tls_descriptor;
2540d236aa3f1e6d31b0c729448ae9d3ed1cad23fb4Elliott Hughes  __init_user_desc(&tls_descriptor, false, tls);
2550d236aa3f1e6d31b0c729448ae9d3ed1cad23fb4Elliott Hughes  tls = &tls_descriptor;
25680906141f79be8be63fc915bfab467029b442ca1Elliott Hughes#endif
2570d236aa3f1e6d31b0c729448ae9d3ed1cad23fb4Elliott Hughes  int rc = clone(__pthread_start, child_stack, flags, thread, &(thread->tid), tls, &(thread->tid));
258877ec6d90418ff1d6597147d355a2229fdffae7eElliott Hughes  if (rc == -1) {
2594b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes    int clone_errno = errno;
260877ec6d90418ff1d6597147d355a2229fdffae7eElliott Hughes    // We don't have to unlock the mutex at all because clone(2) failed so there's no child waiting to
261877ec6d90418ff1d6597147d355a2229fdffae7eElliott Hughes    // be unblocked, but we're about to unmap the memory the mutex is stored in, so this serves as a
262877ec6d90418ff1d6597147d355a2229fdffae7eElliott Hughes    // reminder that you can't rewrite this function to use a ScopedPthreadMutexLocker.
263d26e780df66b9add4cf7e7ebb2f6c6749d1c5050Yabin Cui    thread->startup_handshake_lock.unlock();
264ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui    if (thread->mmap_size != 0) {
265ba8dfc2669d658dc340eb8f9c9b40ca074f05047Yabin Cui      munmap(thread->attr.stack_base, thread->mmap_size);
2664b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes    }
267cfa089df23ff50fcd5ed3854c54991d30be5fc7eElliott Hughes    __libc_format_log(ANDROID_LOG_WARN, "libc", "pthread_create failed: clone failed: %s", strerror(errno));
2684b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes    return clone_errno;
2694b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  }
2704b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
271673b15e4ee2c6d99b150aedddc0f389e29f98e1bYabin Cui  int init_errno = __init_thread(thread);
2724b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  if (init_errno != 0) {
273cef3faec0ea40fdfe58e425fd0be64f00de6a26dElliott Hughes    // Mark the thread detached and replace its start_routine with a no-op.
274cef3faec0ea40fdfe58e425fd0be64f00de6a26dElliott Hughes    // Letting the thread run is the easiest way to clean up its resources.
27558cf31b50699ed9f523de38c8e943f3bbd1ced9eYabin Cui    atomic_store(&thread->join_state, THREAD_DETACHED);
276799cb35f45a161de96b272de38724f77e988f5f3Yabin Cui    __pthread_internal_add(thread);
277cef3faec0ea40fdfe58e425fd0be64f00de6a26dElliott Hughes    thread->start_routine = __do_nothing;
278d26e780df66b9add4cf7e7ebb2f6c6749d1c5050Yabin Cui    thread->startup_handshake_lock.unlock();
2794b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes    return init_errno;
2804b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  }
2814b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
282877ec6d90418ff1d6597147d355a2229fdffae7eElliott Hughes  // Publish the pthread_t and unlock the mutex to let the new thread start running.
283673b15e4ee2c6d99b150aedddc0f389e29f98e1bYabin Cui  *thread_out = __pthread_internal_add(thread);
284d26e780df66b9add4cf7e7ebb2f6c6749d1c5050Yabin Cui  thread->startup_handshake_lock.unlock();
2854b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes
2864b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes  return 0;
2874b4a8824289c48c823cd38bc63289d121aae3d67Elliott Hughes}
288