1 /*
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
17 #include "monitor-inl.h"
18
19 #include <vector>
20
21 #include "android-base/stringprintf.h"
22
23 #include "art_method-inl.h"
24 #include "base/logging.h" // For VLOG.
25 #include "base/mutex.h"
26 #include "base/quasi_atomic.h"
27 #include "base/stl_util.h"
28 #include "base/systrace.h"
29 #include "base/time_utils.h"
30 #include "class_linker.h"
31 #include "dex/dex_file-inl.h"
32 #include "dex/dex_file_types.h"
33 #include "dex/dex_instruction-inl.h"
34 #include "lock_word-inl.h"
35 #include "mirror/class-inl.h"
36 #include "mirror/object-inl.h"
37 #include "object_callbacks.h"
38 #include "scoped_thread_state_change-inl.h"
39 #include "stack.h"
40 #include "thread.h"
41 #include "thread_list.h"
42 #include "verifier/method_verifier.h"
43 #include "well_known_classes.h"
44
45 namespace art {
46
47 using android::base::StringPrintf;
48
49 static constexpr uint64_t kDebugThresholdFudgeFactor = kIsDebugBuild ? 10 : 1;
50 static constexpr uint64_t kLongWaitMs = 100 * kDebugThresholdFudgeFactor;
51
52 /*
53 * Every Object has a monitor associated with it, but not every Object is actually locked. Even
54 * the ones that are locked do not need a full-fledged monitor until a) there is actual contention
55 * or b) wait() is called on the Object.
56 *
57 * For Android, we have implemented a scheme similar to the one described in Bacon et al.'s
58 * "Thin locks: featherweight synchronization for Java" (ACM 1998). Things are even easier for us,
59 * though, because we have a full 32 bits to work with.
60 *
61 * The two states of an Object's lock are referred to as "thin" and "fat". A lock may transition
62 * from the "thin" state to the "fat" state and this transition is referred to as inflation. We
63 * deflate locks from time to time as part of heap trimming.
64 *
65 * The lock value itself is stored in mirror::Object::monitor_ and the representation is described
66 * in the LockWord value type.
67 *
68 * Monitors provide:
69 * - mutually exclusive access to resources
70 * - a way for multiple threads to wait for notification
71 *
72 * In effect, they fill the role of both mutexes and condition variables.
73 *
74 * Only one thread can own the monitor at any time. There may be several threads waiting on it
75 * (the wait call unlocks it). One or more waiting threads may be getting interrupted or notified
76 * at any given time.
77 */
78
79 uint32_t Monitor::lock_profiling_threshold_ = 0;
80 uint32_t Monitor::stack_dump_lock_profiling_threshold_ = 0;
81
Init(uint32_t lock_profiling_threshold,uint32_t stack_dump_lock_profiling_threshold)82 void Monitor::Init(uint32_t lock_profiling_threshold,
83 uint32_t stack_dump_lock_profiling_threshold) {
84 // It isn't great to always include the debug build fudge factor for command-
85 // line driven arguments, but it's easier to adjust here than in the build.
86 lock_profiling_threshold_ =
87 lock_profiling_threshold * kDebugThresholdFudgeFactor;
88 stack_dump_lock_profiling_threshold_ =
89 stack_dump_lock_profiling_threshold * kDebugThresholdFudgeFactor;
90 }
91
Monitor(Thread * self,Thread * owner,ObjPtr<mirror::Object> obj,int32_t hash_code)92 Monitor::Monitor(Thread* self, Thread* owner, ObjPtr<mirror::Object> obj, int32_t hash_code)
93 : monitor_lock_("a monitor lock", kMonitorLock),
94 monitor_contenders_("monitor contenders", monitor_lock_),
95 num_waiters_(0),
96 owner_(owner),
97 lock_count_(0),
98 obj_(GcRoot<mirror::Object>(obj)),
99 wait_set_(nullptr),
100 wake_set_(nullptr),
101 hash_code_(hash_code),
102 locking_method_(nullptr),
103 locking_dex_pc_(0),
104 monitor_id_(MonitorPool::ComputeMonitorId(this, self)) {
105 #ifdef __LP64__
106 DCHECK(false) << "Should not be reached in 64b";
107 next_free_ = nullptr;
108 #endif
109 // We should only inflate a lock if the owner is ourselves or suspended. This avoids a race
110 // with the owner unlocking the thin-lock.
111 CHECK(owner == nullptr || owner == self || owner->IsSuspended());
112 // The identity hash code is set for the life time of the monitor.
113 }
114
Monitor(Thread * self,Thread * owner,ObjPtr<mirror::Object> obj,int32_t hash_code,MonitorId id)115 Monitor::Monitor(Thread* self,
116 Thread* owner,
117 ObjPtr<mirror::Object> obj,
118 int32_t hash_code,
119 MonitorId id)
120 : monitor_lock_("a monitor lock", kMonitorLock),
121 monitor_contenders_("monitor contenders", monitor_lock_),
122 num_waiters_(0),
123 owner_(owner),
124 lock_count_(0),
125 obj_(GcRoot<mirror::Object>(obj)),
126 wait_set_(nullptr),
127 wake_set_(nullptr),
128 hash_code_(hash_code),
129 locking_method_(nullptr),
130 locking_dex_pc_(0),
131 monitor_id_(id) {
132 #ifdef __LP64__
133 next_free_ = nullptr;
134 #endif
135 // We should only inflate a lock if the owner is ourselves or suspended. This avoids a race
136 // with the owner unlocking the thin-lock.
137 CHECK(owner == nullptr || owner == self || owner->IsSuspended());
138 // The identity hash code is set for the life time of the monitor.
139 }
140
GetHashCode()141 int32_t Monitor::GetHashCode() {
142 int32_t hc = hash_code_.load(std::memory_order_relaxed);
143 if (!HasHashCode()) {
144 // Use a strong CAS to prevent spurious failures since these can make the boot image
145 // non-deterministic.
146 hash_code_.CompareAndSetStrongRelaxed(0, mirror::Object::GenerateIdentityHashCode());
147 hc = hash_code_.load(std::memory_order_relaxed);
148 }
149 DCHECK(HasHashCode());
150 return hc;
151 }
152
Install(Thread * self)153 bool Monitor::Install(Thread* self) {
154 MutexLock mu(self, monitor_lock_); // Uncontended mutex acquisition as monitor isn't yet public.
155 CHECK(owner_ == nullptr || owner_ == self || owner_->IsSuspended());
156 // Propagate the lock state.
157 LockWord lw(GetObject()->GetLockWord(false));
158 switch (lw.GetState()) {
159 case LockWord::kThinLocked: {
160 CHECK_EQ(owner_->GetThreadId(), lw.ThinLockOwner());
161 lock_count_ = lw.ThinLockCount();
162 break;
163 }
164 case LockWord::kHashCode: {
165 CHECK_EQ(hash_code_.load(std::memory_order_relaxed), static_cast<int32_t>(lw.GetHashCode()));
166 break;
167 }
168 case LockWord::kFatLocked: {
169 // The owner_ is suspended but another thread beat us to install a monitor.
170 return false;
171 }
172 case LockWord::kUnlocked: {
173 LOG(FATAL) << "Inflating unlocked lock word";
174 UNREACHABLE();
175 }
176 default: {
177 LOG(FATAL) << "Invalid monitor state " << lw.GetState();
178 UNREACHABLE();
179 }
180 }
181 LockWord fat(this, lw.GCState());
182 // Publish the updated lock word, which may race with other threads.
183 bool success = GetObject()->CasLockWord(lw, fat, CASMode::kWeak, std::memory_order_release);
184 // Lock profiling.
185 if (success && owner_ != nullptr && lock_profiling_threshold_ != 0) {
186 // Do not abort on dex pc errors. This can easily happen when we want to dump a stack trace on
187 // abort.
188 locking_method_ = owner_->GetCurrentMethod(&locking_dex_pc_, false);
189 if (locking_method_ != nullptr && UNLIKELY(locking_method_->IsProxyMethod())) {
190 // Grab another frame. Proxy methods are not helpful for lock profiling. This should be rare
191 // enough that it's OK to walk the stack twice.
192 struct NextMethodVisitor final : public StackVisitor {
193 explicit NextMethodVisitor(Thread* thread) REQUIRES_SHARED(Locks::mutator_lock_)
194 : StackVisitor(thread,
195 nullptr,
196 StackVisitor::StackWalkKind::kIncludeInlinedFrames,
197 false),
198 count_(0),
199 method_(nullptr),
200 dex_pc_(0) {}
201 bool VisitFrame() override REQUIRES_SHARED(Locks::mutator_lock_) {
202 ArtMethod* m = GetMethod();
203 if (m->IsRuntimeMethod()) {
204 // Continue if this is a runtime method.
205 return true;
206 }
207 count_++;
208 if (count_ == 2u) {
209 method_ = m;
210 dex_pc_ = GetDexPc(false);
211 return false;
212 }
213 return true;
214 }
215 size_t count_;
216 ArtMethod* method_;
217 uint32_t dex_pc_;
218 };
219 NextMethodVisitor nmv(owner_);
220 nmv.WalkStack();
221 locking_method_ = nmv.method_;
222 locking_dex_pc_ = nmv.dex_pc_;
223 }
224 DCHECK(locking_method_ == nullptr || !locking_method_->IsProxyMethod());
225 }
226 return success;
227 }
228
~Monitor()229 Monitor::~Monitor() {
230 // Deflated monitors have a null object.
231 }
232
AppendToWaitSet(Thread * thread)233 void Monitor::AppendToWaitSet(Thread* thread) {
234 // Not checking that the owner is equal to this thread, since we've released
235 // the monitor by the time this method is called.
236 DCHECK(thread != nullptr);
237 DCHECK(thread->GetWaitNext() == nullptr) << thread->GetWaitNext();
238 if (wait_set_ == nullptr) {
239 wait_set_ = thread;
240 return;
241 }
242
243 // push_back.
244 Thread* t = wait_set_;
245 while (t->GetWaitNext() != nullptr) {
246 t = t->GetWaitNext();
247 }
248 t->SetWaitNext(thread);
249 }
250
RemoveFromWaitSet(Thread * thread)251 void Monitor::RemoveFromWaitSet(Thread *thread) {
252 DCHECK(owner_ == Thread::Current());
253 DCHECK(thread != nullptr);
254 auto remove = [&](Thread*& set){
255 if (set != nullptr) {
256 if (set == thread) {
257 set = thread->GetWaitNext();
258 thread->SetWaitNext(nullptr);
259 return true;
260 }
261 Thread* t = set;
262 while (t->GetWaitNext() != nullptr) {
263 if (t->GetWaitNext() == thread) {
264 t->SetWaitNext(thread->GetWaitNext());
265 thread->SetWaitNext(nullptr);
266 return true;
267 }
268 t = t->GetWaitNext();
269 }
270 }
271 return false;
272 };
273 if (remove(wait_set_)) {
274 return;
275 }
276 remove(wake_set_);
277 }
278
SetObject(ObjPtr<mirror::Object> object)279 void Monitor::SetObject(ObjPtr<mirror::Object> object) {
280 obj_ = GcRoot<mirror::Object>(object);
281 }
282
283 // This function is inlined and just helps to not have the VLOG and ATRACE check at all the
284 // potential tracing points.
AtraceMonitorLock(Thread * self,ObjPtr<mirror::Object> obj,bool is_wait)285 void Monitor::AtraceMonitorLock(Thread* self, ObjPtr<mirror::Object> obj, bool is_wait) {
286 if (UNLIKELY(VLOG_IS_ON(systrace_lock_logging) && ATraceEnabled())) {
287 AtraceMonitorLockImpl(self, obj, is_wait);
288 }
289 }
290
AtraceMonitorLockImpl(Thread * self,ObjPtr<mirror::Object> obj,bool is_wait)291 void Monitor::AtraceMonitorLockImpl(Thread* self, ObjPtr<mirror::Object> obj, bool is_wait) {
292 // Wait() requires a deeper call stack to be useful. Otherwise you'll see "Waiting at
293 // Object.java". Assume that we'll wait a nontrivial amount, so it's OK to do a longer
294 // stack walk than if !is_wait.
295 const size_t wanted_frame_number = is_wait ? 1U : 0U;
296
297 ArtMethod* method = nullptr;
298 uint32_t dex_pc = 0u;
299
300 size_t current_frame_number = 0u;
301 StackVisitor::WalkStack(
302 // Note: Adapted from CurrentMethodVisitor in thread.cc. We must not resolve here.
303 [&](const art::StackVisitor* stack_visitor) REQUIRES_SHARED(Locks::mutator_lock_) {
304 ArtMethod* m = stack_visitor->GetMethod();
305 if (m == nullptr || m->IsRuntimeMethod()) {
306 // Runtime method, upcall, or resolution issue. Skip.
307 return true;
308 }
309
310 // Is this the requested frame?
311 if (current_frame_number == wanted_frame_number) {
312 method = m;
313 dex_pc = stack_visitor->GetDexPc(false /* abort_on_error*/);
314 return false;
315 }
316
317 // Look for more.
318 current_frame_number++;
319 return true;
320 },
321 self,
322 /* context= */ nullptr,
323 art::StackVisitor::StackWalkKind::kIncludeInlinedFrames);
324
325 const char* prefix = is_wait ? "Waiting on " : "Locking ";
326
327 const char* filename;
328 int32_t line_number;
329 TranslateLocation(method, dex_pc, &filename, &line_number);
330
331 // It would be nice to have a stable "ID" for the object here. However, the only stable thing
332 // would be the identity hashcode. But we cannot use IdentityHashcode here: For one, there are
333 // times when it is unsafe to make that call (see stack dumping for an explanation). More
334 // importantly, we would have to give up on thin-locking when adding systrace locks, as the
335 // identity hashcode is stored in the lockword normally (so can't be used with thin-locks).
336 //
337 // Because of thin-locks we also cannot use the monitor id (as there is no monitor). Monitor ids
338 // also do not have to be stable, as the monitor may be deflated.
339 std::string tmp = StringPrintf("%s %d at %s:%d",
340 prefix,
341 (obj == nullptr ? -1 : static_cast<int32_t>(reinterpret_cast<uintptr_t>(obj.Ptr()))),
342 (filename != nullptr ? filename : "null"),
343 line_number);
344 ATraceBegin(tmp.c_str());
345 }
346
AtraceMonitorUnlock()347 void Monitor::AtraceMonitorUnlock() {
348 if (UNLIKELY(VLOG_IS_ON(systrace_lock_logging))) {
349 ATraceEnd();
350 }
351 }
352
PrettyContentionInfo(const std::string & owner_name,pid_t owner_tid,ArtMethod * owners_method,uint32_t owners_dex_pc,size_t num_waiters)353 std::string Monitor::PrettyContentionInfo(const std::string& owner_name,
354 pid_t owner_tid,
355 ArtMethod* owners_method,
356 uint32_t owners_dex_pc,
357 size_t num_waiters) {
358 Locks::mutator_lock_->AssertSharedHeld(Thread::Current());
359 const char* owners_filename;
360 int32_t owners_line_number = 0;
361 if (owners_method != nullptr) {
362 TranslateLocation(owners_method, owners_dex_pc, &owners_filename, &owners_line_number);
363 }
364 std::ostringstream oss;
365 oss << "monitor contention with owner " << owner_name << " (" << owner_tid << ")";
366 if (owners_method != nullptr) {
367 oss << " at " << owners_method->PrettyMethod();
368 oss << "(" << owners_filename << ":" << owners_line_number << ")";
369 }
370 oss << " waiters=" << num_waiters;
371 return oss.str();
372 }
373
TryLockLocked(Thread * self)374 bool Monitor::TryLockLocked(Thread* self) {
375 if (owner_ == nullptr) { // Unowned.
376 owner_ = self;
377 CHECK_EQ(lock_count_, 0);
378 // When debugging, save the current monitor holder for future
379 // acquisition failures to use in sampled logging.
380 if (lock_profiling_threshold_ != 0) {
381 locking_method_ = self->GetCurrentMethod(&locking_dex_pc_);
382 // We don't expect a proxy method here.
383 DCHECK(locking_method_ == nullptr || !locking_method_->IsProxyMethod());
384 }
385 } else if (owner_ == self) { // Recursive.
386 lock_count_++;
387 } else {
388 return false;
389 }
390 AtraceMonitorLock(self, GetObject(), /* is_wait= */ false);
391 return true;
392 }
393
TryLock(Thread * self)394 bool Monitor::TryLock(Thread* self) {
395 MutexLock mu(self, monitor_lock_);
396 return TryLockLocked(self);
397 }
398
399 // Asserts that a mutex isn't held when the class comes into and out of scope.
400 class ScopedAssertNotHeld {
401 public:
ScopedAssertNotHeld(Thread * self,Mutex & mu)402 ScopedAssertNotHeld(Thread* self, Mutex& mu) : self_(self), mu_(mu) {
403 mu_.AssertNotHeld(self_);
404 }
405
~ScopedAssertNotHeld()406 ~ScopedAssertNotHeld() {
407 mu_.AssertNotHeld(self_);
408 }
409
410 private:
411 Thread* const self_;
412 Mutex& mu_;
413 DISALLOW_COPY_AND_ASSIGN(ScopedAssertNotHeld);
414 };
415
416 template <LockReason reason>
Lock(Thread * self)417 void Monitor::Lock(Thread* self) {
418 ScopedAssertNotHeld sanh(self, monitor_lock_);
419 bool called_monitors_callback = false;
420 monitor_lock_.Lock(self);
421 while (true) {
422 if (TryLockLocked(self)) {
423 break;
424 }
425 // Contended.
426 const bool log_contention = (lock_profiling_threshold_ != 0);
427 uint64_t wait_start_ms = log_contention ? MilliTime() : 0;
428 ArtMethod* owners_method = locking_method_;
429 uint32_t owners_dex_pc = locking_dex_pc_;
430 // Do this before releasing the lock so that we don't get deflated.
431 size_t num_waiters = num_waiters_;
432 ++num_waiters_;
433
434 // If systrace logging is enabled, first look at the lock owner. Acquiring the monitor's
435 // lock and then re-acquiring the mutator lock can deadlock.
436 bool started_trace = false;
437 if (ATraceEnabled()) {
438 if (owner_ != nullptr) { // Did the owner_ give the lock up?
439 std::ostringstream oss;
440 std::string name;
441 owner_->GetThreadName(name);
442 oss << PrettyContentionInfo(name,
443 owner_->GetTid(),
444 owners_method,
445 owners_dex_pc,
446 num_waiters);
447 // Add info for contending thread.
448 uint32_t pc;
449 ArtMethod* m = self->GetCurrentMethod(&pc);
450 const char* filename;
451 int32_t line_number;
452 TranslateLocation(m, pc, &filename, &line_number);
453 oss << " blocking from "
454 << ArtMethod::PrettyMethod(m) << "(" << (filename != nullptr ? filename : "null")
455 << ":" << line_number << ")";
456 ATraceBegin(oss.str().c_str());
457 started_trace = true;
458 }
459 }
460
461 monitor_lock_.Unlock(self); // Let go of locks in order.
462 // Call the contended locking cb once and only once. Also only call it if we are locking for
463 // the first time, not during a Wait wakeup.
464 if (reason == LockReason::kForLock && !called_monitors_callback) {
465 called_monitors_callback = true;
466 Runtime::Current()->GetRuntimeCallbacks()->MonitorContendedLocking(this);
467 }
468 self->SetMonitorEnterObject(GetObject().Ptr());
469 {
470 ScopedThreadSuspension tsc(self, kBlocked); // Change to blocked and give up mutator_lock_.
471 uint32_t original_owner_thread_id = 0u;
472 {
473 // Reacquire monitor_lock_ without mutator_lock_ for Wait.
474 MutexLock mu2(self, monitor_lock_);
475 if (owner_ != nullptr) { // Did the owner_ give the lock up?
476 original_owner_thread_id = owner_->GetThreadId();
477 monitor_contenders_.Wait(self); // Still contended so wait.
478 }
479 }
480 if (original_owner_thread_id != 0u) {
481 // Woken from contention.
482 if (log_contention) {
483 uint64_t wait_ms = MilliTime() - wait_start_ms;
484 uint32_t sample_percent;
485 if (wait_ms >= lock_profiling_threshold_) {
486 sample_percent = 100;
487 } else {
488 sample_percent = 100 * wait_ms / lock_profiling_threshold_;
489 }
490 if (sample_percent != 0 && (static_cast<uint32_t>(rand() % 100) < sample_percent)) {
491 // Reacquire mutator_lock_ for logging.
492 ScopedObjectAccess soa(self);
493
494 bool owner_alive = false;
495 pid_t original_owner_tid = 0;
496 std::string original_owner_name;
497
498 const bool should_dump_stacks = stack_dump_lock_profiling_threshold_ > 0 &&
499 wait_ms > stack_dump_lock_profiling_threshold_;
500 std::string owner_stack_dump;
501
502 // Acquire thread-list lock to find thread and keep it from dying until we've got all
503 // the info we need.
504 {
505 Locks::thread_list_lock_->ExclusiveLock(Thread::Current());
506
507 // Re-find the owner in case the thread got killed.
508 Thread* original_owner = Runtime::Current()->GetThreadList()->FindThreadByThreadId(
509 original_owner_thread_id);
510
511 if (original_owner != nullptr) {
512 owner_alive = true;
513 original_owner_tid = original_owner->GetTid();
514 original_owner->GetThreadName(original_owner_name);
515
516 if (should_dump_stacks) {
517 // Very long contention. Dump stacks.
518 struct CollectStackTrace : public Closure {
519 void Run(art::Thread* thread) override
520 REQUIRES_SHARED(art::Locks::mutator_lock_) {
521 thread->DumpJavaStack(oss);
522 }
523
524 std::ostringstream oss;
525 };
526 CollectStackTrace owner_trace;
527 // RequestSynchronousCheckpoint releases the thread_list_lock_ as a part of its
528 // execution.
529 original_owner->RequestSynchronousCheckpoint(&owner_trace);
530 owner_stack_dump = owner_trace.oss.str();
531 } else {
532 Locks::thread_list_lock_->ExclusiveUnlock(Thread::Current());
533 }
534 } else {
535 Locks::thread_list_lock_->ExclusiveUnlock(Thread::Current());
536 }
537 // This is all the data we need. Now drop the thread-list lock, it's OK for the
538 // owner to go away now.
539 }
540
541 // If we found the owner (and thus have owner data), go and log now.
542 if (owner_alive) {
543 // Give the detailed traces for really long contention.
544 if (should_dump_stacks) {
545 // This must be here (and not above) because we cannot hold the thread-list lock
546 // while running the checkpoint.
547 std::ostringstream self_trace_oss;
548 self->DumpJavaStack(self_trace_oss);
549
550 uint32_t pc;
551 ArtMethod* m = self->GetCurrentMethod(&pc);
552
553 LOG(WARNING) << "Long "
554 << PrettyContentionInfo(original_owner_name,
555 original_owner_tid,
556 owners_method,
557 owners_dex_pc,
558 num_waiters)
559 << " in " << ArtMethod::PrettyMethod(m) << " for "
560 << PrettyDuration(MsToNs(wait_ms)) << "\n"
561 << "Current owner stack:\n" << owner_stack_dump
562 << "Contender stack:\n" << self_trace_oss.str();
563 } else if (wait_ms > kLongWaitMs && owners_method != nullptr) {
564 uint32_t pc;
565 ArtMethod* m = self->GetCurrentMethod(&pc);
566 // TODO: We should maybe check that original_owner is still a live thread.
567 LOG(WARNING) << "Long "
568 << PrettyContentionInfo(original_owner_name,
569 original_owner_tid,
570 owners_method,
571 owners_dex_pc,
572 num_waiters)
573 << " in " << ArtMethod::PrettyMethod(m) << " for "
574 << PrettyDuration(MsToNs(wait_ms));
575 }
576 LogContentionEvent(self,
577 wait_ms,
578 sample_percent,
579 owners_method,
580 owners_dex_pc);
581 }
582 }
583 }
584 }
585 }
586 if (started_trace) {
587 ATraceEnd();
588 }
589 self->SetMonitorEnterObject(nullptr);
590 monitor_lock_.Lock(self); // Reacquire locks in order.
591 --num_waiters_;
592 }
593 monitor_lock_.Unlock(self);
594 // We need to pair this with a single contended locking call. NB we match the RI behavior and call
595 // this even if MonitorEnter failed.
596 if (called_monitors_callback) {
597 CHECK(reason == LockReason::kForLock);
598 Runtime::Current()->GetRuntimeCallbacks()->MonitorContendedLocked(this);
599 }
600 }
601
602 template void Monitor::Lock<LockReason::kForLock>(Thread* self);
603 template void Monitor::Lock<LockReason::kForWait>(Thread* self);
604
605 static void ThrowIllegalMonitorStateExceptionF(const char* fmt, ...)
606 __attribute__((format(printf, 1, 2)));
607
ThrowIllegalMonitorStateExceptionF(const char * fmt,...)608 static void ThrowIllegalMonitorStateExceptionF(const char* fmt, ...)
609 REQUIRES_SHARED(Locks::mutator_lock_) {
610 va_list args;
611 va_start(args, fmt);
612 Thread* self = Thread::Current();
613 self->ThrowNewExceptionV("Ljava/lang/IllegalMonitorStateException;", fmt, args);
614 if (!Runtime::Current()->IsStarted() || VLOG_IS_ON(monitor)) {
615 std::ostringstream ss;
616 self->Dump(ss);
617 LOG(Runtime::Current()->IsStarted() ? ::android::base::INFO : ::android::base::ERROR)
618 << self->GetException()->Dump() << "\n" << ss.str();
619 }
620 va_end(args);
621 }
622
ThreadToString(Thread * thread)623 static std::string ThreadToString(Thread* thread) {
624 if (thread == nullptr) {
625 return "nullptr";
626 }
627 std::ostringstream oss;
628 // TODO: alternatively, we could just return the thread's name.
629 oss << *thread;
630 return oss.str();
631 }
632
FailedUnlock(ObjPtr<mirror::Object> o,uint32_t expected_owner_thread_id,uint32_t found_owner_thread_id,Monitor * monitor)633 void Monitor::FailedUnlock(ObjPtr<mirror::Object> o,
634 uint32_t expected_owner_thread_id,
635 uint32_t found_owner_thread_id,
636 Monitor* monitor) {
637 // Acquire thread list lock so threads won't disappear from under us.
638 std::string current_owner_string;
639 std::string expected_owner_string;
640 std::string found_owner_string;
641 uint32_t current_owner_thread_id = 0u;
642 {
643 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
644 ThreadList* const thread_list = Runtime::Current()->GetThreadList();
645 Thread* expected_owner = thread_list->FindThreadByThreadId(expected_owner_thread_id);
646 Thread* found_owner = thread_list->FindThreadByThreadId(found_owner_thread_id);
647
648 // Re-read owner now that we hold lock.
649 Thread* current_owner = (monitor != nullptr) ? monitor->GetOwner() : nullptr;
650 if (current_owner != nullptr) {
651 current_owner_thread_id = current_owner->GetThreadId();
652 }
653 // Get short descriptions of the threads involved.
654 current_owner_string = ThreadToString(current_owner);
655 expected_owner_string = expected_owner != nullptr ? ThreadToString(expected_owner) : "unnamed";
656 found_owner_string = found_owner != nullptr ? ThreadToString(found_owner) : "unnamed";
657 }
658
659 if (current_owner_thread_id == 0u) {
660 if (found_owner_thread_id == 0u) {
661 ThrowIllegalMonitorStateExceptionF("unlock of unowned monitor on object of type '%s'"
662 " on thread '%s'",
663 mirror::Object::PrettyTypeOf(o).c_str(),
664 expected_owner_string.c_str());
665 } else {
666 // Race: the original read found an owner but now there is none
667 ThrowIllegalMonitorStateExceptionF("unlock of monitor owned by '%s' on object of type '%s'"
668 " (where now the monitor appears unowned) on thread '%s'",
669 found_owner_string.c_str(),
670 mirror::Object::PrettyTypeOf(o).c_str(),
671 expected_owner_string.c_str());
672 }
673 } else {
674 if (found_owner_thread_id == 0u) {
675 // Race: originally there was no owner, there is now
676 ThrowIllegalMonitorStateExceptionF("unlock of monitor owned by '%s' on object of type '%s'"
677 " (originally believed to be unowned) on thread '%s'",
678 current_owner_string.c_str(),
679 mirror::Object::PrettyTypeOf(o).c_str(),
680 expected_owner_string.c_str());
681 } else {
682 if (found_owner_thread_id != current_owner_thread_id) {
683 // Race: originally found and current owner have changed
684 ThrowIllegalMonitorStateExceptionF("unlock of monitor originally owned by '%s' (now"
685 " owned by '%s') on object of type '%s' on thread '%s'",
686 found_owner_string.c_str(),
687 current_owner_string.c_str(),
688 mirror::Object::PrettyTypeOf(o).c_str(),
689 expected_owner_string.c_str());
690 } else {
691 ThrowIllegalMonitorStateExceptionF("unlock of monitor owned by '%s' on object of type '%s'"
692 " on thread '%s",
693 current_owner_string.c_str(),
694 mirror::Object::PrettyTypeOf(o).c_str(),
695 expected_owner_string.c_str());
696 }
697 }
698 }
699 }
700
Unlock(Thread * self)701 bool Monitor::Unlock(Thread* self) {
702 DCHECK(self != nullptr);
703 uint32_t owner_thread_id = 0u;
704 DCHECK(!monitor_lock_.IsExclusiveHeld(self));
705 monitor_lock_.Lock(self);
706 Thread* owner = owner_;
707 if (owner != nullptr) {
708 owner_thread_id = owner->GetThreadId();
709 }
710 if (owner == self) {
711 // We own the monitor, so nobody else can be in here.
712 AtraceMonitorUnlock();
713 if (lock_count_ == 0) {
714 owner_ = nullptr;
715 locking_method_ = nullptr;
716 locking_dex_pc_ = 0;
717 SignalContendersAndReleaseMonitorLock(self);
718 return true;
719 } else {
720 --lock_count_;
721 monitor_lock_.Unlock(self);
722 return true;
723 }
724 }
725 // We don't own this, so we're not allowed to unlock it.
726 // The JNI spec says that we should throw IllegalMonitorStateException in this case.
727 FailedUnlock(GetObject(), self->GetThreadId(), owner_thread_id, this);
728 monitor_lock_.Unlock(self);
729 return false;
730 }
731
SignalContendersAndReleaseMonitorLock(Thread * self)732 void Monitor::SignalContendersAndReleaseMonitorLock(Thread* self) {
733 // We want to signal one thread to wake up, to acquire the monitor that
734 // we are releasing. This could either be a Thread waiting on its own
735 // ConditionVariable, or a thread waiting on monitor_contenders_.
736 while (wake_set_ != nullptr) {
737 // No risk of waking ourselves here; since monitor_lock_ is not released until we're ready to
738 // return, notify can't move the current thread from wait_set_ to wake_set_ until this
739 // method is done checking wake_set_.
740 Thread* thread = wake_set_;
741 wake_set_ = thread->GetWaitNext();
742 thread->SetWaitNext(nullptr);
743
744 // Check to see if the thread is still waiting.
745 {
746 // In the case of wait(), we'll be acquiring another thread's GetWaitMutex with
747 // self's GetWaitMutex held. This does not risk deadlock, because we only acquire this lock
748 // for threads in the wake_set_. A thread can only enter wake_set_ from Notify or NotifyAll,
749 // and those hold monitor_lock_. Thus, the threads whose wait mutexes we acquire here must
750 // have already been released from wait(), since we have not released monitor_lock_ until
751 // after we've chosen our thread to wake, so there is no risk of the following lock ordering
752 // leading to deadlock:
753 // Thread 1 waits
754 // Thread 2 waits
755 // Thread 3 moves threads 1 and 2 from wait_set_ to wake_set_
756 // Thread 1 enters this block, and attempts to acquire Thread 2's GetWaitMutex to wake it
757 // Thread 2 enters this block, and attempts to acquire Thread 1's GetWaitMutex to wake it
758 //
759 // Since monitor_lock_ is not released until the thread-to-be-woken-up's GetWaitMutex is
760 // acquired, two threads cannot attempt to acquire each other's GetWaitMutex while holding
761 // their own and cause deadlock.
762 MutexLock wait_mu(self, *thread->GetWaitMutex());
763 if (thread->GetWaitMonitor() != nullptr) {
764 // Release the lock, so that a potentially awakened thread will not
765 // immediately contend on it. The lock ordering here is:
766 // monitor_lock_, self->GetWaitMutex, thread->GetWaitMutex
767 monitor_lock_.Unlock(self);
768 thread->GetWaitConditionVariable()->Signal(self);
769 return;
770 }
771 }
772 }
773 // If we didn't wake any threads that were originally waiting on us,
774 // wake a contender.
775 monitor_contenders_.Signal(self);
776 monitor_lock_.Unlock(self);
777 }
778
Wait(Thread * self,int64_t ms,int32_t ns,bool interruptShouldThrow,ThreadState why)779 void Monitor::Wait(Thread* self, int64_t ms, int32_t ns,
780 bool interruptShouldThrow, ThreadState why) {
781 DCHECK(self != nullptr);
782 DCHECK(why == kTimedWaiting || why == kWaiting || why == kSleeping);
783
784 monitor_lock_.Lock(self);
785
786 // Make sure that we hold the lock.
787 if (owner_ != self) {
788 monitor_lock_.Unlock(self);
789 ThrowIllegalMonitorStateExceptionF("object not locked by thread before wait()");
790 return;
791 }
792
793 // We need to turn a zero-length timed wait into a regular wait because
794 // Object.wait(0, 0) is defined as Object.wait(0), which is defined as Object.wait().
795 if (why == kTimedWaiting && (ms == 0 && ns == 0)) {
796 why = kWaiting;
797 }
798
799 // Enforce the timeout range.
800 if (ms < 0 || ns < 0 || ns > 999999) {
801 monitor_lock_.Unlock(self);
802 self->ThrowNewExceptionF("Ljava/lang/IllegalArgumentException;",
803 "timeout arguments out of range: ms=%" PRId64 " ns=%d", ms, ns);
804 return;
805 }
806
807 /*
808 * Release our hold - we need to let it go even if we're a few levels
809 * deep in a recursive lock, and we need to restore that later.
810 */
811 int prev_lock_count = lock_count_;
812 lock_count_ = 0;
813 owner_ = nullptr;
814 ArtMethod* saved_method = locking_method_;
815 locking_method_ = nullptr;
816 uintptr_t saved_dex_pc = locking_dex_pc_;
817 locking_dex_pc_ = 0;
818
819 AtraceMonitorUnlock(); // For the implict Unlock() just above. This will only end the deepest
820 // nesting, but that is enough for the visualization, and corresponds to
821 // the single Lock() we do afterwards.
822 AtraceMonitorLock(self, GetObject(), /* is_wait= */ true);
823
824 bool was_interrupted = false;
825 bool timed_out = false;
826 {
827 // Update thread state. If the GC wakes up, it'll ignore us, knowing
828 // that we won't touch any references in this state, and we'll check
829 // our suspend mode before we transition out.
830 ScopedThreadSuspension sts(self, why);
831
832 // Pseudo-atomically wait on self's wait_cond_ and release the monitor lock.
833 MutexLock mu(self, *self->GetWaitMutex());
834
835 /*
836 * Add ourselves to the set of threads waiting on this monitor.
837 * It's important that we are only added to the wait set after
838 * acquiring our GetWaitMutex, so that calls to Notify() that occur after we
839 * have released monitor_lock_ will not move us from wait_set_ to wake_set_
840 * until we've signalled contenders on this monitor.
841 */
842 AppendToWaitSet(self);
843 ++num_waiters_;
844
845
846 // Set wait_monitor_ to the monitor object we will be waiting on. When wait_monitor_ is
847 // non-null a notifying or interrupting thread must signal the thread's wait_cond_ to wake it
848 // up.
849 DCHECK(self->GetWaitMonitor() == nullptr);
850 self->SetWaitMonitor(this);
851
852 // Release the monitor lock.
853 SignalContendersAndReleaseMonitorLock(self);
854
855 // Handle the case where the thread was interrupted before we called wait().
856 if (self->IsInterrupted()) {
857 was_interrupted = true;
858 } else {
859 // Wait for a notification or a timeout to occur.
860 if (why == kWaiting) {
861 self->GetWaitConditionVariable()->Wait(self);
862 } else {
863 DCHECK(why == kTimedWaiting || why == kSleeping) << why;
864 timed_out = self->GetWaitConditionVariable()->TimedWait(self, ms, ns);
865 }
866 was_interrupted = self->IsInterrupted();
867 }
868 }
869
870 {
871 // We reset the thread's wait_monitor_ field after transitioning back to runnable so
872 // that a thread in a waiting/sleeping state has a non-null wait_monitor_ for debugging
873 // and diagnostic purposes. (If you reset this earlier, stack dumps will claim that threads
874 // are waiting on "null".)
875 MutexLock mu(self, *self->GetWaitMutex());
876 DCHECK(self->GetWaitMonitor() != nullptr);
877 self->SetWaitMonitor(nullptr);
878 }
879
880 // Allocate the interrupted exception not holding the monitor lock since it may cause a GC.
881 // If the GC requires acquiring the monitor for enqueuing cleared references, this would
882 // cause a deadlock if the monitor is held.
883 if (was_interrupted && interruptShouldThrow) {
884 /*
885 * We were interrupted while waiting, or somebody interrupted an
886 * un-interruptible thread earlier and we're bailing out immediately.
887 *
888 * The doc sayeth: "The interrupted status of the current thread is
889 * cleared when this exception is thrown."
890 */
891 self->SetInterrupted(false);
892 self->ThrowNewException("Ljava/lang/InterruptedException;", nullptr);
893 }
894
895 AtraceMonitorUnlock(); // End Wait().
896
897 // We just slept, tell the runtime callbacks about this.
898 Runtime::Current()->GetRuntimeCallbacks()->MonitorWaitFinished(this, timed_out);
899
900 // Re-acquire the monitor and lock.
901 Lock<LockReason::kForWait>(self);
902 monitor_lock_.Lock(self);
903 self->GetWaitMutex()->AssertNotHeld(self);
904
905 /*
906 * We remove our thread from wait set after restoring the count
907 * and owner fields so the subroutine can check that the calling
908 * thread owns the monitor. Aside from that, the order of member
909 * updates is not order sensitive as we hold the pthread mutex.
910 */
911 owner_ = self;
912 lock_count_ = prev_lock_count;
913 locking_method_ = saved_method;
914 locking_dex_pc_ = saved_dex_pc;
915 --num_waiters_;
916 RemoveFromWaitSet(self);
917
918 monitor_lock_.Unlock(self);
919 }
920
Notify(Thread * self)921 void Monitor::Notify(Thread* self) {
922 DCHECK(self != nullptr);
923 MutexLock mu(self, monitor_lock_);
924 // Make sure that we hold the lock.
925 if (owner_ != self) {
926 ThrowIllegalMonitorStateExceptionF("object not locked by thread before notify()");
927 return;
928 }
929 // Move one thread from waiters to wake set
930 Thread* to_move = wait_set_;
931 if (to_move != nullptr) {
932 wait_set_ = to_move->GetWaitNext();
933 to_move->SetWaitNext(wake_set_);
934 wake_set_ = to_move;
935 }
936 }
937
NotifyAll(Thread * self)938 void Monitor::NotifyAll(Thread* self) {
939 DCHECK(self != nullptr);
940 MutexLock mu(self, monitor_lock_);
941 // Make sure that we hold the lock.
942 if (owner_ != self) {
943 ThrowIllegalMonitorStateExceptionF("object not locked by thread before notifyAll()");
944 return;
945 }
946
947 // Move all threads from waiters to wake set
948 Thread* to_move = wait_set_;
949 if (to_move != nullptr) {
950 wait_set_ = nullptr;
951 Thread* move_to = wake_set_;
952 if (move_to == nullptr) {
953 wake_set_ = to_move;
954 return;
955 }
956 while (move_to->GetWaitNext() != nullptr) {
957 move_to = move_to->GetWaitNext();
958 }
959 move_to->SetWaitNext(to_move);
960 }
961 }
962
Deflate(Thread * self,ObjPtr<mirror::Object> obj)963 bool Monitor::Deflate(Thread* self, ObjPtr<mirror::Object> obj) {
964 DCHECK(obj != nullptr);
965 // Don't need volatile since we only deflate with mutators suspended.
966 LockWord lw(obj->GetLockWord(false));
967 // If the lock isn't an inflated monitor, then we don't need to deflate anything.
968 if (lw.GetState() == LockWord::kFatLocked) {
969 Monitor* monitor = lw.FatLockMonitor();
970 DCHECK(monitor != nullptr);
971 MutexLock mu(self, monitor->monitor_lock_);
972 // Can't deflate if we have anybody waiting on the CV.
973 if (monitor->num_waiters_ > 0) {
974 return false;
975 }
976 Thread* owner = monitor->owner_;
977 if (owner != nullptr) {
978 // Can't deflate if we are locked and have a hash code.
979 if (monitor->HasHashCode()) {
980 return false;
981 }
982 // Can't deflate if our lock count is too high.
983 if (static_cast<uint32_t>(monitor->lock_count_) > LockWord::kThinLockMaxCount) {
984 return false;
985 }
986 // Deflate to a thin lock.
987 LockWord new_lw = LockWord::FromThinLockId(owner->GetThreadId(),
988 monitor->lock_count_,
989 lw.GCState());
990 // Assume no concurrent read barrier state changes as mutators are suspended.
991 obj->SetLockWord(new_lw, false);
992 VLOG(monitor) << "Deflated " << obj << " to thin lock " << owner->GetTid() << " / "
993 << monitor->lock_count_;
994 } else if (monitor->HasHashCode()) {
995 LockWord new_lw = LockWord::FromHashCode(monitor->GetHashCode(), lw.GCState());
996 // Assume no concurrent read barrier state changes as mutators are suspended.
997 obj->SetLockWord(new_lw, false);
998 VLOG(monitor) << "Deflated " << obj << " to hash monitor " << monitor->GetHashCode();
999 } else {
1000 // No lock and no hash, just put an empty lock word inside the object.
1001 LockWord new_lw = LockWord::FromDefault(lw.GCState());
1002 // Assume no concurrent read barrier state changes as mutators are suspended.
1003 obj->SetLockWord(new_lw, false);
1004 VLOG(monitor) << "Deflated" << obj << " to empty lock word";
1005 }
1006 // The monitor is deflated, mark the object as null so that we know to delete it during the
1007 // next GC.
1008 monitor->obj_ = GcRoot<mirror::Object>(nullptr);
1009 }
1010 return true;
1011 }
1012
Inflate(Thread * self,Thread * owner,ObjPtr<mirror::Object> obj,int32_t hash_code)1013 void Monitor::Inflate(Thread* self, Thread* owner, ObjPtr<mirror::Object> obj, int32_t hash_code) {
1014 DCHECK(self != nullptr);
1015 DCHECK(obj != nullptr);
1016 // Allocate and acquire a new monitor.
1017 Monitor* m = MonitorPool::CreateMonitor(self, owner, obj, hash_code);
1018 DCHECK(m != nullptr);
1019 if (m->Install(self)) {
1020 if (owner != nullptr) {
1021 VLOG(monitor) << "monitor: thread" << owner->GetThreadId()
1022 << " created monitor " << m << " for object " << obj;
1023 } else {
1024 VLOG(monitor) << "monitor: Inflate with hashcode " << hash_code
1025 << " created monitor " << m << " for object " << obj;
1026 }
1027 Runtime::Current()->GetMonitorList()->Add(m);
1028 CHECK_EQ(obj->GetLockWord(true).GetState(), LockWord::kFatLocked);
1029 } else {
1030 MonitorPool::ReleaseMonitor(self, m);
1031 }
1032 }
1033
InflateThinLocked(Thread * self,Handle<mirror::Object> obj,LockWord lock_word,uint32_t hash_code)1034 void Monitor::InflateThinLocked(Thread* self, Handle<mirror::Object> obj, LockWord lock_word,
1035 uint32_t hash_code) {
1036 DCHECK_EQ(lock_word.GetState(), LockWord::kThinLocked);
1037 uint32_t owner_thread_id = lock_word.ThinLockOwner();
1038 if (owner_thread_id == self->GetThreadId()) {
1039 // We own the monitor, we can easily inflate it.
1040 Inflate(self, self, obj.Get(), hash_code);
1041 } else {
1042 ThreadList* thread_list = Runtime::Current()->GetThreadList();
1043 // Suspend the owner, inflate. First change to blocked and give up mutator_lock_.
1044 self->SetMonitorEnterObject(obj.Get());
1045 bool timed_out;
1046 Thread* owner;
1047 {
1048 ScopedThreadSuspension sts(self, kWaitingForLockInflation);
1049 owner = thread_list->SuspendThreadByThreadId(owner_thread_id,
1050 SuspendReason::kInternal,
1051 &timed_out);
1052 }
1053 if (owner != nullptr) {
1054 // We succeeded in suspending the thread, check the lock's status didn't change.
1055 lock_word = obj->GetLockWord(true);
1056 if (lock_word.GetState() == LockWord::kThinLocked &&
1057 lock_word.ThinLockOwner() == owner_thread_id) {
1058 // Go ahead and inflate the lock.
1059 Inflate(self, owner, obj.Get(), hash_code);
1060 }
1061 bool resumed = thread_list->Resume(owner, SuspendReason::kInternal);
1062 DCHECK(resumed);
1063 }
1064 self->SetMonitorEnterObject(nullptr);
1065 }
1066 }
1067
1068 // Fool annotalysis into thinking that the lock on obj is acquired.
FakeLock(ObjPtr<mirror::Object> obj)1069 static ObjPtr<mirror::Object> FakeLock(ObjPtr<mirror::Object> obj)
1070 EXCLUSIVE_LOCK_FUNCTION(obj.Ptr()) NO_THREAD_SAFETY_ANALYSIS {
1071 return obj;
1072 }
1073
1074 // Fool annotalysis into thinking that the lock on obj is release.
FakeUnlock(ObjPtr<mirror::Object> obj)1075 static ObjPtr<mirror::Object> FakeUnlock(ObjPtr<mirror::Object> obj)
1076 UNLOCK_FUNCTION(obj.Ptr()) NO_THREAD_SAFETY_ANALYSIS {
1077 return obj;
1078 }
1079
MonitorEnter(Thread * self,ObjPtr<mirror::Object> obj,bool trylock)1080 ObjPtr<mirror::Object> Monitor::MonitorEnter(Thread* self,
1081 ObjPtr<mirror::Object> obj,
1082 bool trylock) {
1083 DCHECK(self != nullptr);
1084 DCHECK(obj != nullptr);
1085 self->AssertThreadSuspensionIsAllowable();
1086 obj = FakeLock(obj);
1087 uint32_t thread_id = self->GetThreadId();
1088 size_t contention_count = 0;
1089 StackHandleScope<1> hs(self);
1090 Handle<mirror::Object> h_obj(hs.NewHandle(obj));
1091 while (true) {
1092 // We initially read the lockword with ordinary Java/relaxed semantics. When stronger
1093 // semantics are needed, we address it below. Since GetLockWord bottoms out to a relaxed load,
1094 // we can fix it later, in an infrequently executed case, with a fence.
1095 LockWord lock_word = h_obj->GetLockWord(false);
1096 switch (lock_word.GetState()) {
1097 case LockWord::kUnlocked: {
1098 // No ordering required for preceding lockword read, since we retest.
1099 LockWord thin_locked(LockWord::FromThinLockId(thread_id, 0, lock_word.GCState()));
1100 if (h_obj->CasLockWord(lock_word, thin_locked, CASMode::kWeak, std::memory_order_acquire)) {
1101 AtraceMonitorLock(self, h_obj.Get(), /* is_wait= */ false);
1102 return h_obj.Get(); // Success!
1103 }
1104 continue; // Go again.
1105 }
1106 case LockWord::kThinLocked: {
1107 uint32_t owner_thread_id = lock_word.ThinLockOwner();
1108 if (owner_thread_id == thread_id) {
1109 // No ordering required for initial lockword read.
1110 // We own the lock, increase the recursion count.
1111 uint32_t new_count = lock_word.ThinLockCount() + 1;
1112 if (LIKELY(new_count <= LockWord::kThinLockMaxCount)) {
1113 LockWord thin_locked(LockWord::FromThinLockId(thread_id,
1114 new_count,
1115 lock_word.GCState()));
1116 // Only this thread pays attention to the count. Thus there is no need for stronger
1117 // than relaxed memory ordering.
1118 if (!kUseReadBarrier) {
1119 h_obj->SetLockWord(thin_locked, /* as_volatile= */ false);
1120 AtraceMonitorLock(self, h_obj.Get(), /* is_wait= */ false);
1121 return h_obj.Get(); // Success!
1122 } else {
1123 // Use CAS to preserve the read barrier state.
1124 if (h_obj->CasLockWord(lock_word,
1125 thin_locked,
1126 CASMode::kWeak,
1127 std::memory_order_relaxed)) {
1128 AtraceMonitorLock(self, h_obj.Get(), /* is_wait= */ false);
1129 return h_obj.Get(); // Success!
1130 }
1131 }
1132 continue; // Go again.
1133 } else {
1134 // We'd overflow the recursion count, so inflate the monitor.
1135 InflateThinLocked(self, h_obj, lock_word, 0);
1136 }
1137 } else {
1138 if (trylock) {
1139 return nullptr;
1140 }
1141 // Contention.
1142 contention_count++;
1143 Runtime* runtime = Runtime::Current();
1144 if (contention_count <= runtime->GetMaxSpinsBeforeThinLockInflation()) {
1145 // TODO: Consider switching the thread state to kWaitingForLockInflation when we are
1146 // yielding. Use sched_yield instead of NanoSleep since NanoSleep can wait much longer
1147 // than the parameter you pass in. This can cause thread suspension to take excessively
1148 // long and make long pauses. See b/16307460.
1149 // TODO: We should literally spin first, without sched_yield. Sched_yield either does
1150 // nothing (at significant expense), or guarantees that we wait at least microseconds.
1151 // If the owner is running, I would expect the median lock hold time to be hundreds
1152 // of nanoseconds or less.
1153 sched_yield();
1154 } else {
1155 contention_count = 0;
1156 // No ordering required for initial lockword read. Install rereads it anyway.
1157 InflateThinLocked(self, h_obj, lock_word, 0);
1158 }
1159 }
1160 continue; // Start from the beginning.
1161 }
1162 case LockWord::kFatLocked: {
1163 // We should have done an acquire read of the lockword initially, to ensure
1164 // visibility of the monitor data structure. Use an explicit fence instead.
1165 std::atomic_thread_fence(std::memory_order_acquire);
1166 Monitor* mon = lock_word.FatLockMonitor();
1167 if (trylock) {
1168 return mon->TryLock(self) ? h_obj.Get() : nullptr;
1169 } else {
1170 mon->Lock(self);
1171 return h_obj.Get(); // Success!
1172 }
1173 }
1174 case LockWord::kHashCode:
1175 // Inflate with the existing hashcode.
1176 // Again no ordering required for initial lockword read, since we don't rely
1177 // on the visibility of any prior computation.
1178 Inflate(self, nullptr, h_obj.Get(), lock_word.GetHashCode());
1179 continue; // Start from the beginning.
1180 default: {
1181 LOG(FATAL) << "Invalid monitor state " << lock_word.GetState();
1182 UNREACHABLE();
1183 }
1184 }
1185 }
1186 }
1187
MonitorExit(Thread * self,ObjPtr<mirror::Object> obj)1188 bool Monitor::MonitorExit(Thread* self, ObjPtr<mirror::Object> obj) {
1189 DCHECK(self != nullptr);
1190 DCHECK(obj != nullptr);
1191 self->AssertThreadSuspensionIsAllowable();
1192 obj = FakeUnlock(obj);
1193 StackHandleScope<1> hs(self);
1194 Handle<mirror::Object> h_obj(hs.NewHandle(obj));
1195 while (true) {
1196 LockWord lock_word = obj->GetLockWord(true);
1197 switch (lock_word.GetState()) {
1198 case LockWord::kHashCode:
1199 // Fall-through.
1200 case LockWord::kUnlocked:
1201 FailedUnlock(h_obj.Get(), self->GetThreadId(), 0u, nullptr);
1202 return false; // Failure.
1203 case LockWord::kThinLocked: {
1204 uint32_t thread_id = self->GetThreadId();
1205 uint32_t owner_thread_id = lock_word.ThinLockOwner();
1206 if (owner_thread_id != thread_id) {
1207 FailedUnlock(h_obj.Get(), thread_id, owner_thread_id, nullptr);
1208 return false; // Failure.
1209 } else {
1210 // We own the lock, decrease the recursion count.
1211 LockWord new_lw = LockWord::Default();
1212 if (lock_word.ThinLockCount() != 0) {
1213 uint32_t new_count = lock_word.ThinLockCount() - 1;
1214 new_lw = LockWord::FromThinLockId(thread_id, new_count, lock_word.GCState());
1215 } else {
1216 new_lw = LockWord::FromDefault(lock_word.GCState());
1217 }
1218 if (!kUseReadBarrier) {
1219 DCHECK_EQ(new_lw.ReadBarrierState(), 0U);
1220 // TODO: This really only needs memory_order_release, but we currently have
1221 // no way to specify that. In fact there seem to be no legitimate uses of SetLockWord
1222 // with a final argument of true. This slows down x86 and ARMv7, but probably not v8.
1223 h_obj->SetLockWord(new_lw, true);
1224 AtraceMonitorUnlock();
1225 // Success!
1226 return true;
1227 } else {
1228 // Use CAS to preserve the read barrier state.
1229 if (h_obj->CasLockWord(lock_word, new_lw, CASMode::kWeak, std::memory_order_release)) {
1230 AtraceMonitorUnlock();
1231 // Success!
1232 return true;
1233 }
1234 }
1235 continue; // Go again.
1236 }
1237 }
1238 case LockWord::kFatLocked: {
1239 Monitor* mon = lock_word.FatLockMonitor();
1240 return mon->Unlock(self);
1241 }
1242 default: {
1243 LOG(FATAL) << "Invalid monitor state " << lock_word.GetState();
1244 UNREACHABLE();
1245 }
1246 }
1247 }
1248 }
1249
Wait(Thread * self,ObjPtr<mirror::Object> obj,int64_t ms,int32_t ns,bool interruptShouldThrow,ThreadState why)1250 void Monitor::Wait(Thread* self,
1251 ObjPtr<mirror::Object> obj,
1252 int64_t ms,
1253 int32_t ns,
1254 bool interruptShouldThrow,
1255 ThreadState why) {
1256 DCHECK(self != nullptr);
1257 DCHECK(obj != nullptr);
1258 StackHandleScope<1> hs(self);
1259 Handle<mirror::Object> h_obj(hs.NewHandle(obj));
1260
1261 Runtime::Current()->GetRuntimeCallbacks()->ObjectWaitStart(h_obj, ms);
1262 if (UNLIKELY(self->ObserveAsyncException() || self->IsExceptionPending())) {
1263 // See b/65558434 for information on handling of exceptions here.
1264 return;
1265 }
1266
1267 LockWord lock_word = h_obj->GetLockWord(true);
1268 while (lock_word.GetState() != LockWord::kFatLocked) {
1269 switch (lock_word.GetState()) {
1270 case LockWord::kHashCode:
1271 // Fall-through.
1272 case LockWord::kUnlocked:
1273 ThrowIllegalMonitorStateExceptionF("object not locked by thread before wait()");
1274 return; // Failure.
1275 case LockWord::kThinLocked: {
1276 uint32_t thread_id = self->GetThreadId();
1277 uint32_t owner_thread_id = lock_word.ThinLockOwner();
1278 if (owner_thread_id != thread_id) {
1279 ThrowIllegalMonitorStateExceptionF("object not locked by thread before wait()");
1280 return; // Failure.
1281 } else {
1282 // We own the lock, inflate to enqueue ourself on the Monitor. May fail spuriously so
1283 // re-load.
1284 Inflate(self, self, h_obj.Get(), 0);
1285 lock_word = h_obj->GetLockWord(true);
1286 }
1287 break;
1288 }
1289 case LockWord::kFatLocked: // Unreachable given the loop condition above. Fall-through.
1290 default: {
1291 LOG(FATAL) << "Invalid monitor state " << lock_word.GetState();
1292 UNREACHABLE();
1293 }
1294 }
1295 }
1296 Monitor* mon = lock_word.FatLockMonitor();
1297 mon->Wait(self, ms, ns, interruptShouldThrow, why);
1298 }
1299
DoNotify(Thread * self,ObjPtr<mirror::Object> obj,bool notify_all)1300 void Monitor::DoNotify(Thread* self, ObjPtr<mirror::Object> obj, bool notify_all) {
1301 DCHECK(self != nullptr);
1302 DCHECK(obj != nullptr);
1303 LockWord lock_word = obj->GetLockWord(true);
1304 switch (lock_word.GetState()) {
1305 case LockWord::kHashCode:
1306 // Fall-through.
1307 case LockWord::kUnlocked:
1308 ThrowIllegalMonitorStateExceptionF("object not locked by thread before notify()");
1309 return; // Failure.
1310 case LockWord::kThinLocked: {
1311 uint32_t thread_id = self->GetThreadId();
1312 uint32_t owner_thread_id = lock_word.ThinLockOwner();
1313 if (owner_thread_id != thread_id) {
1314 ThrowIllegalMonitorStateExceptionF("object not locked by thread before notify()");
1315 return; // Failure.
1316 } else {
1317 // We own the lock but there's no Monitor and therefore no waiters.
1318 return; // Success.
1319 }
1320 }
1321 case LockWord::kFatLocked: {
1322 Monitor* mon = lock_word.FatLockMonitor();
1323 if (notify_all) {
1324 mon->NotifyAll(self);
1325 } else {
1326 mon->Notify(self);
1327 }
1328 return; // Success.
1329 }
1330 default: {
1331 LOG(FATAL) << "Invalid monitor state " << lock_word.GetState();
1332 UNREACHABLE();
1333 }
1334 }
1335 }
1336
GetLockOwnerThreadId(ObjPtr<mirror::Object> obj)1337 uint32_t Monitor::GetLockOwnerThreadId(ObjPtr<mirror::Object> obj) {
1338 DCHECK(obj != nullptr);
1339 LockWord lock_word = obj->GetLockWord(true);
1340 switch (lock_word.GetState()) {
1341 case LockWord::kHashCode:
1342 // Fall-through.
1343 case LockWord::kUnlocked:
1344 return ThreadList::kInvalidThreadId;
1345 case LockWord::kThinLocked:
1346 return lock_word.ThinLockOwner();
1347 case LockWord::kFatLocked: {
1348 Monitor* mon = lock_word.FatLockMonitor();
1349 return mon->GetOwnerThreadId();
1350 }
1351 default: {
1352 LOG(FATAL) << "Unreachable";
1353 UNREACHABLE();
1354 }
1355 }
1356 }
1357
FetchState(const Thread * thread,ObjPtr<mirror::Object> * monitor_object,uint32_t * lock_owner_tid)1358 ThreadState Monitor::FetchState(const Thread* thread,
1359 /* out */ ObjPtr<mirror::Object>* monitor_object,
1360 /* out */ uint32_t* lock_owner_tid) {
1361 DCHECK(monitor_object != nullptr);
1362 DCHECK(lock_owner_tid != nullptr);
1363
1364 *monitor_object = nullptr;
1365 *lock_owner_tid = ThreadList::kInvalidThreadId;
1366
1367 ThreadState state = thread->GetState();
1368
1369 switch (state) {
1370 case kWaiting:
1371 case kTimedWaiting:
1372 case kSleeping:
1373 {
1374 Thread* self = Thread::Current();
1375 MutexLock mu(self, *thread->GetWaitMutex());
1376 Monitor* monitor = thread->GetWaitMonitor();
1377 if (monitor != nullptr) {
1378 *monitor_object = monitor->GetObject();
1379 }
1380 }
1381 break;
1382
1383 case kBlocked:
1384 case kWaitingForLockInflation:
1385 {
1386 ObjPtr<mirror::Object> lock_object = thread->GetMonitorEnterObject();
1387 if (lock_object != nullptr) {
1388 if (kUseReadBarrier && Thread::Current()->GetIsGcMarking()) {
1389 // We may call Thread::Dump() in the middle of the CC thread flip and this thread's stack
1390 // may have not been flipped yet and "pretty_object" may be a from-space (stale) ref, in
1391 // which case the GetLockOwnerThreadId() call below will crash. So explicitly mark/forward
1392 // it here.
1393 lock_object = ReadBarrier::Mark(lock_object.Ptr());
1394 }
1395 *monitor_object = lock_object;
1396 *lock_owner_tid = lock_object->GetLockOwnerThreadId();
1397 }
1398 }
1399 break;
1400
1401 default:
1402 break;
1403 }
1404
1405 return state;
1406 }
1407
GetContendedMonitor(Thread * thread)1408 ObjPtr<mirror::Object> Monitor::GetContendedMonitor(Thread* thread) {
1409 // This is used to implement JDWP's ThreadReference.CurrentContendedMonitor, and has a bizarre
1410 // definition of contended that includes a monitor a thread is trying to enter...
1411 ObjPtr<mirror::Object> result = thread->GetMonitorEnterObject();
1412 if (result == nullptr) {
1413 // ...but also a monitor that the thread is waiting on.
1414 MutexLock mu(Thread::Current(), *thread->GetWaitMutex());
1415 Monitor* monitor = thread->GetWaitMonitor();
1416 if (monitor != nullptr) {
1417 result = monitor->GetObject();
1418 }
1419 }
1420 return result;
1421 }
1422
VisitLocks(StackVisitor * stack_visitor,void (* callback)(ObjPtr<mirror::Object>,void *),void * callback_context,bool abort_on_failure)1423 void Monitor::VisitLocks(StackVisitor* stack_visitor,
1424 void (*callback)(ObjPtr<mirror::Object>, void*),
1425 void* callback_context,
1426 bool abort_on_failure) {
1427 ArtMethod* m = stack_visitor->GetMethod();
1428 CHECK(m != nullptr);
1429
1430 // Native methods are an easy special case.
1431 // TODO: use the JNI implementation's table of explicit MonitorEnter calls and dump those too.
1432 if (m->IsNative()) {
1433 if (m->IsSynchronized()) {
1434 ObjPtr<mirror::Object> jni_this =
1435 stack_visitor->GetCurrentHandleScope(sizeof(void*))->GetReference(0);
1436 callback(jni_this, callback_context);
1437 }
1438 return;
1439 }
1440
1441 // Proxy methods should not be synchronized.
1442 if (m->IsProxyMethod()) {
1443 CHECK(!m->IsSynchronized());
1444 return;
1445 }
1446
1447 // Is there any reason to believe there's any synchronization in this method?
1448 CHECK(m->GetCodeItem() != nullptr) << m->PrettyMethod();
1449 CodeItemDataAccessor accessor(m->DexInstructionData());
1450 if (accessor.TriesSize() == 0) {
1451 return; // No "tries" implies no synchronization, so no held locks to report.
1452 }
1453
1454 // Get the dex pc. If abort_on_failure is false, GetDexPc will not abort in the case it cannot
1455 // find the dex pc, and instead return kDexNoIndex. Then bail out, as it indicates we have an
1456 // inconsistent stack anyways.
1457 uint32_t dex_pc = stack_visitor->GetDexPc(abort_on_failure);
1458 if (!abort_on_failure && dex_pc == dex::kDexNoIndex) {
1459 LOG(ERROR) << "Could not find dex_pc for " << m->PrettyMethod();
1460 return;
1461 }
1462
1463 // Ask the verifier for the dex pcs of all the monitor-enter instructions corresponding to
1464 // the locks held in this stack frame.
1465 std::vector<verifier::MethodVerifier::DexLockInfo> monitor_enter_dex_pcs;
1466 verifier::MethodVerifier::FindLocksAtDexPc(m,
1467 dex_pc,
1468 &monitor_enter_dex_pcs,
1469 Runtime::Current()->GetTargetSdkVersion());
1470 for (verifier::MethodVerifier::DexLockInfo& dex_lock_info : monitor_enter_dex_pcs) {
1471 // As a debug check, check that dex PC corresponds to a monitor-enter.
1472 if (kIsDebugBuild) {
1473 const Instruction& monitor_enter_instruction = accessor.InstructionAt(dex_lock_info.dex_pc);
1474 CHECK_EQ(monitor_enter_instruction.Opcode(), Instruction::MONITOR_ENTER)
1475 << "expected monitor-enter @" << dex_lock_info.dex_pc << "; was "
1476 << reinterpret_cast<const void*>(&monitor_enter_instruction);
1477 }
1478
1479 // Iterate through the set of dex registers, as the compiler may not have held all of them
1480 // live.
1481 bool success = false;
1482 for (uint32_t dex_reg : dex_lock_info.dex_registers) {
1483 uint32_t value;
1484 success = stack_visitor->GetVReg(m, dex_reg, kReferenceVReg, &value);
1485 if (success) {
1486 ObjPtr<mirror::Object> o = reinterpret_cast<mirror::Object*>(value);
1487 callback(o, callback_context);
1488 break;
1489 }
1490 }
1491 DCHECK(success) << "Failed to find/read reference for monitor-enter at dex pc "
1492 << dex_lock_info.dex_pc
1493 << " in method "
1494 << m->PrettyMethod();
1495 if (!success) {
1496 LOG(WARNING) << "Had a lock reported for dex pc " << dex_lock_info.dex_pc
1497 << " but was not able to fetch a corresponding object!";
1498 }
1499 }
1500 }
1501
IsValidLockWord(LockWord lock_word)1502 bool Monitor::IsValidLockWord(LockWord lock_word) {
1503 switch (lock_word.GetState()) {
1504 case LockWord::kUnlocked:
1505 // Nothing to check.
1506 return true;
1507 case LockWord::kThinLocked:
1508 // Basic sanity check of owner.
1509 return lock_word.ThinLockOwner() != ThreadList::kInvalidThreadId;
1510 case LockWord::kFatLocked: {
1511 // Check the monitor appears in the monitor list.
1512 Monitor* mon = lock_word.FatLockMonitor();
1513 MonitorList* list = Runtime::Current()->GetMonitorList();
1514 MutexLock mu(Thread::Current(), list->monitor_list_lock_);
1515 for (Monitor* list_mon : list->list_) {
1516 if (mon == list_mon) {
1517 return true; // Found our monitor.
1518 }
1519 }
1520 return false; // Fail - unowned monitor in an object.
1521 }
1522 case LockWord::kHashCode:
1523 return true;
1524 default:
1525 LOG(FATAL) << "Unreachable";
1526 UNREACHABLE();
1527 }
1528 }
1529
IsLocked()1530 bool Monitor::IsLocked() REQUIRES_SHARED(Locks::mutator_lock_) {
1531 MutexLock mu(Thread::Current(), monitor_lock_);
1532 return owner_ != nullptr;
1533 }
1534
TranslateLocation(ArtMethod * method,uint32_t dex_pc,const char ** source_file,int32_t * line_number)1535 void Monitor::TranslateLocation(ArtMethod* method,
1536 uint32_t dex_pc,
1537 const char** source_file,
1538 int32_t* line_number) {
1539 // If method is null, location is unknown
1540 if (method == nullptr) {
1541 *source_file = "";
1542 *line_number = 0;
1543 return;
1544 }
1545 *source_file = method->GetDeclaringClassSourceFile();
1546 if (*source_file == nullptr) {
1547 *source_file = "";
1548 }
1549 *line_number = method->GetLineNumFromDexPC(dex_pc);
1550 }
1551
GetOwnerThreadId()1552 uint32_t Monitor::GetOwnerThreadId() {
1553 MutexLock mu(Thread::Current(), monitor_lock_);
1554 Thread* owner = owner_;
1555 if (owner != nullptr) {
1556 return owner->GetThreadId();
1557 } else {
1558 return ThreadList::kInvalidThreadId;
1559 }
1560 }
1561
MonitorList()1562 MonitorList::MonitorList()
1563 : allow_new_monitors_(true), monitor_list_lock_("MonitorList lock", kMonitorListLock),
1564 monitor_add_condition_("MonitorList disallow condition", monitor_list_lock_) {
1565 }
1566
~MonitorList()1567 MonitorList::~MonitorList() {
1568 Thread* self = Thread::Current();
1569 MutexLock mu(self, monitor_list_lock_);
1570 // Release all monitors to the pool.
1571 // TODO: Is it an invariant that *all* open monitors are in the list? Then we could
1572 // clear faster in the pool.
1573 MonitorPool::ReleaseMonitors(self, &list_);
1574 }
1575
DisallowNewMonitors()1576 void MonitorList::DisallowNewMonitors() {
1577 CHECK(!kUseReadBarrier);
1578 MutexLock mu(Thread::Current(), monitor_list_lock_);
1579 allow_new_monitors_ = false;
1580 }
1581
AllowNewMonitors()1582 void MonitorList::AllowNewMonitors() {
1583 CHECK(!kUseReadBarrier);
1584 Thread* self = Thread::Current();
1585 MutexLock mu(self, monitor_list_lock_);
1586 allow_new_monitors_ = true;
1587 monitor_add_condition_.Broadcast(self);
1588 }
1589
BroadcastForNewMonitors()1590 void MonitorList::BroadcastForNewMonitors() {
1591 Thread* self = Thread::Current();
1592 MutexLock mu(self, monitor_list_lock_);
1593 monitor_add_condition_.Broadcast(self);
1594 }
1595
Add(Monitor * m)1596 void MonitorList::Add(Monitor* m) {
1597 Thread* self = Thread::Current();
1598 MutexLock mu(self, monitor_list_lock_);
1599 // CMS needs this to block for concurrent reference processing because an object allocated during
1600 // the GC won't be marked and concurrent reference processing would incorrectly clear the JNI weak
1601 // ref. But CC (kUseReadBarrier == true) doesn't because of the to-space invariant.
1602 while (!kUseReadBarrier && UNLIKELY(!allow_new_monitors_)) {
1603 // Check and run the empty checkpoint before blocking so the empty checkpoint will work in the
1604 // presence of threads blocking for weak ref access.
1605 self->CheckEmptyCheckpointFromWeakRefAccess(&monitor_list_lock_);
1606 monitor_add_condition_.WaitHoldingLocks(self);
1607 }
1608 list_.push_front(m);
1609 }
1610
SweepMonitorList(IsMarkedVisitor * visitor)1611 void MonitorList::SweepMonitorList(IsMarkedVisitor* visitor) {
1612 Thread* self = Thread::Current();
1613 MutexLock mu(self, monitor_list_lock_);
1614 for (auto it = list_.begin(); it != list_.end(); ) {
1615 Monitor* m = *it;
1616 // Disable the read barrier in GetObject() as this is called by GC.
1617 ObjPtr<mirror::Object> obj = m->GetObject<kWithoutReadBarrier>();
1618 // The object of a monitor can be null if we have deflated it.
1619 ObjPtr<mirror::Object> new_obj = obj != nullptr ? visitor->IsMarked(obj.Ptr()) : nullptr;
1620 if (new_obj == nullptr) {
1621 VLOG(monitor) << "freeing monitor " << m << " belonging to unmarked object "
1622 << obj;
1623 MonitorPool::ReleaseMonitor(self, m);
1624 it = list_.erase(it);
1625 } else {
1626 m->SetObject(new_obj);
1627 ++it;
1628 }
1629 }
1630 }
1631
Size()1632 size_t MonitorList::Size() {
1633 Thread* self = Thread::Current();
1634 MutexLock mu(self, monitor_list_lock_);
1635 return list_.size();
1636 }
1637
1638 class MonitorDeflateVisitor : public IsMarkedVisitor {
1639 public:
MonitorDeflateVisitor()1640 MonitorDeflateVisitor() : self_(Thread::Current()), deflate_count_(0) {}
1641
IsMarked(mirror::Object * object)1642 mirror::Object* IsMarked(mirror::Object* object) override
1643 REQUIRES_SHARED(Locks::mutator_lock_) {
1644 if (Monitor::Deflate(self_, object)) {
1645 DCHECK_NE(object->GetLockWord(true).GetState(), LockWord::kFatLocked);
1646 ++deflate_count_;
1647 // If we deflated, return null so that the monitor gets removed from the array.
1648 return nullptr;
1649 }
1650 return object; // Monitor was not deflated.
1651 }
1652
1653 Thread* const self_;
1654 size_t deflate_count_;
1655 };
1656
DeflateMonitors()1657 size_t MonitorList::DeflateMonitors() {
1658 MonitorDeflateVisitor visitor;
1659 Locks::mutator_lock_->AssertExclusiveHeld(visitor.self_);
1660 SweepMonitorList(&visitor);
1661 return visitor.deflate_count_;
1662 }
1663
MonitorInfo(ObjPtr<mirror::Object> obj)1664 MonitorInfo::MonitorInfo(ObjPtr<mirror::Object> obj) : owner_(nullptr), entry_count_(0) {
1665 DCHECK(obj != nullptr);
1666 LockWord lock_word = obj->GetLockWord(true);
1667 switch (lock_word.GetState()) {
1668 case LockWord::kUnlocked:
1669 // Fall-through.
1670 case LockWord::kForwardingAddress:
1671 // Fall-through.
1672 case LockWord::kHashCode:
1673 break;
1674 case LockWord::kThinLocked:
1675 owner_ = Runtime::Current()->GetThreadList()->FindThreadByThreadId(lock_word.ThinLockOwner());
1676 DCHECK(owner_ != nullptr) << "Thin-locked without owner!";
1677 entry_count_ = 1 + lock_word.ThinLockCount();
1678 // Thin locks have no waiters.
1679 break;
1680 case LockWord::kFatLocked: {
1681 Monitor* mon = lock_word.FatLockMonitor();
1682 owner_ = mon->owner_;
1683 // Here it is okay for the owner to be null since we don't reset the LockWord back to
1684 // kUnlocked until we get a GC. In cases where this hasn't happened yet we will have a fat
1685 // lock without an owner.
1686 if (owner_ != nullptr) {
1687 entry_count_ = 1 + mon->lock_count_;
1688 } else {
1689 DCHECK_EQ(mon->lock_count_, 0) << "Monitor is fat-locked without any owner!";
1690 }
1691 for (Thread* waiter = mon->wait_set_; waiter != nullptr; waiter = waiter->GetWaitNext()) {
1692 waiters_.push_back(waiter);
1693 }
1694 break;
1695 }
1696 }
1697 }
1698
1699 } // namespace art
1700