1//===------------------------- mutex.cpp ----------------------------------===//
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#include "mutex"
10#include "limits"
11#include "system_error"
12#include "include/atomic_support.h"
13#include "__undef_macros"
14
15#ifndef _LIBCPP_HAS_NO_THREADS
16#if defined(__unix__) && defined(__ELF__) && defined(_LIBCPP_HAS_COMMENT_LIB_PRAGMA)
17#pragma comment(lib, "pthread")
18#endif
19#endif
20
21_LIBCPP_BEGIN_NAMESPACE_STD
22#ifndef _LIBCPP_HAS_NO_THREADS
23
24const defer_lock_t defer_lock = {};
25const try_to_lock_t try_to_lock = {};
26const adopt_lock_t adopt_lock = {};
27
28// ~mutex is defined elsewhere
29
30void
31mutex::lock()
32{
33 int ec = __libcpp_mutex_lock(&__m_);
34 if (ec)
35 __throw_system_error(ec, "mutex lock failed");
36}
37
38bool
39mutex::try_lock() _NOEXCEPT
40{
41 return __libcpp_mutex_trylock(&__m_);
42}
43
44void
45mutex::unlock() _NOEXCEPT
46{
47 int ec = __libcpp_mutex_unlock(&__m_);
48 (void)ec;
49 _LIBCPP_ASSERT(ec == 0, "call to mutex::unlock failed");
50}
51
52// recursive_mutex
53
54recursive_mutex::recursive_mutex()
55{
56 int ec = __libcpp_recursive_mutex_init(&__m_);
57 if (ec)
58 __throw_system_error(ec, "recursive_mutex constructor failed");
59}
60
61recursive_mutex::~recursive_mutex()
62{
63 int e = __libcpp_recursive_mutex_destroy(&__m_);
64 (void)e;
65 _LIBCPP_ASSERT(e == 0, "call to ~recursive_mutex() failed");
66}
67
68void
69recursive_mutex::lock()
70{
71 int ec = __libcpp_recursive_mutex_lock(&__m_);
72 if (ec)
73 __throw_system_error(ec, "recursive_mutex lock failed");
74}
75
76void
77recursive_mutex::unlock() _NOEXCEPT
78{
79 int e = __libcpp_recursive_mutex_unlock(&__m_);
80 (void)e;
81 _LIBCPP_ASSERT(e == 0, "call to recursive_mutex::unlock() failed");
82}
83
84bool
85recursive_mutex::try_lock() _NOEXCEPT
86{
87 return __libcpp_recursive_mutex_trylock(&__m_);
88}
89
90// timed_mutex
91
92timed_mutex::timed_mutex()
93 : __locked_(false)
94{
95}
96
97timed_mutex::~timed_mutex()
98{
99 lock_guard<mutex> _(__m_);
100}
101
102void
103timed_mutex::lock()
104{
105 unique_lock<mutex> lk(__m_);
106 while (__locked_)
107 __cv_.wait(lk);
108 __locked_ = true;
109}
110
111bool
112timed_mutex::try_lock() _NOEXCEPT
113{
114 unique_lock<mutex> lk(__m_, try_to_lock);
115 if (lk.owns_lock() && !__locked_)
116 {
117 __locked_ = true;
118 return true;
119 }
120 return false;
121}
122
123void
124timed_mutex::unlock() _NOEXCEPT
125{
126 lock_guard<mutex> _(__m_);
127 __locked_ = false;
128 __cv_.notify_one();
129}
130
131// recursive_timed_mutex
132
133recursive_timed_mutex::recursive_timed_mutex()
134 : __count_(0),
135 __id_(0)
136{
137}
138
139recursive_timed_mutex::~recursive_timed_mutex()
140{
141 lock_guard<mutex> _(__m_);
142}
143
144void
145recursive_timed_mutex::lock()
146{
147 __libcpp_thread_id id = __libcpp_thread_get_current_id();
148 unique_lock<mutex> lk(__m_);
149 if (__libcpp_thread_id_equal(id, __id_))
150 {
151 if (__count_ == numeric_limits<size_t>::max())
152 __throw_system_error(EAGAIN, "recursive_timed_mutex lock limit reached");
153 ++__count_;
154 return;
155 }
156 while (__count_ != 0)
157 __cv_.wait(lk);
158 __count_ = 1;
159 __id_ = id;
160}
161
162bool
163recursive_timed_mutex::try_lock() _NOEXCEPT
164{
165 __libcpp_thread_id id = __libcpp_thread_get_current_id();
166 unique_lock<mutex> lk(__m_, try_to_lock);
167 if (lk.owns_lock() && (__count_ == 0 || __libcpp_thread_id_equal(id, __id_)))
168 {
169 if (__count_ == numeric_limits<size_t>::max())
170 return false;
171 ++__count_;
172 __id_ = id;
173 return true;
174 }
175 return false;
176}
177
178void
179recursive_timed_mutex::unlock() _NOEXCEPT
180{
181 unique_lock<mutex> lk(__m_);
182 if (--__count_ == 0)
183 {
184 __id_ = 0;
185 lk.unlock();
186 __cv_.notify_one();
187 }
188}
189
190#endif // !_LIBCPP_HAS_NO_THREADS
191
192// If dispatch_once_f ever handles C++ exceptions, and if one can get to it
193// without illegal macros (unexpected macros not beginning with _UpperCase or
194// __lowercase), and if it stops spinning waiting threads, then call_once should
195// call into dispatch_once_f instead of here. Relevant radar this code needs to
196// keep in sync with: 7741191.
197
198#ifndef _LIBCPP_HAS_NO_THREADS
199_LIBCPP_SAFE_STATIC static __libcpp_mutex_t mut = _LIBCPP_MUTEX_INITIALIZER;
200_LIBCPP_SAFE_STATIC static __libcpp_condvar_t cv = _LIBCPP_CONDVAR_INITIALIZER;
201#endif
202
203void __call_once(volatile once_flag::_State_type& flag, void* arg,
204 void (*func)(void*))
205{
206#if defined(_LIBCPP_HAS_NO_THREADS)
207 if (flag == 0)
208 {
209#ifndef _LIBCPP_NO_EXCEPTIONS
210 try
211 {
212#endif // _LIBCPP_NO_EXCEPTIONS
213 flag = 1;
214 func(arg);
215 flag = ~once_flag::_State_type(0);
216#ifndef _LIBCPP_NO_EXCEPTIONS
217 }
218 catch (...)
219 {
220 flag = 0;
221 throw;
222 }
223#endif // _LIBCPP_NO_EXCEPTIONS
224 }
225#else // !_LIBCPP_HAS_NO_THREADS
226 __libcpp_mutex_lock(&mut);
227 while (flag == 1)
228 __libcpp_condvar_wait(&cv, &mut);
229 if (flag == 0)
230 {
231#ifndef _LIBCPP_NO_EXCEPTIONS
232 try
233 {
234#endif // _LIBCPP_NO_EXCEPTIONS
235 __libcpp_relaxed_store(&flag, once_flag::_State_type(1));
236 __libcpp_mutex_unlock(&mut);
237 func(arg);
238 __libcpp_mutex_lock(&mut);
239 __libcpp_atomic_store(&flag, ~once_flag::_State_type(0),
240 _AO_Release);
241 __libcpp_mutex_unlock(&mut);
242 __libcpp_condvar_broadcast(&cv);
243#ifndef _LIBCPP_NO_EXCEPTIONS
244 }
245 catch (...)
246 {
247 __libcpp_mutex_lock(&mut);
248 __libcpp_relaxed_store(&flag, once_flag::_State_type(0));
249 __libcpp_mutex_unlock(&mut);
250 __libcpp_condvar_broadcast(&cv);
251 throw;
252 }
253#endif // _LIBCPP_NO_EXCEPTIONS
254 }
255 else
256 __libcpp_mutex_unlock(&mut);
257#endif // !_LIBCPP_HAS_NO_THREADS
258}
259
260_LIBCPP_END_NAMESPACE_STD
261