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