1// std::mutex implementation -*- C++ -*- 
2 
3// Copyright (C) 2003-2019 Free Software Foundation, Inc. 
4// 
5// This file is part of the GNU ISO C++ Library. This library is free 
6// software; you can redistribute it and/or modify it under the 
7// terms of the GNU General Public License as published by the 
8// Free Software Foundation; either version 3, or (at your option) 
9// any later version. 
10 
11// This library is distributed in the hope that it will be useful, 
12// but WITHOUT ANY WARRANTY; without even the implied warranty of 
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
14// GNU General Public License for more details. 
15 
16// Under Section 7 of GPL version 3, you are granted additional 
17// permissions described in the GCC Runtime Library Exception, version 
18// 3.1, as published by the Free Software Foundation. 
19 
20// You should have received a copy of the GNU General Public License and 
21// a copy of the GCC Runtime Library Exception along with this program; 
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 
23// <http://www.gnu.org/licenses/>. 
24 
25/** @file bits/std_mutex.h 
26 * This is an internal header file, included by other library headers. 
27 * Do not attempt to use it directly. @headername{mutex} 
28 */ 
29 
30#ifndef _GLIBCXX_MUTEX_H 
31#define _GLIBCXX_MUTEX_H 1 
32 
33#pragma GCC system_header 
34 
35#if __cplusplus < 201103L 
36# include <bits/c++0x_warning.h> 
37#else 
38 
39#include <system_error> 
40#include <bits/functexcept.h> 
41#include <bits/gthr.h> 
42 
43namespace std _GLIBCXX_VISIBILITY(default) 
44{ 
45_GLIBCXX_BEGIN_NAMESPACE_VERSION 
46 
47 /** 
48 * @defgroup mutexes Mutexes 
49 * @ingroup concurrency 
50 * 
51 * Classes for mutex support. 
52 * @{ 
53 */ 
54 
55#ifdef _GLIBCXX_HAS_GTHREADS 
56 // Common base class for std::mutex and std::timed_mutex 
57 class __mutex_base 
58 { 
59 protected: 
60 typedef __gthread_mutex_t __native_type; 
61 
62#ifdef __GTHREAD_MUTEX_INIT 
63 __native_type _M_mutex = __GTHREAD_MUTEX_INIT; 
64 
65 constexpr __mutex_base() noexcept = default; 
66#else 
67 __native_type _M_mutex; 
68 
69 __mutex_base() noexcept 
70 { 
71 // XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may) 
72 __GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex); 
73 } 
74 
75 ~__mutex_base() noexcept { __gthread_mutex_destroy(&_M_mutex); } 
76#endif 
77 
78 __mutex_base(const __mutex_base&) = delete; 
79 __mutex_base& operator=(const __mutex_base&) = delete; 
80 }; 
81 
82 /// The standard mutex type. 
83 class mutex : private __mutex_base 
84 { 
85 public: 
86 typedef __native_type* native_handle_type; 
87 
88#ifdef __GTHREAD_MUTEX_INIT 
89 constexpr 
90#endif 
91 mutex() noexcept = default; 
92 ~mutex() = default; 
93 
94 mutex(const mutex&) = delete; 
95 mutex& operator=(const mutex&) = delete; 
96 
97 void 
98 lock() 
99 { 
100 int __e = __gthread_mutex_lock(&_M_mutex); 
101 
102 // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may) 
103 if (__e) 
104 __throw_system_error(__e); 
105 } 
106 
107 bool 
108 try_lock() noexcept 
109 { 
110 // XXX EINVAL, EAGAIN, EBUSY 
111 return !__gthread_mutex_trylock(&_M_mutex); 
112 } 
113 
114 void 
115 unlock() 
116 { 
117 // XXX EINVAL, EAGAIN, EPERM 
118 __gthread_mutex_unlock(&_M_mutex); 
119 } 
120 
121 native_handle_type 
122 native_handle() noexcept 
123 { return &_M_mutex; } 
124 }; 
125 
126#endif // _GLIBCXX_HAS_GTHREADS 
127 
128 /// Do not acquire ownership of the mutex. 
129 struct defer_lock_t { explicit defer_lock_t() = default; }; 
130 
131 /// Try to acquire ownership of the mutex without blocking. 
132 struct try_to_lock_t { explicit try_to_lock_t() = default; }; 
133 
134 /// Assume the calling thread has already obtained mutex ownership 
135 /// and manage it. 
136 struct adopt_lock_t { explicit adopt_lock_t() = default; }; 
137 
138 /// Tag used to prevent a scoped lock from acquiring ownership of a mutex. 
139 _GLIBCXX17_INLINE constexpr defer_lock_t defer_lock { }; 
140 
141 /// Tag used to prevent a scoped lock from blocking if a mutex is locked. 
142 _GLIBCXX17_INLINE constexpr try_to_lock_t try_to_lock { }; 
143 
144 /// Tag used to make a scoped lock take ownership of a locked mutex. 
145 _GLIBCXX17_INLINE constexpr adopt_lock_t adopt_lock { }; 
146 
147 /** @brief A simple scoped lock type. 
148 * 
149 * A lock_guard controls mutex ownership within a scope, releasing 
150 * ownership in the destructor. 
151 */ 
152 template<typename _Mutex> 
153 class lock_guard 
154 { 
155 public: 
156 typedef _Mutex mutex_type; 
157 
158 explicit lock_guard(mutex_type& __m) : _M_device(__m) 
159 { _M_device.lock(); } 
160 
161 lock_guard(mutex_type& __m, adopt_lock_t) noexcept : _M_device(__m) 
162 { } // calling thread owns mutex 
163 
164 ~lock_guard() 
165 { _M_device.unlock(); } 
166 
167 lock_guard(const lock_guard&) = delete; 
168 lock_guard& operator=(const lock_guard&) = delete; 
169 
170 private: 
171 mutex_type& _M_device; 
172 }; 
173 
174 // @} group mutexes 
175_GLIBCXX_END_NAMESPACE_VERSION 
176} // namespace 
177#endif // C++11 
178#endif // _GLIBCXX_MUTEX_H 
179