1 //===------------------------- mutex.cpp ----------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #define _LIBCPP_BUILDING_MUTEX
11 #include "mutex"
12 #include "limits"
13 #include "system_error"
14 #include "cassert"
15
16 _LIBCPP_BEGIN_NAMESPACE_STD
17
18 const defer_lock_t defer_lock = {};
19 const try_to_lock_t try_to_lock = {};
20 const adopt_lock_t adopt_lock = {};
21
~mutex()22 mutex::~mutex()
23 {
24 pthread_mutex_destroy(&__m_);
25 }
26
27 void
lock()28 mutex::lock()
29 {
30 int ec = pthread_mutex_lock(&__m_);
31 if (ec)
32 __throw_system_error(ec, "mutex lock failed");
33 }
34
35 bool
try_lock()36 mutex::try_lock() _NOEXCEPT
37 {
38 return pthread_mutex_trylock(&__m_) == 0;
39 }
40
41 void
unlock()42 mutex::unlock() _NOEXCEPT
43 {
44 int ec = pthread_mutex_unlock(&__m_);
45 assert(ec == 0);
46 }
47
48 // recursive_mutex
49
recursive_mutex()50 recursive_mutex::recursive_mutex()
51 {
52 pthread_mutexattr_t attr;
53 int ec = pthread_mutexattr_init(&attr);
54 if (ec)
55 goto fail;
56 ec = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
57 if (ec)
58 {
59 pthread_mutexattr_destroy(&attr);
60 goto fail;
61 }
62 ec = pthread_mutex_init(&__m_, &attr);
63 if (ec)
64 {
65 pthread_mutexattr_destroy(&attr);
66 goto fail;
67 }
68 ec = pthread_mutexattr_destroy(&attr);
69 if (ec)
70 {
71 pthread_mutex_destroy(&__m_);
72 goto fail;
73 }
74 return;
75 fail:
76 __throw_system_error(ec, "recursive_mutex constructor failed");
77 }
78
~recursive_mutex()79 recursive_mutex::~recursive_mutex()
80 {
81 int e = pthread_mutex_destroy(&__m_);
82 assert(e == 0);
83 }
84
85 void
lock()86 recursive_mutex::lock()
87 {
88 int ec = pthread_mutex_lock(&__m_);
89 if (ec)
90 __throw_system_error(ec, "recursive_mutex lock failed");
91 }
92
93 void
unlock()94 recursive_mutex::unlock() _NOEXCEPT
95 {
96 int e = pthread_mutex_unlock(&__m_);
97 assert(e == 0);
98 }
99
100 bool
try_lock()101 recursive_mutex::try_lock() _NOEXCEPT
102 {
103 return pthread_mutex_trylock(&__m_) == 0;
104 }
105
106 // timed_mutex
107
timed_mutex()108 timed_mutex::timed_mutex()
109 : __locked_(false)
110 {
111 }
112
~timed_mutex()113 timed_mutex::~timed_mutex()
114 {
115 lock_guard<mutex> _(__m_);
116 }
117
118 void
lock()119 timed_mutex::lock()
120 {
121 unique_lock<mutex> lk(__m_);
122 while (__locked_)
123 __cv_.wait(lk);
124 __locked_ = true;
125 }
126
127 bool
try_lock()128 timed_mutex::try_lock() _NOEXCEPT
129 {
130 unique_lock<mutex> lk(__m_, try_to_lock);
131 if (lk.owns_lock() && !__locked_)
132 {
133 __locked_ = true;
134 return true;
135 }
136 return false;
137 }
138
139 void
unlock()140 timed_mutex::unlock() _NOEXCEPT
141 {
142 lock_guard<mutex> _(__m_);
143 __locked_ = false;
144 __cv_.notify_one();
145 }
146
147 // recursive_timed_mutex
148
recursive_timed_mutex()149 recursive_timed_mutex::recursive_timed_mutex()
150 : __count_(0),
151 __id_(0)
152 {
153 }
154
~recursive_timed_mutex()155 recursive_timed_mutex::~recursive_timed_mutex()
156 {
157 lock_guard<mutex> _(__m_);
158 }
159
160 void
lock()161 recursive_timed_mutex::lock()
162 {
163 pthread_t id = pthread_self();
164 unique_lock<mutex> lk(__m_);
165 if (pthread_equal(id, __id_))
166 {
167 if (__count_ == numeric_limits<size_t>::max())
168 __throw_system_error(EAGAIN, "recursive_timed_mutex lock limit reached");
169 ++__count_;
170 return;
171 }
172 while (__count_ != 0)
173 __cv_.wait(lk);
174 __count_ = 1;
175 __id_ = id;
176 }
177
178 bool
try_lock()179 recursive_timed_mutex::try_lock() _NOEXCEPT
180 {
181 pthread_t id = pthread_self();
182 unique_lock<mutex> lk(__m_, try_to_lock);
183 if (lk.owns_lock() && (__count_ == 0 || pthread_equal(id, __id_)))
184 {
185 if (__count_ == numeric_limits<size_t>::max())
186 return false;
187 ++__count_;
188 __id_ = id;
189 return true;
190 }
191 return false;
192 }
193
194 void
unlock()195 recursive_timed_mutex::unlock() _NOEXCEPT
196 {
197 unique_lock<mutex> lk(__m_);
198 if (--__count_ == 0)
199 {
200 __id_ = 0;
201 lk.unlock();
202 __cv_.notify_one();
203 }
204 }
205
206 // If dispatch_once_f ever handles C++ exceptions, and if one can get to it
207 // without illegal macros (unexpected macros not beginning with _UpperCase or
208 // __lowercase), and if it stops spinning waiting threads, then call_once should
209 // call into dispatch_once_f instead of here. Relevant radar this code needs to
210 // keep in sync with: 7741191.
211
212 static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
213 static pthread_cond_t cv = PTHREAD_COND_INITIALIZER;
214
215 void
__call_once(volatile unsigned long & flag,void * arg,void (* func)(void *))216 __call_once(volatile unsigned long& flag, void* arg, void(*func)(void*))
217 {
218 pthread_mutex_lock(&mut);
219 while (flag == 1)
220 pthread_cond_wait(&cv, &mut);
221 if (flag == 0)
222 {
223 #ifndef _LIBCPP_NO_EXCEPTIONS
224 try
225 {
226 #endif // _LIBCPP_NO_EXCEPTIONS
227 flag = 1;
228 pthread_mutex_unlock(&mut);
229 func(arg);
230 pthread_mutex_lock(&mut);
231 flag = ~0ul;
232 pthread_mutex_unlock(&mut);
233 pthread_cond_broadcast(&cv);
234 #ifndef _LIBCPP_NO_EXCEPTIONS
235 }
236 catch (...)
237 {
238 pthread_mutex_lock(&mut);
239 flag = 0ul;
240 pthread_mutex_unlock(&mut);
241 pthread_cond_broadcast(&cv);
242 throw;
243 }
244 #endif // _LIBCPP_NO_EXCEPTIONS
245 }
246 else
247 pthread_mutex_unlock(&mut);
248 }
249
250 _LIBCPP_END_NAMESPACE_STD
251