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