libsanitizer/tsan/tsan_sync.h

   1 //===-- tsan_sync.h ---------------------------------------------*- C++ -*-===//
   2 //
   3 // This file is distributed under the University of Illinois Open Source
   4 // License. See LICENSE.TXT for details.
   5 //
   6 //===----------------------------------------------------------------------===//
   7 //
   8 // This file is a part of ThreadSanitizer (TSan), a race detector.
   9 //
  10 //===----------------------------------------------------------------------===//
  11 #ifndef TSAN_SYNC_H
  12 #define TSAN_SYNC_H
  13
  14 #include "sanitizer_common/sanitizer_atomic.h"
  15 #include "sanitizer_common/sanitizer_common.h"
  16 #include "tsan_clock.h"
  17 #include "tsan_defs.h"
  18 #include "tsan_mutex.h"
  19
  20 namespace __tsan {
  21
  22 class SlabCache;
  23
  24 class StackTrace {
  25  public:
  26   StackTrace();
  27   // Initialized the object in "static mode",
  28   // in this mode it never calls malloc/free but uses the provided buffer.
  29   StackTrace(uptr *buf, uptr cnt);
  30   ~StackTrace();
  31   void Reset();
  32
  33   void Init(const uptr *pcs, uptr cnt);
  34   void ObtainCurrent(ThreadState *thr, uptr toppc);
  35   bool IsEmpty() const;
  36   uptr Size() const;
  37   uptr Get(uptr i) const;
  38   const uptr *Begin() const;
  39   void CopyFrom(const StackTrace& other);
  40
  41  private:
  42   uptr n_;
  43   uptr *s_;
  44   const uptr c_;
  45
  46   StackTrace(const StackTrace&);
  47   void operator = (const StackTrace&);
  48 };
  49
  50 struct SyncVar {
  51   explicit SyncVar(uptr addr, u64 uid);
  52
  53   static const int kInvalidTid = -1;
  54
  55   Mutex mtx;
  56   uptr addr;
  57   const u64 uid;  // Globally unique id.
  58   SyncClock clock;
  59   SyncClock read_clock;  // Used for rw mutexes only.
  60   u32 creation_stack_id;
  61   int owner_tid;  // Set only by exclusive owners.
  62   u64 last_lock;
  63   int recursion;
  64   bool is_rw;
  65   bool is_recursive;
  66   bool is_broken;
  67   bool is_linker_init;
  68   SyncVar *next;  // In SyncTab hashtable.
  69
  70   uptr GetMemoryConsumption();
  71   u64 GetId() const {
  72     // 47 lsb is addr, then 14 bits is low part of uid, then 3 zero bits.
  73     return GetLsb((u64)addr | (uid << 47), 61);
  74   }
  75   bool CheckId(u64 uid) const {
  76     CHECK_EQ(uid, GetLsb(uid, 14));
  77     return GetLsb(this->uid, 14) == uid;
  78   }
  79   static uptr SplitId(u64 id, u64 *uid) {
  80     *uid = id >> 47;
  81     return (uptr)GetLsb(id, 47);
  82   }
  83 };
  84
  85 class SyncTab {
  86  public:
  87   SyncTab();
  88   ~SyncTab();
  89
  90   SyncVar* GetOrCreateAndLock(ThreadState *thr, uptr pc,
  91                               uptr addr, bool write_lock);
  92   SyncVar* GetIfExistsAndLock(uptr addr, bool write_lock);
  93
  94   // If the SyncVar does not exist, returns 0.
  95   SyncVar* GetAndRemove(ThreadState *thr, uptr pc, uptr addr);
  96
  97   SyncVar* Create(ThreadState *thr, uptr pc, uptr addr);
  98
  99   uptr GetMemoryConsumption(uptr *nsync);
 100
 101  private:
 102   struct Part {
 103     Mutex mtx;
 104     SyncVar *val;
 105     char pad[kCacheLineSize - sizeof(Mutex) - sizeof(SyncVar*)];  // NOLINT
 106     Part();
 107   };
 108
 109   // FIXME: Implement something more sane.
 110   static const int kPartCount = 1009;
 111   Part tab_[kPartCount];
 112   atomic_uint64_t uid_gen_;
 113
 114   int PartIdx(uptr addr);
 115
 116   SyncVar* GetAndLock(ThreadState *thr, uptr pc,
 117                       uptr addr, bool write_lock, bool create);
 118
 119   SyncTab(const SyncTab&);  // Not implemented.
 120   void operator = (const SyncTab&);  // Not implemented.
 121 };
 122
 123 }  // namespace __tsan
 124
 125 #endif  // TSAN_SYNC_H