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_ssp.h"
37 #include "private/bionic_tls.h"
38 #include "private/libc_logging.h"
39 #include "private/thread_private.h"
40 #include "private/ErrnoRestorer.h"
41 #include "private/ScopedPthreadMutexLocker.h"
43 extern "C" pid_t __bionic_clone(uint32_t flags, void* child_stack, int* parent_tid, void* tls, int* child_tid, int (*fn)(void*), void* arg);
44 extern "C" int __set_tls(void*);
46 #ifdef __i386__
47 #define ATTRIBUTES __attribute__((noinline)) __attribute__((fastcall))
48 #else
49 #define ATTRIBUTES __attribute__((noinline))
50 #endif
52 extern "C" void ATTRIBUTES _thread_created_hook(pid_t thread_id);
54 static pthread_mutex_t gPthreadStackCreationLock = PTHREAD_MUTEX_INITIALIZER;
56 static pthread_mutex_t gDebuggerNotificationLock = PTHREAD_MUTEX_INITIALIZER;
58 // This code is used both by each new pthread and the code that initializes the main thread.
59 void __init_tls(pthread_internal_t* thread) {
60 // Zero-initialize all the slots after TLS_SLOT_SELF and TLS_SLOT_THREAD_ID.
61 for (size_t i = TLS_SLOT_ERRNO; i < BIONIC_TLS_SLOTS; ++i) {
62 thread->tls[i] = NULL;
63 }
65 #if defined(__i386__)
66 __set_tls(thread->tls);
67 #endif
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(&gPthreadStackCreationLock);
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_t* start_mutex = (pthread_mutex_t*) &thread->tls[TLS_SLOT_START_MUTEX];
149 pthread_mutex_lock(start_mutex);
150 pthread_mutex_destroy(start_mutex);
152 __init_tls(thread);
154 __init_alternate_signal_stack(thread);
156 void* result = thread->start_routine(thread->start_routine_arg);
157 pthread_exit(result);
159 return 0;
160 }
162 // A dummy start routine for pthread_create failures where we've created a thread but aren't
163 // going to run user code on it. We swap out the user's start routine for this and take advantage
164 // of the regular thread teardown to free up resources.
165 static void* __do_nothing(void*) {
166 return NULL;
167 }
169 int pthread_create(pthread_t* thread_out, pthread_attr_t const* attr,
170 void* (*start_routine)(void*), void* arg) {
171 ErrnoRestorer errno_restorer;
173 // Inform the rest of the C library that at least one thread
174 // was created. This will enforce certain functions to acquire/release
175 // locks (e.g. atexit()) to protect shared global structures.
176 // This works because pthread_create() is not called by the C library
177 // initialization routine that sets up the main thread's data structures.
178 __isthreaded = 1;
180 pthread_internal_t* thread = reinterpret_cast<pthread_internal_t*>(calloc(sizeof(*thread), 1));
181 if (thread == NULL) {
182 __libc_format_log(ANDROID_LOG_WARN, "libc", "pthread_create failed: couldn't allocate thread");
183 return EAGAIN;
184 }
186 if (attr == NULL) {
187 pthread_attr_init(&thread->attr);
188 } else {
189 thread->attr = *attr;
190 attr = NULL; // Prevent misuse below.
191 }
193 // Make sure the stack size and guard size are multiples of PAGE_SIZE.
194 thread->attr.stack_size = (thread->attr.stack_size + (PAGE_SIZE-1)) & ~(PAGE_SIZE-1);
195 thread->attr.guard_size = (thread->attr.guard_size + (PAGE_SIZE-1)) & ~(PAGE_SIZE-1);
197 if (thread->attr.stack_base == NULL) {
198 // The caller didn't provide a stack, so allocate one.
199 thread->attr.stack_base = __create_thread_stack(thread);
200 if (thread->attr.stack_base == NULL) {
201 free(thread);
202 return EAGAIN;
203 }
204 } else {
205 // The caller did provide a stack, so remember we're not supposed to free it.
206 thread->attr.flags |= PTHREAD_ATTR_FLAG_USER_ALLOCATED_STACK;
207 }
209 // Make room for the TLS area.
210 // The child stack is the same address, just growing in the opposite direction.
211 // At offsets >= 0, we have the TLS slots.
212 // At offsets < 0, we have the child stack.
213 thread->tls = (void**)((uint8_t*)(thread->attr.stack_base) + thread->attr.stack_size - BIONIC_TLS_SLOTS * sizeof(void*));
214 void* child_stack = thread->tls;
216 // Create a mutex for the thread in TLS to wait on once it starts so we can keep
217 // it from doing anything until after we notify the debugger about it
218 //
219 // This also provides the memory barrier we need to ensure that all
220 // memory accesses previously performed by this thread are visible to
221 // the new thread.
222 pthread_mutex_t* start_mutex = (pthread_mutex_t*) &thread->tls[TLS_SLOT_START_MUTEX];
223 pthread_mutex_init(start_mutex, NULL);
224 pthread_mutex_lock(start_mutex);
226 thread->tls[TLS_SLOT_THREAD_ID] = thread;
228 thread->start_routine = start_routine;
229 thread->start_routine_arg = arg;
231 int flags = CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_THREAD | CLONE_SYSVSEM |
232 CLONE_SETTLS | CLONE_PARENT_SETTID | CLONE_CHILD_CLEARTID;
233 #if defined(__i386__)
234 // On x86 (but not x86-64), CLONE_SETTLS takes a pointer to a struct user_desc rather than
235 // a pointer to the TLS itself. Rather than try to deal with that here, we just let x86 set
236 // the TLS manually in __init_tls, like all architectures used to.
237 flags &= ~CLONE_SETTLS;
238 #endif
239 int rc = __bionic_clone(flags, child_stack, &(thread->tid), thread->tls, &(thread->tid), __pthread_start, thread);
240 if (rc == -1) {
241 int clone_errno = errno;
242 // We don't have to unlock the mutex at all because clone(2) failed so there's no child waiting to
243 // be unblocked, but we're about to unmap the memory the mutex is stored in, so this serves as a
244 // reminder that you can't rewrite this function to use a ScopedPthreadMutexLocker.
245 pthread_mutex_unlock(start_mutex);
246 if ((thread->attr.flags & PTHREAD_ATTR_FLAG_USER_ALLOCATED_STACK) == 0) {
247 munmap(thread->attr.stack_base, thread->attr.stack_size);
248 }
249 free(thread);
250 __libc_format_log(ANDROID_LOG_WARN, "libc", "pthread_create failed: clone failed: %s", strerror(errno));
251 return clone_errno;
252 }
254 int init_errno = __init_thread(thread, true);
255 if (init_errno != 0) {
256 // Mark the thread detached and replace its start_routine with a no-op.
257 // Letting the thread run is the easiest way to clean up its resources.
258 thread->attr.flags |= PTHREAD_ATTR_FLAG_DETACHED;
259 thread->start_routine = __do_nothing;
260 pthread_mutex_unlock(start_mutex);
261 return init_errno;
262 }
264 // Notify any debuggers about the new thread.
265 {
266 ScopedPthreadMutexLocker debugger_locker(&gDebuggerNotificationLock);
267 _thread_created_hook(thread->tid);
268 }
270 // Publish the pthread_t and unlock the mutex to let the new thread start running.
271 *thread_out = reinterpret_cast<pthread_t>(thread);
272 pthread_mutex_unlock(start_mutex);
274 return 0;
275 }