1//===-- sanitizer_mutex.h ---------------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef SANITIZER_MUTEX_H
15#define SANITIZER_MUTEX_H
16
17#include "sanitizer_atomic.h"
18#include "sanitizer_internal_defs.h"
19#include "sanitizer_libc.h"
20
21namespace __sanitizer {
22
23class StaticSpinMutex {
24 public:
25  void Init() {
26    atomic_store(&state_, 0, memory_order_relaxed);
27  }
28
29  void Lock() {
30    if (TryLock())
31      return;
32    LockSlow();
33  }
34
35  bool TryLock() {
36    return atomic_exchange(&state_, 1, memory_order_acquire) == 0;
37  }
38
39  void Unlock() {
40    atomic_store(&state_, 0, memory_order_release);
41  }
42
43  void CheckLocked() {
44    CHECK_EQ(atomic_load(&state_, memory_order_relaxed), 1);
45  }
46
47 private:
48  atomic_uint8_t state_;
49
50  void NOINLINE LockSlow() {
51    for (int i = 0;; i++) {
52      if (i < 10)
53        proc_yield(10);
54      else
55        internal_sched_yield();
56      if (atomic_load(&state_, memory_order_relaxed) == 0
57          && atomic_exchange(&state_, 1, memory_order_acquire) == 0)
58        return;
59    }
60  }
61};
62
63class SpinMutex : public StaticSpinMutex {
64 public:
65  SpinMutex() {
66    Init();
67  }
68
69 private:
70  SpinMutex(const SpinMutex&);
71  void operator=(const SpinMutex&);
72};
73
74class BlockingMutex {
75 public:
76#if SANITIZER_WINDOWS
77  // Windows does not currently support LinkerInitialized
78  explicit BlockingMutex(LinkerInitialized);
79#else
80  explicit constexpr BlockingMutex(LinkerInitialized)
81      : opaque_storage_ {0, }, owner_(0) {}
82#endif
83  BlockingMutex();
84  void Lock();
85  void Unlock();
86  void CheckLocked();
87 private:
88  uptr opaque_storage_[10];
89  uptr owner_;  // for debugging
90};
91
92// Reader-writer spin mutex.
93class RWMutex {
94 public:
95  RWMutex() {
96    atomic_store(&state_, kUnlocked, memory_order_relaxed);
97  }
98
99  ~RWMutex() {
100    CHECK_EQ(atomic_load(&state_, memory_order_relaxed), kUnlocked);
101  }
102
103  void Lock() {
104    u32 cmp = kUnlocked;
105    if (atomic_compare_exchange_strong(&state_, &cmp, kWriteLock,
106                                       memory_order_acquire))
107      return;
108    LockSlow();
109  }
110
111  void Unlock() {
112    u32 prev = atomic_fetch_sub(&state_, kWriteLock, memory_order_release);
113    DCHECK_NE(prev & kWriteLock, 0);
114    (void)prev;
115  }
116
117  void ReadLock() {
118    u32 prev = atomic_fetch_add(&state_, kReadLock, memory_order_acquire);
119    if ((prev & kWriteLock) == 0)
120      return;
121    ReadLockSlow();
122  }
123
124  void ReadUnlock() {
125    u32 prev = atomic_fetch_sub(&state_, kReadLock, memory_order_release);
126    DCHECK_EQ(prev & kWriteLock, 0);
127    DCHECK_GT(prev & ~kWriteLock, 0);
128    (void)prev;
129  }
130
131  void CheckLocked() {
132    CHECK_NE(atomic_load(&state_, memory_order_relaxed), kUnlocked);
133  }
134
135 private:
136  atomic_uint32_t state_;
137
138  enum {
139    kUnlocked = 0,
140    kWriteLock = 1,
141    kReadLock = 2
142  };
143
144  void NOINLINE LockSlow() {
145    for (int i = 0;; i++) {
146      if (i < 10)
147        proc_yield(10);
148      else
149        internal_sched_yield();
150      u32 cmp = atomic_load(&state_, memory_order_relaxed);
151      if (cmp == kUnlocked &&
152          atomic_compare_exchange_weak(&state_, &cmp, kWriteLock,
153                                       memory_order_acquire))
154          return;
155    }
156  }
157
158  void NOINLINE ReadLockSlow() {
159    for (int i = 0;; i++) {
160      if (i < 10)
161        proc_yield(10);
162      else
163        internal_sched_yield();
164      u32 prev = atomic_load(&state_, memory_order_acquire);
165      if ((prev & kWriteLock) == 0)
166        return;
167    }
168  }
169
170  RWMutex(const RWMutex&);
171  void operator = (const RWMutex&);
172};
173
174template<typename MutexType>
175class GenericScopedLock {
176 public:
177  explicit GenericScopedLock(MutexType *mu)
178      : mu_(mu) {
179    mu_->Lock();
180  }
181
182  ~GenericScopedLock() {
183    mu_->Unlock();
184  }
185
186 private:
187  MutexType *mu_;
188
189  GenericScopedLock(const GenericScopedLock&);
190  void operator=(const GenericScopedLock&);
191};
192
193template<typename MutexType>
194class GenericScopedReadLock {
195 public:
196  explicit GenericScopedReadLock(MutexType *mu)
197      : mu_(mu) {
198    mu_->ReadLock();
199  }
200
201  ~GenericScopedReadLock() {
202    mu_->ReadUnlock();
203  }
204
205 private:
206  MutexType *mu_;
207
208  GenericScopedReadLock(const GenericScopedReadLock&);
209  void operator=(const GenericScopedReadLock&);
210};
211
212typedef GenericScopedLock<StaticSpinMutex> SpinMutexLock;
213typedef GenericScopedLock<BlockingMutex> BlockingMutexLock;
214typedef GenericScopedLock<RWMutex> RWMutexLock;
215typedef GenericScopedReadLock<RWMutex> RWMutexReadLock;
216
217}  // namespace __sanitizer
218
219#endif  // SANITIZER_MUTEX_H
220