1 //===-- tsan_sync.h ---------------------------------------------*- 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 a part of ThreadSanitizer (TSan), a race detector.
10 //
11 //===----------------------------------------------------------------------===//
12 #ifndef TSAN_SYNC_H
13 #define TSAN_SYNC_H
14 
15 #include "sanitizer_common/sanitizer_atomic.h"
16 #include "sanitizer_common/sanitizer_common.h"
17 #include "sanitizer_common/sanitizer_deadlock_detector_interface.h"
18 #include "tsan_defs.h"
19 #include "tsan_clock.h"
20 #include "tsan_dense_alloc.h"
21 
22 namespace __tsan {
23 
24 // These need to match __tsan_mutex_* flags defined in tsan_interface.h.
25 // See documentation there as well.
26 enum 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 
49 struct SyncVar {
50   SyncVar();
51 
52   uptr addr;  // overwritten by DenseSlabAlloc freelist
53   Mutex mtx;
54   u64 uid;  // Globally unique id.
55   u32 creation_stack_id;
56   u32 owner_tid;  // Set only by exclusive owners.
57   u64 last_lock;
58   int recursion;
59   atomic_uint32_t flags;
60   u32 next;  // in MetaMap
61   DDMutex dd;
62   SyncClock read_clock;  // Used for rw mutexes only.
63   // The clock is placed last, so that it is situated on a different cache line
64   // with the mtx. This reduces contention for hot sync objects.
65   SyncClock clock;
66 
67   void Init(ThreadState *thr, uptr pc, uptr addr, u64 uid);
68   void Reset(Processor *proc);
69 
GetIdSyncVar70   u64 GetId() const {
71     // 48 lsb is addr, then 14 bits is low part of uid, then 2 zero bits.
72     return GetLsb((u64)addr | (uid << 48), 60);
73   }
CheckIdSyncVar74   bool CheckId(u64 uid) const {
75     CHECK_EQ(uid, GetLsb(uid, 14));
76     return GetLsb(this->uid, 14) == uid;
77   }
SplitIdSyncVar78   static uptr SplitId(u64 id, u64 *uid) {
79     *uid = id >> 48;
80     return (uptr)GetLsb(id, 48);
81   }
82 
IsFlagSetSyncVar83   bool IsFlagSet(u32 f) const {
84     return atomic_load_relaxed(&flags) & f;
85   }
86 
SetFlagsSyncVar87   void SetFlags(u32 f) {
88     atomic_store_relaxed(&flags, atomic_load_relaxed(&flags) | f);
89   }
90 
UpdateFlagsSyncVar91   void UpdateFlags(u32 flagz) {
92     // Filter out operation flags.
93     if (!(flagz & MutexCreationFlagMask))
94       return;
95     u32 current = atomic_load_relaxed(&flags);
96     if (current & MutexCreationFlagMask)
97       return;
98     // Note: this can be called from MutexPostReadLock which holds only read
99     // lock on the SyncVar.
100     atomic_store_relaxed(&flags, current | (flagz & MutexCreationFlagMask));
101   }
102 };
103 
104 /* MetaMap allows to map arbitrary user pointers onto various descriptors.
105    Currently it maps pointers to heap block descriptors and sync var descs.
106    It uses 1/2 direct shadow, see tsan_platform.h.
107 */
108 class MetaMap {
109  public:
110   MetaMap();
111 
112   void AllocBlock(ThreadState *thr, uptr pc, uptr p, uptr sz);
113   uptr FreeBlock(Processor *proc, uptr p);
114   bool FreeRange(Processor *proc, uptr p, uptr sz);
115   void ResetRange(Processor *proc, uptr p, uptr sz);
116   MBlock* GetBlock(uptr p);
117 
118   SyncVar* GetOrCreateAndLock(ThreadState *thr, uptr pc,
119                               uptr addr, bool write_lock);
120   SyncVar* GetIfExistsAndLock(uptr addr, bool write_lock);
121 
122   void MoveMemory(uptr src, uptr dst, uptr sz);
123 
124   void OnProcIdle(Processor *proc);
125 
126  private:
127   static const u32 kFlagMask  = 3u << 30;
128   static const u32 kFlagBlock = 1u << 30;
129   static const u32 kFlagSync  = 2u << 30;
130   typedef DenseSlabAlloc<MBlock, 1 << 18, 1 << 12, kFlagMask> BlockAlloc;
131   typedef DenseSlabAlloc<SyncVar, 1 << 20, 1 << 10, kFlagMask> SyncAlloc;
132   BlockAlloc block_alloc_;
133   SyncAlloc sync_alloc_;
134   atomic_uint64_t uid_gen_;
135 
136   SyncVar* GetAndLock(ThreadState *thr, uptr pc, uptr addr, bool write_lock,
137                       bool create);
138 };
139 
140 }  // namespace __tsan
141 
142 #endif  // TSAN_SYNC_H
143