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/thread_private.h"
40 #include "private/ErrnoRestorer.h"
41 #include "private/ScopedPthreadMutexLocker.h"
42
43 extern "C" int __pthread_clone(void* (*fn)(void*), void* child_stack, int flags, void* arg);
44
45 #ifdef __i386__
46 #define ATTRIBUTES __attribute__((noinline)) __attribute__((fastcall))
47 #else
48 #define ATTRIBUTES __attribute__((noinline))
49 #endif
50
51 extern "C" void ATTRIBUTES _thread_created_hook(pid_t thread_id);
52
53 static const int kPthreadInitFailed = 1;
54
55 static pthread_mutex_t gPthreadStackCreationLock = PTHREAD_MUTEX_INITIALIZER;
56
57 static pthread_mutex_t gDebuggerNotificationLock = PTHREAD_MUTEX_INITIALIZER;
58
__init_tls(pthread_internal_t * thread)59 void __init_tls(pthread_internal_t* thread) {
60 // Zero-initialize all the slots.
61 for (size_t i = 0; i < BIONIC_TLS_SLOTS; ++i) {
62 thread->tls[i] = NULL;
63 }
64
65 // Slot 0 must point to itself. The x86 Linux kernel reads the TLS from %fs:0.
66 thread->tls[TLS_SLOT_SELF] = thread->tls;
67 thread->tls[TLS_SLOT_THREAD_ID] = thread;
68 // GCC looks in the TLS for the stack guard on x86, so copy it there from our global.
69 thread->tls[TLS_SLOT_STACK_GUARD] = (void*) __stack_chk_guard;
70
71 __set_tls(thread->tls);
72
73 // Create and set an alternate signal stack.
74 // This must happen after __set_tls, in case a system call fails and tries to set errno.
75 stack_t ss;
76 ss.ss_sp = mmap(NULL, SIGSTKSZ, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
77 if (ss.ss_sp != MAP_FAILED) {
78 ss.ss_size = SIGSTKSZ;
79 ss.ss_flags = 0;
80 sigaltstack(&ss, NULL);
81 thread->alternate_signal_stack = ss.ss_sp;
82 }
83 }
84
85 // This trampoline is called from the assembly _pthread_clone function.
86 // Our 'tls' and __pthread_clone's 'child_stack' are one and the same, just growing in
87 // opposite directions.
__thread_entry(void * (* func)(void *),void * arg,void ** tls)88 extern "C" void __thread_entry(void* (*func)(void*), void* arg, void** tls) {
89 // Wait for our creating thread to release us. This lets it have time to
90 // notify gdb about this thread before we start doing anything.
91 // This also provides the memory barrier needed to ensure that all memory
92 // accesses previously made by the creating thread are visible to us.
93 pthread_mutex_t* start_mutex = (pthread_mutex_t*) &tls[TLS_SLOT_SELF];
94 pthread_mutex_lock(start_mutex);
95 pthread_mutex_destroy(start_mutex);
96
97 pthread_internal_t* thread = (pthread_internal_t*) tls[TLS_SLOT_THREAD_ID];
98 thread->tls = tls;
99 __init_tls(thread);
100
101 if ((thread->internal_flags & kPthreadInitFailed) != 0) {
102 pthread_exit(NULL);
103 }
104
105 void* result = func(arg);
106 pthread_exit(result);
107 }
108
109 __LIBC_ABI_PRIVATE__
_init_thread(pthread_internal_t * thread,bool add_to_thread_list)110 int _init_thread(pthread_internal_t* thread, bool add_to_thread_list) {
111 int error = 0;
112
113 // Set the scheduling policy/priority of the thread.
114 if (thread->attr.sched_policy != SCHED_NORMAL) {
115 struct sched_param param;
116 param.sched_priority = thread->attr.sched_priority;
117 if (sched_setscheduler(thread->tid, thread->attr.sched_policy, ¶m) == -1) {
118 // For backwards compatibility reasons, we just warn about failures here.
119 // error = errno;
120 __libc_format_log(ANDROID_LOG_WARN, "libc",
121 "pthread_create sched_setscheduler call failed: %s", strerror(errno));
122 }
123 }
124
125 pthread_cond_init(&thread->join_cond, NULL);
126 thread->cleanup_stack = NULL;
127
128 if (add_to_thread_list) {
129 _pthread_internal_add(thread);
130 }
131
132 return error;
133 }
134
__create_thread_stack(pthread_internal_t * thread)135 static void* __create_thread_stack(pthread_internal_t* thread) {
136 ScopedPthreadMutexLocker lock(&gPthreadStackCreationLock);
137
138 // Create a new private anonymous map.
139 int prot = PROT_READ | PROT_WRITE;
140 int flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE;
141 void* stack = mmap(NULL, thread->attr.stack_size, prot, flags, -1, 0);
142 if (stack == MAP_FAILED) {
143 __libc_format_log(ANDROID_LOG_WARN,
144 "libc",
145 "pthread_create failed: couldn't allocate %zd-byte stack: %s",
146 thread->attr.stack_size, strerror(errno));
147 return NULL;
148 }
149
150 // Set the guard region at the end of the stack to PROT_NONE.
151 if (mprotect(stack, thread->attr.guard_size, PROT_NONE) == -1) {
152 __libc_format_log(ANDROID_LOG_WARN, "libc",
153 "pthread_create failed: couldn't mprotect PROT_NONE %zd-byte stack guard region: %s",
154 thread->attr.guard_size, strerror(errno));
155 munmap(stack, thread->attr.stack_size);
156 return NULL;
157 }
158
159 return stack;
160 }
161
pthread_create(pthread_t * thread_out,pthread_attr_t const * attr,void * (* start_routine)(void *),void * arg)162 int pthread_create(pthread_t* thread_out, pthread_attr_t const* attr,
163 void* (*start_routine)(void*), void* arg) {
164 ErrnoRestorer errno_restorer;
165
166 // Inform the rest of the C library that at least one thread
167 // was created. This will enforce certain functions to acquire/release
168 // locks (e.g. atexit()) to protect shared global structures.
169 // This works because pthread_create() is not called by the C library
170 // initialization routine that sets up the main thread's data structures.
171 __isthreaded = 1;
172
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 }
178 thread->allocated_on_heap = true;
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_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 void** tls = (void**)((uint8_t*)(thread->attr.stack_base) + thread->attr.stack_size - BIONIC_TLS_SLOTS * sizeof(void*));
208 void* child_stack = tls;
209
210 // Create a mutex for the thread in TLS_SLOT_SELF to wait on once it starts so we can keep
211 // it from doing anything until after we notify the debugger about it
212 //
213 // This also provides the memory barrier we need to ensure that all
214 // memory accesses previously performed by this thread are visible to
215 // the new thread.
216 pthread_mutex_t* start_mutex = (pthread_mutex_t*) &tls[TLS_SLOT_SELF];
217 pthread_mutex_init(start_mutex, NULL);
218 ScopedPthreadMutexLocker start_locker(start_mutex);
219
220 tls[TLS_SLOT_THREAD_ID] = thread;
221
222 int flags = CLONE_FILES | CLONE_FS | CLONE_VM | CLONE_SIGHAND | CLONE_THREAD | CLONE_SYSVSEM;
223
224 int tid = __pthread_clone(start_routine, child_stack, flags, arg);
225 if (tid < 0) {
226 int clone_errno = errno;
227 if ((thread->attr.flags & PTHREAD_ATTR_FLAG_USER_STACK) == 0) {
228 munmap(thread->attr.stack_base, thread->attr.stack_size);
229 }
230 free(thread);
231 __libc_format_log(ANDROID_LOG_WARN, "libc", "pthread_create failed: clone failed: %s", strerror(errno));
232 return clone_errno;
233 }
234
235 thread->tid = tid;
236
237 int init_errno = _init_thread(thread, true);
238 if (init_errno != 0) {
239 // Mark the thread detached and let its __thread_entry run to
240 // completion. (It'll just exit immediately, cleaning up its resources.)
241 thread->internal_flags |= kPthreadInitFailed;
242 thread->attr.flags |= PTHREAD_ATTR_FLAG_DETACHED;
243 return init_errno;
244 }
245
246 // Notify any debuggers about the new thread.
247 {
248 ScopedPthreadMutexLocker debugger_locker(&gDebuggerNotificationLock);
249 _thread_created_hook(thread->tid);
250 }
251
252 // Publish the pthread_t and let the thread run.
253 *thread_out = (pthread_t) thread;
254
255 return 0;
256 }
257