blob: 1183dea7c4e723534d3533ba0fd325a0eabb1a83 [file] [log] [blame]
Elliott Hughes8daa0922011-09-11 13:46:25 -07001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "mutex.h"
18
19#include <errno.h>
Ian Rogersc604d732012-10-14 16:09:54 -070020#include <sys/time.h>
Elliott Hughes8daa0922011-09-11 13:46:25 -070021
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -070022#include "atomic.h"
Elliott Hughes07ed66b2012-12-12 18:34:25 -080023#include "base/logging.h"
Vladimir Marko80afd022015-05-19 18:08:00 +010024#include "base/time_utils.h"
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -080025#include "base/systrace.h"
Ian Rogerscf7f1912014-10-22 22:06:39 -070026#include "base/value_object.h"
Ian Rogers693ff612013-02-01 10:56:12 -080027#include "mutex-inl.h"
Elliott Hughes6b355752012-01-13 16:49:08 -080028#include "runtime.h"
Mathieu Chartier0795f232016-09-27 18:43:30 -070029#include "scoped_thread_state_change-inl.h"
Ian Rogers04d7aa92013-03-16 14:29:17 -070030#include "thread-inl.h"
Elliott Hughes8daa0922011-09-11 13:46:25 -070031
32namespace art {
33
Ian Rogers719d1a32014-03-06 12:13:39 -080034Mutex* Locks::abort_lock_ = nullptr;
Brian Carlstrom306db812014-09-05 13:01:41 -070035Mutex* Locks::alloc_tracker_lock_ = nullptr;
Andreas Gampe74240812014-04-17 10:35:09 -070036Mutex* Locks::allocated_monitor_ids_lock_ = nullptr;
Chao-ying Fu9e369312014-05-21 11:20:52 -070037Mutex* Locks::allocated_thread_ids_lock_ = nullptr;
Sebastien Hertzed2be172014-08-19 15:33:43 +020038ReaderWriterMutex* Locks::breakpoint_lock_ = nullptr;
Ian Rogers719d1a32014-03-06 12:13:39 -080039ReaderWriterMutex* Locks::classlinker_classes_lock_ = nullptr;
Brian Carlstrom306db812014-09-05 13:01:41 -070040Mutex* Locks::deoptimization_lock_ = nullptr;
Ian Rogers719d1a32014-03-06 12:13:39 -080041ReaderWriterMutex* Locks::heap_bitmap_lock_ = nullptr;
Mathieu Chartier9ef78b52014-09-25 17:03:12 -070042Mutex* Locks::instrument_entrypoints_lock_ = nullptr;
Mathieu Chartiera5a53ef2014-09-12 12:58:05 -070043Mutex* Locks::intern_table_lock_ = nullptr;
Jeff Haoa2c38642015-09-17 17:29:01 -070044Mutex* Locks::interpreter_string_init_map_lock_ = nullptr;
Ian Rogers68d8b422014-07-17 11:09:10 -070045Mutex* Locks::jni_libraries_lock_ = nullptr;
Ian Rogers719d1a32014-03-06 12:13:39 -080046Mutex* Locks::logging_lock_ = nullptr;
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -070047Mutex* Locks::mem_maps_lock_ = nullptr;
Chao-ying Fu9e369312014-05-21 11:20:52 -070048Mutex* Locks::modify_ldt_lock_ = nullptr;
Yu Lieac44242015-06-29 10:50:03 +080049MutatorMutex* Locks::mutator_lock_ = nullptr;
Brian Carlstrom306db812014-09-05 13:01:41 -070050Mutex* Locks::profiler_lock_ = nullptr;
David Brazdilca3c8c32016-09-06 14:04:48 +010051Mutex* Locks::verifier_deps_lock_ = nullptr;
Mathieu Chartierf9c6fc62015-10-07 11:44:05 -070052ReaderWriterMutex* Locks::oat_file_manager_lock_ = nullptr;
Richard Uhlera206c742016-05-24 15:04:22 -070053Mutex* Locks::host_dlopen_handles_lock_ = nullptr;
Mathieu Chartiera5a53ef2014-09-12 12:58:05 -070054Mutex* Locks::reference_processor_lock_ = nullptr;
55Mutex* Locks::reference_queue_cleared_references_lock_ = nullptr;
56Mutex* Locks::reference_queue_finalizer_references_lock_ = nullptr;
57Mutex* Locks::reference_queue_phantom_references_lock_ = nullptr;
58Mutex* Locks::reference_queue_soft_references_lock_ = nullptr;
59Mutex* Locks::reference_queue_weak_references_lock_ = nullptr;
Ian Rogers719d1a32014-03-06 12:13:39 -080060Mutex* Locks::runtime_shutdown_lock_ = nullptr;
61Mutex* Locks::thread_list_lock_ = nullptr;
Mathieu Chartier91e56692015-03-03 13:51:04 -080062ConditionVariable* Locks::thread_exit_cond_ = nullptr;
Ian Rogers719d1a32014-03-06 12:13:39 -080063Mutex* Locks::thread_suspend_count_lock_ = nullptr;
64Mutex* Locks::trace_lock_ = nullptr;
Ian Rogers719d1a32014-03-06 12:13:39 -080065Mutex* Locks::unexpected_signal_lock_ = nullptr;
Andreas Gampe5bdb6552015-07-22 23:44:55 -070066Uninterruptible Roles::uninterruptible_;
Ian Rogers719d1a32014-03-06 12:13:39 -080067
68struct AllMutexData {
69 // A guard for all_mutexes_ that's not a mutex (Mutexes must CAS to acquire and busy wait).
70 Atomic<const BaseMutex*> all_mutexes_guard;
71 // All created mutexes guarded by all_mutexes_guard_.
72 std::set<BaseMutex*>* all_mutexes;
Mathieu Chartier2cebb242015-04-21 16:50:40 -070073 AllMutexData() : all_mutexes(nullptr) {}
Ian Rogers719d1a32014-03-06 12:13:39 -080074};
75static struct AllMutexData gAllMutexData[kAllMutexDataSize];
76
Ian Rogersc604d732012-10-14 16:09:54 -070077#if ART_USE_FUTEXES
78static bool ComputeRelativeTimeSpec(timespec* result_ts, const timespec& lhs, const timespec& rhs) {
Brian Carlstromfb6996f2013-07-18 18:21:14 -070079 const int32_t one_sec = 1000 * 1000 * 1000; // one second in nanoseconds.
Ian Rogersc604d732012-10-14 16:09:54 -070080 result_ts->tv_sec = lhs.tv_sec - rhs.tv_sec;
81 result_ts->tv_nsec = lhs.tv_nsec - rhs.tv_nsec;
82 if (result_ts->tv_nsec < 0) {
83 result_ts->tv_sec--;
84 result_ts->tv_nsec += one_sec;
85 } else if (result_ts->tv_nsec > one_sec) {
86 result_ts->tv_sec++;
87 result_ts->tv_nsec -= one_sec;
88 }
89 return result_ts->tv_sec < 0;
90}
91#endif
92
Ian Rogers6f3dbba2014-10-14 17:41:57 -070093class ScopedAllMutexesLock FINAL {
Ian Rogers56edc432013-01-18 16:51:51 -080094 public:
Brian Carlstrom93ba8932013-07-17 21:31:49 -070095 explicit ScopedAllMutexesLock(const BaseMutex* mutex) : mutex_(mutex) {
Ian Rogers3e5cf302014-05-20 16:40:37 -070096 while (!gAllMutexData->all_mutexes_guard.CompareExchangeWeakAcquire(0, mutex)) {
Ian Rogers56edc432013-01-18 16:51:51 -080097 NanoSleep(100);
98 }
99 }
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700100
Ian Rogers56edc432013-01-18 16:51:51 -0800101 ~ScopedAllMutexesLock() {
Ian Rogers3e5cf302014-05-20 16:40:37 -0700102 while (!gAllMutexData->all_mutexes_guard.CompareExchangeWeakRelease(mutex_, 0)) {
Ian Rogers56edc432013-01-18 16:51:51 -0800103 NanoSleep(100);
104 }
105 }
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700106
Ian Rogers56edc432013-01-18 16:51:51 -0800107 private:
108 const BaseMutex* const mutex_;
109};
Ian Rogers56edc432013-01-18 16:51:51 -0800110
Ian Rogerscf7f1912014-10-22 22:06:39 -0700111// Scoped class that generates events at the beginning and end of lock contention.
112class ScopedContentionRecorder FINAL : public ValueObject {
113 public:
114 ScopedContentionRecorder(BaseMutex* mutex, uint64_t blocked_tid, uint64_t owner_tid)
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700115 : mutex_(kLogLockContentions ? mutex : nullptr),
Ian Rogerscf7f1912014-10-22 22:06:39 -0700116 blocked_tid_(kLogLockContentions ? blocked_tid : 0),
117 owner_tid_(kLogLockContentions ? owner_tid : 0),
118 start_nano_time_(kLogLockContentions ? NanoTime() : 0) {
119 if (ATRACE_ENABLED()) {
120 std::string msg = StringPrintf("Lock contention on %s (owner tid: %" PRIu64 ")",
121 mutex->GetName(), owner_tid);
122 ATRACE_BEGIN(msg.c_str());
123 }
124 }
125
126 ~ScopedContentionRecorder() {
127 ATRACE_END();
128 if (kLogLockContentions) {
129 uint64_t end_nano_time = NanoTime();
130 mutex_->RecordContention(blocked_tid_, owner_tid_, end_nano_time - start_nano_time_);
131 }
132 }
133
134 private:
135 BaseMutex* const mutex_;
136 const uint64_t blocked_tid_;
137 const uint64_t owner_tid_;
138 const uint64_t start_nano_time_;
139};
140
Ian Rogers56edc432013-01-18 16:51:51 -0800141BaseMutex::BaseMutex(const char* name, LockLevel level) : level_(level), name_(name) {
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700142 if (kLogLockContentions) {
143 ScopedAllMutexesLock mu(this);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700144 std::set<BaseMutex*>** all_mutexes_ptr = &gAllMutexData->all_mutexes;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700145 if (*all_mutexes_ptr == nullptr) {
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700146 // We leak the global set of all mutexes to avoid ordering issues in global variable
147 // construction/destruction.
148 *all_mutexes_ptr = new std::set<BaseMutex*>();
149 }
150 (*all_mutexes_ptr)->insert(this);
Ian Rogers56edc432013-01-18 16:51:51 -0800151 }
Ian Rogers56edc432013-01-18 16:51:51 -0800152}
153
154BaseMutex::~BaseMutex() {
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700155 if (kLogLockContentions) {
156 ScopedAllMutexesLock mu(this);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700157 gAllMutexData->all_mutexes->erase(this);
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700158 }
Ian Rogers56edc432013-01-18 16:51:51 -0800159}
160
161void BaseMutex::DumpAll(std::ostream& os) {
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700162 if (kLogLockContentions) {
163 os << "Mutex logging:\n";
164 ScopedAllMutexesLock mu(reinterpret_cast<const BaseMutex*>(-1));
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700165 std::set<BaseMutex*>* all_mutexes = gAllMutexData->all_mutexes;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700166 if (all_mutexes == nullptr) {
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700167 // No mutexes have been created yet during at startup.
168 return;
169 }
170 typedef std::set<BaseMutex*>::const_iterator It;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700171 os << "(Contended)\n";
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700172 for (It it = all_mutexes->begin(); it != all_mutexes->end(); ++it) {
173 BaseMutex* mutex = *it;
174 if (mutex->HasEverContended()) {
175 mutex->Dump(os);
176 os << "\n";
177 }
178 }
179 os << "(Never contented)\n";
180 for (It it = all_mutexes->begin(); it != all_mutexes->end(); ++it) {
181 BaseMutex* mutex = *it;
182 if (!mutex->HasEverContended()) {
183 mutex->Dump(os);
184 os << "\n";
185 }
186 }
Ian Rogers56edc432013-01-18 16:51:51 -0800187 }
Ian Rogers56edc432013-01-18 16:51:51 -0800188}
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700189
Ian Rogers81d425b2012-09-27 16:03:43 -0700190void BaseMutex::CheckSafeToWait(Thread* self) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700191 if (self == nullptr) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700192 CheckUnattachedThread(level_);
193 return;
194 }
Ian Rogers25fd14b2012-09-05 10:56:38 -0700195 if (kDebugLocking) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700196 CHECK(self->GetHeldMutex(level_) == this || level_ == kMonitorLock)
197 << "Waiting on unacquired mutex: " << name_;
Ian Rogers25fd14b2012-09-05 10:56:38 -0700198 bool bad_mutexes_held = false;
Elliott Hughes0f827162013-02-26 12:12:58 -0800199 for (int i = kLockLevelCount - 1; i >= 0; --i) {
Ian Rogers25fd14b2012-09-05 10:56:38 -0700200 if (i != level_) {
Ian Rogers81d425b2012-09-27 16:03:43 -0700201 BaseMutex* held_mutex = self->GetHeldMutex(static_cast<LockLevel>(i));
Ian Rogersf3d874c2014-07-17 18:52:42 -0700202 // We expect waits to happen while holding the thread list suspend thread lock.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700203 if (held_mutex != nullptr) {
Elliott Hughes0f827162013-02-26 12:12:58 -0800204 LOG(ERROR) << "Holding \"" << held_mutex->name_ << "\" "
205 << "(level " << LockLevel(i) << ") while performing wait on "
206 << "\"" << name_ << "\" (level " << level_ << ")";
Ian Rogers25fd14b2012-09-05 10:56:38 -0700207 bad_mutexes_held = true;
208 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700209 }
210 }
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000211 if (gAborting == 0) { // Avoid recursive aborts.
212 CHECK(!bad_mutexes_held);
213 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700214 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700215}
216
Ian Rogers37f3c962014-07-17 11:25:30 -0700217void BaseMutex::ContentionLogData::AddToWaitTime(uint64_t value) {
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700218 if (kLogLockContentions) {
219 // Atomically add value to wait_time.
Ian Rogers37f3c962014-07-17 11:25:30 -0700220 wait_time.FetchAndAddSequentiallyConsistent(value);
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700221 }
222}
223
Brian Carlstrom0de79852013-07-25 22:29:58 -0700224void BaseMutex::RecordContention(uint64_t blocked_tid,
225 uint64_t owner_tid,
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700226 uint64_t nano_time_blocked) {
227 if (kLogLockContentions) {
Ian Rogers3e5cf302014-05-20 16:40:37 -0700228 ContentionLogData* data = contention_log_data_;
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700229 ++(data->contention_count);
230 data->AddToWaitTime(nano_time_blocked);
231 ContentionLogEntry* log = data->contention_log;
232 // This code is intentionally racy as it is only used for diagnostics.
Ian Rogers3e5cf302014-05-20 16:40:37 -0700233 uint32_t slot = data->cur_content_log_entry.LoadRelaxed();
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700234 if (log[slot].blocked_tid == blocked_tid &&
235 log[slot].owner_tid == blocked_tid) {
236 ++log[slot].count;
237 } else {
238 uint32_t new_slot;
239 do {
Ian Rogers3e5cf302014-05-20 16:40:37 -0700240 slot = data->cur_content_log_entry.LoadRelaxed();
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700241 new_slot = (slot + 1) % kContentionLogSize;
Ian Rogers3e5cf302014-05-20 16:40:37 -0700242 } while (!data->cur_content_log_entry.CompareExchangeWeakRelaxed(slot, new_slot));
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700243 log[new_slot].blocked_tid = blocked_tid;
244 log[new_slot].owner_tid = owner_tid;
Ian Rogers3e5cf302014-05-20 16:40:37 -0700245 log[new_slot].count.StoreRelaxed(1);
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700246 }
Ian Rogers56edc432013-01-18 16:51:51 -0800247 }
Ian Rogers56edc432013-01-18 16:51:51 -0800248}
249
Ian Rogers56edc432013-01-18 16:51:51 -0800250void BaseMutex::DumpContention(std::ostream& os) const {
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700251 if (kLogLockContentions) {
Ian Rogers3e5cf302014-05-20 16:40:37 -0700252 const ContentionLogData* data = contention_log_data_;
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700253 const ContentionLogEntry* log = data->contention_log;
Ian Rogers37f3c962014-07-17 11:25:30 -0700254 uint64_t wait_time = data->wait_time.LoadRelaxed();
Ian Rogers3e5cf302014-05-20 16:40:37 -0700255 uint32_t contention_count = data->contention_count.LoadRelaxed();
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700256 if (contention_count == 0) {
257 os << "never contended";
258 } else {
259 os << "contended " << contention_count
Mathieu Chartier73d1e172014-04-11 17:53:48 -0700260 << " total wait of contender " << PrettyDuration(wait_time)
261 << " average " << PrettyDuration(wait_time / contention_count);
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700262 SafeMap<uint64_t, size_t> most_common_blocker;
263 SafeMap<uint64_t, size_t> most_common_blocked;
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700264 for (size_t i = 0; i < kContentionLogSize; ++i) {
265 uint64_t blocked_tid = log[i].blocked_tid;
266 uint64_t owner_tid = log[i].owner_tid;
Ian Rogers3e5cf302014-05-20 16:40:37 -0700267 uint32_t count = log[i].count.LoadRelaxed();
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700268 if (count > 0) {
Mathieu Chartier73d1e172014-04-11 17:53:48 -0700269 auto it = most_common_blocked.find(blocked_tid);
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700270 if (it != most_common_blocked.end()) {
271 most_common_blocked.Overwrite(blocked_tid, it->second + count);
272 } else {
273 most_common_blocked.Put(blocked_tid, count);
274 }
275 it = most_common_blocker.find(owner_tid);
276 if (it != most_common_blocker.end()) {
277 most_common_blocker.Overwrite(owner_tid, it->second + count);
278 } else {
279 most_common_blocker.Put(owner_tid, count);
280 }
Ian Rogers56edc432013-01-18 16:51:51 -0800281 }
282 }
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700283 uint64_t max_tid = 0;
284 size_t max_tid_count = 0;
Mathieu Chartier73d1e172014-04-11 17:53:48 -0700285 for (const auto& pair : most_common_blocked) {
286 if (pair.second > max_tid_count) {
287 max_tid = pair.first;
288 max_tid_count = pair.second;
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700289 }
Ian Rogers56edc432013-01-18 16:51:51 -0800290 }
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700291 if (max_tid != 0) {
292 os << " sample shows most blocked tid=" << max_tid;
Ian Rogers56edc432013-01-18 16:51:51 -0800293 }
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700294 max_tid = 0;
295 max_tid_count = 0;
Mathieu Chartier73d1e172014-04-11 17:53:48 -0700296 for (const auto& pair : most_common_blocker) {
297 if (pair.second > max_tid_count) {
298 max_tid = pair.first;
299 max_tid_count = pair.second;
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700300 }
301 }
302 if (max_tid != 0) {
303 os << " sample shows tid=" << max_tid << " owning during this time";
304 }
Ian Rogers56edc432013-01-18 16:51:51 -0800305 }
306 }
Ian Rogers56edc432013-01-18 16:51:51 -0800307}
308
309
Ian Rogers81d425b2012-09-27 16:03:43 -0700310Mutex::Mutex(const char* name, LockLevel level, bool recursive)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700311 : BaseMutex(name, level), recursive_(recursive), recursion_count_(0) {
Ian Rogersc604d732012-10-14 16:09:54 -0700312#if ART_USE_FUTEXES
Ian Rogersc7190692014-07-08 23:50:26 -0700313 DCHECK_EQ(0, state_.LoadRelaxed());
Ian Rogers3e5cf302014-05-20 16:40:37 -0700314 DCHECK_EQ(0, num_contenders_.LoadRelaxed());
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700315#else
Ian Rogersc5f17732014-06-05 20:48:42 -0700316 CHECK_MUTEX_CALL(pthread_mutex_init, (&mutex_, nullptr));
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700317#endif
Ian Rogersc5f17732014-06-05 20:48:42 -0700318 exclusive_owner_ = 0;
Elliott Hughes8daa0922011-09-11 13:46:25 -0700319}
320
Andreas Gampe8f1fa102015-01-22 19:48:51 -0800321// Helper to ignore the lock requirement.
322static bool IsShuttingDown() NO_THREAD_SAFETY_ANALYSIS {
323 Runtime* runtime = Runtime::Current();
324 return runtime == nullptr || runtime->IsShuttingDownLocked();
325}
326
Elliott Hughes8daa0922011-09-11 13:46:25 -0700327Mutex::~Mutex() {
Andreas Gampe8f1fa102015-01-22 19:48:51 -0800328 bool shutting_down = IsShuttingDown();
Ian Rogersc604d732012-10-14 16:09:54 -0700329#if ART_USE_FUTEXES
Ian Rogersc7190692014-07-08 23:50:26 -0700330 if (state_.LoadRelaxed() != 0) {
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700331 LOG(shutting_down
332 ? ::android::base::WARNING
333 : ::android::base::FATAL) << "destroying mutex with owner: " << exclusive_owner_;
Ian Rogersc604d732012-10-14 16:09:54 -0700334 } else {
Andreas Gampe8f1fa102015-01-22 19:48:51 -0800335 if (exclusive_owner_ != 0) {
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700336 LOG(shutting_down
337 ? ::android::base::WARNING
338 : ::android::base::FATAL) << "unexpectedly found an owner on unlocked mutex "
Andreas Gampe8f1fa102015-01-22 19:48:51 -0800339 << name_;
340 }
341 if (num_contenders_.LoadSequentiallyConsistent() != 0) {
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700342 LOG(shutting_down
343 ? ::android::base::WARNING
344 : ::android::base::FATAL) << "unexpectedly found a contender on mutex " << name_;
Mathieu Chartiercef50f02014-12-09 17:38:52 -0800345 }
Ian Rogersc604d732012-10-14 16:09:54 -0700346 }
347#else
Elliott Hughese62934d2012-04-09 11:24:29 -0700348 // We can't use CHECK_MUTEX_CALL here because on shutdown a suspended daemon thread
349 // may still be using locks.
Elliott Hughes6b355752012-01-13 16:49:08 -0800350 int rc = pthread_mutex_destroy(&mutex_);
351 if (rc != 0) {
352 errno = rc;
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800353 // TODO: should we just not log at all if shutting down? this could be the logging mutex!
Ian Rogers50b35e22012-10-04 10:09:15 -0700354 MutexLock mu(Thread::Current(), *Locks::runtime_shutdown_lock_);
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700355 PLOG(shutting_down
356 ? ::android::base::WARNING
357 : ::android::base::FATAL) << "pthread_mutex_destroy failed for " << name_;
Elliott Hughes6b355752012-01-13 16:49:08 -0800358 }
Ian Rogersc604d732012-10-14 16:09:54 -0700359#endif
Elliott Hughes8daa0922011-09-11 13:46:25 -0700360}
361
Ian Rogers81d425b2012-09-27 16:03:43 -0700362void Mutex::ExclusiveLock(Thread* self) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700363 DCHECK(self == nullptr || self == Thread::Current());
Ian Rogers25fd14b2012-09-05 10:56:38 -0700364 if (kDebugLocking && !recursive_) {
Ian Rogers81d425b2012-09-27 16:03:43 -0700365 AssertNotHeld(self);
Ian Rogers25fd14b2012-09-05 10:56:38 -0700366 }
Ian Rogers81d425b2012-09-27 16:03:43 -0700367 if (!recursive_ || !IsExclusiveHeld(self)) {
Ian Rogersc604d732012-10-14 16:09:54 -0700368#if ART_USE_FUTEXES
369 bool done = false;
370 do {
Ian Rogersc7190692014-07-08 23:50:26 -0700371 int32_t cur_state = state_.LoadRelaxed();
Hiroshi Yamauchi967a0ad2013-09-10 16:24:21 -0700372 if (LIKELY(cur_state == 0)) {
Ian Rogersc7190692014-07-08 23:50:26 -0700373 // Change state from 0 to 1 and impose load/store ordering appropriate for lock acquisition.
374 done = state_.CompareExchangeWeakAcquire(0 /* cur_state */, 1 /* new state */);
Ian Rogersc604d732012-10-14 16:09:54 -0700375 } else {
376 // Failed to acquire, hang up.
Hiroshi Yamauchib3733082013-08-12 17:28:49 -0700377 ScopedContentionRecorder scr(this, SafeGetTid(self), GetExclusiveOwnerTid());
Ian Rogersb122a4b2013-11-19 18:00:50 -0800378 num_contenders_++;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700379 if (futex(state_.Address(), FUTEX_WAIT, 1, nullptr, nullptr, 0) != 0) {
Brian Carlstrom0de79852013-07-25 22:29:58 -0700380 // EAGAIN and EINTR both indicate a spurious failure, try again from the beginning.
381 // We don't use TEMP_FAILURE_RETRY so we can intentionally retry to acquire the lock.
382 if ((errno != EAGAIN) && (errno != EINTR)) {
Ian Rogersc604d732012-10-14 16:09:54 -0700383 PLOG(FATAL) << "futex wait failed for " << name_;
384 }
385 }
Ian Rogersb122a4b2013-11-19 18:00:50 -0800386 num_contenders_--;
Ian Rogersc604d732012-10-14 16:09:54 -0700387 }
Brian Carlstromdf629502013-07-17 22:39:56 -0700388 } while (!done);
Ian Rogersc7190692014-07-08 23:50:26 -0700389 DCHECK_EQ(state_.LoadRelaxed(), 1);
Ian Rogersc604d732012-10-14 16:09:54 -0700390#else
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700391 CHECK_MUTEX_CALL(pthread_mutex_lock, (&mutex_));
Ian Rogersc604d732012-10-14 16:09:54 -0700392#endif
Ian Rogersc5f17732014-06-05 20:48:42 -0700393 DCHECK_EQ(exclusive_owner_, 0U);
394 exclusive_owner_ = SafeGetTid(self);
Ian Rogers81d425b2012-09-27 16:03:43 -0700395 RegisterAsLocked(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700396 }
397 recursion_count_++;
Ian Rogers25fd14b2012-09-05 10:56:38 -0700398 if (kDebugLocking) {
399 CHECK(recursion_count_ == 1 || recursive_) << "Unexpected recursion count on mutex: "
400 << name_ << " " << recursion_count_;
Ian Rogers81d425b2012-09-27 16:03:43 -0700401 AssertHeld(self);
Ian Rogers25fd14b2012-09-05 10:56:38 -0700402 }
Elliott Hughes8daa0922011-09-11 13:46:25 -0700403}
404
Ian Rogers81d425b2012-09-27 16:03:43 -0700405bool Mutex::ExclusiveTryLock(Thread* self) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700406 DCHECK(self == nullptr || self == Thread::Current());
Ian Rogers25fd14b2012-09-05 10:56:38 -0700407 if (kDebugLocking && !recursive_) {
Ian Rogers81d425b2012-09-27 16:03:43 -0700408 AssertNotHeld(self);
Ian Rogers25fd14b2012-09-05 10:56:38 -0700409 }
Ian Rogers81d425b2012-09-27 16:03:43 -0700410 if (!recursive_ || !IsExclusiveHeld(self)) {
Ian Rogersc604d732012-10-14 16:09:54 -0700411#if ART_USE_FUTEXES
412 bool done = false;
413 do {
Ian Rogersc7190692014-07-08 23:50:26 -0700414 int32_t cur_state = state_.LoadRelaxed();
Ian Rogersc604d732012-10-14 16:09:54 -0700415 if (cur_state == 0) {
Ian Rogersc7190692014-07-08 23:50:26 -0700416 // Change state from 0 to 1 and impose load/store ordering appropriate for lock acquisition.
417 done = state_.CompareExchangeWeakAcquire(0 /* cur_state */, 1 /* new state */);
Ian Rogersc604d732012-10-14 16:09:54 -0700418 } else {
419 return false;
420 }
Brian Carlstromdf629502013-07-17 22:39:56 -0700421 } while (!done);
Ian Rogersc7190692014-07-08 23:50:26 -0700422 DCHECK_EQ(state_.LoadRelaxed(), 1);
Ian Rogersc604d732012-10-14 16:09:54 -0700423#else
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700424 int result = pthread_mutex_trylock(&mutex_);
425 if (result == EBUSY) {
426 return false;
427 }
428 if (result != 0) {
429 errno = result;
430 PLOG(FATAL) << "pthread_mutex_trylock failed for " << name_;
431 }
Ian Rogersc604d732012-10-14 16:09:54 -0700432#endif
Ian Rogersc5f17732014-06-05 20:48:42 -0700433 DCHECK_EQ(exclusive_owner_, 0U);
434 exclusive_owner_ = SafeGetTid(self);
Ian Rogers81d425b2012-09-27 16:03:43 -0700435 RegisterAsLocked(self);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700436 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700437 recursion_count_++;
Ian Rogers25fd14b2012-09-05 10:56:38 -0700438 if (kDebugLocking) {
439 CHECK(recursion_count_ == 1 || recursive_) << "Unexpected recursion count on mutex: "
440 << name_ << " " << recursion_count_;
Ian Rogers81d425b2012-09-27 16:03:43 -0700441 AssertHeld(self);
Ian Rogers25fd14b2012-09-05 10:56:38 -0700442 }
Elliott Hughes8daa0922011-09-11 13:46:25 -0700443 return true;
444}
445
Ian Rogers81d425b2012-09-27 16:03:43 -0700446void Mutex::ExclusiveUnlock(Thread* self) {
Mathieu Chartiereb0a1792014-12-15 17:23:45 -0800447 if (kIsDebugBuild && self != nullptr && self != Thread::Current()) {
448 std::string name1 = "<null>";
449 std::string name2 = "<null>";
450 if (self != nullptr) {
451 self->GetThreadName(name1);
452 }
453 if (Thread::Current() != nullptr) {
454 Thread::Current()->GetThreadName(name2);
455 }
Mathieu Chartier4c101102015-01-27 17:14:16 -0800456 LOG(FATAL) << GetName() << " level=" << level_ << " self=" << name1
457 << " Thread::Current()=" << name2;
Mathieu Chartiereb0a1792014-12-15 17:23:45 -0800458 }
Ian Rogers81d425b2012-09-27 16:03:43 -0700459 AssertHeld(self);
Ian Rogersc5f17732014-06-05 20:48:42 -0700460 DCHECK_NE(exclusive_owner_, 0U);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700461 recursion_count_--;
462 if (!recursive_ || recursion_count_ == 0) {
Ian Rogers25fd14b2012-09-05 10:56:38 -0700463 if (kDebugLocking) {
464 CHECK(recursion_count_ == 0 || recursive_) << "Unexpected recursion count on mutex: "
465 << name_ << " " << recursion_count_;
466 }
Ian Rogers81d425b2012-09-27 16:03:43 -0700467 RegisterAsUnlocked(self);
Ian Rogersc604d732012-10-14 16:09:54 -0700468#if ART_USE_FUTEXES
Ian Rogersc5f17732014-06-05 20:48:42 -0700469 bool done = false;
470 do {
Ian Rogersc7190692014-07-08 23:50:26 -0700471 int32_t cur_state = state_.LoadRelaxed();
Ian Rogersc5f17732014-06-05 20:48:42 -0700472 if (LIKELY(cur_state == 1)) {
Ian Rogersc5f17732014-06-05 20:48:42 -0700473 // We're no longer the owner.
474 exclusive_owner_ = 0;
Ian Rogersc7190692014-07-08 23:50:26 -0700475 // Change state to 0 and impose load/store ordering appropriate for lock release.
476 // Note, the relaxed loads below musn't reorder before the CompareExchange.
477 // TODO: the ordering here is non-trivial as state is split across 3 fields, fix by placing
478 // a status bit into the state on contention.
479 done = state_.CompareExchangeWeakSequentiallyConsistent(cur_state, 0 /* new state */);
Ian Rogersc5f17732014-06-05 20:48:42 -0700480 if (LIKELY(done)) { // Spurious fail?
Ian Rogersc7190692014-07-08 23:50:26 -0700481 // Wake a contender.
Ian Rogersc5f17732014-06-05 20:48:42 -0700482 if (UNLIKELY(num_contenders_.LoadRelaxed() > 0)) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700483 futex(state_.Address(), FUTEX_WAKE, 1, nullptr, nullptr, 0);
Ian Rogersc5f17732014-06-05 20:48:42 -0700484 }
485 }
486 } else {
487 // Logging acquires the logging lock, avoid infinite recursion in that case.
488 if (this != Locks::logging_lock_) {
489 LOG(FATAL) << "Unexpected state_ in unlock " << cur_state << " for " << name_;
490 } else {
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700491 LogHelper::LogLineLowStack(__FILE__,
492 __LINE__,
493 ::android::base::FATAL_WITHOUT_ABORT,
494 StringPrintf("Unexpected state_ %d in unlock for %s",
495 cur_state, name_).c_str());
Ian Rogersc5f17732014-06-05 20:48:42 -0700496 _exit(1);
Ian Rogersc604d732012-10-14 16:09:54 -0700497 }
498 }
Ian Rogersc5f17732014-06-05 20:48:42 -0700499 } while (!done);
Ian Rogersc604d732012-10-14 16:09:54 -0700500#else
Ian Rogersc5f17732014-06-05 20:48:42 -0700501 exclusive_owner_ = 0;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700502 CHECK_MUTEX_CALL(pthread_mutex_unlock, (&mutex_));
Ian Rogersc604d732012-10-14 16:09:54 -0700503#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700504 }
Elliott Hughes8daa0922011-09-11 13:46:25 -0700505}
506
Ian Rogers56edc432013-01-18 16:51:51 -0800507void Mutex::Dump(std::ostream& os) const {
508 os << (recursive_ ? "recursive " : "non-recursive ")
509 << name_
510 << " level=" << static_cast<int>(level_)
511 << " rec=" << recursion_count_
512 << " owner=" << GetExclusiveOwnerTid() << " ";
513 DumpContention(os);
Ian Rogers01ae5802012-09-28 16:14:01 -0700514}
515
516std::ostream& operator<<(std::ostream& os, const Mutex& mu) {
Ian Rogers56edc432013-01-18 16:51:51 -0800517 mu.Dump(os);
518 return os;
Ian Rogers01ae5802012-09-28 16:14:01 -0700519}
520
Brian Carlstrom02c8cc62013-07-18 15:54:44 -0700521ReaderWriterMutex::ReaderWriterMutex(const char* name, LockLevel level)
522 : BaseMutex(name, level)
Ian Rogers81d425b2012-09-27 16:03:43 -0700523#if ART_USE_FUTEXES
Ian Rogersc5f17732014-06-05 20:48:42 -0700524 , state_(0), num_pending_readers_(0), num_pending_writers_(0)
Ian Rogers81d425b2012-09-27 16:03:43 -0700525#endif
Brian Carlstrom7934ac22013-07-26 10:54:15 -0700526{ // NOLINT(whitespace/braces)
Ian Rogers81d425b2012-09-27 16:03:43 -0700527#if !ART_USE_FUTEXES
Ian Rogersc5f17732014-06-05 20:48:42 -0700528 CHECK_MUTEX_CALL(pthread_rwlock_init, (&rwlock_, nullptr));
Ian Rogers81d425b2012-09-27 16:03:43 -0700529#endif
Ian Rogersc5f17732014-06-05 20:48:42 -0700530 exclusive_owner_ = 0;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700531}
532
533ReaderWriterMutex::~ReaderWriterMutex() {
Ian Rogers81d425b2012-09-27 16:03:43 -0700534#if ART_USE_FUTEXES
Ian Rogersc7190692014-07-08 23:50:26 -0700535 CHECK_EQ(state_.LoadRelaxed(), 0);
Ian Rogers81d425b2012-09-27 16:03:43 -0700536 CHECK_EQ(exclusive_owner_, 0U);
Ian Rogersc7190692014-07-08 23:50:26 -0700537 CHECK_EQ(num_pending_readers_.LoadRelaxed(), 0);
Ian Rogers3e5cf302014-05-20 16:40:37 -0700538 CHECK_EQ(num_pending_writers_.LoadRelaxed(), 0);
Ian Rogers81d425b2012-09-27 16:03:43 -0700539#else
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700540 // We can't use CHECK_MUTEX_CALL here because on shutdown a suspended daemon thread
541 // may still be using locks.
542 int rc = pthread_rwlock_destroy(&rwlock_);
543 if (rc != 0) {
544 errno = rc;
545 // TODO: should we just not log at all if shutting down? this could be the logging mutex!
Ian Rogers50b35e22012-10-04 10:09:15 -0700546 MutexLock mu(Thread::Current(), *Locks::runtime_shutdown_lock_);
Ian Rogers120f1c72012-09-28 17:17:10 -0700547 Runtime* runtime = Runtime::Current();
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700548 bool shutting_down = runtime == nullptr || runtime->IsShuttingDownLocked();
Ian Rogers120f1c72012-09-28 17:17:10 -0700549 PLOG(shutting_down ? WARNING : FATAL) << "pthread_rwlock_destroy failed for " << name_;
Brian Carlstromcd74c4b2012-01-23 13:21:00 -0800550 }
Ian Rogers81d425b2012-09-27 16:03:43 -0700551#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700552}
553
Ian Rogers81d425b2012-09-27 16:03:43 -0700554void ReaderWriterMutex::ExclusiveLock(Thread* self) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700555 DCHECK(self == nullptr || self == Thread::Current());
Ian Rogers81d425b2012-09-27 16:03:43 -0700556 AssertNotExclusiveHeld(self);
557#if ART_USE_FUTEXES
558 bool done = false;
559 do {
Ian Rogersc7190692014-07-08 23:50:26 -0700560 int32_t cur_state = state_.LoadRelaxed();
Hiroshi Yamauchi967a0ad2013-09-10 16:24:21 -0700561 if (LIKELY(cur_state == 0)) {
Ian Rogersc7190692014-07-08 23:50:26 -0700562 // Change state from 0 to -1 and impose load/store ordering appropriate for lock acquisition.
563 done = state_.CompareExchangeWeakAcquire(0 /* cur_state*/, -1 /* new state */);
Ian Rogers81d425b2012-09-27 16:03:43 -0700564 } else {
565 // Failed to acquire, hang up.
Hiroshi Yamauchib3733082013-08-12 17:28:49 -0700566 ScopedContentionRecorder scr(this, SafeGetTid(self), GetExclusiveOwnerTid());
Ian Rogersc7190692014-07-08 23:50:26 -0700567 ++num_pending_writers_;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700568 if (futex(state_.Address(), FUTEX_WAIT, cur_state, nullptr, nullptr, 0) != 0) {
Brian Carlstrom0de79852013-07-25 22:29:58 -0700569 // EAGAIN and EINTR both indicate a spurious failure, try again from the beginning.
570 // We don't use TEMP_FAILURE_RETRY so we can intentionally retry to acquire the lock.
571 if ((errno != EAGAIN) && (errno != EINTR)) {
Ian Rogers81d425b2012-09-27 16:03:43 -0700572 PLOG(FATAL) << "futex wait failed for " << name_;
573 }
574 }
Ian Rogersc7190692014-07-08 23:50:26 -0700575 --num_pending_writers_;
Ian Rogers81d425b2012-09-27 16:03:43 -0700576 }
Brian Carlstromdf629502013-07-17 22:39:56 -0700577 } while (!done);
Ian Rogersc7190692014-07-08 23:50:26 -0700578 DCHECK_EQ(state_.LoadRelaxed(), -1);
Ian Rogers81d425b2012-09-27 16:03:43 -0700579#else
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700580 CHECK_MUTEX_CALL(pthread_rwlock_wrlock, (&rwlock_));
Ian Rogers81d425b2012-09-27 16:03:43 -0700581#endif
Ian Rogersc5f17732014-06-05 20:48:42 -0700582 DCHECK_EQ(exclusive_owner_, 0U);
583 exclusive_owner_ = SafeGetTid(self);
Ian Rogers81d425b2012-09-27 16:03:43 -0700584 RegisterAsLocked(self);
585 AssertExclusiveHeld(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700586}
587
Ian Rogers81d425b2012-09-27 16:03:43 -0700588void ReaderWriterMutex::ExclusiveUnlock(Thread* self) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700589 DCHECK(self == nullptr || self == Thread::Current());
Ian Rogers81d425b2012-09-27 16:03:43 -0700590 AssertExclusiveHeld(self);
591 RegisterAsUnlocked(self);
Ian Rogersc5f17732014-06-05 20:48:42 -0700592 DCHECK_NE(exclusive_owner_, 0U);
Ian Rogers81d425b2012-09-27 16:03:43 -0700593#if ART_USE_FUTEXES
594 bool done = false;
595 do {
Ian Rogersc7190692014-07-08 23:50:26 -0700596 int32_t cur_state = state_.LoadRelaxed();
Hiroshi Yamauchi967a0ad2013-09-10 16:24:21 -0700597 if (LIKELY(cur_state == -1)) {
Ian Rogers81d425b2012-09-27 16:03:43 -0700598 // We're no longer the owner.
599 exclusive_owner_ = 0;
Ian Rogersc7190692014-07-08 23:50:26 -0700600 // Change state from -1 to 0 and impose load/store ordering appropriate for lock release.
601 // Note, the relaxed loads below musn't reorder before the CompareExchange.
602 // TODO: the ordering here is non-trivial as state is split across 3 fields, fix by placing
603 // a status bit into the state on contention.
604 done = state_.CompareExchangeWeakSequentiallyConsistent(-1 /* cur_state*/, 0 /* new state */);
605 if (LIKELY(done)) { // Weak CAS may fail spuriously.
Ian Rogers81d425b2012-09-27 16:03:43 -0700606 // Wake any waiters.
Ian Rogersc7190692014-07-08 23:50:26 -0700607 if (UNLIKELY(num_pending_readers_.LoadRelaxed() > 0 ||
608 num_pending_writers_.LoadRelaxed() > 0)) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700609 futex(state_.Address(), FUTEX_WAKE, -1, nullptr, nullptr, 0);
Ian Rogers81d425b2012-09-27 16:03:43 -0700610 }
611 }
612 } else {
613 LOG(FATAL) << "Unexpected state_:" << cur_state << " for " << name_;
614 }
Brian Carlstromdf629502013-07-17 22:39:56 -0700615 } while (!done);
Ian Rogers81d425b2012-09-27 16:03:43 -0700616#else
Ian Rogersc5f17732014-06-05 20:48:42 -0700617 exclusive_owner_ = 0;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700618 CHECK_MUTEX_CALL(pthread_rwlock_unlock, (&rwlock_));
Ian Rogers81d425b2012-09-27 16:03:43 -0700619#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700620}
621
Ian Rogers66aee5c2012-08-15 17:17:47 -0700622#if HAVE_TIMED_RWLOCK
Ian Rogersc604d732012-10-14 16:09:54 -0700623bool ReaderWriterMutex::ExclusiveLockWithTimeout(Thread* self, int64_t ms, int32_t ns) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700624 DCHECK(self == nullptr || self == Thread::Current());
Ian Rogers81d425b2012-09-27 16:03:43 -0700625#if ART_USE_FUTEXES
626 bool done = false;
Ian Rogersc604d732012-10-14 16:09:54 -0700627 timespec end_abs_ts;
tony.ys_liu071e48e2015-01-14 18:28:03 +0800628 InitTimeSpec(true, CLOCK_MONOTONIC, ms, ns, &end_abs_ts);
Ian Rogers81d425b2012-09-27 16:03:43 -0700629 do {
Ian Rogersc7190692014-07-08 23:50:26 -0700630 int32_t cur_state = state_.LoadRelaxed();
Ian Rogers81d425b2012-09-27 16:03:43 -0700631 if (cur_state == 0) {
Ian Rogersc7190692014-07-08 23:50:26 -0700632 // Change state from 0 to -1 and impose load/store ordering appropriate for lock acquisition.
633 done = state_.CompareExchangeWeakAcquire(0 /* cur_state */, -1 /* new state */);
Ian Rogers81d425b2012-09-27 16:03:43 -0700634 } else {
635 // Failed to acquire, hang up.
Ian Rogersc604d732012-10-14 16:09:54 -0700636 timespec now_abs_ts;
tony.ys_liu071e48e2015-01-14 18:28:03 +0800637 InitTimeSpec(true, CLOCK_MONOTONIC, 0, 0, &now_abs_ts);
Ian Rogersc604d732012-10-14 16:09:54 -0700638 timespec rel_ts;
639 if (ComputeRelativeTimeSpec(&rel_ts, end_abs_ts, now_abs_ts)) {
640 return false; // Timed out.
641 }
Hiroshi Yamauchib3733082013-08-12 17:28:49 -0700642 ScopedContentionRecorder scr(this, SafeGetTid(self), GetExclusiveOwnerTid());
Ian Rogersc7190692014-07-08 23:50:26 -0700643 ++num_pending_writers_;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700644 if (futex(state_.Address(), FUTEX_WAIT, cur_state, &rel_ts, nullptr, 0) != 0) {
Ian Rogers81d425b2012-09-27 16:03:43 -0700645 if (errno == ETIMEDOUT) {
Ian Rogersc7190692014-07-08 23:50:26 -0700646 --num_pending_writers_;
Ian Rogersc604d732012-10-14 16:09:54 -0700647 return false; // Timed out.
Brian Carlstrom0de79852013-07-25 22:29:58 -0700648 } else if ((errno != EAGAIN) && (errno != EINTR)) {
649 // EAGAIN and EINTR both indicate a spurious failure,
650 // recompute the relative time out from now and try again.
651 // We don't use TEMP_FAILURE_RETRY so we can recompute rel_ts;
Ian Rogers81d425b2012-09-27 16:03:43 -0700652 PLOG(FATAL) << "timed futex wait failed for " << name_;
653 }
654 }
Ian Rogersc7190692014-07-08 23:50:26 -0700655 --num_pending_writers_;
Ian Rogers81d425b2012-09-27 16:03:43 -0700656 }
Brian Carlstromdf629502013-07-17 22:39:56 -0700657 } while (!done);
Ian Rogers81d425b2012-09-27 16:03:43 -0700658#else
Ian Rogersc604d732012-10-14 16:09:54 -0700659 timespec ts;
Brian Carlstrombcc29262012-11-02 11:36:03 -0700660 InitTimeSpec(true, CLOCK_REALTIME, ms, ns, &ts);
Ian Rogersc604d732012-10-14 16:09:54 -0700661 int result = pthread_rwlock_timedwrlock(&rwlock_, &ts);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700662 if (result == ETIMEDOUT) {
663 return false;
664 }
665 if (result != 0) {
666 errno = result;
Ian Rogersa5acfd32012-08-15 11:50:10 -0700667 PLOG(FATAL) << "pthread_rwlock_timedwrlock failed for " << name_;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700668 }
Ian Rogers81d425b2012-09-27 16:03:43 -0700669#endif
Ian Rogersc5f17732014-06-05 20:48:42 -0700670 exclusive_owner_ = SafeGetTid(self);
Ian Rogers81d425b2012-09-27 16:03:43 -0700671 RegisterAsLocked(self);
672 AssertSharedHeld(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700673 return true;
674}
Ian Rogers66aee5c2012-08-15 17:17:47 -0700675#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700676
Ian Rogers51d212e2014-10-23 17:48:20 -0700677#if ART_USE_FUTEXES
Ian Rogerscf7f1912014-10-22 22:06:39 -0700678void ReaderWriterMutex::HandleSharedLockContention(Thread* self, int32_t cur_state) {
679 // Owner holds it exclusively, hang up.
680 ScopedContentionRecorder scr(this, GetExclusiveOwnerTid(), SafeGetTid(self));
681 ++num_pending_readers_;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700682 if (futex(state_.Address(), FUTEX_WAIT, cur_state, nullptr, nullptr, 0) != 0) {
Ian Rogerscf7f1912014-10-22 22:06:39 -0700683 if (errno != EAGAIN) {
684 PLOG(FATAL) << "futex wait failed for " << name_;
685 }
686 }
687 --num_pending_readers_;
688}
Ian Rogers51d212e2014-10-23 17:48:20 -0700689#endif
Ian Rogerscf7f1912014-10-22 22:06:39 -0700690
Ian Rogers81d425b2012-09-27 16:03:43 -0700691bool ReaderWriterMutex::SharedTryLock(Thread* self) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700692 DCHECK(self == nullptr || self == Thread::Current());
Ian Rogers81d425b2012-09-27 16:03:43 -0700693#if ART_USE_FUTEXES
694 bool done = false;
695 do {
Ian Rogersc7190692014-07-08 23:50:26 -0700696 int32_t cur_state = state_.LoadRelaxed();
Ian Rogers81d425b2012-09-27 16:03:43 -0700697 if (cur_state >= 0) {
Ian Rogersc7190692014-07-08 23:50:26 -0700698 // Add as an extra reader and impose load/store ordering appropriate for lock acquisition.
699 done = state_.CompareExchangeWeakAcquire(cur_state, cur_state + 1);
Ian Rogers81d425b2012-09-27 16:03:43 -0700700 } else {
701 // Owner holds it exclusively.
702 return false;
703 }
Brian Carlstromdf629502013-07-17 22:39:56 -0700704 } while (!done);
Ian Rogers81d425b2012-09-27 16:03:43 -0700705#else
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700706 int result = pthread_rwlock_tryrdlock(&rwlock_);
707 if (result == EBUSY) {
708 return false;
709 }
710 if (result != 0) {
711 errno = result;
712 PLOG(FATAL) << "pthread_mutex_trylock failed for " << name_;
713 }
Ian Rogers81d425b2012-09-27 16:03:43 -0700714#endif
715 RegisterAsLocked(self);
716 AssertSharedHeld(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700717 return true;
718}
719
Ian Rogers81d425b2012-09-27 16:03:43 -0700720bool ReaderWriterMutex::IsSharedHeld(const Thread* self) const {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700721 DCHECK(self == nullptr || self == Thread::Current());
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700722 bool result;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700723 if (UNLIKELY(self == nullptr)) { // Handle unattached threads.
Ian Rogers01ae5802012-09-28 16:14:01 -0700724 result = IsExclusiveHeld(self); // TODO: a better best effort here.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700725 } else {
726 result = (self->GetHeldMutex(level_) == this);
727 }
728 return result;
729}
730
Ian Rogers56edc432013-01-18 16:51:51 -0800731void ReaderWriterMutex::Dump(std::ostream& os) const {
732 os << name_
733 << " level=" << static_cast<int>(level_)
Mathieu Chartier5869a2c2014-10-08 14:26:23 -0700734 << " owner=" << GetExclusiveOwnerTid()
735#if ART_USE_FUTEXES
736 << " state=" << state_.LoadSequentiallyConsistent()
737 << " num_pending_writers=" << num_pending_writers_.LoadSequentiallyConsistent()
738 << " num_pending_readers=" << num_pending_readers_.LoadSequentiallyConsistent()
739#endif
740 << " ";
Ian Rogers56edc432013-01-18 16:51:51 -0800741 DumpContention(os);
Ian Rogers01ae5802012-09-28 16:14:01 -0700742}
743
744std::ostream& operator<<(std::ostream& os, const ReaderWriterMutex& mu) {
Ian Rogers56edc432013-01-18 16:51:51 -0800745 mu.Dump(os);
746 return os;
Ian Rogers01ae5802012-09-28 16:14:01 -0700747}
748
Yu Lieac44242015-06-29 10:50:03 +0800749std::ostream& operator<<(std::ostream& os, const MutatorMutex& mu) {
750 mu.Dump(os);
751 return os;
752}
753
Ian Rogers23055dc2013-04-18 16:29:16 -0700754ConditionVariable::ConditionVariable(const char* name, Mutex& guard)
Ian Rogersc604d732012-10-14 16:09:54 -0700755 : name_(name), guard_(guard) {
756#if ART_USE_FUTEXES
Ian Rogers3e5cf302014-05-20 16:40:37 -0700757 DCHECK_EQ(0, sequence_.LoadRelaxed());
Ian Rogersc604d732012-10-14 16:09:54 -0700758 num_waiters_ = 0;
Ian Rogersc604d732012-10-14 16:09:54 -0700759#else
Narayan Kamath51b71022014-03-04 11:57:09 +0000760 pthread_condattr_t cond_attrs;
Ian Rogersc5f17732014-06-05 20:48:42 -0700761 CHECK_MUTEX_CALL(pthread_condattr_init, (&cond_attrs));
Narayan Kamath51b71022014-03-04 11:57:09 +0000762#if !defined(__APPLE__)
763 // Apple doesn't have CLOCK_MONOTONIC or pthread_condattr_setclock.
Ian Rogers51d212e2014-10-23 17:48:20 -0700764 CHECK_MUTEX_CALL(pthread_condattr_setclock, (&cond_attrs, CLOCK_MONOTONIC));
Narayan Kamath51b71022014-03-04 11:57:09 +0000765#endif
766 CHECK_MUTEX_CALL(pthread_cond_init, (&cond_, &cond_attrs));
Ian Rogersc604d732012-10-14 16:09:54 -0700767#endif
Elliott Hughes5f791332011-09-15 17:45:30 -0700768}
769
770ConditionVariable::~ConditionVariable() {
Ian Rogers5bd97c42012-11-27 02:38:26 -0800771#if ART_USE_FUTEXES
772 if (num_waiters_!= 0) {
Ian Rogers5bd97c42012-11-27 02:38:26 -0800773 Runtime* runtime = Runtime::Current();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700774 bool shutting_down = runtime == nullptr || runtime->IsShuttingDown(Thread::Current());
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700775 LOG(shutting_down
776 ? ::android::base::WARNING
777 : ::android::base::FATAL)
778 << "ConditionVariable::~ConditionVariable for " << name_
Ian Rogersd45f2012012-11-28 11:46:23 -0800779 << " called with " << num_waiters_ << " waiters.";
Ian Rogers5bd97c42012-11-27 02:38:26 -0800780 }
781#else
Elliott Hughese62934d2012-04-09 11:24:29 -0700782 // We can't use CHECK_MUTEX_CALL here because on shutdown a suspended daemon thread
783 // may still be using condition variables.
784 int rc = pthread_cond_destroy(&cond_);
785 if (rc != 0) {
786 errno = rc;
Ian Rogers50b35e22012-10-04 10:09:15 -0700787 MutexLock mu(Thread::Current(), *Locks::runtime_shutdown_lock_);
Ian Rogers120f1c72012-09-28 17:17:10 -0700788 Runtime* runtime = Runtime::Current();
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700789 bool shutting_down = (runtime == nullptr) || runtime->IsShuttingDownLocked();
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700790 PLOG(shutting_down
791 ? ::android::base::WARNING
792 : ::android::base::FATAL) << "pthread_cond_destroy failed for " << name_;
Elliott Hughese62934d2012-04-09 11:24:29 -0700793 }
Ian Rogersc604d732012-10-14 16:09:54 -0700794#endif
Elliott Hughes5f791332011-09-15 17:45:30 -0700795}
796
Ian Rogersc604d732012-10-14 16:09:54 -0700797void ConditionVariable::Broadcast(Thread* self) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700798 DCHECK(self == nullptr || self == Thread::Current());
Ian Rogersc604d732012-10-14 16:09:54 -0700799 // TODO: enable below, there's a race in thread creation that causes false failures currently.
800 // guard_.AssertExclusiveHeld(self);
Mathieu Chartiere46cd752012-10-31 16:56:18 -0700801 DCHECK_EQ(guard_.GetExclusiveOwnerTid(), SafeGetTid(self));
Ian Rogersc604d732012-10-14 16:09:54 -0700802#if ART_USE_FUTEXES
Ian Rogersd45f2012012-11-28 11:46:23 -0800803 if (num_waiters_ > 0) {
Ian Rogersb122a4b2013-11-19 18:00:50 -0800804 sequence_++; // Indicate the broadcast occurred.
Ian Rogersc604d732012-10-14 16:09:54 -0700805 bool done = false;
806 do {
Ian Rogers3e5cf302014-05-20 16:40:37 -0700807 int32_t cur_sequence = sequence_.LoadRelaxed();
Ian Rogersd45f2012012-11-28 11:46:23 -0800808 // Requeue waiters onto mutex. The waiter holds the contender count on the mutex high ensuring
809 // mutex unlocks will awaken the requeued waiter thread.
Ian Rogersb122a4b2013-11-19 18:00:50 -0800810 done = futex(sequence_.Address(), FUTEX_CMP_REQUEUE, 0,
Ian Rogers5bd97c42012-11-27 02:38:26 -0800811 reinterpret_cast<const timespec*>(std::numeric_limits<int32_t>::max()),
Ian Rogersc7190692014-07-08 23:50:26 -0700812 guard_.state_.Address(), cur_sequence) != -1;
Ian Rogers5bd97c42012-11-27 02:38:26 -0800813 if (!done) {
814 if (errno != EAGAIN) {
815 PLOG(FATAL) << "futex cmp requeue failed for " << name_;
816 }
Ian Rogers5bd97c42012-11-27 02:38:26 -0800817 }
Ian Rogersc604d732012-10-14 16:09:54 -0700818 } while (!done);
819 }
820#else
Elliott Hughes5f791332011-09-15 17:45:30 -0700821 CHECK_MUTEX_CALL(pthread_cond_broadcast, (&cond_));
Ian Rogersc604d732012-10-14 16:09:54 -0700822#endif
Elliott Hughes5f791332011-09-15 17:45:30 -0700823}
824
Ian Rogersc604d732012-10-14 16:09:54 -0700825void ConditionVariable::Signal(Thread* self) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700826 DCHECK(self == nullptr || self == Thread::Current());
Ian Rogersc604d732012-10-14 16:09:54 -0700827 guard_.AssertExclusiveHeld(self);
828#if ART_USE_FUTEXES
Ian Rogersd45f2012012-11-28 11:46:23 -0800829 if (num_waiters_ > 0) {
Ian Rogersb122a4b2013-11-19 18:00:50 -0800830 sequence_++; // Indicate a signal occurred.
Ian Rogersc604d732012-10-14 16:09:54 -0700831 // Futex wake 1 waiter who will then come and in contend on mutex. It'd be nice to requeue them
832 // to avoid this, however, requeueing can only move all waiters.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700833 int num_woken = futex(sequence_.Address(), FUTEX_WAKE, 1, nullptr, nullptr, 0);
Ian Rogersd45f2012012-11-28 11:46:23 -0800834 // Check something was woken or else we changed sequence_ before they had chance to wait.
Ian Rogers5bd97c42012-11-27 02:38:26 -0800835 CHECK((num_woken == 0) || (num_woken == 1));
Ian Rogersc604d732012-10-14 16:09:54 -0700836 }
837#else
Elliott Hughes5f791332011-09-15 17:45:30 -0700838 CHECK_MUTEX_CALL(pthread_cond_signal, (&cond_));
Ian Rogersc604d732012-10-14 16:09:54 -0700839#endif
Elliott Hughes5f791332011-09-15 17:45:30 -0700840}
841
Ian Rogersc604d732012-10-14 16:09:54 -0700842void ConditionVariable::Wait(Thread* self) {
Ian Rogers1d54e732013-05-02 21:10:01 -0700843 guard_.CheckSafeToWait(self);
844 WaitHoldingLocks(self);
845}
846
847void ConditionVariable::WaitHoldingLocks(Thread* self) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700848 DCHECK(self == nullptr || self == Thread::Current());
Ian Rogersc604d732012-10-14 16:09:54 -0700849 guard_.AssertExclusiveHeld(self);
Ian Rogersc604d732012-10-14 16:09:54 -0700850 unsigned int old_recursion_count = guard_.recursion_count_;
851#if ART_USE_FUTEXES
Ian Rogersc604d732012-10-14 16:09:54 -0700852 num_waiters_++;
Ian Rogersd45f2012012-11-28 11:46:23 -0800853 // Ensure the Mutex is contended so that requeued threads are awoken.
Ian Rogersb122a4b2013-11-19 18:00:50 -0800854 guard_.num_contenders_++;
Ian Rogersc604d732012-10-14 16:09:54 -0700855 guard_.recursion_count_ = 1;
Ian Rogers3e5cf302014-05-20 16:40:37 -0700856 int32_t cur_sequence = sequence_.LoadRelaxed();
Ian Rogersc604d732012-10-14 16:09:54 -0700857 guard_.ExclusiveUnlock(self);
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700858 if (futex(sequence_.Address(), FUTEX_WAIT, cur_sequence, nullptr, nullptr, 0) != 0) {
Ian Rogersd45f2012012-11-28 11:46:23 -0800859 // Futex failed, check it is an expected error.
860 // EAGAIN == EWOULDBLK, so we let the caller try again.
861 // EINTR implies a signal was sent to this thread.
862 if ((errno != EINTR) && (errno != EAGAIN)) {
Ian Rogersc604d732012-10-14 16:09:54 -0700863 PLOG(FATAL) << "futex wait failed for " << name_;
864 }
865 }
Mathieu Chartier4d87df62016-01-07 15:14:19 -0800866 if (self != nullptr) {
867 JNIEnvExt* const env = self->GetJniEnv();
868 if (UNLIKELY(env != nullptr && env->runtime_deleted)) {
869 CHECK(self->IsDaemon());
870 // If the runtime has been deleted, then we cannot proceed. Just sleep forever. This may
871 // occur for user daemon threads that get a spurious wakeup. This occurs for test 132 with
872 // --host and --gdb.
873 // After we wake up, the runtime may have been shutdown, which means that this condition may
874 // have been deleted. It is not safe to retry the wait.
875 SleepForever();
876 }
877 }
Ian Rogersc604d732012-10-14 16:09:54 -0700878 guard_.ExclusiveLock(self);
Ian Rogersd45f2012012-11-28 11:46:23 -0800879 CHECK_GE(num_waiters_, 0);
Ian Rogersc604d732012-10-14 16:09:54 -0700880 num_waiters_--;
Ian Rogersd45f2012012-11-28 11:46:23 -0800881 // We awoke and so no longer require awakes from the guard_'s unlock.
Ian Rogers3e5cf302014-05-20 16:40:37 -0700882 CHECK_GE(guard_.num_contenders_.LoadRelaxed(), 0);
Ian Rogersb122a4b2013-11-19 18:00:50 -0800883 guard_.num_contenders_--;
Ian Rogersc604d732012-10-14 16:09:54 -0700884#else
Ian Rogersc5f17732014-06-05 20:48:42 -0700885 uint64_t old_owner = guard_.exclusive_owner_;
886 guard_.exclusive_owner_ = 0;
Ian Rogersc604d732012-10-14 16:09:54 -0700887 guard_.recursion_count_ = 0;
888 CHECK_MUTEX_CALL(pthread_cond_wait, (&cond_, &guard_.mutex_));
Ian Rogersc5f17732014-06-05 20:48:42 -0700889 guard_.exclusive_owner_ = old_owner;
Ian Rogersc604d732012-10-14 16:09:54 -0700890#endif
891 guard_.recursion_count_ = old_recursion_count;
Elliott Hughes5f791332011-09-15 17:45:30 -0700892}
893
Ian Rogers7b078e82014-09-10 14:44:24 -0700894bool ConditionVariable::TimedWait(Thread* self, int64_t ms, int32_t ns) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700895 DCHECK(self == nullptr || self == Thread::Current());
Ian Rogers7b078e82014-09-10 14:44:24 -0700896 bool timed_out = false;
Ian Rogersc604d732012-10-14 16:09:54 -0700897 guard_.AssertExclusiveHeld(self);
Ian Rogers1d54e732013-05-02 21:10:01 -0700898 guard_.CheckSafeToWait(self);
Ian Rogersc604d732012-10-14 16:09:54 -0700899 unsigned int old_recursion_count = guard_.recursion_count_;
900#if ART_USE_FUTEXES
Ian Rogersc604d732012-10-14 16:09:54 -0700901 timespec rel_ts;
Ian Rogers5bd97c42012-11-27 02:38:26 -0800902 InitTimeSpec(false, CLOCK_REALTIME, ms, ns, &rel_ts);
Ian Rogersc604d732012-10-14 16:09:54 -0700903 num_waiters_++;
Ian Rogersd45f2012012-11-28 11:46:23 -0800904 // Ensure the Mutex is contended so that requeued threads are awoken.
Ian Rogersb122a4b2013-11-19 18:00:50 -0800905 guard_.num_contenders_++;
Ian Rogersc604d732012-10-14 16:09:54 -0700906 guard_.recursion_count_ = 1;
Ian Rogers3e5cf302014-05-20 16:40:37 -0700907 int32_t cur_sequence = sequence_.LoadRelaxed();
Ian Rogersc604d732012-10-14 16:09:54 -0700908 guard_.ExclusiveUnlock(self);
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700909 if (futex(sequence_.Address(), FUTEX_WAIT, cur_sequence, &rel_ts, nullptr, 0) != 0) {
Ian Rogersc604d732012-10-14 16:09:54 -0700910 if (errno == ETIMEDOUT) {
Ian Rogersd45f2012012-11-28 11:46:23 -0800911 // Timed out we're done.
Ian Rogers7b078e82014-09-10 14:44:24 -0700912 timed_out = true;
Brian Carlstrom0de79852013-07-25 22:29:58 -0700913 } else if ((errno == EAGAIN) || (errno == EINTR)) {
Ian Rogersd45f2012012-11-28 11:46:23 -0800914 // A signal or ConditionVariable::Signal/Broadcast has come in.
Ian Rogersc604d732012-10-14 16:09:54 -0700915 } else {
916 PLOG(FATAL) << "timed futex wait failed for " << name_;
917 }
918 }
919 guard_.ExclusiveLock(self);
Ian Rogersd45f2012012-11-28 11:46:23 -0800920 CHECK_GE(num_waiters_, 0);
Ian Rogersc604d732012-10-14 16:09:54 -0700921 num_waiters_--;
Ian Rogersd45f2012012-11-28 11:46:23 -0800922 // We awoke and so no longer require awakes from the guard_'s unlock.
Ian Rogers3e5cf302014-05-20 16:40:37 -0700923 CHECK_GE(guard_.num_contenders_.LoadRelaxed(), 0);
Ian Rogersb122a4b2013-11-19 18:00:50 -0800924 guard_.num_contenders_--;
Ian Rogersc604d732012-10-14 16:09:54 -0700925#else
Narayan Kamath51b71022014-03-04 11:57:09 +0000926#if !defined(__APPLE__)
Ian Rogersc604d732012-10-14 16:09:54 -0700927 int clock = CLOCK_MONOTONIC;
Elliott Hughes5f791332011-09-15 17:45:30 -0700928#else
Ian Rogersc604d732012-10-14 16:09:54 -0700929 int clock = CLOCK_REALTIME;
Elliott Hughes5f791332011-09-15 17:45:30 -0700930#endif
Ian Rogersc5f17732014-06-05 20:48:42 -0700931 uint64_t old_owner = guard_.exclusive_owner_;
932 guard_.exclusive_owner_ = 0;
Ian Rogersc604d732012-10-14 16:09:54 -0700933 guard_.recursion_count_ = 0;
934 timespec ts;
Brian Carlstrombcc29262012-11-02 11:36:03 -0700935 InitTimeSpec(true, clock, ms, ns, &ts);
Narayan Kamath51b71022014-03-04 11:57:09 +0000936 int rc = TEMP_FAILURE_RETRY(pthread_cond_timedwait(&cond_, &guard_.mutex_, &ts));
Ian Rogers7b078e82014-09-10 14:44:24 -0700937 if (rc == ETIMEDOUT) {
938 timed_out = true;
939 } else if (rc != 0) {
Elliott Hughes5f791332011-09-15 17:45:30 -0700940 errno = rc;
941 PLOG(FATAL) << "TimedWait failed for " << name_;
942 }
Ian Rogersc5f17732014-06-05 20:48:42 -0700943 guard_.exclusive_owner_ = old_owner;
Ian Rogersc604d732012-10-14 16:09:54 -0700944#endif
945 guard_.recursion_count_ = old_recursion_count;
Ian Rogers7b078e82014-09-10 14:44:24 -0700946 return timed_out;
Elliott Hughes5f791332011-09-15 17:45:30 -0700947}
948
Ian Rogers719d1a32014-03-06 12:13:39 -0800949void Locks::Init() {
950 if (logging_lock_ != nullptr) {
951 // Already initialized.
Nicolas Geoffray7f0a6d62014-05-26 14:01:46 +0100952 if (kRuntimeISA == kX86 || kRuntimeISA == kX86_64) {
Chao-ying Fu9e369312014-05-21 11:20:52 -0700953 DCHECK(modify_ldt_lock_ != nullptr);
954 } else {
955 DCHECK(modify_ldt_lock_ == nullptr);
956 }
Ian Rogers719d1a32014-03-06 12:13:39 -0800957 DCHECK(abort_lock_ != nullptr);
Brian Carlstrom306db812014-09-05 13:01:41 -0700958 DCHECK(alloc_tracker_lock_ != nullptr);
Andreas Gampe74240812014-04-17 10:35:09 -0700959 DCHECK(allocated_monitor_ids_lock_ != nullptr);
Chao-ying Fu9e369312014-05-21 11:20:52 -0700960 DCHECK(allocated_thread_ids_lock_ != nullptr);
Ian Rogers719d1a32014-03-06 12:13:39 -0800961 DCHECK(breakpoint_lock_ != nullptr);
Ian Rogers719d1a32014-03-06 12:13:39 -0800962 DCHECK(classlinker_classes_lock_ != nullptr);
Brian Carlstrom306db812014-09-05 13:01:41 -0700963 DCHECK(deoptimization_lock_ != nullptr);
Ian Rogers719d1a32014-03-06 12:13:39 -0800964 DCHECK(heap_bitmap_lock_ != nullptr);
Mathieu Chartierf9c6fc62015-10-07 11:44:05 -0700965 DCHECK(oat_file_manager_lock_ != nullptr);
David Brazdilca3c8c32016-09-06 14:04:48 +0100966 DCHECK(verifier_deps_lock_ != nullptr);
Richard Uhlera206c742016-05-24 15:04:22 -0700967 DCHECK(host_dlopen_handles_lock_ != nullptr);
Brian Carlstrom306db812014-09-05 13:01:41 -0700968 DCHECK(intern_table_lock_ != nullptr);
Ian Rogers68d8b422014-07-17 11:09:10 -0700969 DCHECK(jni_libraries_lock_ != nullptr);
Ian Rogers719d1a32014-03-06 12:13:39 -0800970 DCHECK(logging_lock_ != nullptr);
971 DCHECK(mutator_lock_ != nullptr);
Brian Carlstrom306db812014-09-05 13:01:41 -0700972 DCHECK(profiler_lock_ != nullptr);
Ian Rogers719d1a32014-03-06 12:13:39 -0800973 DCHECK(thread_list_lock_ != nullptr);
974 DCHECK(thread_suspend_count_lock_ != nullptr);
975 DCHECK(trace_lock_ != nullptr);
Ian Rogers719d1a32014-03-06 12:13:39 -0800976 DCHECK(unexpected_signal_lock_ != nullptr);
Ian Rogers719d1a32014-03-06 12:13:39 -0800977 } else {
Chao-ying Fu9e369312014-05-21 11:20:52 -0700978 // Create global locks in level order from highest lock level to lowest.
Ian Rogers4ad5cd32014-11-11 23:08:07 -0800979 LockLevel current_lock_level = kInstrumentEntrypointsLock;
980 DCHECK(instrument_entrypoints_lock_ == nullptr);
981 instrument_entrypoints_lock_ = new Mutex("instrument entrypoint lock", current_lock_level);
Ian Rogers719d1a32014-03-06 12:13:39 -0800982
Chao-ying Fu9e369312014-05-21 11:20:52 -0700983 #define UPDATE_CURRENT_LOCK_LEVEL(new_level) \
Chih-Hung Hsiehfba39972016-05-11 11:26:48 -0700984 if ((new_level) >= current_lock_level) { \
Brian Carlstrom306db812014-09-05 13:01:41 -0700985 /* Do not use CHECKs or FATAL here, abort_lock_ is not setup yet. */ \
986 fprintf(stderr, "New local level %d is not less than current level %d\n", \
987 new_level, current_lock_level); \
988 exit(1); \
989 } \
Ian Rogersf3d874c2014-07-17 18:52:42 -0700990 current_lock_level = new_level;
991
992 UPDATE_CURRENT_LOCK_LEVEL(kMutatorLock);
993 DCHECK(mutator_lock_ == nullptr);
Yu Lieac44242015-06-29 10:50:03 +0800994 mutator_lock_ = new MutatorMutex("mutator lock", current_lock_level);
Chao-ying Fu9e369312014-05-21 11:20:52 -0700995
996 UPDATE_CURRENT_LOCK_LEVEL(kHeapBitmapLock);
997 DCHECK(heap_bitmap_lock_ == nullptr);
998 heap_bitmap_lock_ = new ReaderWriterMutex("heap bitmap lock", current_lock_level);
999
Jeff Hao69dbec62014-09-15 18:03:41 -07001000 UPDATE_CURRENT_LOCK_LEVEL(kTraceLock);
1001 DCHECK(trace_lock_ == nullptr);
1002 trace_lock_ = new Mutex("trace lock", current_lock_level);
1003
Chao-ying Fu9e369312014-05-21 11:20:52 -07001004 UPDATE_CURRENT_LOCK_LEVEL(kRuntimeShutdownLock);
1005 DCHECK(runtime_shutdown_lock_ == nullptr);
1006 runtime_shutdown_lock_ = new Mutex("runtime shutdown lock", current_lock_level);
1007
1008 UPDATE_CURRENT_LOCK_LEVEL(kProfilerLock);
1009 DCHECK(profiler_lock_ == nullptr);
1010 profiler_lock_ = new Mutex("profiler lock", current_lock_level);
1011
Brian Carlstrom306db812014-09-05 13:01:41 -07001012 UPDATE_CURRENT_LOCK_LEVEL(kDeoptimizationLock);
1013 DCHECK(deoptimization_lock_ == nullptr);
1014 deoptimization_lock_ = new Mutex("Deoptimization lock", current_lock_level);
1015
1016 UPDATE_CURRENT_LOCK_LEVEL(kAllocTrackerLock);
1017 DCHECK(alloc_tracker_lock_ == nullptr);
1018 alloc_tracker_lock_ = new Mutex("AllocTracker lock", current_lock_level);
1019
Chao-ying Fu9e369312014-05-21 11:20:52 -07001020 UPDATE_CURRENT_LOCK_LEVEL(kThreadListLock);
1021 DCHECK(thread_list_lock_ == nullptr);
1022 thread_list_lock_ = new Mutex("thread list lock", current_lock_level);
1023
Ian Rogers68d8b422014-07-17 11:09:10 -07001024 UPDATE_CURRENT_LOCK_LEVEL(kJniLoadLibraryLock);
1025 DCHECK(jni_libraries_lock_ == nullptr);
1026 jni_libraries_lock_ = new Mutex("JNI shared libraries map lock", current_lock_level);
1027
Chao-ying Fu9e369312014-05-21 11:20:52 -07001028 UPDATE_CURRENT_LOCK_LEVEL(kBreakpointLock);
Ian Rogers719d1a32014-03-06 12:13:39 -08001029 DCHECK(breakpoint_lock_ == nullptr);
Sebastien Hertzed2be172014-08-19 15:33:43 +02001030 breakpoint_lock_ = new ReaderWriterMutex("breakpoint lock", current_lock_level);
Chao-ying Fu9e369312014-05-21 11:20:52 -07001031
1032 UPDATE_CURRENT_LOCK_LEVEL(kClassLinkerClassesLock);
Ian Rogers719d1a32014-03-06 12:13:39 -08001033 DCHECK(classlinker_classes_lock_ == nullptr);
1034 classlinker_classes_lock_ = new ReaderWriterMutex("ClassLinker classes lock",
Chao-ying Fu9e369312014-05-21 11:20:52 -07001035 current_lock_level);
1036
Andreas Gampe74240812014-04-17 10:35:09 -07001037 UPDATE_CURRENT_LOCK_LEVEL(kMonitorPoolLock);
1038 DCHECK(allocated_monitor_ids_lock_ == nullptr);
1039 allocated_monitor_ids_lock_ = new Mutex("allocated monitor ids lock", current_lock_level);
1040
Chao-ying Fu9e369312014-05-21 11:20:52 -07001041 UPDATE_CURRENT_LOCK_LEVEL(kAllocatedThreadIdsLock);
1042 DCHECK(allocated_thread_ids_lock_ == nullptr);
1043 allocated_thread_ids_lock_ = new Mutex("allocated thread ids lock", current_lock_level);
1044
Nicolas Geoffray7f0a6d62014-05-26 14:01:46 +01001045 if (kRuntimeISA == kX86 || kRuntimeISA == kX86_64) {
Chao-ying Fu9e369312014-05-21 11:20:52 -07001046 UPDATE_CURRENT_LOCK_LEVEL(kModifyLdtLock);
1047 DCHECK(modify_ldt_lock_ == nullptr);
1048 modify_ldt_lock_ = new Mutex("modify_ldt lock", current_lock_level);
1049 }
1050
Mathieu Chartierf9c6fc62015-10-07 11:44:05 -07001051 UPDATE_CURRENT_LOCK_LEVEL(kOatFileManagerLock);
1052 DCHECK(oat_file_manager_lock_ == nullptr);
1053 oat_file_manager_lock_ = new ReaderWriterMutex("OatFile manager lock", current_lock_level);
1054
David Brazdilca3c8c32016-09-06 14:04:48 +01001055 UPDATE_CURRENT_LOCK_LEVEL(kVerifierDepsLock);
1056 DCHECK(verifier_deps_lock_ == nullptr);
1057 verifier_deps_lock_ = new Mutex("verifier deps lock", current_lock_level);
1058
Richard Uhlera206c742016-05-24 15:04:22 -07001059 UPDATE_CURRENT_LOCK_LEVEL(kHostDlOpenHandlesLock);
1060 DCHECK(host_dlopen_handles_lock_ == nullptr);
1061 host_dlopen_handles_lock_ = new Mutex("host dlopen handles lock", current_lock_level);
Mathieu Chartiere58991b2015-10-13 07:59:34 -07001062
Chao-ying Fu9e369312014-05-21 11:20:52 -07001063 UPDATE_CURRENT_LOCK_LEVEL(kInternTableLock);
Ian Rogers719d1a32014-03-06 12:13:39 -08001064 DCHECK(intern_table_lock_ == nullptr);
Chao-ying Fu9e369312014-05-21 11:20:52 -07001065 intern_table_lock_ = new Mutex("InternTable lock", current_lock_level);
1066
Mathieu Chartiera5a53ef2014-09-12 12:58:05 -07001067 UPDATE_CURRENT_LOCK_LEVEL(kReferenceProcessorLock);
1068 DCHECK(reference_processor_lock_ == nullptr);
1069 reference_processor_lock_ = new Mutex("ReferenceProcessor lock", current_lock_level);
1070
1071 UPDATE_CURRENT_LOCK_LEVEL(kReferenceQueueClearedReferencesLock);
1072 DCHECK(reference_queue_cleared_references_lock_ == nullptr);
1073 reference_queue_cleared_references_lock_ = new Mutex("ReferenceQueue cleared references lock", current_lock_level);
1074
1075 UPDATE_CURRENT_LOCK_LEVEL(kReferenceQueueWeakReferencesLock);
1076 DCHECK(reference_queue_weak_references_lock_ == nullptr);
1077 reference_queue_weak_references_lock_ = new Mutex("ReferenceQueue cleared references lock", current_lock_level);
1078
1079 UPDATE_CURRENT_LOCK_LEVEL(kReferenceQueueFinalizerReferencesLock);
1080 DCHECK(reference_queue_finalizer_references_lock_ == nullptr);
1081 reference_queue_finalizer_references_lock_ = new Mutex("ReferenceQueue finalizer references lock", current_lock_level);
1082
1083 UPDATE_CURRENT_LOCK_LEVEL(kReferenceQueuePhantomReferencesLock);
1084 DCHECK(reference_queue_phantom_references_lock_ == nullptr);
1085 reference_queue_phantom_references_lock_ = new Mutex("ReferenceQueue phantom references lock", current_lock_level);
1086
1087 UPDATE_CURRENT_LOCK_LEVEL(kReferenceQueueSoftReferencesLock);
1088 DCHECK(reference_queue_soft_references_lock_ == nullptr);
1089 reference_queue_soft_references_lock_ = new Mutex("ReferenceQueue soft references lock", current_lock_level);
1090
Chao-ying Fu9e369312014-05-21 11:20:52 -07001091 UPDATE_CURRENT_LOCK_LEVEL(kAbortLock);
1092 DCHECK(abort_lock_ == nullptr);
1093 abort_lock_ = new Mutex("abort lock", current_lock_level, true);
1094
1095 UPDATE_CURRENT_LOCK_LEVEL(kThreadSuspendCountLock);
1096 DCHECK(thread_suspend_count_lock_ == nullptr);
1097 thread_suspend_count_lock_ = new Mutex("thread suspend count lock", current_lock_level);
1098
1099 UPDATE_CURRENT_LOCK_LEVEL(kUnexpectedSignalLock);
1100 DCHECK(unexpected_signal_lock_ == nullptr);
1101 unexpected_signal_lock_ = new Mutex("unexpected signal lock", current_lock_level, true);
1102
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -07001103 UPDATE_CURRENT_LOCK_LEVEL(kMemMapsLock);
1104 DCHECK(mem_maps_lock_ == nullptr);
1105 mem_maps_lock_ = new Mutex("mem maps lock", current_lock_level);
1106
Chao-ying Fu9e369312014-05-21 11:20:52 -07001107 UPDATE_CURRENT_LOCK_LEVEL(kLoggingLock);
1108 DCHECK(logging_lock_ == nullptr);
1109 logging_lock_ = new Mutex("logging lock", current_lock_level, true);
1110
1111 #undef UPDATE_CURRENT_LOCK_LEVEL
Mathieu Chartier91e56692015-03-03 13:51:04 -08001112
1113 InitConditions();
Ian Rogers719d1a32014-03-06 12:13:39 -08001114 }
1115}
1116
Mathieu Chartier91e56692015-03-03 13:51:04 -08001117void Locks::InitConditions() {
1118 thread_exit_cond_ = new ConditionVariable("thread exit condition variable", *thread_list_lock_);
1119}
Ian Rogers719d1a32014-03-06 12:13:39 -08001120
Elliott Hughese62934d2012-04-09 11:24:29 -07001121} // namespace art