1//===-- asan_fuchsia.cc --------------------------------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===---------------------------------------------------------------------===// 9// 10// This file is a part of AddressSanitizer, an address sanity checker. 11// 12// Fuchsia-specific details. 13//===---------------------------------------------------------------------===// 14 15#include "sanitizer_common/sanitizer_fuchsia.h" 16#if SANITIZER_FUCHSIA 17 18#include "asan_interceptors.h" 19#include "asan_internal.h" 20#include "asan_stack.h" 21#include "asan_thread.h" 22 23#include <limits.h> 24#include <zircon/sanitizer.h> 25#include <zircon/syscalls.h> 26#include <zircon/threads.h> 27 28namespace __asan { 29 30// The system already set up the shadow memory for us. 31// __sanitizer::GetMaxUserVirtualAddress has already been called by 32// AsanInitInternal->InitializeHighMemEnd (asan_rtl.cc). 33// Just do some additional sanity checks here. 34void InitializeShadowMemory() { 35 if (Verbosity()) PrintAddressSpaceLayout(); 36 37 // Make sure SHADOW_OFFSET doesn't use __asan_shadow_memory_dynamic_address. 38 __asan_shadow_memory_dynamic_address = kDefaultShadowSentinel; 39 DCHECK(kLowShadowBeg != kDefaultShadowSentinel); 40 __asan_shadow_memory_dynamic_address = kLowShadowBeg; 41 42 CHECK_EQ(kShadowGapEnd, kHighShadowBeg - 1); 43 CHECK_EQ(kHighMemEnd, __sanitizer::ShadowBounds.memory_limit - 1); 44 CHECK_EQ(kHighMemBeg, __sanitizer::ShadowBounds.shadow_limit); 45 CHECK_EQ(kHighShadowBeg, __sanitizer::ShadowBounds.shadow_base); 46 CHECK_EQ(kShadowGapEnd, __sanitizer::ShadowBounds.shadow_base - 1); 47 CHECK_EQ(kLowShadowEnd, 0); 48 CHECK_EQ(kLowShadowBeg, 0); 49} 50 51void AsanApplyToGlobals(globals_op_fptr op, const void *needle) { 52 UNIMPLEMENTED(); 53} 54 55void AsanCheckDynamicRTPrereqs() {} 56void AsanCheckIncompatibleRT() {} 57void InitializeAsanInterceptors() {} 58 59void *AsanDoesNotSupportStaticLinkage() { return nullptr; } 60 61void InitializePlatformExceptionHandlers() {} 62void AsanOnDeadlySignal(int signo, void *siginfo, void *context) { 63 UNIMPLEMENTED(); 64} 65 66// We can use a plain thread_local variable for TSD. 67static thread_local void *per_thread; 68 69void *AsanTSDGet() { return per_thread; } 70 71void AsanTSDSet(void *tsd) { per_thread = tsd; } 72 73// There's no initialization needed, and the passed-in destructor 74// will never be called. Instead, our own thread destruction hook 75// (below) will call AsanThread::TSDDtor directly. 76void AsanTSDInit(void (*destructor)(void *tsd)) { 77 DCHECK(destructor == &PlatformTSDDtor); 78} 79 80void PlatformTSDDtor(void *tsd) { UNREACHABLE(__func__); } 81 82static inline size_t AsanThreadMmapSize() { 83 return RoundUpTo(sizeof(AsanThread), PAGE_SIZE); 84} 85 86struct AsanThread::InitOptions { 87 uptr stack_bottom, stack_size; 88}; 89 90// Shared setup between thread creation and startup for the initial thread. 91static AsanThread *CreateAsanThread(StackTrace *stack, u32 parent_tid, 92 uptr user_id, bool detached, 93 const char *name, uptr stack_bottom, 94 uptr stack_size) { 95 // In lieu of AsanThread::Create. 96 AsanThread *thread = (AsanThread *)MmapOrDie(AsanThreadMmapSize(), __func__); 97 98 AsanThreadContext::CreateThreadContextArgs args = {thread, stack}; 99 u32 tid = 100 asanThreadRegistry().CreateThread(user_id, detached, parent_tid, &args); 101 asanThreadRegistry().SetThreadName(tid, name); 102 103 // On other systems, AsanThread::Init() is called from the new 104 // thread itself. But on Fuchsia we already know the stack address 105 // range beforehand, so we can do most of the setup right now. 106 const AsanThread::InitOptions options = {stack_bottom, stack_size}; 107 thread->Init(&options); 108 109 return thread; 110} 111 112// This gets the same arguments passed to Init by CreateAsanThread, above. 113// We're in the creator thread before the new thread is actually started, 114// but its stack address range is already known. We don't bother tracking 115// the static TLS address range because the system itself already uses an 116// ASan-aware allocator for that. 117void AsanThread::SetThreadStackAndTls(const AsanThread::InitOptions *options) { 118 DCHECK_NE(GetCurrentThread(), this); 119 DCHECK_NE(GetCurrentThread(), nullptr); 120 CHECK_NE(options->stack_bottom, 0); 121 CHECK_NE(options->stack_size, 0); 122 stack_bottom_ = options->stack_bottom; 123 stack_top_ = options->stack_bottom + options->stack_size; 124} 125 126// Called by __asan::AsanInitInternal (asan_rtl.c). 127AsanThread *CreateMainThread() { 128 thrd_t self = thrd_current(); 129 char name[ZX_MAX_NAME_LEN]; 130 CHECK_NE(__sanitizer::MainThreadStackBase, 0); 131 CHECK_GT(__sanitizer::MainThreadStackSize, 0); 132 AsanThread *t = CreateAsanThread( 133 nullptr, 0, reinterpret_cast<uptr>(self), true, 134 _zx_object_get_property(thrd_get_zx_handle(self), ZX_PROP_NAME, name, 135 sizeof(name)) == ZX_OK 136 ? name 137 : nullptr, 138 __sanitizer::MainThreadStackBase, __sanitizer::MainThreadStackSize); 139 SetCurrentThread(t); 140 return t; 141} 142 143// This is called before each thread creation is attempted. So, in 144// its first call, the calling thread is the initial and sole thread. 145static void *BeforeThreadCreateHook(uptr user_id, bool detached, 146 const char *name, uptr stack_bottom, 147 uptr stack_size) { 148 EnsureMainThreadIDIsCorrect(); 149 // Strict init-order checking is thread-hostile. 150 if (flags()->strict_init_order) StopInitOrderChecking(); 151 152 GET_STACK_TRACE_THREAD; 153 u32 parent_tid = GetCurrentTidOrInvalid(); 154 155 return CreateAsanThread(&stack, parent_tid, user_id, detached, name, 156 stack_bottom, stack_size); 157} 158 159// This is called after creating a new thread (in the creating thread), 160// with the pointer returned by BeforeThreadCreateHook (above). 161static void ThreadCreateHook(void *hook, bool aborted) { 162 AsanThread *thread = static_cast<AsanThread *>(hook); 163 if (!aborted) { 164 // The thread was created successfully. 165 // ThreadStartHook is already running in the new thread. 166 } else { 167 // The thread wasn't created after all. 168 // Clean up everything we set up in BeforeThreadCreateHook. 169 asanThreadRegistry().FinishThread(thread->tid()); 170 UnmapOrDie(thread, AsanThreadMmapSize()); 171 } 172} 173 174// This is called in the newly-created thread before it runs anything else, 175// with the pointer returned by BeforeThreadCreateHook (above). 176// cf. asan_interceptors.cc:asan_thread_start 177static void ThreadStartHook(void *hook, uptr os_id) { 178 AsanThread *thread = static_cast<AsanThread *>(hook); 179 SetCurrentThread(thread); 180 181 // In lieu of AsanThread::ThreadStart. 182 asanThreadRegistry().StartThread(thread->tid(), os_id, /*workerthread*/ false, 183 nullptr); 184} 185 186// Each thread runs this just before it exits, 187// with the pointer returned by BeforeThreadCreateHook (above). 188// All per-thread destructors have already been called. 189static void ThreadExitHook(void *hook, uptr os_id) { 190 AsanThread::TSDDtor(per_thread); 191} 192 193bool HandleDlopenInit() { 194 // Not supported on this platform. 195 static_assert(!SANITIZER_SUPPORTS_INIT_FOR_DLOPEN, 196 "Expected SANITIZER_SUPPORTS_INIT_FOR_DLOPEN to be false"); 197 return false; 198} 199 200} // namespace __asan 201 202// These are declared (in extern "C") by <zircon/sanitizer.h>. 203// The system runtime will call our definitions directly. 204 205void *__sanitizer_before_thread_create_hook(thrd_t thread, bool detached, 206 const char *name, void *stack_base, 207 size_t stack_size) { 208 return __asan::BeforeThreadCreateHook( 209 reinterpret_cast<uptr>(thread), detached, name, 210 reinterpret_cast<uptr>(stack_base), stack_size); 211} 212 213void __sanitizer_thread_create_hook(void *hook, thrd_t thread, int error) { 214 __asan::ThreadCreateHook(hook, error != thrd_success); 215} 216 217void __sanitizer_thread_start_hook(void *hook, thrd_t self) { 218 __asan::ThreadStartHook(hook, reinterpret_cast<uptr>(self)); 219} 220 221void __sanitizer_thread_exit_hook(void *hook, thrd_t self) { 222 __asan::ThreadExitHook(hook, reinterpret_cast<uptr>(self)); 223} 224 225#endif // SANITIZER_FUCHSIA 226