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
18const defer_lock_t  defer_lock = {};
19const try_to_lock_t try_to_lock = {};
20const adopt_lock_t  adopt_lock = {};
21
22mutex::~mutex()
23{
24    pthread_mutex_destroy(&__m_);
25}
26
27void
28mutex::lock()
29{
30    int ec = pthread_mutex_lock(&__m_);
31    if (ec)
32        __throw_system_error(ec, "mutex lock failed");
33}
34
35bool
36mutex::try_lock() _NOEXCEPT
37{
38    return pthread_mutex_trylock(&__m_) == 0;
39}
40
41void
42mutex::unlock() _NOEXCEPT
43{
44    int ec = pthread_mutex_unlock(&__m_);
45    assert(ec == 0);
46}
47
48// recursive_mutex
49
50recursive_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;
75fail:
76    __throw_system_error(ec, "recursive_mutex constructor failed");
77}
78
79recursive_mutex::~recursive_mutex()
80{
81    int e = pthread_mutex_destroy(&__m_);
82    assert(e == 0);
83}
84
85void
86recursive_mutex::lock()
87{
88    int ec = pthread_mutex_lock(&__m_);
89    if (ec)
90        __throw_system_error(ec, "recursive_mutex lock failed");
91}
92
93void
94recursive_mutex::unlock() _NOEXCEPT
95{
96    int e = pthread_mutex_unlock(&__m_);
97    assert(e == 0);
98}
99
100bool
101recursive_mutex::try_lock() _NOEXCEPT
102{
103    return pthread_mutex_trylock(&__m_) == 0;
104}
105
106// timed_mutex
107
108timed_mutex::timed_mutex()
109    : __locked_(false)
110{
111}
112
113timed_mutex::~timed_mutex()
114{
115    lock_guard<mutex> _(__m_);
116}
117
118void
119timed_mutex::lock()
120{
121    unique_lock<mutex> lk(__m_);
122    while (__locked_)
123        __cv_.wait(lk);
124    __locked_ = true;
125}
126
127bool
128timed_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
139void
140timed_mutex::unlock() _NOEXCEPT
141{
142    lock_guard<mutex> _(__m_);
143    __locked_ = false;
144    __cv_.notify_one();
145}
146
147// recursive_timed_mutex
148
149recursive_timed_mutex::recursive_timed_mutex()
150    : __count_(0),
151      __id_(0)
152{
153}
154
155recursive_timed_mutex::~recursive_timed_mutex()
156{
157    lock_guard<mutex> _(__m_);
158}
159
160void
161recursive_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
178bool
179recursive_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
194void
195recursive_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
212static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
213static pthread_cond_t  cv  = PTHREAD_COND_INITIALIZER;
214
215void
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