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 <signal.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <sys/mman.h>
35
36 #include "private/bionic_constants.h"
37 #include "private/bionic_defs.h"
38 #include "private/ScopedRWLock.h"
39 #include "private/ScopedSignalBlocker.h"
40 #include "pthread_internal.h"
41
42 extern "C" __noreturn void _exit_with_stack_teardown(void*, size_t);
43 extern "C" __noreturn void __exit(int);
44 extern "C" int __set_tid_address(int*);
45 extern "C" void __cxa_thread_finalize();
46
47 /* CAVEAT: our implementation of pthread_cleanup_push/pop doesn't support C++ exceptions
48 * and thread cancelation
49 */
50
51 __BIONIC_WEAK_FOR_NATIVE_BRIDGE
__pthread_cleanup_push(__pthread_cleanup_t * c,__pthread_cleanup_func_t routine,void * arg)52 void __pthread_cleanup_push(__pthread_cleanup_t* c, __pthread_cleanup_func_t routine, void* arg) {
53 pthread_internal_t* thread = __get_thread();
54 c->__cleanup_routine = routine;
55 c->__cleanup_arg = arg;
56 c->__cleanup_prev = thread->cleanup_stack;
57 thread->cleanup_stack = c;
58 }
59
60 __BIONIC_WEAK_FOR_NATIVE_BRIDGE
__pthread_cleanup_pop(__pthread_cleanup_t * c,int execute)61 void __pthread_cleanup_pop(__pthread_cleanup_t* c, int execute) {
62 pthread_internal_t* thread = __get_thread();
63 thread->cleanup_stack = c->__cleanup_prev;
64 if (execute) {
65 c->__cleanup_routine(c->__cleanup_arg);
66 }
67 }
68
69 __BIONIC_WEAK_FOR_NATIVE_BRIDGE
pthread_exit(void * return_value)70 void pthread_exit(void* return_value) {
71 // Call dtors for thread_local objects first.
72 __cxa_thread_finalize();
73
74 pthread_internal_t* thread = __get_thread();
75 thread->return_value = return_value;
76
77 // Call the cleanup handlers.
78 while (thread->cleanup_stack) {
79 __pthread_cleanup_t* c = thread->cleanup_stack;
80 thread->cleanup_stack = c->__cleanup_prev;
81 c->__cleanup_routine(c->__cleanup_arg);
82 }
83
84 // Call the TLS destructors. It is important to do that before removing this
85 // thread from the global list. This will ensure that if someone else deletes
86 // a TLS key, the corresponding value will be set to NULL in this thread's TLS
87 // space (see pthread_key_delete).
88 pthread_key_clean_all();
89
90 if (thread->alternate_signal_stack != nullptr) {
91 // Tell the kernel to stop using the alternate signal stack.
92 stack_t ss;
93 memset(&ss, 0, sizeof(ss));
94 ss.ss_flags = SS_DISABLE;
95 sigaltstack(&ss, nullptr);
96
97 // Free it.
98 munmap(thread->alternate_signal_stack, SIGNAL_STACK_SIZE);
99 thread->alternate_signal_stack = nullptr;
100 }
101
102 ThreadJoinState old_state = THREAD_NOT_JOINED;
103 while (old_state == THREAD_NOT_JOINED &&
104 !atomic_compare_exchange_weak(&thread->join_state, &old_state, THREAD_EXITED_NOT_JOINED)) {
105 }
106
107 // android_run_on_all_threads() needs to see signals blocked atomically with setting the
108 // terminating flag, so take the creation lock while doing these operations.
109 {
110 ScopedReadLock locker(&g_thread_creation_lock);
111 atomic_store(&thread->terminating, true);
112
113 // We don't want to take a signal after unmapping the stack, the shadow call stack, or dynamic
114 // TLS memory.
115 sigset64_t set;
116 sigfillset64(&set);
117 __rt_sigprocmask(SIG_BLOCK, &set, nullptr, sizeof(sigset64_t));
118 }
119
120 #ifdef __aarch64__
121 // Free the shadow call stack and guard pages.
122 munmap(thread->shadow_call_stack_guard_region, SCS_GUARD_REGION_SIZE);
123 #endif
124
125 __free_dynamic_tls(__get_bionic_tcb());
126
127 if (old_state == THREAD_DETACHED) {
128 // The thread is detached, no one will use pthread_internal_t after pthread_exit.
129 // So we can free mapped space, which includes pthread_internal_t and thread stack.
130 // First make sure that the kernel does not try to clear the tid field
131 // because we'll have freed the memory before the thread actually exits.
132 __set_tid_address(nullptr);
133
134 // pthread_internal_t is freed below with stack, not here.
135 __pthread_internal_remove(thread);
136
137 if (thread->mmap_size != 0) {
138 // We need to free mapped space for detached threads when they exit.
139 // That's not something we can do in C.
140 __notify_thread_exit_callbacks();
141 __hwasan_thread_exit();
142 _exit_with_stack_teardown(thread->mmap_base, thread->mmap_size);
143 }
144 }
145
146 // No need to free mapped space. Either there was no space mapped, or it is left for
147 // the pthread_join caller to clean up.
148 __notify_thread_exit_callbacks();
149 __hwasan_thread_exit();
150
151 __exit(0);
152 }
153