compiler-rt/lib/sanitizer_common/sanitizer_thread_arg_retval.cpp

   1 //===-- sanitizer_thread_arg_retval.cpp -------------------------*- C++ -*-===//
   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 shared between sanitizer tools.
  10 //
  11 // Tracks thread arguments and return value for leak checking.
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "sanitizer_thread_arg_retval.h"
  15
  16 #include "sanitizer_placement_new.h"
  17
  18 namespace __sanitizer {
  19
  20 void ThreadArgRetval::CreateLocked(uptr thread, bool detached,
  21                                    const Args& args) {
  22   CheckLocked();
  23   Data& t = data_[thread];
  24   t = {};
  25   t.gen = gen_++;
  26   static_assert(sizeof(gen_) == sizeof(u32) && kInvalidGen == UINT32_MAX);
  27   if (gen_ == kInvalidGen)
  28     gen_ = 0;
  29   t.detached = detached;
  30   t.args = args;
  31 }
  32
  33 ThreadArgRetval::Args ThreadArgRetval::GetArgs(uptr thread) const {
  34   __sanitizer::Lock lock(&mtx_);
  35   auto t = data_.find(thread);
  36   CHECK(t);
  37   if (t->second.done)
  38     return {};
  39   return t->second.args;
  40 }
  41
  42 void ThreadArgRetval::Finish(uptr thread, void* retval) {
  43   __sanitizer::Lock lock(&mtx_);
  44   auto t = data_.find(thread);
  45   if (!t)
  46     return;
  47   if (t->second.detached) {
  48     // Retval of detached thread connot be retrieved.
  49     data_.erase(t);
  50     return;
  51   }
  52   t->second.done = true;
  53   t->second.args.arg_retval = retval;
  54 }
  55
  56 u32 ThreadArgRetval::BeforeJoin(uptr thread) const {
  57   __sanitizer::Lock lock(&mtx_);
  58   auto t = data_.find(thread);
  59   if (t && !t->second.detached) {
  60     return t->second.gen;
  61   }
  62   if (!common_flags()->detect_invalid_join)
  63     return kInvalidGen;
  64   const char* reason = "unknown";
  65   if (!t) {
  66     reason = "already joined";
  67   } else if (t->second.detached) {
  68     reason = "detached";
  69   }
  70   Report("ERROR: %s: Joining %s thread, aborting.\n", SanitizerToolName,
  71          reason);
  72   Die();
  73 }
  74
  75 void ThreadArgRetval::AfterJoin(uptr thread, u32 gen) {
  76   __sanitizer::Lock lock(&mtx_);
  77   auto t = data_.find(thread);
  78   if (!t || gen != t->second.gen) {
  79     // Thread was reused and erased by any other event, or we had an invalid
  80     // join.
  81     return;
  82   }
  83   CHECK(!t->second.detached);
  84   data_.erase(t);
  85 }
  86
  87 void ThreadArgRetval::DetachLocked(uptr thread) {
  88   CheckLocked();
  89   auto t = data_.find(thread);
  90   CHECK(t);
  91   CHECK(!t->second.detached);
  92   if (t->second.done) {
  93     // We can't retrive retval after detached thread finished.
  94     data_.erase(t);
  95     return;
  96   }
  97   t->second.detached = true;
  98 }
  99
 100 void ThreadArgRetval::GetAllPtrsLocked(InternalMmapVector<uptr>* ptrs) {
 101   CheckLocked();
 102   CHECK(ptrs);
 103   data_.forEach([&](DenseMap<uptr, Data>::value_type& kv) -> bool {
 104     ptrs->push_back((uptr)kv.second.args.arg_retval);
 105     return true;
 106   });
 107 }
 108
 109 }  // namespace __sanitizer