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(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB) 17 #pragma comment(lib, "pthread") 18 #endif 19 #endif 20 21 _LIBCPP_BEGIN_NAMESPACE_STD 22 #ifndef _LIBCPP_HAS_NO_THREADS 23 24 const defer_lock_t defer_lock{}; 25 const try_to_lock_t try_to_lock{}; 26 const adopt_lock_t adopt_lock{}; 27 28 // ~mutex is defined elsewhere 29 30 void 31 mutex::lock() 32 { 33 int ec = __libcpp_mutex_lock(&__m_); 34 if (ec) 35 __throw_system_error(ec, "mutex lock failed"); 36 } 37 38 bool 39 mutex::try_lock() noexcept 40 { 41 return __libcpp_mutex_trylock(&__m_); 42 } 43 44 void 45 mutex::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 54 recursive_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 61 recursive_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 68 void 69 recursive_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 76 void 77 recursive_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 84 bool 85 recursive_mutex::try_lock() noexcept 86 { 87 return __libcpp_recursive_mutex_trylock(&__m_); 88 } 89 90 // timed_mutex 91 92 timed_mutex::timed_mutex() 93 : __locked_(false) 94 { 95 } 96 97 timed_mutex::~timed_mutex() 98 { 99 lock_guard<mutex> _(__m_); 100 } 101 102 void 103 timed_mutex::lock() 104 { 105 unique_lock<mutex> lk(__m_); 106 while (__locked_) 107 __cv_.wait(lk); 108 __locked_ = true; 109 } 110 111 bool 112 timed_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 123 void 124 timed_mutex::unlock() noexcept 125 { 126 lock_guard<mutex> _(__m_); 127 __locked_ = false; 128 __cv_.notify_one(); 129 } 130 131 // recursive_timed_mutex 132 133 recursive_timed_mutex::recursive_timed_mutex() 134 : __count_(0), 135 __id_{} 136 { 137 } 138 139 recursive_timed_mutex::~recursive_timed_mutex() 140 { 141 lock_guard<mutex> _(__m_); 142 } 143 144 void 145 recursive_timed_mutex::lock() 146 { 147 __thread_id id = this_thread::get_id(); 148 unique_lock<mutex> lk(__m_); 149 if (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 162 bool 163 recursive_timed_mutex::try_lock() noexcept 164 { 165 __thread_id id = this_thread::get_id(); 166 unique_lock<mutex> lk(__m_, try_to_lock); 167 if (lk.owns_lock() && (__count_ == 0 || 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 178 void 179 recursive_timed_mutex::unlock() noexcept 180 { 181 unique_lock<mutex> lk(__m_); 182 if (--__count_ == 0) 183 { 184 __id_.__reset(); 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 203 void __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