libsanitizer/lsan/lsan_fuchsia.cpp

   1 //=-- lsan_fuchsia.cpp ---------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===---------------------------------------------------------------------===//
   8 //
   9 // This file is a part of LeakSanitizer.
  10 // Standalone LSan RTL code specific to Fuchsia.
  11 //
  12 //===---------------------------------------------------------------------===//
  13
  14 #include "sanitizer_common/sanitizer_platform.h"
  15
  16 #if SANITIZER_FUCHSIA
  17 #include <zircon/sanitizer.h>
  18
  19 #include "lsan.h"
  20 #include "lsan_allocator.h"
  21
  22 using namespace __lsan;
  23
  24 namespace __lsan {
  25
  26 void LsanOnDeadlySignal(int signo, void *siginfo, void *context) {}
  27
  28 ThreadContext::ThreadContext(int tid) : ThreadContextLsanBase(tid) {}
  29
  30 struct OnCreatedArgs {
  31   uptr stack_begin, stack_end;
  32 };
  33
  34 // On Fuchsia, the stack bounds of a new thread are available before
  35 // the thread itself has started running.
  36 void ThreadContext::OnCreated(void *arg) {
  37   // Stack bounds passed through from __sanitizer_before_thread_create_hook
  38   // or InitializeMainThread.
  39   auto args = reinterpret_cast<const OnCreatedArgs *>(arg);
  40   stack_begin_ = args->stack_begin;
  41   stack_end_ = args->stack_end;
  42 }
  43
  44 struct OnStartedArgs {
  45   uptr cache_begin, cache_end;
  46 };
  47
  48 void ThreadContext::OnStarted(void *arg) {
  49   ThreadContextLsanBase::OnStarted(arg);
  50   auto args = reinterpret_cast<const OnStartedArgs *>(arg);
  51   cache_begin_ = args->cache_begin;
  52   cache_end_ = args->cache_end;
  53 }
  54
  55 void ThreadStart(u32 tid) {
  56   OnStartedArgs args;
  57   GetAllocatorCacheRange(&args.cache_begin, &args.cache_end);
  58   CHECK_EQ(args.cache_end - args.cache_begin, sizeof(AllocatorCache));
  59   ThreadContextLsanBase::ThreadStart(tid, GetTid(), ThreadType::Regular, &args);
  60 }
  61
  62 void InitializeMainThread() {
  63   OnCreatedArgs args;
  64   __sanitizer::GetThreadStackTopAndBottom(true, &args.stack_end,
  65                                           &args.stack_begin);
  66   u32 tid = ThreadCreate(kMainTid, true, &args);
  67   CHECK_EQ(tid, 0);
  68   ThreadStart(tid);
  69 }
  70
  71 void GetAllThreadAllocatorCachesLocked(InternalMmapVector<uptr> *caches) {
  72   GetLsanThreadRegistryLocked()->RunCallbackForEachThreadLocked(
  73       [](ThreadContextBase *tctx, void *arg) {
  74         auto ctx = static_cast<ThreadContext *>(tctx);
  75         static_cast<decltype(caches)>(arg)->push_back(ctx->cache_begin());
  76       },
  77       caches);
  78 }
  79
  80 // On Fuchsia, leak detection is done by a special hook after atexit hooks.
  81 // So this doesn't install any atexit hook like on other platforms.
  82 void InstallAtExitCheckLeaks() {}
  83
  84 // ASan defines this to check its `halt_on_error` flag.
  85 bool UseExitcodeOnLeak() { return true; }
  86
  87 }  // namespace __lsan
  88
  89 // These are declared (in extern "C") by <zircon/sanitizer.h>.
  90 // The system runtime will call our definitions directly.
  91
  92 // This is called before each thread creation is attempted.  So, in
  93 // its first call, the calling thread is the initial and sole thread.
  94 void *__sanitizer_before_thread_create_hook(thrd_t thread, bool detached,
  95                                             const char *name, void *stack_base,
  96                                             size_t stack_size) {
  97   ENSURE_LSAN_INITED;
  98   EnsureMainThreadIDIsCorrect();
  99   OnCreatedArgs args;
 100   args.stack_begin = reinterpret_cast<uptr>(stack_base);
 101   args.stack_end = args.stack_begin + stack_size;
 102   u32 parent_tid = GetCurrentThreadId();
 103   u32 tid = ThreadCreate(parent_tid, detached, &args);
 104   return reinterpret_cast<void *>(static_cast<uptr>(tid));
 105 }
 106
 107 // This is called after creating a new thread (in the creating thread),
 108 // with the pointer returned by __sanitizer_before_thread_create_hook (above).
 109 void __sanitizer_thread_create_hook(void *hook, thrd_t thread, int error) {
 110   u32 tid = static_cast<u32>(reinterpret_cast<uptr>(hook));
 111   // On success, there is nothing to do here.
 112   if (error != thrd_success) {
 113     // Clean up the thread registry for the thread creation that didn't happen.
 114     GetLsanThreadRegistryLocked()->FinishThread(tid);
 115   }
 116 }
 117
 118 // This is called in the newly-created thread before it runs anything else,
 119 // with the pointer returned by __sanitizer_before_thread_create_hook (above).
 120 void __sanitizer_thread_start_hook(void *hook, thrd_t self) {
 121   u32 tid = static_cast<u32>(reinterpret_cast<uptr>(hook));
 122   ThreadStart(tid);
 123 }
 124
 125 // Each thread runs this just before it exits,
 126 // with the pointer returned by BeforeThreadCreateHook (above).
 127 // All per-thread destructors have already been called.
 128 void __sanitizer_thread_exit_hook(void *hook, thrd_t self) { ThreadFinish(); }
 129
 130 #endif  // SANITIZER_FUCHSIA