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_dense_alloc.h"
20#include "tsan_shadow.h"
21#include "tsan_vector_clock.h"
22
23namespace __tsan {
24
25// These need to match __tsan_mutex_* flags defined in tsan_interface.h.
26// See documentation there as well.
27enum MutexFlags {
28  MutexFlagLinkerInit          = 1 << 0, // __tsan_mutex_linker_init
29  MutexFlagWriteReentrant      = 1 << 1, // __tsan_mutex_write_reentrant
30  MutexFlagReadReentrant       = 1 << 2, // __tsan_mutex_read_reentrant
31  MutexFlagReadLock            = 1 << 3, // __tsan_mutex_read_lock
32  MutexFlagTryLock             = 1 << 4, // __tsan_mutex_try_lock
33  MutexFlagTryLockFailed       = 1 << 5, // __tsan_mutex_try_lock_failed
34  MutexFlagRecursiveLock       = 1 << 6, // __tsan_mutex_recursive_lock
35  MutexFlagRecursiveUnlock     = 1 << 7, // __tsan_mutex_recursive_unlock
36  MutexFlagNotStatic           = 1 << 8, // __tsan_mutex_not_static
37
38  // The following flags are runtime private.
39  // Mutex API misuse was detected, so don't report any more.
40  MutexFlagBroken              = 1 << 30,
41  // We did not intercept pre lock event, so handle it on post lock.
42  MutexFlagDoPreLockOnPostLock = 1 << 29,
43  // Must list all mutex creation flags.
44  MutexCreationFlagMask        = MutexFlagLinkerInit |
45                                 MutexFlagWriteReentrant |
46                                 MutexFlagReadReentrant |
47                                 MutexFlagNotStatic,
48};
49
50// SyncVar is a descriptor of a user synchronization object
51// (mutex or an atomic variable).
52struct SyncVar {
53  SyncVar();
54
55  uptr addr;  // overwritten by DenseSlabAlloc freelist
56  Mutex mtx;
57  StackID creation_stack_id;
58  Tid owner_tid;  // Set only by exclusive owners.
59  FastState last_lock;
60  int recursion;
61  atomic_uint32_t flags;
62  u32 next;  // in MetaMap
63  DDMutex dd;
64  VectorClock *read_clock;  // Used for rw mutexes only.
65  VectorClock *clock;
66
67  void Init(ThreadState *thr, uptr pc, uptr addr, bool save_stack);
68  void Reset();
69
70  bool IsFlagSet(u32 f) const {
71    return atomic_load_relaxed(&flags) & f;
72  }
73
74  void SetFlags(u32 f) {
75    atomic_store_relaxed(&flags, atomic_load_relaxed(&flags) | f);
76  }
77
78  void UpdateFlags(u32 flagz) {
79    // Filter out operation flags.
80    if (!(flagz & MutexCreationFlagMask))
81      return;
82    u32 current = atomic_load_relaxed(&flags);
83    if (current & MutexCreationFlagMask)
84      return;
85    // Note: this can be called from MutexPostReadLock which holds only read
86    // lock on the SyncVar.
87    atomic_store_relaxed(&flags, current | (flagz & MutexCreationFlagMask));
88  }
89};
90
91// MetaMap maps app addresses to heap block (MBlock) and sync var (SyncVar)
92// descriptors. It uses 1/2 direct shadow, see tsan_platform.h for the mapping.
93class MetaMap {
94 public:
95  MetaMap();
96
97  void AllocBlock(ThreadState *thr, uptr pc, uptr p, uptr sz);
98
99  // FreeBlock resets all sync objects in the range if reset=true and must not
100  // run concurrently with ResetClocks which resets all sync objects
101  // w/o any synchronization (as part of DoReset).
102  // If we don't have a thread slot (very early/late in thread lifetime or
103  // Go/Java callbacks) or the slot is not locked, then reset must be set to
104  // false. In such case sync object clocks will be reset later (when it's
105  // reused or during the next ResetClocks).
106  uptr FreeBlock(Processor *proc, uptr p, bool reset);
107  bool FreeRange(Processor *proc, uptr p, uptr sz, bool reset);
108  void ResetRange(Processor *proc, uptr p, uptr sz, bool reset);
109  // Reset vector clocks of all sync objects.
110  // Must be called when no other threads access sync objects.
111  void ResetClocks();
112  MBlock* GetBlock(uptr p);
113
114  SyncVar *GetSyncOrCreate(ThreadState *thr, uptr pc, uptr addr,
115                           bool save_stack) {
116    return GetSync(thr, pc, addr, true, save_stack);
117  }
118  SyncVar *GetSyncIfExists(uptr addr) {
119    return GetSync(nullptr, 0, addr, false, false);
120  }
121
122  void MoveMemory(uptr src, uptr dst, uptr sz);
123
124  void OnProcIdle(Processor *proc);
125
126  struct MemoryStats {
127    uptr mem_block;
128    uptr sync_obj;
129  };
130
131  MemoryStats GetMemoryStats() const;
132
133 private:
134  static const u32 kFlagMask  = 3u << 30;
135  static const u32 kFlagBlock = 1u << 30;
136  static const u32 kFlagSync  = 2u << 30;
137  typedef DenseSlabAlloc<MBlock, 1 << 18, 1 << 12, kFlagMask> BlockAlloc;
138  typedef DenseSlabAlloc<SyncVar, 1 << 20, 1 << 10, kFlagMask> SyncAlloc;
139  BlockAlloc block_alloc_;
140  SyncAlloc sync_alloc_;
141
142  SyncVar *GetSync(ThreadState *thr, uptr pc, uptr addr, bool create,
143                   bool save_stack);
144};
145
146}  // namespace __tsan
147
148#endif  // TSAN_SYNC_H
149