blob: 9c0927584eb2e1d9a96d50def15f2e874bfbda28 [file] [log] [blame]
Elliott Hughes5f791332011-09-15 17:45:30 -07001/*
2 * Copyright (C) 2008 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
Elliott Hughes54e7df12011-09-16 11:47:04 -070017#include "monitor.h"
Elliott Hughes5f791332011-09-15 17:45:30 -070018
Elliott Hughes08fc03a2012-06-26 17:34:00 -070019#include <vector>
20
Andreas Gampe46ee31b2016-12-14 10:11:49 -080021#include "android-base/stringprintf.h"
22
Mathieu Chartiere401d142015-04-22 13:56:20 -070023#include "art_method-inl.h"
Elliott Hughes76b61672012-12-12 17:47:30 -080024#include "base/mutex.h"
Elliott Hughes1aa246d2012-12-13 09:29:36 -080025#include "base/stl_util.h"
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -080026#include "base/systrace.h"
Vladimir Marko80afd022015-05-19 18:08:00 +010027#include "base/time_utils.h"
jeffhao33dc7712011-11-09 17:54:24 -080028#include "class_linker.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070029#include "dex_file-inl.h"
Sebastien Hertz0f7c9332015-11-05 15:57:30 +010030#include "dex_instruction-inl.h"
Ian Rogersd9c4fc92013-10-01 19:45:43 -070031#include "lock_word-inl.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070032#include "mirror/class-inl.h"
Ian Rogers05f30572013-02-20 12:13:11 -080033#include "mirror/object-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080034#include "mirror/object_array-inl.h"
Mathieu Chartier0795f232016-09-27 18:43:30 -070035#include "scoped_thread_state_change-inl.h"
Elliott Hughes5f791332011-09-15 17:45:30 -070036#include "thread.h"
Elliott Hughes8e4aac52011-09-26 17:03:36 -070037#include "thread_list.h"
Elliott Hughes08fc03a2012-06-26 17:34:00 -070038#include "verifier/method_verifier.h"
Elliott Hughes044288f2012-06-25 14:46:39 -070039#include "well_known_classes.h"
Elliott Hughes5f791332011-09-15 17:45:30 -070040
41namespace art {
42
Andreas Gampe46ee31b2016-12-14 10:11:49 -080043using android::base::StringPrintf;
44
Mathieu Chartierb9001ab2014-10-03 13:28:46 -070045static constexpr uint64_t kLongWaitMs = 100;
46
Elliott Hughes5f791332011-09-15 17:45:30 -070047/*
Ian Rogersd9c4fc92013-10-01 19:45:43 -070048 * Every Object has a monitor associated with it, but not every Object is actually locked. Even
49 * the ones that are locked do not need a full-fledged monitor until a) there is actual contention
50 * or b) wait() is called on the Object.
Elliott Hughes5f791332011-09-15 17:45:30 -070051 *
Ian Rogersd9c4fc92013-10-01 19:45:43 -070052 * For Android, we have implemented a scheme similar to the one described in Bacon et al.'s
53 * "Thin locks: featherweight synchronization for Java" (ACM 1998). Things are even easier for us,
54 * though, because we have a full 32 bits to work with.
Elliott Hughes5f791332011-09-15 17:45:30 -070055 *
Ian Rogersd9c4fc92013-10-01 19:45:43 -070056 * The two states of an Object's lock are referred to as "thin" and "fat". A lock may transition
57 * from the "thin" state to the "fat" state and this transition is referred to as inflation. Once
58 * a lock has been inflated it remains in the "fat" state indefinitely.
Elliott Hughes5f791332011-09-15 17:45:30 -070059 *
Ian Rogersd9c4fc92013-10-01 19:45:43 -070060 * The lock value itself is stored in mirror::Object::monitor_ and the representation is described
61 * in the LockWord value type.
Elliott Hughes54e7df12011-09-16 11:47:04 -070062 *
Elliott Hughes5f791332011-09-15 17:45:30 -070063 * Monitors provide:
64 * - mutually exclusive access to resources
65 * - a way for multiple threads to wait for notification
66 *
67 * In effect, they fill the role of both mutexes and condition variables.
68 *
Ian Rogersd9c4fc92013-10-01 19:45:43 -070069 * Only one thread can own the monitor at any time. There may be several threads waiting on it
70 * (the wait call unlocks it). One or more waiting threads may be getting interrupted or notified
71 * at any given time.
Elliott Hughes5f791332011-09-15 17:45:30 -070072 */
Elliott Hughes54e7df12011-09-16 11:47:04 -070073
Elliott Hughesfc861622011-10-17 17:57:47 -070074uint32_t Monitor::lock_profiling_threshold_ = 0;
Elliott Hughes32d6e1e2011-10-11 14:47:44 -070075
Calin Juravleb2771b42016-04-07 17:09:25 +010076void Monitor::Init(uint32_t lock_profiling_threshold) {
Elliott Hughesfc861622011-10-17 17:57:47 -070077 lock_profiling_threshold_ = lock_profiling_threshold;
Elliott Hughes32d6e1e2011-10-11 14:47:44 -070078}
79
Ian Rogersef7d42f2014-01-06 12:55:46 -080080Monitor::Monitor(Thread* self, Thread* owner, mirror::Object* obj, int32_t hash_code)
Ian Rogers00f7d0e2012-07-19 15:28:27 -070081 : monitor_lock_("a monitor lock", kMonitorLock),
Ian Rogersd9c4fc92013-10-01 19:45:43 -070082 monitor_contenders_("monitor contenders", monitor_lock_),
Mathieu Chartier46bc7782013-11-12 17:03:02 -080083 num_waiters_(0),
Ian Rogers00f7d0e2012-07-19 15:28:27 -070084 owner_(owner),
Elliott Hughes5f791332011-09-15 17:45:30 -070085 lock_count_(0),
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -070086 obj_(GcRoot<mirror::Object>(obj)),
Mathieu Chartier2cebb242015-04-21 16:50:40 -070087 wait_set_(nullptr),
Mathieu Chartierad2541a2013-10-25 10:05:23 -070088 hash_code_(hash_code),
Mathieu Chartier2cebb242015-04-21 16:50:40 -070089 locking_method_(nullptr),
Ian Rogersef7d42f2014-01-06 12:55:46 -080090 locking_dex_pc_(0),
Andreas Gampe74240812014-04-17 10:35:09 -070091 monitor_id_(MonitorPool::ComputeMonitorId(this, self)) {
92#ifdef __LP64__
93 DCHECK(false) << "Should not be reached in 64b";
94 next_free_ = nullptr;
95#endif
96 // We should only inflate a lock if the owner is ourselves or suspended. This avoids a race
97 // with the owner unlocking the thin-lock.
98 CHECK(owner == nullptr || owner == self || owner->IsSuspended());
99 // The identity hash code is set for the life time of the monitor.
100}
101
102Monitor::Monitor(Thread* self, Thread* owner, mirror::Object* obj, int32_t hash_code,
103 MonitorId id)
104 : monitor_lock_("a monitor lock", kMonitorLock),
105 monitor_contenders_("monitor contenders", monitor_lock_),
106 num_waiters_(0),
107 owner_(owner),
108 lock_count_(0),
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700109 obj_(GcRoot<mirror::Object>(obj)),
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700110 wait_set_(nullptr),
Andreas Gampe74240812014-04-17 10:35:09 -0700111 hash_code_(hash_code),
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700112 locking_method_(nullptr),
Andreas Gampe74240812014-04-17 10:35:09 -0700113 locking_dex_pc_(0),
114 monitor_id_(id) {
115#ifdef __LP64__
116 next_free_ = nullptr;
117#endif
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700118 // We should only inflate a lock if the owner is ourselves or suspended. This avoids a race
119 // with the owner unlocking the thin-lock.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800120 CHECK(owner == nullptr || owner == self || owner->IsSuspended());
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700121 // The identity hash code is set for the life time of the monitor.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700122}
123
Mathieu Chartier4e6a31e2013-10-31 10:35:05 -0700124int32_t Monitor::GetHashCode() {
125 while (!HasHashCode()) {
Ian Rogers3e5cf302014-05-20 16:40:37 -0700126 if (hash_code_.CompareExchangeWeakRelaxed(0, mirror::Object::GenerateIdentityHashCode())) {
Mathieu Chartier4e6a31e2013-10-31 10:35:05 -0700127 break;
128 }
129 }
130 DCHECK(HasHashCode());
Ian Rogers3e5cf302014-05-20 16:40:37 -0700131 return hash_code_.LoadRelaxed();
Mathieu Chartier4e6a31e2013-10-31 10:35:05 -0700132}
133
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700134bool Monitor::Install(Thread* self) {
135 MutexLock mu(self, monitor_lock_); // Uncontended mutex acquisition as monitor isn't yet public.
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700136 CHECK(owner_ == nullptr || owner_ == self || owner_->IsSuspended());
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700137 // Propagate the lock state.
Hiroshi Yamauchi4cba0d92014-05-21 21:10:23 -0700138 LockWord lw(GetObject()->GetLockWord(false));
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700139 switch (lw.GetState()) {
140 case LockWord::kThinLocked: {
141 CHECK_EQ(owner_->GetThreadId(), lw.ThinLockOwner());
142 lock_count_ = lw.ThinLockCount();
143 break;
144 }
145 case LockWord::kHashCode: {
Ian Rogers3e5cf302014-05-20 16:40:37 -0700146 CHECK_EQ(hash_code_.LoadRelaxed(), static_cast<int32_t>(lw.GetHashCode()));
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700147 break;
148 }
149 case LockWord::kFatLocked: {
150 // The owner_ is suspended but another thread beat us to install a monitor.
151 return false;
152 }
153 case LockWord::kUnlocked: {
154 LOG(FATAL) << "Inflating unlocked lock word";
155 break;
156 }
Mathieu Chartier590fee92013-09-13 13:46:47 -0700157 default: {
158 LOG(FATAL) << "Invalid monitor state " << lw.GetState();
159 return false;
160 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700161 }
Mathieu Chartier36a270a2016-07-28 18:08:51 -0700162 LockWord fat(this, lw.GCState());
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700163 // Publish the updated lock word, which may race with other threads.
Hans Boehmb3da36c2016-12-15 13:12:59 -0800164 bool success = GetObject()->CasLockWordWeakRelease(lw, fat);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700165 // Lock profiling.
Mathieu Chartier9728f912013-10-30 09:45:13 -0700166 if (success && owner_ != nullptr && lock_profiling_threshold_ != 0) {
Andreas Gampe6ec8ebd2014-07-25 13:36:56 -0700167 // Do not abort on dex pc errors. This can easily happen when we want to dump a stack trace on
168 // abort.
169 locking_method_ = owner_->GetCurrentMethod(&locking_dex_pc_, false);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700170 }
171 return success;
Elliott Hughes5f791332011-09-15 17:45:30 -0700172}
173
174Monitor::~Monitor() {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700175 // Deflated monitors have a null object.
Elliott Hughes5f791332011-09-15 17:45:30 -0700176}
177
Elliott Hughes5f791332011-09-15 17:45:30 -0700178void Monitor::AppendToWaitSet(Thread* thread) {
179 DCHECK(owner_ == Thread::Current());
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700180 DCHECK(thread != nullptr);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700181 DCHECK(thread->GetWaitNext() == nullptr) << thread->GetWaitNext();
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700182 if (wait_set_ == nullptr) {
Elliott Hughes5f791332011-09-15 17:45:30 -0700183 wait_set_ = thread;
184 return;
185 }
186
187 // push_back.
188 Thread* t = wait_set_;
Ian Rogersdd7624d2014-03-14 17:43:00 -0700189 while (t->GetWaitNext() != nullptr) {
190 t = t->GetWaitNext();
Elliott Hughes5f791332011-09-15 17:45:30 -0700191 }
Ian Rogersdd7624d2014-03-14 17:43:00 -0700192 t->SetWaitNext(thread);
Elliott Hughes5f791332011-09-15 17:45:30 -0700193}
194
Elliott Hughes5f791332011-09-15 17:45:30 -0700195void Monitor::RemoveFromWaitSet(Thread *thread) {
196 DCHECK(owner_ == Thread::Current());
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700197 DCHECK(thread != nullptr);
198 if (wait_set_ == nullptr) {
Elliott Hughes5f791332011-09-15 17:45:30 -0700199 return;
200 }
201 if (wait_set_ == thread) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700202 wait_set_ = thread->GetWaitNext();
203 thread->SetWaitNext(nullptr);
Elliott Hughes5f791332011-09-15 17:45:30 -0700204 return;
205 }
206
207 Thread* t = wait_set_;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700208 while (t->GetWaitNext() != nullptr) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700209 if (t->GetWaitNext() == thread) {
210 t->SetWaitNext(thread->GetWaitNext());
211 thread->SetWaitNext(nullptr);
Elliott Hughes5f791332011-09-15 17:45:30 -0700212 return;
213 }
Ian Rogersdd7624d2014-03-14 17:43:00 -0700214 t = t->GetWaitNext();
Elliott Hughes5f791332011-09-15 17:45:30 -0700215 }
216}
217
Mathieu Chartier6aa3df92013-09-17 15:17:28 -0700218void Monitor::SetObject(mirror::Object* object) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700219 obj_ = GcRoot<mirror::Object>(object);
Mathieu Chartier6aa3df92013-09-17 15:17:28 -0700220}
221
Andreas Gampec7ed09b2016-04-25 20:08:55 -0700222// Note: Adapted from CurrentMethodVisitor in thread.cc. We must not resolve here.
223
224struct NthCallerWithDexPcVisitor FINAL : public StackVisitor {
225 explicit NthCallerWithDexPcVisitor(Thread* thread, size_t frame)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700226 REQUIRES_SHARED(Locks::mutator_lock_)
Nicolas Geoffrayc6df1e32016-07-04 10:15:47 +0100227 : StackVisitor(thread, nullptr, StackVisitor::StackWalkKind::kIncludeInlinedFrames),
Andreas Gampec7ed09b2016-04-25 20:08:55 -0700228 method_(nullptr),
229 dex_pc_(0),
230 current_frame_number_(0),
231 wanted_frame_number_(frame) {}
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700232 bool VisitFrame() OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Andreas Gampec7ed09b2016-04-25 20:08:55 -0700233 ArtMethod* m = GetMethod();
234 if (m == nullptr || m->IsRuntimeMethod()) {
235 // Runtime method, upcall, or resolution issue. Skip.
236 return true;
237 }
238
239 // Is this the requested frame?
240 if (current_frame_number_ == wanted_frame_number_) {
241 method_ = m;
242 dex_pc_ = GetDexPc(false /* abort_on_error*/);
243 return false;
244 }
245
246 // Look for more.
247 current_frame_number_++;
248 return true;
249 }
250
251 ArtMethod* method_;
252 uint32_t dex_pc_;
253
254 private:
255 size_t current_frame_number_;
256 const size_t wanted_frame_number_;
257};
258
259// This function is inlined and just helps to not have the VLOG and ATRACE check at all the
260// potential tracing points.
261void Monitor::AtraceMonitorLock(Thread* self, mirror::Object* obj, bool is_wait) {
262 if (UNLIKELY(VLOG_IS_ON(systrace_lock_logging) && ATRACE_ENABLED())) {
263 AtraceMonitorLockImpl(self, obj, is_wait);
264 }
265}
266
267void Monitor::AtraceMonitorLockImpl(Thread* self, mirror::Object* obj, bool is_wait) {
268 // Wait() requires a deeper call stack to be useful. Otherwise you'll see "Waiting at
269 // Object.java". Assume that we'll wait a nontrivial amount, so it's OK to do a longer
270 // stack walk than if !is_wait.
271 NthCallerWithDexPcVisitor visitor(self, is_wait ? 1U : 0U);
272 visitor.WalkStack(false);
273 const char* prefix = is_wait ? "Waiting on " : "Locking ";
274
275 const char* filename;
276 int32_t line_number;
277 TranslateLocation(visitor.method_, visitor.dex_pc_, &filename, &line_number);
278
279 // It would be nice to have a stable "ID" for the object here. However, the only stable thing
280 // would be the identity hashcode. But we cannot use IdentityHashcode here: For one, there are
281 // times when it is unsafe to make that call (see stack dumping for an explanation). More
282 // importantly, we would have to give up on thin-locking when adding systrace locks, as the
283 // identity hashcode is stored in the lockword normally (so can't be used with thin-locks).
284 //
285 // Because of thin-locks we also cannot use the monitor id (as there is no monitor). Monitor ids
286 // also do not have to be stable, as the monitor may be deflated.
287 std::string tmp = StringPrintf("%s %d at %s:%d",
288 prefix,
289 (obj == nullptr ? -1 : static_cast<int32_t>(reinterpret_cast<uintptr_t>(obj))),
290 (filename != nullptr ? filename : "null"),
291 line_number);
292 ATRACE_BEGIN(tmp.c_str());
293}
294
295void Monitor::AtraceMonitorUnlock() {
296 if (UNLIKELY(VLOG_IS_ON(systrace_lock_logging))) {
297 ATRACE_END();
298 }
299}
300
Mathieu Chartier0ffdc9c2016-04-19 13:46:03 -0700301std::string Monitor::PrettyContentionInfo(const std::string& owner_name,
302 pid_t owner_tid,
Mathieu Chartier74b3c8f2016-04-15 19:11:45 -0700303 ArtMethod* owners_method,
304 uint32_t owners_dex_pc,
305 size_t num_waiters) {
Mathieu Chartier74b3c8f2016-04-15 19:11:45 -0700306 const char* owners_filename;
Goran Jakovljevic49c882b2016-04-19 10:27:21 +0200307 int32_t owners_line_number = 0;
Mathieu Chartier74b3c8f2016-04-15 19:11:45 -0700308 if (owners_method != nullptr) {
309 TranslateLocation(owners_method, owners_dex_pc, &owners_filename, &owners_line_number);
310 }
311 std::ostringstream oss;
Mathieu Chartier0ffdc9c2016-04-19 13:46:03 -0700312 oss << "monitor contention with owner " << owner_name << " (" << owner_tid << ")";
Mathieu Chartier74b3c8f2016-04-15 19:11:45 -0700313 if (owners_method != nullptr) {
David Sehr709b0702016-10-13 09:12:37 -0700314 oss << " at " << owners_method->PrettyMethod();
Mathieu Chartier36891fe2016-04-28 17:21:08 -0700315 oss << "(" << owners_filename << ":" << owners_line_number << ")";
Mathieu Chartier74b3c8f2016-04-15 19:11:45 -0700316 }
317 oss << " waiters=" << num_waiters;
318 return oss.str();
319}
320
Mathieu Chartier4b0ef1c2016-07-29 16:26:01 -0700321bool Monitor::TryLockLocked(Thread* self) {
322 if (owner_ == nullptr) { // Unowned.
323 owner_ = self;
324 CHECK_EQ(lock_count_, 0);
325 // When debugging, save the current monitor holder for future
326 // acquisition failures to use in sampled logging.
327 if (lock_profiling_threshold_ != 0) {
328 locking_method_ = self->GetCurrentMethod(&locking_dex_pc_);
329 }
330 } else if (owner_ == self) { // Recursive.
331 lock_count_++;
332 } else {
333 return false;
334 }
335 AtraceMonitorLock(self, GetObject(), false /* is_wait */);
336 return true;
337}
338
339bool Monitor::TryLock(Thread* self) {
340 MutexLock mu(self, monitor_lock_);
341 return TryLockLocked(self);
342}
343
Elliott Hughes5f791332011-09-15 17:45:30 -0700344void Monitor::Lock(Thread* self) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700345 MutexLock mu(self, monitor_lock_);
346 while (true) {
Mathieu Chartier4b0ef1c2016-07-29 16:26:01 -0700347 if (TryLockLocked(self)) {
348 return;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700349 }
350 // Contended.
351 const bool log_contention = (lock_profiling_threshold_ != 0);
Xin Guanb894a192014-08-22 11:55:37 -0500352 uint64_t wait_start_ms = log_contention ? MilliTime() : 0;
Mathieu Chartiere401d142015-04-22 13:56:20 -0700353 ArtMethod* owners_method = locking_method_;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700354 uint32_t owners_dex_pc = locking_dex_pc_;
Mathieu Chartier440e4ce2014-03-31 16:36:35 -0700355 // Do this before releasing the lock so that we don't get deflated.
Mathieu Chartierb9001ab2014-10-03 13:28:46 -0700356 size_t num_waiters = num_waiters_;
Mathieu Chartier440e4ce2014-03-31 16:36:35 -0700357 ++num_waiters_;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700358 monitor_lock_.Unlock(self); // Let go of locks in order.
Mathieu Chartiera6e7f082014-05-22 14:43:37 -0700359 self->SetMonitorEnterObject(GetObject());
Elliott Hughes5f791332011-09-15 17:45:30 -0700360 {
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700361 uint32_t original_owner_thread_id = 0u;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700362 ScopedThreadStateChange tsc(self, kBlocked); // Change to blocked and give up mutator_lock_.
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700363 {
364 // Reacquire monitor_lock_ without mutator_lock_ for Wait.
365 MutexLock mu2(self, monitor_lock_);
366 if (owner_ != nullptr) { // Did the owner_ give the lock up?
367 original_owner_thread_id = owner_->GetThreadId();
368 if (ATRACE_ENABLED()) {
369 std::ostringstream oss;
Mathieu Chartier0ffdc9c2016-04-19 13:46:03 -0700370 std::string name;
371 owner_->GetThreadName(name);
372 oss << PrettyContentionInfo(name,
373 owner_->GetTid(),
374 owners_method,
375 owners_dex_pc,
376 num_waiters);
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700377 // Add info for contending thread.
378 uint32_t pc;
379 ArtMethod* m = self->GetCurrentMethod(&pc);
380 const char* filename;
381 int32_t line_number;
382 TranslateLocation(m, pc, &filename, &line_number);
Mathieu Chartier36891fe2016-04-28 17:21:08 -0700383 oss << " blocking from "
David Sehr709b0702016-10-13 09:12:37 -0700384 << ArtMethod::PrettyMethod(m) << "(" << (filename != nullptr ? filename : "null")
385 << ":" << line_number << ")";
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700386 ATRACE_BEGIN(oss.str().c_str());
387 }
388 monitor_contenders_.Wait(self); // Still contended so wait.
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -0800389 }
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700390 }
391 if (original_owner_thread_id != 0u) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700392 // Woken from contention.
393 if (log_contention) {
Mathieu Chartier0ffdc9c2016-04-19 13:46:03 -0700394 uint32_t original_owner_tid = 0;
395 std::string original_owner_name;
396 {
397 MutexLock mu2(Thread::Current(), *Locks::thread_list_lock_);
398 // Re-find the owner in case the thread got killed.
399 Thread* original_owner = Runtime::Current()->GetThreadList()->FindThreadByThreadId(
400 original_owner_thread_id);
401 // Do not do any work that requires the mutator lock.
402 if (original_owner != nullptr) {
403 original_owner_tid = original_owner->GetTid();
404 original_owner->GetThreadName(original_owner_name);
405 }
406 }
407
408 if (original_owner_tid != 0u) {
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700409 uint64_t wait_ms = MilliTime() - wait_start_ms;
410 uint32_t sample_percent;
411 if (wait_ms >= lock_profiling_threshold_) {
412 sample_percent = 100;
413 } else {
414 sample_percent = 100 * wait_ms / lock_profiling_threshold_;
Mathieu Chartier74b3c8f2016-04-15 19:11:45 -0700415 }
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700416 if (sample_percent != 0 && (static_cast<uint32_t>(rand() % 100) < sample_percent)) {
417 if (wait_ms > kLongWaitMs && owners_method != nullptr) {
Mathieu Chartier36891fe2016-04-28 17:21:08 -0700418 uint32_t pc;
419 ArtMethod* m = self->GetCurrentMethod(&pc);
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700420 // TODO: We should maybe check that original_owner is still a live thread.
421 LOG(WARNING) << "Long "
Mathieu Chartier0ffdc9c2016-04-19 13:46:03 -0700422 << PrettyContentionInfo(original_owner_name,
423 original_owner_tid,
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700424 owners_method,
425 owners_dex_pc,
426 num_waiters)
David Sehr709b0702016-10-13 09:12:37 -0700427 << " in " << ArtMethod::PrettyMethod(m) << " for "
428 << PrettyDuration(MsToNs(wait_ms));
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700429 }
430 const char* owners_filename;
431 int32_t owners_line_number;
432 TranslateLocation(owners_method,
433 owners_dex_pc,
434 &owners_filename,
435 &owners_line_number);
436 LogContentionEvent(self,
437 wait_ms,
438 sample_percent,
439 owners_filename,
440 owners_line_number);
441 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700442 }
443 }
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -0800444 ATRACE_END();
Elliott Hughesfc861622011-10-17 17:57:47 -0700445 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700446 }
Mathieu Chartiera6e7f082014-05-22 14:43:37 -0700447 self->SetMonitorEnterObject(nullptr);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700448 monitor_lock_.Lock(self); // Reacquire locks in order.
Mathieu Chartier440e4ce2014-03-31 16:36:35 -0700449 --num_waiters_;
Elliott Hughesfc861622011-10-17 17:57:47 -0700450 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700451}
452
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800453static void ThrowIllegalMonitorStateExceptionF(const char* fmt, ...)
454 __attribute__((format(printf, 1, 2)));
455
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700456static void ThrowIllegalMonitorStateExceptionF(const char* fmt, ...)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700457 REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800458 va_list args;
459 va_start(args, fmt);
Ian Rogers62d6c772013-02-27 08:32:07 -0800460 Thread* self = Thread::Current();
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000461 self->ThrowNewExceptionV("Ljava/lang/IllegalMonitorStateException;", fmt, args);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700462 if (!Runtime::Current()->IsStarted() || VLOG_IS_ON(monitor)) {
Brian Carlstrom64277f32012-03-26 23:53:34 -0700463 std::ostringstream ss;
Ian Rogers62d6c772013-02-27 08:32:07 -0800464 self->Dump(ss);
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700465 LOG(Runtime::Current()->IsStarted() ? ::android::base::INFO : ::android::base::ERROR)
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000466 << self->GetException()->Dump() << "\n" << ss.str();
Brian Carlstrom64277f32012-03-26 23:53:34 -0700467 }
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800468 va_end(args);
469}
470
Elliott Hughesd4237412012-02-21 11:24:45 -0800471static std::string ThreadToString(Thread* thread) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700472 if (thread == nullptr) {
473 return "nullptr";
Elliott Hughesd4237412012-02-21 11:24:45 -0800474 }
475 std::ostringstream oss;
476 // TODO: alternatively, we could just return the thread's name.
477 oss << *thread;
478 return oss.str();
479}
480
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700481void Monitor::FailedUnlock(mirror::Object* o,
482 uint32_t expected_owner_thread_id,
483 uint32_t found_owner_thread_id,
Elliott Hughesffb465f2012-03-01 18:46:05 -0800484 Monitor* monitor) {
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700485 // Acquire thread list lock so threads won't disappear from under us.
Elliott Hughesffb465f2012-03-01 18:46:05 -0800486 std::string current_owner_string;
487 std::string expected_owner_string;
488 std::string found_owner_string;
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700489 uint32_t current_owner_thread_id = 0u;
Elliott Hughesffb465f2012-03-01 18:46:05 -0800490 {
Ian Rogers50b35e22012-10-04 10:09:15 -0700491 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700492 ThreadList* const thread_list = Runtime::Current()->GetThreadList();
493 Thread* expected_owner = thread_list->FindThreadByThreadId(expected_owner_thread_id);
494 Thread* found_owner = thread_list->FindThreadByThreadId(found_owner_thread_id);
495
Elliott Hughesffb465f2012-03-01 18:46:05 -0800496 // Re-read owner now that we hold lock.
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700497 Thread* current_owner = (monitor != nullptr) ? monitor->GetOwner() : nullptr;
498 if (current_owner != nullptr) {
499 current_owner_thread_id = current_owner->GetThreadId();
500 }
Elliott Hughesffb465f2012-03-01 18:46:05 -0800501 // Get short descriptions of the threads involved.
502 current_owner_string = ThreadToString(current_owner);
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700503 expected_owner_string = expected_owner != nullptr ? ThreadToString(expected_owner) : "unnamed";
504 found_owner_string = found_owner != nullptr ? ThreadToString(found_owner) : "unnamed";
Elliott Hughesffb465f2012-03-01 18:46:05 -0800505 }
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700506
507 if (current_owner_thread_id == 0u) {
508 if (found_owner_thread_id == 0u) {
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800509 ThrowIllegalMonitorStateExceptionF("unlock of unowned monitor on object of type '%s'"
510 " on thread '%s'",
David Sehr709b0702016-10-13 09:12:37 -0700511 mirror::Object::PrettyTypeOf(o).c_str(),
Elliott Hughesffb465f2012-03-01 18:46:05 -0800512 expected_owner_string.c_str());
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800513 } else {
514 // Race: the original read found an owner but now there is none
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800515 ThrowIllegalMonitorStateExceptionF("unlock of monitor owned by '%s' on object of type '%s'"
516 " (where now the monitor appears unowned) on thread '%s'",
Elliott Hughesffb465f2012-03-01 18:46:05 -0800517 found_owner_string.c_str(),
David Sehr709b0702016-10-13 09:12:37 -0700518 mirror::Object::PrettyTypeOf(o).c_str(),
Elliott Hughesffb465f2012-03-01 18:46:05 -0800519 expected_owner_string.c_str());
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800520 }
521 } else {
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700522 if (found_owner_thread_id == 0u) {
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800523 // Race: originally there was no owner, there is now
524 ThrowIllegalMonitorStateExceptionF("unlock of monitor owned by '%s' on object of type '%s'"
525 " (originally believed to be unowned) on thread '%s'",
Elliott Hughesffb465f2012-03-01 18:46:05 -0800526 current_owner_string.c_str(),
David Sehr709b0702016-10-13 09:12:37 -0700527 mirror::Object::PrettyTypeOf(o).c_str(),
Elliott Hughesffb465f2012-03-01 18:46:05 -0800528 expected_owner_string.c_str());
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800529 } else {
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700530 if (found_owner_thread_id != current_owner_thread_id) {
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800531 // Race: originally found and current owner have changed
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800532 ThrowIllegalMonitorStateExceptionF("unlock of monitor originally owned by '%s' (now"
533 " owned by '%s') on object of type '%s' on thread '%s'",
Elliott Hughesffb465f2012-03-01 18:46:05 -0800534 found_owner_string.c_str(),
535 current_owner_string.c_str(),
David Sehr709b0702016-10-13 09:12:37 -0700536 mirror::Object::PrettyTypeOf(o).c_str(),
Elliott Hughesffb465f2012-03-01 18:46:05 -0800537 expected_owner_string.c_str());
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800538 } else {
539 ThrowIllegalMonitorStateExceptionF("unlock of monitor owned by '%s' on object of type '%s'"
540 " on thread '%s",
Elliott Hughesffb465f2012-03-01 18:46:05 -0800541 current_owner_string.c_str(),
David Sehr709b0702016-10-13 09:12:37 -0700542 mirror::Object::PrettyTypeOf(o).c_str(),
Elliott Hughesffb465f2012-03-01 18:46:05 -0800543 expected_owner_string.c_str());
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800544 }
545 }
546 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700547}
548
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700549bool Monitor::Unlock(Thread* self) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700550 DCHECK(self != nullptr);
Mathieu Chartier0ffdc9c2016-04-19 13:46:03 -0700551 uint32_t owner_thread_id = 0u;
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700552 {
553 MutexLock mu(self, monitor_lock_);
554 Thread* owner = owner_;
Mathieu Chartier0ffdc9c2016-04-19 13:46:03 -0700555 if (owner != nullptr) {
556 owner_thread_id = owner->GetThreadId();
557 }
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700558 if (owner == self) {
559 // We own the monitor, so nobody else can be in here.
Andreas Gampec7ed09b2016-04-25 20:08:55 -0700560 AtraceMonitorUnlock();
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700561 if (lock_count_ == 0) {
562 owner_ = nullptr;
563 locking_method_ = nullptr;
564 locking_dex_pc_ = 0;
565 // Wake a contender.
566 monitor_contenders_.Signal(self);
567 } else {
568 --lock_count_;
569 }
570 return true;
Elliott Hughes5f791332011-09-15 17:45:30 -0700571 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700572 }
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700573 // We don't own this, so we're not allowed to unlock it.
574 // The JNI spec says that we should throw IllegalMonitorStateException in this case.
575 FailedUnlock(GetObject(), self->GetThreadId(), owner_thread_id, this);
576 return false;
Elliott Hughes5f791332011-09-15 17:45:30 -0700577}
578
Elliott Hughes4cd121e2013-01-07 17:35:41 -0800579void Monitor::Wait(Thread* self, int64_t ms, int32_t ns,
580 bool interruptShouldThrow, ThreadState why) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700581 DCHECK(self != nullptr);
Elliott Hughes4cd121e2013-01-07 17:35:41 -0800582 DCHECK(why == kTimedWaiting || why == kWaiting || why == kSleeping);
Elliott Hughes5f791332011-09-15 17:45:30 -0700583
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700584 monitor_lock_.Lock(self);
585
Elliott Hughes5f791332011-09-15 17:45:30 -0700586 // Make sure that we hold the lock.
587 if (owner_ != self) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700588 monitor_lock_.Unlock(self);
Elena Sayapina1af6a1f2014-06-20 16:58:37 +0700589 ThrowIllegalMonitorStateExceptionF("object not locked by thread before wait()");
Elliott Hughes5f791332011-09-15 17:45:30 -0700590 return;
591 }
Elliott Hughes4cd121e2013-01-07 17:35:41 -0800592
Elliott Hughesdf42c482013-01-09 12:49:02 -0800593 // We need to turn a zero-length timed wait into a regular wait because
594 // Object.wait(0, 0) is defined as Object.wait(0), which is defined as Object.wait().
595 if (why == kTimedWaiting && (ms == 0 && ns == 0)) {
596 why = kWaiting;
597 }
598
Elliott Hughes5f791332011-09-15 17:45:30 -0700599 // Enforce the timeout range.
600 if (ms < 0 || ns < 0 || ns > 999999) {
Elena Sayapina1af6a1f2014-06-20 16:58:37 +0700601 monitor_lock_.Unlock(self);
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000602 self->ThrowNewExceptionF("Ljava/lang/IllegalArgumentException;",
Ian Rogersef7d42f2014-01-06 12:55:46 -0800603 "timeout arguments out of range: ms=%" PRId64 " ns=%d", ms, ns);
Elliott Hughes5f791332011-09-15 17:45:30 -0700604 return;
605 }
606
Elliott Hughes5f791332011-09-15 17:45:30 -0700607 /*
608 * Add ourselves to the set of threads waiting on this monitor, and
609 * release our hold. We need to let it go even if we're a few levels
610 * deep in a recursive lock, and we need to restore that later.
611 *
612 * We append to the wait set ahead of clearing the count and owner
613 * fields so the subroutine can check that the calling thread owns
614 * the monitor. Aside from that, the order of member updates is
615 * not order sensitive as we hold the pthread mutex.
616 */
617 AppendToWaitSet(self);
Mathieu Chartier440e4ce2014-03-31 16:36:35 -0700618 ++num_waiters_;
Ian Rogers0399dde2012-06-06 17:09:28 -0700619 int prev_lock_count = lock_count_;
Elliott Hughes5f791332011-09-15 17:45:30 -0700620 lock_count_ = 0;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700621 owner_ = nullptr;
Mathieu Chartiere401d142015-04-22 13:56:20 -0700622 ArtMethod* saved_method = locking_method_;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700623 locking_method_ = nullptr;
Ian Rogers0399dde2012-06-06 17:09:28 -0700624 uintptr_t saved_dex_pc = locking_dex_pc_;
625 locking_dex_pc_ = 0;
Elliott Hughes5f791332011-09-15 17:45:30 -0700626
Andreas Gampec7ed09b2016-04-25 20:08:55 -0700627 AtraceMonitorUnlock(); // For the implict Unlock() just above. This will only end the deepest
628 // nesting, but that is enough for the visualization, and corresponds to
629 // the single Lock() we do afterwards.
630 AtraceMonitorLock(self, GetObject(), true /* is_wait */);
631
Elliott Hughesb4e94fd2013-01-08 14:41:26 -0800632 bool was_interrupted = false;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700633 {
Mathieu Chartierf1d666e2015-09-03 16:13:34 -0700634 // Update thread state. If the GC wakes up, it'll ignore us, knowing
635 // that we won't touch any references in this state, and we'll check
636 // our suspend mode before we transition out.
637 ScopedThreadSuspension sts(self, why);
638
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700639 // Pseudo-atomically wait on self's wait_cond_ and release the monitor lock.
Ian Rogersdd7624d2014-03-14 17:43:00 -0700640 MutexLock mu(self, *self->GetWaitMutex());
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700641
642 // Set wait_monitor_ to the monitor object we will be waiting on. When wait_monitor_ is
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700643 // non-null a notifying or interrupting thread must signal the thread's wait_cond_ to wake it
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700644 // up.
Ian Rogersdd7624d2014-03-14 17:43:00 -0700645 DCHECK(self->GetWaitMonitor() == nullptr);
646 self->SetWaitMonitor(this);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700647
648 // Release the monitor lock.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700649 monitor_contenders_.Signal(self);
650 monitor_lock_.Unlock(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700651
Elliott Hughesb4e94fd2013-01-08 14:41:26 -0800652 // Handle the case where the thread was interrupted before we called wait().
Ian Rogersdd7624d2014-03-14 17:43:00 -0700653 if (self->IsInterruptedLocked()) {
Elliott Hughesb4e94fd2013-01-08 14:41:26 -0800654 was_interrupted = true;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700655 } else {
656 // Wait for a notification or a timeout to occur.
Elliott Hughes4cd121e2013-01-07 17:35:41 -0800657 if (why == kWaiting) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700658 self->GetWaitConditionVariable()->Wait(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700659 } else {
Elliott Hughes4cd121e2013-01-07 17:35:41 -0800660 DCHECK(why == kTimedWaiting || why == kSleeping) << why;
Ian Rogersdd7624d2014-03-14 17:43:00 -0700661 self->GetWaitConditionVariable()->TimedWait(self, ms, ns);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700662 }
Hans Boehm328c5dc2015-11-11 16:13:57 -0800663 was_interrupted = self->IsInterruptedLocked();
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700664 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700665 }
666
Elliott Hughesb4e94fd2013-01-08 14:41:26 -0800667 {
668 // We reset the thread's wait_monitor_ field after transitioning back to runnable so
669 // that a thread in a waiting/sleeping state has a non-null wait_monitor_ for debugging
670 // and diagnostic purposes. (If you reset this earlier, stack dumps will claim that threads
671 // are waiting on "null".)
Ian Rogersdd7624d2014-03-14 17:43:00 -0700672 MutexLock mu(self, *self->GetWaitMutex());
673 DCHECK(self->GetWaitMonitor() != nullptr);
674 self->SetWaitMonitor(nullptr);
Elliott Hughesb4e94fd2013-01-08 14:41:26 -0800675 }
676
Mathieu Chartierdaed5d82016-03-10 10:49:35 -0800677 // Allocate the interrupted exception not holding the monitor lock since it may cause a GC.
678 // If the GC requires acquiring the monitor for enqueuing cleared references, this would
679 // cause a deadlock if the monitor is held.
680 if (was_interrupted && interruptShouldThrow) {
681 /*
682 * We were interrupted while waiting, or somebody interrupted an
683 * un-interruptible thread earlier and we're bailing out immediately.
684 *
685 * The doc sayeth: "The interrupted status of the current thread is
686 * cleared when this exception is thrown."
687 */
688 {
689 MutexLock mu(self, *self->GetWaitMutex());
690 self->SetInterruptedLocked(false);
691 }
692 self->ThrowNewException("Ljava/lang/InterruptedException;", nullptr);
693 }
694
Andreas Gampec7ed09b2016-04-25 20:08:55 -0700695 AtraceMonitorUnlock(); // End Wait().
696
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700697 // Re-acquire the monitor and lock.
Elliott Hughes5f791332011-09-15 17:45:30 -0700698 Lock(self);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700699 monitor_lock_.Lock(self);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700700 self->GetWaitMutex()->AssertNotHeld(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700701
Elliott Hughes5f791332011-09-15 17:45:30 -0700702 /*
703 * We remove our thread from wait set after restoring the count
704 * and owner fields so the subroutine can check that the calling
705 * thread owns the monitor. Aside from that, the order of member
706 * updates is not order sensitive as we hold the pthread mutex.
707 */
708 owner_ = self;
Ian Rogers0399dde2012-06-06 17:09:28 -0700709 lock_count_ = prev_lock_count;
710 locking_method_ = saved_method;
711 locking_dex_pc_ = saved_dex_pc;
Mathieu Chartier440e4ce2014-03-31 16:36:35 -0700712 --num_waiters_;
Elliott Hughes5f791332011-09-15 17:45:30 -0700713 RemoveFromWaitSet(self);
714
Elena Sayapina1af6a1f2014-06-20 16:58:37 +0700715 monitor_lock_.Unlock(self);
Elliott Hughes5f791332011-09-15 17:45:30 -0700716}
717
718void Monitor::Notify(Thread* self) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700719 DCHECK(self != nullptr);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700720 MutexLock mu(self, monitor_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700721 // Make sure that we hold the lock.
722 if (owner_ != self) {
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800723 ThrowIllegalMonitorStateExceptionF("object not locked by thread before notify()");
Elliott Hughes5f791332011-09-15 17:45:30 -0700724 return;
725 }
726 // Signal the first waiting thread in the wait set.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700727 while (wait_set_ != nullptr) {
Elliott Hughes5f791332011-09-15 17:45:30 -0700728 Thread* thread = wait_set_;
Ian Rogersdd7624d2014-03-14 17:43:00 -0700729 wait_set_ = thread->GetWaitNext();
730 thread->SetWaitNext(nullptr);
Elliott Hughes5f791332011-09-15 17:45:30 -0700731
732 // Check to see if the thread is still waiting.
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800733 MutexLock wait_mu(self, *thread->GetWaitMutex());
Ian Rogersdd7624d2014-03-14 17:43:00 -0700734 if (thread->GetWaitMonitor() != nullptr) {
735 thread->GetWaitConditionVariable()->Signal(self);
Elliott Hughes5f791332011-09-15 17:45:30 -0700736 return;
737 }
738 }
739}
740
741void Monitor::NotifyAll(Thread* self) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700742 DCHECK(self != nullptr);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700743 MutexLock mu(self, monitor_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700744 // Make sure that we hold the lock.
745 if (owner_ != self) {
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800746 ThrowIllegalMonitorStateExceptionF("object not locked by thread before notifyAll()");
Elliott Hughes5f791332011-09-15 17:45:30 -0700747 return;
748 }
749 // Signal all threads in the wait set.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700750 while (wait_set_ != nullptr) {
Elliott Hughes5f791332011-09-15 17:45:30 -0700751 Thread* thread = wait_set_;
Ian Rogersdd7624d2014-03-14 17:43:00 -0700752 wait_set_ = thread->GetWaitNext();
753 thread->SetWaitNext(nullptr);
Elliott Hughes5f791332011-09-15 17:45:30 -0700754 thread->Notify();
755 }
756}
757
Mathieu Chartier590fee92013-09-13 13:46:47 -0700758bool Monitor::Deflate(Thread* self, mirror::Object* obj) {
759 DCHECK(obj != nullptr);
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -0700760 // Don't need volatile since we only deflate with mutators suspended.
761 LockWord lw(obj->GetLockWord(false));
Mathieu Chartier590fee92013-09-13 13:46:47 -0700762 // If the lock isn't an inflated monitor, then we don't need to deflate anything.
763 if (lw.GetState() == LockWord::kFatLocked) {
764 Monitor* monitor = lw.FatLockMonitor();
Mathieu Chartier440e4ce2014-03-31 16:36:35 -0700765 DCHECK(monitor != nullptr);
Mathieu Chartier590fee92013-09-13 13:46:47 -0700766 MutexLock mu(self, monitor->monitor_lock_);
Mathieu Chartier440e4ce2014-03-31 16:36:35 -0700767 // Can't deflate if we have anybody waiting on the CV.
768 if (monitor->num_waiters_ > 0) {
769 return false;
770 }
Mathieu Chartier590fee92013-09-13 13:46:47 -0700771 Thread* owner = monitor->owner_;
772 if (owner != nullptr) {
773 // Can't deflate if we are locked and have a hash code.
774 if (monitor->HasHashCode()) {
775 return false;
776 }
777 // Can't deflate if our lock count is too high.
Mathieu Chartier1cf194f2016-11-01 20:13:24 -0700778 if (static_cast<uint32_t>(monitor->lock_count_) > LockWord::kThinLockMaxCount) {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700779 return false;
780 }
Mathieu Chartier590fee92013-09-13 13:46:47 -0700781 // Deflate to a thin lock.
Mathieu Chartier36a270a2016-07-28 18:08:51 -0700782 LockWord new_lw = LockWord::FromThinLockId(owner->GetThreadId(),
783 monitor->lock_count_,
784 lw.GCState());
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -0800785 // Assume no concurrent read barrier state changes as mutators are suspended.
786 obj->SetLockWord(new_lw, false);
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -0700787 VLOG(monitor) << "Deflated " << obj << " to thin lock " << owner->GetTid() << " / "
788 << monitor->lock_count_;
Mathieu Chartier590fee92013-09-13 13:46:47 -0700789 } else if (monitor->HasHashCode()) {
Mathieu Chartier36a270a2016-07-28 18:08:51 -0700790 LockWord new_lw = LockWord::FromHashCode(monitor->GetHashCode(), lw.GCState());
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -0800791 // Assume no concurrent read barrier state changes as mutators are suspended.
792 obj->SetLockWord(new_lw, false);
Mathieu Chartier440e4ce2014-03-31 16:36:35 -0700793 VLOG(monitor) << "Deflated " << obj << " to hash monitor " << monitor->GetHashCode();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700794 } else {
795 // No lock and no hash, just put an empty lock word inside the object.
Mathieu Chartier36a270a2016-07-28 18:08:51 -0700796 LockWord new_lw = LockWord::FromDefault(lw.GCState());
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -0800797 // Assume no concurrent read barrier state changes as mutators are suspended.
798 obj->SetLockWord(new_lw, false);
Mathieu Chartier440e4ce2014-03-31 16:36:35 -0700799 VLOG(monitor) << "Deflated" << obj << " to empty lock word";
Mathieu Chartier590fee92013-09-13 13:46:47 -0700800 }
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700801 // The monitor is deflated, mark the object as null so that we know to delete it during the
Mathieu Chartier590fee92013-09-13 13:46:47 -0700802 // next GC.
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700803 monitor->obj_ = GcRoot<mirror::Object>(nullptr);
Mathieu Chartier590fee92013-09-13 13:46:47 -0700804 }
805 return true;
806}
807
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700808void Monitor::Inflate(Thread* self, Thread* owner, mirror::Object* obj, int32_t hash_code) {
Andreas Gampe74240812014-04-17 10:35:09 -0700809 DCHECK(self != nullptr);
810 DCHECK(obj != nullptr);
Elliott Hughes5f791332011-09-15 17:45:30 -0700811 // Allocate and acquire a new monitor.
Andreas Gampe74240812014-04-17 10:35:09 -0700812 Monitor* m = MonitorPool::CreateMonitor(self, owner, obj, hash_code);
813 DCHECK(m != nullptr);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700814 if (m->Install(self)) {
Haifeng Li86ab7912014-05-16 10:47:59 +0800815 if (owner != nullptr) {
816 VLOG(monitor) << "monitor: thread" << owner->GetThreadId()
Andreas Gampe74240812014-04-17 10:35:09 -0700817 << " created monitor " << m << " for object " << obj;
Haifeng Li86ab7912014-05-16 10:47:59 +0800818 } else {
819 VLOG(monitor) << "monitor: Inflate with hashcode " << hash_code
Andreas Gampe74240812014-04-17 10:35:09 -0700820 << " created monitor " << m << " for object " << obj;
Haifeng Li86ab7912014-05-16 10:47:59 +0800821 }
Andreas Gampe74240812014-04-17 10:35:09 -0700822 Runtime::Current()->GetMonitorList()->Add(m);
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -0700823 CHECK_EQ(obj->GetLockWord(true).GetState(), LockWord::kFatLocked);
Andreas Gampe74240812014-04-17 10:35:09 -0700824 } else {
825 MonitorPool::ReleaseMonitor(self, m);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700826 }
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700827}
828
Mathieu Chartier0cd81352014-05-22 16:48:55 -0700829void Monitor::InflateThinLocked(Thread* self, Handle<mirror::Object> obj, LockWord lock_word,
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700830 uint32_t hash_code) {
831 DCHECK_EQ(lock_word.GetState(), LockWord::kThinLocked);
832 uint32_t owner_thread_id = lock_word.ThinLockOwner();
833 if (owner_thread_id == self->GetThreadId()) {
834 // We own the monitor, we can easily inflate it.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700835 Inflate(self, self, obj.Get(), hash_code);
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700836 } else {
837 ThreadList* thread_list = Runtime::Current()->GetThreadList();
838 // Suspend the owner, inflate. First change to blocked and give up mutator_lock_.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700839 self->SetMonitorEnterObject(obj.Get());
Mathieu Chartiera1ee14f2014-05-14 16:51:03 -0700840 bool timed_out;
Mathieu Chartierf1d666e2015-09-03 16:13:34 -0700841 Thread* owner;
842 {
843 ScopedThreadSuspension sts(self, kBlocked);
844 owner = thread_list->SuspendThreadByThreadId(owner_thread_id, false, &timed_out);
845 }
Mathieu Chartiera1ee14f2014-05-14 16:51:03 -0700846 if (owner != nullptr) {
847 // We succeeded in suspending the thread, check the lock's status didn't change.
848 lock_word = obj->GetLockWord(true);
849 if (lock_word.GetState() == LockWord::kThinLocked &&
850 lock_word.ThinLockOwner() == owner_thread_id) {
851 // Go ahead and inflate the lock.
852 Inflate(self, owner, obj.Get(), hash_code);
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700853 }
Mathieu Chartiera1ee14f2014-05-14 16:51:03 -0700854 thread_list->Resume(owner, false);
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700855 }
Ian Rogersdd7624d2014-03-14 17:43:00 -0700856 self->SetMonitorEnterObject(nullptr);
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700857 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700858}
859
Ian Rogers719d1a32014-03-06 12:13:39 -0800860// Fool annotalysis into thinking that the lock on obj is acquired.
861static mirror::Object* FakeLock(mirror::Object* obj)
862 EXCLUSIVE_LOCK_FUNCTION(obj) NO_THREAD_SAFETY_ANALYSIS {
863 return obj;
864}
865
866// Fool annotalysis into thinking that the lock on obj is release.
867static mirror::Object* FakeUnlock(mirror::Object* obj)
868 UNLOCK_FUNCTION(obj) NO_THREAD_SAFETY_ANALYSIS {
869 return obj;
870}
871
Mathieu Chartier4b0ef1c2016-07-29 16:26:01 -0700872mirror::Object* Monitor::MonitorEnter(Thread* self, mirror::Object* obj, bool trylock) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700873 DCHECK(self != nullptr);
874 DCHECK(obj != nullptr);
Mathieu Chartier2d096c92015-10-12 16:18:20 -0700875 self->AssertThreadSuspensionIsAllowable();
Ian Rogers719d1a32014-03-06 12:13:39 -0800876 obj = FakeLock(obj);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700877 uint32_t thread_id = self->GetThreadId();
878 size_t contention_count = 0;
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700879 StackHandleScope<1> hs(self);
880 Handle<mirror::Object> h_obj(hs.NewHandle(obj));
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700881 while (true) {
Hans Boehmb3da36c2016-12-15 13:12:59 -0800882 // We initially read the lockword with ordinary Java/relaxed semantics. When stronger
883 // semantics are needed, we address it below. Since GetLockWord bottoms out to a relaxed load,
884 // we can fix it later, in an infrequently executed case, with a fence.
885 LockWord lock_word = h_obj->GetLockWord(false);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700886 switch (lock_word.GetState()) {
887 case LockWord::kUnlocked: {
Hans Boehmb3da36c2016-12-15 13:12:59 -0800888 // No ordering required for preceding lockword read, since we retest.
Mathieu Chartier36a270a2016-07-28 18:08:51 -0700889 LockWord thin_locked(LockWord::FromThinLockId(thread_id, 0, lock_word.GCState()));
Hans Boehmb3da36c2016-12-15 13:12:59 -0800890 if (h_obj->CasLockWordWeakAcquire(lock_word, thin_locked)) {
Andreas Gampec7ed09b2016-04-25 20:08:55 -0700891 AtraceMonitorLock(self, h_obj.Get(), false /* is_wait */);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700892 return h_obj.Get(); // Success!
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700893 }
894 continue; // Go again.
Elliott Hughes5f791332011-09-15 17:45:30 -0700895 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700896 case LockWord::kThinLocked: {
897 uint32_t owner_thread_id = lock_word.ThinLockOwner();
898 if (owner_thread_id == thread_id) {
Hans Boehmb3da36c2016-12-15 13:12:59 -0800899 // No ordering required for initial lockword read.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700900 // We own the lock, increase the recursion count.
901 uint32_t new_count = lock_word.ThinLockCount() + 1;
902 if (LIKELY(new_count <= LockWord::kThinLockMaxCount)) {
Mathieu Chartier36a270a2016-07-28 18:08:51 -0700903 LockWord thin_locked(LockWord::FromThinLockId(thread_id,
904 new_count,
905 lock_word.GCState()));
Hans Boehmb3da36c2016-12-15 13:12:59 -0800906 // Only this thread pays attention to the count. Thus there is no need for stronger
907 // than relaxed memory ordering.
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -0800908 if (!kUseReadBarrier) {
Hans Boehmb3da36c2016-12-15 13:12:59 -0800909 h_obj->SetLockWord(thin_locked, false /* volatile */);
Andreas Gampec7ed09b2016-04-25 20:08:55 -0700910 AtraceMonitorLock(self, h_obj.Get(), false /* is_wait */);
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -0800911 return h_obj.Get(); // Success!
912 } else {
913 // Use CAS to preserve the read barrier state.
Hans Boehmb3da36c2016-12-15 13:12:59 -0800914 if (h_obj->CasLockWordWeakRelaxed(lock_word, thin_locked)) {
Andreas Gampec7ed09b2016-04-25 20:08:55 -0700915 AtraceMonitorLock(self, h_obj.Get(), false /* is_wait */);
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -0800916 return h_obj.Get(); // Success!
917 }
918 }
919 continue; // Go again.
Elliott Hughes5f791332011-09-15 17:45:30 -0700920 } else {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700921 // We'd overflow the recursion count, so inflate the monitor.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700922 InflateThinLocked(self, h_obj, lock_word, 0);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700923 }
924 } else {
Mathieu Chartier4b0ef1c2016-07-29 16:26:01 -0700925 if (trylock) {
926 return nullptr;
927 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700928 // Contention.
929 contention_count++;
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700930 Runtime* runtime = Runtime::Current();
Hans Boehmb3da36c2016-12-15 13:12:59 -0800931 if (contention_count <= runtime->GetMaxSpinsBeforeThinLockInflation()) {
Mathieu Chartierb363f662014-07-16 13:28:58 -0700932 // TODO: Consider switching the thread state to kBlocked when we are yielding.
Mathieu Chartier251755c2014-07-15 18:10:25 -0700933 // Use sched_yield instead of NanoSleep since NanoSleep can wait much longer than the
934 // parameter you pass in. This can cause thread suspension to take excessively long
Mathieu Chartierb363f662014-07-16 13:28:58 -0700935 // and make long pauses. See b/16307460.
Hans Boehmb3da36c2016-12-15 13:12:59 -0800936 // TODO: We should literally spin first, without sched_yield. Sched_yield either does
937 // nothing (at significant expense), or guarantees that we wait at least microseconds.
938 // If the owner is running, I would expect the median lock hold time to be hundreds
939 // of nanoseconds or less.
Mathieu Chartier251755c2014-07-15 18:10:25 -0700940 sched_yield();
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700941 } else {
942 contention_count = 0;
Hans Boehmb3da36c2016-12-15 13:12:59 -0800943 // No ordering required for initial lockword read. Install rereads it anyway.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700944 InflateThinLocked(self, h_obj, lock_word, 0);
Elliott Hughes5f791332011-09-15 17:45:30 -0700945 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700946 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700947 continue; // Start from the beginning.
Elliott Hughes5f791332011-09-15 17:45:30 -0700948 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700949 case LockWord::kFatLocked: {
Hans Boehmb3da36c2016-12-15 13:12:59 -0800950 // We should have done an acquire read of the lockword initially, to ensure
951 // visibility of the monitor data structure. Use an explicit fence instead.
952 QuasiAtomic::ThreadFenceAcquire();
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700953 Monitor* mon = lock_word.FatLockMonitor();
Mathieu Chartier4b0ef1c2016-07-29 16:26:01 -0700954 if (trylock) {
955 return mon->TryLock(self) ? h_obj.Get() : nullptr;
956 } else {
957 mon->Lock(self);
958 return h_obj.Get(); // Success!
959 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700960 }
Ian Rogers719d1a32014-03-06 12:13:39 -0800961 case LockWord::kHashCode:
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700962 // Inflate with the existing hashcode.
Hans Boehmb3da36c2016-12-15 13:12:59 -0800963 // Again no ordering required for initial lockword read, since we don't rely
964 // on the visibility of any prior computation.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700965 Inflate(self, nullptr, h_obj.Get(), lock_word.GetHashCode());
Ian Rogers719d1a32014-03-06 12:13:39 -0800966 continue; // Start from the beginning.
Mathieu Chartier590fee92013-09-13 13:46:47 -0700967 default: {
968 LOG(FATAL) << "Invalid monitor state " << lock_word.GetState();
Andreas Gampec7ed09b2016-04-25 20:08:55 -0700969 UNREACHABLE();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700970 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700971 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700972 }
973}
974
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800975bool Monitor::MonitorExit(Thread* self, mirror::Object* obj) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700976 DCHECK(self != nullptr);
977 DCHECK(obj != nullptr);
Mathieu Chartier2d096c92015-10-12 16:18:20 -0700978 self->AssertThreadSuspensionIsAllowable();
Ian Rogers719d1a32014-03-06 12:13:39 -0800979 obj = FakeUnlock(obj);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700980 StackHandleScope<1> hs(self);
981 Handle<mirror::Object> h_obj(hs.NewHandle(obj));
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -0800982 while (true) {
983 LockWord lock_word = obj->GetLockWord(true);
984 switch (lock_word.GetState()) {
985 case LockWord::kHashCode:
986 // Fall-through.
987 case LockWord::kUnlocked:
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700988 FailedUnlock(h_obj.Get(), self->GetThreadId(), 0u, nullptr);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700989 return false; // Failure.
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -0800990 case LockWord::kThinLocked: {
991 uint32_t thread_id = self->GetThreadId();
992 uint32_t owner_thread_id = lock_word.ThinLockOwner();
993 if (owner_thread_id != thread_id) {
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700994 FailedUnlock(h_obj.Get(), thread_id, owner_thread_id, nullptr);
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -0800995 return false; // Failure.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700996 } else {
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -0800997 // We own the lock, decrease the recursion count.
998 LockWord new_lw = LockWord::Default();
999 if (lock_word.ThinLockCount() != 0) {
1000 uint32_t new_count = lock_word.ThinLockCount() - 1;
Mathieu Chartier36a270a2016-07-28 18:08:51 -07001001 new_lw = LockWord::FromThinLockId(thread_id, new_count, lock_word.GCState());
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -08001002 } else {
Mathieu Chartier36a270a2016-07-28 18:08:51 -07001003 new_lw = LockWord::FromDefault(lock_word.GCState());
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -08001004 }
1005 if (!kUseReadBarrier) {
1006 DCHECK_EQ(new_lw.ReadBarrierState(), 0U);
Hans Boehmb3da36c2016-12-15 13:12:59 -08001007 // TODO: This really only needs memory_order_release, but we currently have
1008 // no way to specify that. In fact there seem to be no legitimate uses of SetLockWord
1009 // with a final argument of true. This slows down x86 and ARMv7, but probably not v8.
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -08001010 h_obj->SetLockWord(new_lw, true);
Andreas Gampe6e759ad2016-05-17 10:13:10 -07001011 AtraceMonitorUnlock();
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -08001012 // Success!
1013 return true;
1014 } else {
1015 // Use CAS to preserve the read barrier state.
Hans Boehmb3da36c2016-12-15 13:12:59 -08001016 if (h_obj->CasLockWordWeakRelease(lock_word, new_lw)) {
Andreas Gampe6e759ad2016-05-17 10:13:10 -07001017 AtraceMonitorUnlock();
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -08001018 // Success!
1019 return true;
1020 }
1021 }
1022 continue; // Go again.
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001023 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001024 }
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -08001025 case LockWord::kFatLocked: {
1026 Monitor* mon = lock_word.FatLockMonitor();
1027 return mon->Unlock(self);
1028 }
1029 default: {
1030 LOG(FATAL) << "Invalid monitor state " << lock_word.GetState();
1031 return false;
1032 }
Mathieu Chartier590fee92013-09-13 13:46:47 -07001033 }
Elliott Hughes5f791332011-09-15 17:45:30 -07001034 }
Elliott Hughes5f791332011-09-15 17:45:30 -07001035}
1036
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001037void Monitor::Wait(Thread* self, mirror::Object *obj, int64_t ms, int32_t ns,
Elliott Hughes4cd121e2013-01-07 17:35:41 -08001038 bool interruptShouldThrow, ThreadState why) {
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -07001039 DCHECK(self != nullptr);
1040 DCHECK(obj != nullptr);
1041 LockWord lock_word = obj->GetLockWord(true);
Ian Rogers43c69cc2014-08-15 11:09:28 -07001042 while (lock_word.GetState() != LockWord::kFatLocked) {
1043 switch (lock_word.GetState()) {
1044 case LockWord::kHashCode:
1045 // Fall-through.
1046 case LockWord::kUnlocked:
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001047 ThrowIllegalMonitorStateExceptionF("object not locked by thread before wait()");
1048 return; // Failure.
Ian Rogers43c69cc2014-08-15 11:09:28 -07001049 case LockWord::kThinLocked: {
1050 uint32_t thread_id = self->GetThreadId();
1051 uint32_t owner_thread_id = lock_word.ThinLockOwner();
1052 if (owner_thread_id != thread_id) {
1053 ThrowIllegalMonitorStateExceptionF("object not locked by thread before wait()");
1054 return; // Failure.
1055 } else {
1056 // We own the lock, inflate to enqueue ourself on the Monitor. May fail spuriously so
1057 // re-load.
1058 Inflate(self, self, obj, 0);
1059 lock_word = obj->GetLockWord(true);
1060 }
1061 break;
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001062 }
Ian Rogers43c69cc2014-08-15 11:09:28 -07001063 case LockWord::kFatLocked: // Unreachable given the loop condition above. Fall-through.
1064 default: {
1065 LOG(FATAL) << "Invalid monitor state " << lock_word.GetState();
1066 return;
1067 }
Mathieu Chartier590fee92013-09-13 13:46:47 -07001068 }
Elliott Hughes5f791332011-09-15 17:45:30 -07001069 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001070 Monitor* mon = lock_word.FatLockMonitor();
1071 mon->Wait(self, ms, ns, interruptShouldThrow, why);
Elliott Hughes5f791332011-09-15 17:45:30 -07001072}
1073
Ian Rogers13c479e2013-10-11 07:59:01 -07001074void Monitor::DoNotify(Thread* self, mirror::Object* obj, bool notify_all) {
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -07001075 DCHECK(self != nullptr);
1076 DCHECK(obj != nullptr);
1077 LockWord lock_word = obj->GetLockWord(true);
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001078 switch (lock_word.GetState()) {
Mathieu Chartierad2541a2013-10-25 10:05:23 -07001079 case LockWord::kHashCode:
1080 // Fall-through.
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001081 case LockWord::kUnlocked:
Ian Rogers6d0b13e2012-02-07 09:25:29 -08001082 ThrowIllegalMonitorStateExceptionF("object not locked by thread before notify()");
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001083 return; // Failure.
1084 case LockWord::kThinLocked: {
1085 uint32_t thread_id = self->GetThreadId();
1086 uint32_t owner_thread_id = lock_word.ThinLockOwner();
1087 if (owner_thread_id != thread_id) {
1088 ThrowIllegalMonitorStateExceptionF("object not locked by thread before notify()");
1089 return; // Failure.
1090 } else {
1091 // We own the lock but there's no Monitor and therefore no waiters.
1092 return; // Success.
1093 }
Elliott Hughes5f791332011-09-15 17:45:30 -07001094 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001095 case LockWord::kFatLocked: {
1096 Monitor* mon = lock_word.FatLockMonitor();
1097 if (notify_all) {
1098 mon->NotifyAll(self);
1099 } else {
1100 mon->Notify(self);
1101 }
1102 return; // Success.
1103 }
Mathieu Chartier590fee92013-09-13 13:46:47 -07001104 default: {
1105 LOG(FATAL) << "Invalid monitor state " << lock_word.GetState();
1106 return;
1107 }
Elliott Hughes5f791332011-09-15 17:45:30 -07001108 }
1109}
1110
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001111uint32_t Monitor::GetLockOwnerThreadId(mirror::Object* obj) {
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -07001112 DCHECK(obj != nullptr);
1113 LockWord lock_word = obj->GetLockWord(true);
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001114 switch (lock_word.GetState()) {
Mathieu Chartierad2541a2013-10-25 10:05:23 -07001115 case LockWord::kHashCode:
1116 // Fall-through.
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001117 case LockWord::kUnlocked:
1118 return ThreadList::kInvalidThreadId;
1119 case LockWord::kThinLocked:
1120 return lock_word.ThinLockOwner();
1121 case LockWord::kFatLocked: {
1122 Monitor* mon = lock_word.FatLockMonitor();
1123 return mon->GetOwnerThreadId();
Elliott Hughes5f791332011-09-15 17:45:30 -07001124 }
Mathieu Chartier590fee92013-09-13 13:46:47 -07001125 default: {
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001126 LOG(FATAL) << "Unreachable";
Ian Rogers2c4257b2014-10-24 14:20:06 -07001127 UNREACHABLE();
Mathieu Chartier590fee92013-09-13 13:46:47 -07001128 }
Elliott Hughes5f791332011-09-15 17:45:30 -07001129 }
1130}
1131
Elliott Hughes8e4aac52011-09-26 17:03:36 -07001132void Monitor::DescribeWait(std::ostream& os, const Thread* thread) {
Ian Rogersd803bc72014-04-01 15:33:03 -07001133 // Determine the wait message and object we're waiting or blocked upon.
1134 mirror::Object* pretty_object = nullptr;
1135 const char* wait_message = nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001136 uint32_t lock_owner = ThreadList::kInvalidThreadId;
Ian Rogersd803bc72014-04-01 15:33:03 -07001137 ThreadState state = thread->GetState();
Elliott Hughesb4e94fd2013-01-08 14:41:26 -08001138 if (state == kWaiting || state == kTimedWaiting || state == kSleeping) {
Ian Rogersd803bc72014-04-01 15:33:03 -07001139 wait_message = (state == kSleeping) ? " - sleeping on " : " - waiting on ";
1140 Thread* self = Thread::Current();
1141 MutexLock mu(self, *thread->GetWaitMutex());
1142 Monitor* monitor = thread->GetWaitMonitor();
1143 if (monitor != nullptr) {
Hiroshi Yamauchi4cba0d92014-05-21 21:10:23 -07001144 pretty_object = monitor->GetObject();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001145 }
Elliott Hughes34e06962012-04-09 13:55:55 -07001146 } else if (state == kBlocked) {
Ian Rogersd803bc72014-04-01 15:33:03 -07001147 wait_message = " - waiting to lock ";
1148 pretty_object = thread->GetMonitorEnterObject();
1149 if (pretty_object != nullptr) {
Hiroshi Yamauchi7b08ae42016-10-04 15:20:36 -07001150 if (kUseReadBarrier && Thread::Current()->GetIsGcMarking()) {
1151 // We may call Thread::Dump() in the middle of the CC thread flip and this thread's stack
1152 // may have not been flipped yet and "pretty_object" may be a from-space (stale) ref, in
1153 // which case the GetLockOwnerThreadId() call below will crash. So explicitly mark/forward
1154 // it here.
1155 pretty_object = ReadBarrier::Mark(pretty_object);
1156 }
Ian Rogersd803bc72014-04-01 15:33:03 -07001157 lock_owner = pretty_object->GetLockOwnerThreadId();
Elliott Hughes8e4aac52011-09-26 17:03:36 -07001158 }
Elliott Hughes8e4aac52011-09-26 17:03:36 -07001159 }
Elliott Hughes8e4aac52011-09-26 17:03:36 -07001160
Ian Rogersd803bc72014-04-01 15:33:03 -07001161 if (wait_message != nullptr) {
1162 if (pretty_object == nullptr) {
1163 os << wait_message << "an unknown object";
1164 } else {
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -07001165 if ((pretty_object->GetLockWord(true).GetState() == LockWord::kThinLocked) &&
Ian Rogersd803bc72014-04-01 15:33:03 -07001166 Locks::mutator_lock_->IsExclusiveHeld(Thread::Current())) {
1167 // Getting the identity hashcode here would result in lock inflation and suspension of the
1168 // current thread, which isn't safe if this is the only runnable thread.
1169 os << wait_message << StringPrintf("<@addr=0x%" PRIxPTR "> (a %s)",
1170 reinterpret_cast<intptr_t>(pretty_object),
David Sehr709b0702016-10-13 09:12:37 -07001171 pretty_object->PrettyTypeOf().c_str());
Ian Rogersd803bc72014-04-01 15:33:03 -07001172 } else {
1173 // - waiting on <0x6008c468> (a java.lang.Class<java.lang.ref.ReferenceQueue>)
Mathieu Chartier49361592015-01-22 16:36:10 -08001174 // Call PrettyTypeOf before IdentityHashCode since IdentityHashCode can cause thread
1175 // suspension and move pretty_object.
David Sehr709b0702016-10-13 09:12:37 -07001176 const std::string pretty_type(pretty_object->PrettyTypeOf());
Ian Rogersd803bc72014-04-01 15:33:03 -07001177 os << wait_message << StringPrintf("<0x%08x> (a %s)", pretty_object->IdentityHashCode(),
Mathieu Chartier49361592015-01-22 16:36:10 -08001178 pretty_type.c_str());
Ian Rogersd803bc72014-04-01 15:33:03 -07001179 }
1180 }
1181 // - waiting to lock <0x613f83d8> (a java.lang.Object) held by thread 5
1182 if (lock_owner != ThreadList::kInvalidThreadId) {
1183 os << " held by thread " << lock_owner;
1184 }
1185 os << "\n";
Elliott Hughes8e4aac52011-09-26 17:03:36 -07001186 }
Elliott Hughes8e4aac52011-09-26 17:03:36 -07001187}
1188
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001189mirror::Object* Monitor::GetContendedMonitor(Thread* thread) {
Elliott Hughesf9501702013-01-11 11:22:27 -08001190 // This is used to implement JDWP's ThreadReference.CurrentContendedMonitor, and has a bizarre
1191 // definition of contended that includes a monitor a thread is trying to enter...
Ian Rogersdd7624d2014-03-14 17:43:00 -07001192 mirror::Object* result = thread->GetMonitorEnterObject();
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001193 if (result == nullptr) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001194 // ...but also a monitor that the thread is waiting on.
Ian Rogersdd7624d2014-03-14 17:43:00 -07001195 MutexLock mu(Thread::Current(), *thread->GetWaitMutex());
1196 Monitor* monitor = thread->GetWaitMonitor();
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001197 if (monitor != nullptr) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001198 result = monitor->GetObject();
Elliott Hughesf9501702013-01-11 11:22:27 -08001199 }
1200 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001201 return result;
Elliott Hughesf9501702013-01-11 11:22:27 -08001202}
1203
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001204void Monitor::VisitLocks(StackVisitor* stack_visitor, void (*callback)(mirror::Object*, void*),
Andreas Gampe760172c2014-08-16 13:41:10 -07001205 void* callback_context, bool abort_on_failure) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001206 ArtMethod* m = stack_visitor->GetMethod();
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001207 CHECK(m != nullptr);
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001208
1209 // Native methods are an easy special case.
1210 // TODO: use the JNI implementation's table of explicit MonitorEnter calls and dump those too.
1211 if (m->IsNative()) {
1212 if (m->IsSynchronized()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001213 mirror::Object* jni_this =
1214 stack_visitor->GetCurrentHandleScope(sizeof(void*))->GetReference(0);
Elliott Hughes4993bbc2013-01-10 15:41:25 -08001215 callback(jni_this, callback_context);
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001216 }
1217 return;
1218 }
1219
jeffhao61f916c2012-10-25 17:48:51 -07001220 // Proxy methods should not be synchronized.
1221 if (m->IsProxyMethod()) {
1222 CHECK(!m->IsSynchronized());
1223 return;
1224 }
1225
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001226 // Is there any reason to believe there's any synchronization in this method?
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07001227 const DexFile::CodeItem* code_item = m->GetCodeItem();
David Sehr709b0702016-10-13 09:12:37 -07001228 CHECK(code_item != nullptr) << m->PrettyMethod();
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001229 if (code_item->tries_size_ == 0) {
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001230 return; // No "tries" implies no synchronization, so no held locks to report.
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001231 }
1232
Andreas Gampe760172c2014-08-16 13:41:10 -07001233 // Get the dex pc. If abort_on_failure is false, GetDexPc will not abort in the case it cannot
1234 // find the dex pc, and instead return kDexNoIndex. Then bail out, as it indicates we have an
1235 // inconsistent stack anyways.
1236 uint32_t dex_pc = stack_visitor->GetDexPc(abort_on_failure);
1237 if (!abort_on_failure && dex_pc == DexFile::kDexNoIndex) {
David Sehr709b0702016-10-13 09:12:37 -07001238 LOG(ERROR) << "Could not find dex_pc for " << m->PrettyMethod();
Andreas Gampe760172c2014-08-16 13:41:10 -07001239 return;
1240 }
1241
Elliott Hughes80537bb2013-01-04 16:37:26 -08001242 // Ask the verifier for the dex pcs of all the monitor-enter instructions corresponding to
1243 // the locks held in this stack frame.
1244 std::vector<uint32_t> monitor_enter_dex_pcs;
Andreas Gampe760172c2014-08-16 13:41:10 -07001245 verifier::MethodVerifier::FindLocksAtDexPc(m, dex_pc, &monitor_enter_dex_pcs);
Mathieu Chartiere6a8eec2015-01-06 14:17:57 -08001246 for (uint32_t monitor_dex_pc : monitor_enter_dex_pcs) {
Elliott Hughes80537bb2013-01-04 16:37:26 -08001247 // The verifier works in terms of the dex pcs of the monitor-enter instructions.
1248 // We want the registers used by those instructions (so we can read the values out of them).
Sebastien Hertz0f7c9332015-11-05 15:57:30 +01001249 const Instruction* monitor_enter_instruction =
1250 Instruction::At(&code_item->insns_[monitor_dex_pc]);
Elliott Hughes80537bb2013-01-04 16:37:26 -08001251
1252 // Quick sanity check.
Sebastien Hertz0f7c9332015-11-05 15:57:30 +01001253 CHECK_EQ(monitor_enter_instruction->Opcode(), Instruction::MONITOR_ENTER)
1254 << "expected monitor-enter @" << monitor_dex_pc << "; was "
1255 << reinterpret_cast<const void*>(monitor_enter_instruction);
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001256
Sebastien Hertz0f7c9332015-11-05 15:57:30 +01001257 uint16_t monitor_register = monitor_enter_instruction->VRegA();
Nicolas Geoffray15b9d522015-03-12 15:05:13 +00001258 uint32_t value;
1259 bool success = stack_visitor->GetVReg(m, monitor_register, kReferenceVReg, &value);
1260 CHECK(success) << "Failed to read v" << monitor_register << " of kind "
David Sehr709b0702016-10-13 09:12:37 -07001261 << kReferenceVReg << " in method " << m->PrettyMethod();
Nicolas Geoffray15b9d522015-03-12 15:05:13 +00001262 mirror::Object* o = reinterpret_cast<mirror::Object*>(value);
Elliott Hughes4993bbc2013-01-10 15:41:25 -08001263 callback(o, callback_context);
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001264 }
1265}
1266
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001267bool Monitor::IsValidLockWord(LockWord lock_word) {
1268 switch (lock_word.GetState()) {
1269 case LockWord::kUnlocked:
1270 // Nothing to check.
1271 return true;
1272 case LockWord::kThinLocked:
1273 // Basic sanity check of owner.
1274 return lock_word.ThinLockOwner() != ThreadList::kInvalidThreadId;
1275 case LockWord::kFatLocked: {
1276 // Check the monitor appears in the monitor list.
1277 Monitor* mon = lock_word.FatLockMonitor();
1278 MonitorList* list = Runtime::Current()->GetMonitorList();
1279 MutexLock mu(Thread::Current(), list->monitor_list_lock_);
1280 for (Monitor* list_mon : list->list_) {
1281 if (mon == list_mon) {
1282 return true; // Found our monitor.
1283 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001284 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001285 return false; // Fail - unowned monitor in an object.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001286 }
Mathieu Chartierad2541a2013-10-25 10:05:23 -07001287 case LockWord::kHashCode:
1288 return true;
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001289 default:
1290 LOG(FATAL) << "Unreachable";
Ian Rogers2c4257b2014-10-24 14:20:06 -07001291 UNREACHABLE();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001292 }
1293}
1294
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001295bool Monitor::IsLocked() REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartierad2541a2013-10-25 10:05:23 -07001296 MutexLock mu(Thread::Current(), monitor_lock_);
1297 return owner_ != nullptr;
1298}
1299
Mathieu Chartier74b3c8f2016-04-15 19:11:45 -07001300void Monitor::TranslateLocation(ArtMethod* method,
1301 uint32_t dex_pc,
1302 const char** source_file,
1303 int32_t* line_number) {
jeffhao33dc7712011-11-09 17:54:24 -08001304 // If method is null, location is unknown
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001305 if (method == nullptr) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001306 *source_file = "";
1307 *line_number = 0;
jeffhao33dc7712011-11-09 17:54:24 -08001308 return;
1309 }
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07001310 *source_file = method->GetDeclaringClassSourceFile();
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001311 if (*source_file == nullptr) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001312 *source_file = "";
Elliott Hughes12c51e32012-01-17 20:25:05 -08001313 }
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07001314 *line_number = method->GetLineNumFromDexPC(dex_pc);
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001315}
1316
1317uint32_t Monitor::GetOwnerThreadId() {
1318 MutexLock mu(Thread::Current(), monitor_lock_);
1319 Thread* owner = owner_;
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001320 if (owner != nullptr) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001321 return owner->GetThreadId();
1322 } else {
1323 return ThreadList::kInvalidThreadId;
1324 }
jeffhao33dc7712011-11-09 17:54:24 -08001325}
1326
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07001327MonitorList::MonitorList()
Mathieu Chartier440e4ce2014-03-31 16:36:35 -07001328 : allow_new_monitors_(true), monitor_list_lock_("MonitorList lock", kMonitorListLock),
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07001329 monitor_add_condition_("MonitorList disallow condition", monitor_list_lock_) {
Elliott Hughesc33a32b2011-10-11 18:18:07 -07001330}
1331
1332MonitorList::~MonitorList() {
Andreas Gampe74240812014-04-17 10:35:09 -07001333 Thread* self = Thread::Current();
1334 MutexLock mu(self, monitor_list_lock_);
1335 // Release all monitors to the pool.
1336 // TODO: Is it an invariant that *all* open monitors are in the list? Then we could
1337 // clear faster in the pool.
1338 MonitorPool::ReleaseMonitors(self, &list_);
Elliott Hughesc33a32b2011-10-11 18:18:07 -07001339}
1340
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07001341void MonitorList::DisallowNewMonitors() {
Hiroshi Yamauchifdbd13c2015-09-02 16:16:58 -07001342 CHECK(!kUseReadBarrier);
Ian Rogers50b35e22012-10-04 10:09:15 -07001343 MutexLock mu(Thread::Current(), monitor_list_lock_);
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07001344 allow_new_monitors_ = false;
1345}
1346
1347void MonitorList::AllowNewMonitors() {
Hiroshi Yamauchifdbd13c2015-09-02 16:16:58 -07001348 CHECK(!kUseReadBarrier);
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07001349 Thread* self = Thread::Current();
1350 MutexLock mu(self, monitor_list_lock_);
1351 allow_new_monitors_ = true;
1352 monitor_add_condition_.Broadcast(self);
1353}
1354
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001355void MonitorList::BroadcastForNewMonitors() {
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001356 Thread* self = Thread::Current();
1357 MutexLock mu(self, monitor_list_lock_);
1358 monitor_add_condition_.Broadcast(self);
1359}
1360
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07001361void MonitorList::Add(Monitor* m) {
1362 Thread* self = Thread::Current();
1363 MutexLock mu(self, monitor_list_lock_);
Hiroshi Yamauchif1c6f872017-01-06 12:23:47 -08001364 // CMS needs this to block for concurrent reference processing because an object allocated during
1365 // the GC won't be marked and concurrent reference processing would incorrectly clear the JNI weak
1366 // ref. But CC (kUseReadBarrier == true) doesn't because of the to-space invariant.
1367 while (!kUseReadBarrier && UNLIKELY(!allow_new_monitors_)) {
Hiroshi Yamauchi30493242016-11-03 13:06:52 -07001368 // Check and run the empty checkpoint before blocking so the empty checkpoint will work in the
1369 // presence of threads blocking for weak ref access.
1370 self->CheckEmptyCheckpoint();
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07001371 monitor_add_condition_.WaitHoldingLocks(self);
1372 }
Elliott Hughesc33a32b2011-10-11 18:18:07 -07001373 list_.push_front(m);
1374}
1375
Mathieu Chartier97509952015-07-13 14:35:43 -07001376void MonitorList::SweepMonitorList(IsMarkedVisitor* visitor) {
Andreas Gampe74240812014-04-17 10:35:09 -07001377 Thread* self = Thread::Current();
1378 MutexLock mu(self, monitor_list_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001379 for (auto it = list_.begin(); it != list_.end(); ) {
Elliott Hughesc33a32b2011-10-11 18:18:07 -07001380 Monitor* m = *it;
Hiroshi Yamauchi4cba0d92014-05-21 21:10:23 -07001381 // Disable the read barrier in GetObject() as this is called by GC.
1382 mirror::Object* obj = m->GetObject<kWithoutReadBarrier>();
Mathieu Chartier590fee92013-09-13 13:46:47 -07001383 // The object of a monitor can be null if we have deflated it.
Mathieu Chartier97509952015-07-13 14:35:43 -07001384 mirror::Object* new_obj = obj != nullptr ? visitor->IsMarked(obj) : nullptr;
Mathieu Chartier6aa3df92013-09-17 15:17:28 -07001385 if (new_obj == nullptr) {
1386 VLOG(monitor) << "freeing monitor " << m << " belonging to unmarked object "
Hiroshi Yamauchi4cba0d92014-05-21 21:10:23 -07001387 << obj;
Andreas Gampe74240812014-04-17 10:35:09 -07001388 MonitorPool::ReleaseMonitor(self, m);
Elliott Hughesc33a32b2011-10-11 18:18:07 -07001389 it = list_.erase(it);
1390 } else {
Mathieu Chartier6aa3df92013-09-17 15:17:28 -07001391 m->SetObject(new_obj);
Elliott Hughesc33a32b2011-10-11 18:18:07 -07001392 ++it;
1393 }
1394 }
1395}
1396
Mathieu Chartier97509952015-07-13 14:35:43 -07001397class MonitorDeflateVisitor : public IsMarkedVisitor {
1398 public:
1399 MonitorDeflateVisitor() : self_(Thread::Current()), deflate_count_(0) {}
1400
1401 virtual mirror::Object* IsMarked(mirror::Object* object) OVERRIDE
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001402 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartier97509952015-07-13 14:35:43 -07001403 if (Monitor::Deflate(self_, object)) {
1404 DCHECK_NE(object->GetLockWord(true).GetState(), LockWord::kFatLocked);
1405 ++deflate_count_;
1406 // If we deflated, return null so that the monitor gets removed from the array.
1407 return nullptr;
1408 }
1409 return object; // Monitor was not deflated.
1410 }
1411
1412 Thread* const self_;
1413 size_t deflate_count_;
Mathieu Chartier48ab6872014-06-24 11:21:59 -07001414};
1415
Mathieu Chartier48ab6872014-06-24 11:21:59 -07001416size_t MonitorList::DeflateMonitors() {
Mathieu Chartier97509952015-07-13 14:35:43 -07001417 MonitorDeflateVisitor visitor;
1418 Locks::mutator_lock_->AssertExclusiveHeld(visitor.self_);
1419 SweepMonitorList(&visitor);
1420 return visitor.deflate_count_;
Mathieu Chartier440e4ce2014-03-31 16:36:35 -07001421}
1422
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001423MonitorInfo::MonitorInfo(mirror::Object* obj) : owner_(nullptr), entry_count_(0) {
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -07001424 DCHECK(obj != nullptr);
1425 LockWord lock_word = obj->GetLockWord(true);
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001426 switch (lock_word.GetState()) {
1427 case LockWord::kUnlocked:
Mathieu Chartierad2541a2013-10-25 10:05:23 -07001428 // Fall-through.
Mathieu Chartier590fee92013-09-13 13:46:47 -07001429 case LockWord::kForwardingAddress:
1430 // Fall-through.
Mathieu Chartierad2541a2013-10-25 10:05:23 -07001431 case LockWord::kHashCode:
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001432 break;
1433 case LockWord::kThinLocked:
1434 owner_ = Runtime::Current()->GetThreadList()->FindThreadByThreadId(lock_word.ThinLockOwner());
1435 entry_count_ = 1 + lock_word.ThinLockCount();
1436 // Thin locks have no waiters.
1437 break;
1438 case LockWord::kFatLocked: {
1439 Monitor* mon = lock_word.FatLockMonitor();
1440 owner_ = mon->owner_;
1441 entry_count_ = 1 + mon->lock_count_;
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001442 for (Thread* waiter = mon->wait_set_; waiter != nullptr; waiter = waiter->GetWaitNext()) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001443 waiters_.push_back(waiter);
1444 }
1445 break;
Elliott Hughesf327e072013-01-09 16:01:26 -08001446 }
1447 }
1448}
1449
Elliott Hughes5f791332011-09-15 17:45:30 -07001450} // namespace art