• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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