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