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 */
29 #include <pthread.h>
31 #include <errno.h>
32 #include <sys/mman.h>
34 #include "pthread_internal.h"
36 #include "private/bionic_macros.h"
37 #include "private/bionic_ssp.h"
38 #include "private/bionic_tls.h"
39 #include "private/libc_logging.h"
40 #include "private/ErrnoRestorer.h"
41 #include "private/ScopedPthreadMutexLocker.h"
43 // Used by gdb to track thread creation. See libthread_db.
44 #ifdef __i386__
45 extern "C" __attribute__((noinline)) __attribute__((fastcall)) void _thread_created_hook(pid_t) {}
46 #else
47 extern "C" __attribute__((noinline)) void _thread_created_hook(pid_t) {}
48 #endif
50 // x86 uses segment descriptors rather than a direct pointer to TLS.
51 #if __i386__
52 #include <asm/ldt.h>
53 extern "C" __LIBC_HIDDEN__ void __init_user_desc(struct user_desc*, int, void*);
54 #endif
56 static pthread_mutex_t g_pthread_stack_creation_lock = PTHREAD_MUTEX_INITIALIZER;
58 static pthread_mutex_t g_debugger_notification_lock = PTHREAD_MUTEX_INITIALIZER;
60 extern "C" int __isthreaded;
62 // This code is used both by each new pthread and the code that initializes the main thread.
63 void __init_tls(pthread_internal_t* thread) {
64 // Zero-initialize all the slots after TLS_SLOT_SELF and TLS_SLOT_THREAD_ID.
65 for (size_t i = TLS_SLOT_ERRNO; i < BIONIC_TLS_SLOTS; ++i) {
66 thread->tls[i] = NULL;
67 }
69 // Slot 0 must point to itself. The x86 Linux kernel reads the TLS from %fs:0.
70 thread->tls[TLS_SLOT_SELF] = thread->tls;
71 thread->tls[TLS_SLOT_THREAD_ID] = thread;
72 // GCC looks in the TLS for the stack guard on x86, so copy it there from our global.
73 thread->tls[TLS_SLOT_STACK_GUARD] = (void*) __stack_chk_guard;
74 }
76 void __init_alternate_signal_stack(pthread_internal_t* thread) {
77 // Create and set an alternate signal stack.
78 stack_t ss;
79 ss.ss_sp = mmap(NULL, SIGSTKSZ, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
80 if (ss.ss_sp != MAP_FAILED) {
81 ss.ss_size = SIGSTKSZ;
82 ss.ss_flags = 0;
83 sigaltstack(&ss, NULL);
84 thread->alternate_signal_stack = ss.ss_sp;
85 }
86 }
88 int __init_thread(pthread_internal_t* thread, bool add_to_thread_list) {
89 int error = 0;
91 // Set the scheduling policy/priority of the thread.
92 if (thread->attr.sched_policy != SCHED_NORMAL) {
93 sched_param param;
94 param.sched_priority = thread->attr.sched_priority;
95 if (sched_setscheduler(thread->tid, thread->attr.sched_policy, ¶m) == -1) {
96 #if __LP64__
97 // For backwards compatibility reasons, we only report failures on 64-bit devices.
98 error = errno;
99 #endif
100 __libc_format_log(ANDROID_LOG_WARN, "libc",
101 "pthread_create sched_setscheduler call failed: %s", strerror(errno));
102 }
103 }
105 thread->cleanup_stack = NULL;
107 if (add_to_thread_list) {
108 _pthread_internal_add(thread);
109 }
111 return error;
112 }
114 static void* __create_thread_stack(pthread_internal_t* thread) {
115 ScopedPthreadMutexLocker lock(&g_pthread_stack_creation_lock);
117 // Create a new private anonymous map.
118 int prot = PROT_READ | PROT_WRITE;
119 int flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE;
120 void* stack = mmap(NULL, thread->attr.stack_size, prot, flags, -1, 0);
121 if (stack == MAP_FAILED) {
122 __libc_format_log(ANDROID_LOG_WARN,
123 "libc",
124 "pthread_create failed: couldn't allocate %zd-byte stack: %s",
125 thread->attr.stack_size, strerror(errno));
126 return NULL;
127 }
129 // Set the guard region at the end of the stack to PROT_NONE.
130 if (mprotect(stack, thread->attr.guard_size, PROT_NONE) == -1) {
131 __libc_format_log(ANDROID_LOG_WARN, "libc",
132 "pthread_create failed: couldn't mprotect PROT_NONE %zd-byte stack guard region: %s",
133 thread->attr.guard_size, strerror(errno));
134 munmap(stack, thread->attr.stack_size);
135 return NULL;
136 }
138 return stack;
139 }
141 static int __pthread_start(void* arg) {
142 pthread_internal_t* thread = reinterpret_cast<pthread_internal_t*>(arg);
144 // Wait for our creating thread to release us. This lets it have time to
145 // notify gdb about this thread before we start doing anything.
146 // This also provides the memory barrier needed to ensure that all memory
147 // accesses previously made by the creating thread are visible to us.
148 pthread_mutex_lock(&thread->startup_handshake_mutex);
149 pthread_mutex_destroy(&thread->startup_handshake_mutex);
151 __init_alternate_signal_stack(thread);
153 void* result = thread->start_routine(thread->start_routine_arg);
154 pthread_exit(result);
156 return 0;
157 }
159 // A dummy start routine for pthread_create failures where we've created a thread but aren't
160 // going to run user code on it. We swap out the user's start routine for this and take advantage
161 // of the regular thread teardown to free up resources.
162 static void* __do_nothing(void*) {
163 return NULL;
164 }
166 int pthread_create(pthread_t* thread_out, pthread_attr_t const* attr,
167 void* (*start_routine)(void*), void* arg) {
168 ErrnoRestorer errno_restorer;
170 // Inform the rest of the C library that at least one thread was created.
171 __isthreaded = 1;
173 pthread_internal_t* thread = reinterpret_cast<pthread_internal_t*>(calloc(sizeof(*thread), 1));
174 if (thread == NULL) {
175 __libc_format_log(ANDROID_LOG_WARN, "libc", "pthread_create failed: couldn't allocate thread");
176 return EAGAIN;
177 }
179 if (attr == NULL) {
180 pthread_attr_init(&thread->attr);
181 } else {
182 thread->attr = *attr;
183 attr = NULL; // Prevent misuse below.
184 }
186 // Make sure the stack size and guard size are multiples of PAGE_SIZE.
187 thread->attr.stack_size = BIONIC_ALIGN(thread->attr.stack_size, PAGE_SIZE);
188 thread->attr.guard_size = BIONIC_ALIGN(thread->attr.guard_size, PAGE_SIZE);
190 if (thread->attr.stack_base == NULL) {
191 // The caller didn't provide a stack, so allocate one.
192 thread->attr.stack_base = __create_thread_stack(thread);
193 if (thread->attr.stack_base == NULL) {
194 free(thread);
195 return EAGAIN;
196 }
197 } else {
198 // The caller did provide a stack, so remember we're not supposed to free it.
199 thread->attr.flags |= PTHREAD_ATTR_FLAG_USER_ALLOCATED_STACK;
200 }
202 // Make room for the TLS area.
203 // The child stack is the same address, just growing in the opposite direction.
204 // At offsets >= 0, we have the TLS slots.
205 // At offsets < 0, we have the child stack.
206 thread->tls = reinterpret_cast<void**>(reinterpret_cast<uint8_t*>(thread->attr.stack_base) +
207 thread->attr.stack_size - BIONIC_TLS_SLOTS * sizeof(void*));
208 void* child_stack = thread->tls;
209 __init_tls(thread);
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_init(&thread->startup_handshake_mutex, NULL);
218 pthread_mutex_lock(&thread->startup_handshake_mutex);
220 thread->start_routine = start_routine;
221 thread->start_routine_arg = arg;
223 int flags = CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_THREAD | CLONE_SYSVSEM |
224 CLONE_SETTLS | CLONE_PARENT_SETTID | CLONE_CHILD_CLEARTID;
225 void* tls = thread->tls;
226 #if defined(__i386__)
227 // On x86 (but not x86-64), CLONE_SETTLS takes a pointer to a struct user_desc rather than
228 // a pointer to the TLS itself.
229 user_desc tls_descriptor;
230 __init_user_desc(&tls_descriptor, false, tls);
231 tls = &tls_descriptor;
232 #endif
233 int rc = clone(__pthread_start, child_stack, flags, thread, &(thread->tid), tls, &(thread->tid));
234 if (rc == -1) {
235 int clone_errno = errno;
236 // We don't have to unlock the mutex at all because clone(2) failed so there's no child waiting to
237 // be unblocked, but we're about to unmap the memory the mutex is stored in, so this serves as a
238 // reminder that you can't rewrite this function to use a ScopedPthreadMutexLocker.
239 pthread_mutex_unlock(&thread->startup_handshake_mutex);
240 if ((thread->attr.flags & PTHREAD_ATTR_FLAG_USER_ALLOCATED_STACK) == 0) {
241 munmap(thread->attr.stack_base, thread->attr.stack_size);
242 }
243 free(thread);
244 __libc_format_log(ANDROID_LOG_WARN, "libc", "pthread_create failed: clone failed: %s", strerror(errno));
245 return clone_errno;
246 }
248 int init_errno = __init_thread(thread, true);
249 if (init_errno != 0) {
250 // Mark the thread detached and replace its start_routine with a no-op.
251 // Letting the thread run is the easiest way to clean up its resources.
252 thread->attr.flags |= PTHREAD_ATTR_FLAG_DETACHED;
253 thread->start_routine = __do_nothing;
254 pthread_mutex_unlock(&thread->startup_handshake_mutex);
255 return init_errno;
256 }
258 // Notify any debuggers about the new thread.
259 {
260 ScopedPthreadMutexLocker debugger_locker(&g_debugger_notification_lock);
261 _thread_created_hook(thread->tid);
262 }
264 // Publish the pthread_t and unlock the mutex to let the new thread start running.
265 *thread_out = reinterpret_cast<pthread_t>(thread);
266 pthread_mutex_unlock(&thread->startup_handshake_mutex);
268 return 0;
269 }