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 "sanitizer_common/sanitizer_deadlock_detector_interface.h"
17#include "tsan_defs.h"
18#include "tsan_clock.h"
19#include "tsan_mutex.h"
20#include "tsan_dense_alloc.h"
21
22namespace __tsan {
23
24// These need to match __tsan_mutex_* flags defined in tsan_interface.h.
25// See documentation there as well.
26enum MutexFlags {
27  MutexFlagLinkerInit          = 1 << 0, // __tsan_mutex_linker_init
28  MutexFlagWriteReentrant      = 1 << 1, // __tsan_mutex_write_reentrant
29  MutexFlagReadReentrant       = 1 << 2, // __tsan_mutex_read_reentrant
30  MutexFlagReadLock            = 1 << 3, // __tsan_mutex_read_lock
31  MutexFlagTryLock             = 1 << 4, // __tsan_mutex_try_lock
32  MutexFlagTryLockFailed       = 1 << 5, // __tsan_mutex_try_lock_failed
33  MutexFlagRecursiveLock       = 1 << 6, // __tsan_mutex_recursive_lock
34  MutexFlagRecursiveUnlock     = 1 << 7, // __tsan_mutex_recursive_unlock
35  MutexFlagNotStatic           = 1 << 8, // __tsan_mutex_not_static
36
37  // The following flags are runtime private.
38  // Mutex API misuse was detected, so don't report any more.
39  MutexFlagBroken              = 1 << 30,
40  // We did not intercept pre lock event, so handle it on post lock.
41  MutexFlagDoPreLockOnPostLock = 1 << 29,
42  // Must list all mutex creation flags.
43  MutexCreationFlagMask        = MutexFlagLinkerInit |
44                                 MutexFlagWriteReentrant |
45                                 MutexFlagReadReentrant |
46                                 MutexFlagNotStatic,
47};
48
49struct SyncVar {
50  SyncVar();
51
52  static const int kInvalidTid = -1;
53
54  uptr addr;  // overwritten by DenseSlabAlloc freelist
55  Mutex mtx;
56  u64 uid;  // Globally unique id.
57  u32 creation_stack_id;
58  int owner_tid;  // Set only by exclusive owners.
59  u64 last_lock;
60  int recursion;
61  atomic_uint32_t flags;
62  u32 next;  // in MetaMap
63  DDMutex dd;
64  SyncClock read_clock;  // Used for rw mutexes only.
65  // The clock is placed last, so that it is situated on a different cache line
66  // with the mtx. This reduces contention for hot sync objects.
67  SyncClock clock;
68
69  void Init(ThreadState *thr, uptr pc, uptr addr, u64 uid);
70  void Reset(Processor *proc);
71
72  u64 GetId() const {
73    // 48 lsb is addr, then 14 bits is low part of uid, then 2 zero bits.
74    return GetLsb((u64)addr | (uid << 48), 60);
75  }
76  bool CheckId(u64 uid) const {
77    CHECK_EQ(uid, GetLsb(uid, 14));
78    return GetLsb(this->uid, 14) == uid;
79  }
80  static uptr SplitId(u64 id, u64 *uid) {
81    *uid = id >> 48;
82    return (uptr)GetLsb(id, 48);
83  }
84
85  bool IsFlagSet(u32 f) const {
86    return atomic_load_relaxed(&flags) & f;
87  }
88
89  void SetFlags(u32 f) {
90    atomic_store_relaxed(&flags, atomic_load_relaxed(&flags) | f);
91  }
92
93  void UpdateFlags(u32 flagz) {
94    // Filter out operation flags.
95    if (!(flagz & MutexCreationFlagMask))
96      return;
97    u32 current = atomic_load_relaxed(&flags);
98    if (current & MutexCreationFlagMask)
99      return;
100    // Note: this can be called from MutexPostReadLock which holds only read
101    // lock on the SyncVar.
102    atomic_store_relaxed(&flags, current | (flagz & MutexCreationFlagMask));
103  }
104};
105
106/* MetaMap allows to map arbitrary user pointers onto various descriptors.
107   Currently it maps pointers to heap block descriptors and sync var descs.
108   It uses 1/2 direct shadow, see tsan_platform.h.
109*/
110class MetaMap {
111 public:
112  MetaMap();
113
114  void AllocBlock(ThreadState *thr, uptr pc, uptr p, uptr sz);
115  uptr FreeBlock(Processor *proc, uptr p);
116  bool FreeRange(Processor *proc, uptr p, uptr sz);
117  void ResetRange(Processor *proc, uptr p, uptr sz);
118  MBlock* GetBlock(uptr p);
119
120  SyncVar* GetOrCreateAndLock(ThreadState *thr, uptr pc,
121                              uptr addr, bool write_lock);
122  SyncVar* GetIfExistsAndLock(uptr addr, bool write_lock);
123
124  void MoveMemory(uptr src, uptr dst, uptr sz);
125
126  void OnProcIdle(Processor *proc);
127
128 private:
129  static const u32 kFlagMask  = 3u << 30;
130  static const u32 kFlagBlock = 1u << 30;
131  static const u32 kFlagSync  = 2u << 30;
132  typedef DenseSlabAlloc<MBlock, 1<<16, 1<<12> BlockAlloc;
133  typedef DenseSlabAlloc<SyncVar, 1<<16, 1<<10> SyncAlloc;
134  BlockAlloc block_alloc_;
135  SyncAlloc sync_alloc_;
136  atomic_uint64_t uid_gen_;
137
138  SyncVar* GetAndLock(ThreadState *thr, uptr pc, uptr addr, bool write_lock,
139                      bool create);
140};
141
142}  // namespace __tsan
143
144#endif  // TSAN_SYNC_H
145