monitor.cc revision 2d096c94fbd3fd2470b8ac1a0da6f577b3f69f42
15f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes/* 25f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * Copyright (C) 2008 The Android Open Source Project 35f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * 45f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * Licensed under the Apache License, Version 2.0 (the "License"); 55f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * you may not use this file except in compliance with the License. 65f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * You may obtain a copy of the License at 75f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * 85f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * http://www.apache.org/licenses/LICENSE-2.0 95f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * 105f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * Unless required by applicable law or agreed to in writing, software 115f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * distributed under the License is distributed on an "AS IS" BASIS, 125f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 135f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * See the License for the specific language governing permissions and 145f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * limitations under the License. 155f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes */ 165f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 1754e7df1896a4066cbb9fe6f72249829f0b8c49c6Elliott Hughes#include "monitor.h" 185f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 19f0dc8b5519102b3d3e738aed846975ae4239421eMathieu Chartier#define ATRACE_TAG ATRACE_TAG_DALVIK 20f0dc8b5519102b3d3e738aed846975ae4239421eMathieu Chartier 21f0dc8b5519102b3d3e738aed846975ae4239421eMathieu Chartier#include <cutils/trace.h> 2208fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes#include <vector> 2308fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes 24e401d146407d61eeb99f8d6176b2ac13c4df1e33Mathieu Chartier#include "art_method-inl.h" 2576b6167407c2b6f5d40ad895b2793a6b037f54b2Elliott Hughes#include "base/mutex.h" 261aa246dec5abe212f699de1413a0c4a191ca364aElliott Hughes#include "base/stl_util.h" 2780afd02024d20e60b197d3adfbb43cc303cf29e0Vladimir Marko#include "base/time_utils.h" 2833dc7717cd16592bcc825350bea6305be9eb2ea1jeffhao#include "class_linker.h" 294f6ad8ab428038129b2d0d6c40b7fd625cca15e1Ian Rogers#include "dex_file-inl.h" 3008fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes#include "dex_instruction.h" 31d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers#include "lock_word-inl.h" 324f6ad8ab428038129b2d0d6c40b7fd625cca15e1Ian Rogers#include "mirror/class-inl.h" 3305f3057d6a4d23d712092ccd36a531590bff323bIan Rogers#include "mirror/object-inl.h" 342dd0e2cea360bc9206eb88ecc40d259e796c239dIan Rogers#include "mirror/object_array-inl.h" 3500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers#include "scoped_thread_state_change.h" 365f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes#include "thread.h" 378e4aac52962d54cb4be2078b9cd95685e067133aElliott Hughes#include "thread_list.h" 3808fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes#include "verifier/method_verifier.h" 39044288fb8f69e154862763a6b3bfea2bac1b397eElliott Hughes#include "well_known_classes.h" 405f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 415f79133a435ebcb20000370d56046fe01201dd80Elliott Hughesnamespace art { 425f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 43b9001abff3a45f1ae90536da7dd1ec28a6ae0174Mathieu Chartierstatic constexpr uint64_t kLongWaitMs = 100; 44b9001abff3a45f1ae90536da7dd1ec28a6ae0174Mathieu Chartier 455f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes/* 46d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers * Every Object has a monitor associated with it, but not every Object is actually locked. Even 47d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers * the ones that are locked do not need a full-fledged monitor until a) there is actual contention 48d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers * or b) wait() is called on the Object. 495f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * 50d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers * For Android, we have implemented a scheme similar to the one described in Bacon et al.'s 51d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers * "Thin locks: featherweight synchronization for Java" (ACM 1998). Things are even easier for us, 52d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers * though, because we have a full 32 bits to work with. 535f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * 54d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers * The two states of an Object's lock are referred to as "thin" and "fat". A lock may transition 55d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers * from the "thin" state to the "fat" state and this transition is referred to as inflation. Once 56d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers * a lock has been inflated it remains in the "fat" state indefinitely. 575f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * 58d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers * The lock value itself is stored in mirror::Object::monitor_ and the representation is described 59d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers * in the LockWord value type. 6054e7df1896a4066cbb9fe6f72249829f0b8c49c6Elliott Hughes * 615f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * Monitors provide: 625f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * - mutually exclusive access to resources 635f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * - a way for multiple threads to wait for notification 645f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * 655f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * In effect, they fill the role of both mutexes and condition variables. 665f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * 67d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers * Only one thread can own the monitor at any time. There may be several threads waiting on it 68d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers * (the wait call unlocks it). One or more waiting threads may be getting interrupted or notified 69d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers * at any given time. 705f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes */ 7154e7df1896a4066cbb9fe6f72249829f0b8c49c6Elliott Hughes 722cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartierbool (*Monitor::is_sensitive_thread_hook_)() = nullptr; 73fc86162ce2a3467acb690e18cc8bd9b3daafc606Elliott Hughesuint32_t Monitor::lock_profiling_threshold_ = 0; 7432d6e1e5654433d7eadede89e1c770b2c839aee9Elliott Hughes 75fc86162ce2a3467acb690e18cc8bd9b3daafc606Elliott Hughesbool Monitor::IsSensitiveThread() { 762cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier if (is_sensitive_thread_hook_ != nullptr) { 77fc86162ce2a3467acb690e18cc8bd9b3daafc606Elliott Hughes return (*is_sensitive_thread_hook_)(); 78fc86162ce2a3467acb690e18cc8bd9b3daafc606Elliott Hughes } 79fc86162ce2a3467acb690e18cc8bd9b3daafc606Elliott Hughes return false; 80fc86162ce2a3467acb690e18cc8bd9b3daafc606Elliott Hughes} 81fc86162ce2a3467acb690e18cc8bd9b3daafc606Elliott Hughes 824dd9b4d95eec9db5338fb9bf132f9bb8facf6cf4Elliott Hughesvoid Monitor::Init(uint32_t lock_profiling_threshold, bool (*is_sensitive_thread_hook)()) { 83fc86162ce2a3467acb690e18cc8bd9b3daafc606Elliott Hughes lock_profiling_threshold_ = lock_profiling_threshold; 84fc86162ce2a3467acb690e18cc8bd9b3daafc606Elliott Hughes is_sensitive_thread_hook_ = is_sensitive_thread_hook; 8532d6e1e5654433d7eadede89e1c770b2c839aee9Elliott Hughes} 8632d6e1e5654433d7eadede89e1c770b2c839aee9Elliott Hughes 87ef7d42fca18c16fbaf103822ad16f23246e2905dIan RogersMonitor::Monitor(Thread* self, Thread* owner, mirror::Object* obj, int32_t hash_code) 8800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers : monitor_lock_("a monitor lock", kMonitorLock), 89d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers monitor_contenders_("monitor contenders", monitor_lock_), 9046bc778f1feed02b20d25e3d03470c93ca2c0506Mathieu Chartier num_waiters_(0), 9100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers owner_(owner), 925f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes lock_count_(0), 9394f7b49578b6aaa80de8ffed230648d601393905Hiroshi Yamauchi obj_(GcRoot<mirror::Object>(obj)), 942cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier wait_set_(nullptr), 95ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier hash_code_(hash_code), 962cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier locking_method_(nullptr), 97ef7d42fca18c16fbaf103822ad16f23246e2905dIan Rogers locking_dex_pc_(0), 9874240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe monitor_id_(MonitorPool::ComputeMonitorId(this, self)) { 9974240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe#ifdef __LP64__ 10074240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe DCHECK(false) << "Should not be reached in 64b"; 10174240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe next_free_ = nullptr; 10274240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe#endif 10374240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe // We should only inflate a lock if the owner is ourselves or suspended. This avoids a race 10474240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe // with the owner unlocking the thin-lock. 10574240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe CHECK(owner == nullptr || owner == self || owner->IsSuspended()); 10674240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe // The identity hash code is set for the life time of the monitor. 10774240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe} 10874240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe 10974240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas GampeMonitor::Monitor(Thread* self, Thread* owner, mirror::Object* obj, int32_t hash_code, 11074240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe MonitorId id) 11174240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe : monitor_lock_("a monitor lock", kMonitorLock), 11274240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe monitor_contenders_("monitor contenders", monitor_lock_), 11374240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe num_waiters_(0), 11474240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe owner_(owner), 11574240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe lock_count_(0), 11694f7b49578b6aaa80de8ffed230648d601393905Hiroshi Yamauchi obj_(GcRoot<mirror::Object>(obj)), 1172cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier wait_set_(nullptr), 11874240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe hash_code_(hash_code), 1192cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier locking_method_(nullptr), 12074240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe locking_dex_pc_(0), 12174240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe monitor_id_(id) { 12274240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe#ifdef __LP64__ 12374240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe next_free_ = nullptr; 12474240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe#endif 125d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers // We should only inflate a lock if the owner is ourselves or suspended. This avoids a race 126d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers // with the owner unlocking the thin-lock. 127ef7d42fca18c16fbaf103822ad16f23246e2905dIan Rogers CHECK(owner == nullptr || owner == self || owner->IsSuspended()); 128ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier // The identity hash code is set for the life time of the monitor. 129d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers} 130d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers 1314e6a31eb97f22f4480827474b30b9e64f396eaceMathieu Chartierint32_t Monitor::GetHashCode() { 1324e6a31eb97f22f4480827474b30b9e64f396eaceMathieu Chartier while (!HasHashCode()) { 1333e5cf305db800b2989ad57b7cde8fb3cc9fa1b9eIan Rogers if (hash_code_.CompareExchangeWeakRelaxed(0, mirror::Object::GenerateIdentityHashCode())) { 1344e6a31eb97f22f4480827474b30b9e64f396eaceMathieu Chartier break; 1354e6a31eb97f22f4480827474b30b9e64f396eaceMathieu Chartier } 1364e6a31eb97f22f4480827474b30b9e64f396eaceMathieu Chartier } 1374e6a31eb97f22f4480827474b30b9e64f396eaceMathieu Chartier DCHECK(HasHashCode()); 1383e5cf305db800b2989ad57b7cde8fb3cc9fa1b9eIan Rogers return hash_code_.LoadRelaxed(); 1394e6a31eb97f22f4480827474b30b9e64f396eaceMathieu Chartier} 1404e6a31eb97f22f4480827474b30b9e64f396eaceMathieu Chartier 141d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogersbool Monitor::Install(Thread* self) { 142d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers MutexLock mu(self, monitor_lock_); // Uncontended mutex acquisition as monitor isn't yet public. 143ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier CHECK(owner_ == nullptr || owner_ == self || owner_->IsSuspended()); 14400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Propagate the lock state. 1454cba0d979a11f955e6ec3c0f1bf61478af7aa810Hiroshi Yamauchi LockWord lw(GetObject()->GetLockWord(false)); 146ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier switch (lw.GetState()) { 147ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier case LockWord::kThinLocked: { 148ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier CHECK_EQ(owner_->GetThreadId(), lw.ThinLockOwner()); 149ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier lock_count_ = lw.ThinLockCount(); 150ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier break; 151ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier } 152ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier case LockWord::kHashCode: { 1533e5cf305db800b2989ad57b7cde8fb3cc9fa1b9eIan Rogers CHECK_EQ(hash_code_.LoadRelaxed(), static_cast<int32_t>(lw.GetHashCode())); 154ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier break; 155ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier } 156ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier case LockWord::kFatLocked: { 157ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier // The owner_ is suspended but another thread beat us to install a monitor. 158ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier return false; 159ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier } 160ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier case LockWord::kUnlocked: { 161ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier LOG(FATAL) << "Inflating unlocked lock word"; 162ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier break; 163ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier } 164590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier default: { 165590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier LOG(FATAL) << "Invalid monitor state " << lw.GetState(); 166590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier return false; 167590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier } 168d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } 169e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi LockWord fat(this, lw.ReadBarrierState()); 170d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers // Publish the updated lock word, which may race with other threads. 171228602f562f1d130d06e60a98752d99c2d467d6aIan Rogers bool success = GetObject()->CasLockWordWeakSequentiallyConsistent(lw, fat); 17200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Lock profiling. 1739728f91a63016136261231ff5213bde703bd27b6Mathieu Chartier if (success && owner_ != nullptr && lock_profiling_threshold_ != 0) { 1746ec8ebd178ed39aa09e4c7fad194900114c4121aAndreas Gampe // Do not abort on dex pc errors. This can easily happen when we want to dump a stack trace on 1756ec8ebd178ed39aa09e4c7fad194900114c4121aAndreas Gampe // abort. 1766ec8ebd178ed39aa09e4c7fad194900114c4121aAndreas Gampe locking_method_ = owner_->GetCurrentMethod(&locking_dex_pc_, false); 17700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 178d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers return success; 1795f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes} 1805f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 1815f79133a435ebcb20000370d56046fe01201dd80Elliott HughesMonitor::~Monitor() { 182590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier // Deflated monitors have a null object. 1835f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes} 1845f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 1855f79133a435ebcb20000370d56046fe01201dd80Elliott Hughesvoid Monitor::AppendToWaitSet(Thread* thread) { 1865f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes DCHECK(owner_ == Thread::Current()); 1872cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier DCHECK(thread != nullptr); 188dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers DCHECK(thread->GetWaitNext() == nullptr) << thread->GetWaitNext(); 1892cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier if (wait_set_ == nullptr) { 1905f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes wait_set_ = thread; 1915f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes return; 1925f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 1935f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 1945f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes // push_back. 1955f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes Thread* t = wait_set_; 196dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers while (t->GetWaitNext() != nullptr) { 197dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers t = t->GetWaitNext(); 1985f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 199dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers t->SetWaitNext(thread); 2005f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes} 2015f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 2025f79133a435ebcb20000370d56046fe01201dd80Elliott Hughesvoid Monitor::RemoveFromWaitSet(Thread *thread) { 2035f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes DCHECK(owner_ == Thread::Current()); 2042cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier DCHECK(thread != nullptr); 2052cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier if (wait_set_ == nullptr) { 2065f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes return; 2075f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 2085f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes if (wait_set_ == thread) { 209dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers wait_set_ = thread->GetWaitNext(); 210dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers thread->SetWaitNext(nullptr); 2115f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes return; 2125f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 2135f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 2145f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes Thread* t = wait_set_; 2152cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier while (t->GetWaitNext() != nullptr) { 216dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers if (t->GetWaitNext() == thread) { 217dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers t->SetWaitNext(thread->GetWaitNext()); 218dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers thread->SetWaitNext(nullptr); 2195f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes return; 2205f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 221dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers t = t->GetWaitNext(); 2225f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 2235f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes} 2245f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 2256aa3df965395566ed6a4fec4af37c2b7577992e9Mathieu Chartiervoid Monitor::SetObject(mirror::Object* object) { 22694f7b49578b6aaa80de8ffed230648d601393905Hiroshi Yamauchi obj_ = GcRoot<mirror::Object>(object); 2276aa3df965395566ed6a4fec4af37c2b7577992e9Mathieu Chartier} 2286aa3df965395566ed6a4fec4af37c2b7577992e9Mathieu Chartier 2295f79133a435ebcb20000370d56046fe01201dd80Elliott Hughesvoid Monitor::Lock(Thread* self) { 230d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers MutexLock mu(self, monitor_lock_); 231d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers while (true) { 232440e4ceb310349ee8eb569495bc04d3d7fbe71cbMathieu Chartier if (owner_ == nullptr) { // Unowned. 233d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers owner_ = self; 234d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers CHECK_EQ(lock_count_, 0); 235d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers // When debugging, save the current monitor holder for future 236d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers // acquisition failures to use in sampled logging. 237d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers if (lock_profiling_threshold_ != 0) { 238d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers locking_method_ = self->GetCurrentMethod(&locking_dex_pc_); 239fc86162ce2a3467acb690e18cc8bd9b3daafc606Elliott Hughes } 240d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers return; 241d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } else if (owner_ == self) { // Recursive. 242d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers lock_count_++; 243d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers return; 244fc86162ce2a3467acb690e18cc8bd9b3daafc606Elliott Hughes } 245d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers // Contended. 246d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers const bool log_contention = (lock_profiling_threshold_ != 0); 247b894a19dfd668b6779de939cf5265b7e409d8809Xin Guan uint64_t wait_start_ms = log_contention ? MilliTime() : 0; 248e401d146407d61eeb99f8d6176b2ac13c4df1e33Mathieu Chartier ArtMethod* owners_method = locking_method_; 249d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers uint32_t owners_dex_pc = locking_dex_pc_; 250440e4ceb310349ee8eb569495bc04d3d7fbe71cbMathieu Chartier // Do this before releasing the lock so that we don't get deflated. 251b9001abff3a45f1ae90536da7dd1ec28a6ae0174Mathieu Chartier size_t num_waiters = num_waiters_; 252440e4ceb310349ee8eb569495bc04d3d7fbe71cbMathieu Chartier ++num_waiters_; 253d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers monitor_lock_.Unlock(self); // Let go of locks in order. 254a6e7f0872c42009ecbee82d7fbe452deef9ae65bMathieu Chartier self->SetMonitorEnterObject(GetObject()); 255d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers { 256d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers ScopedThreadStateChange tsc(self, kBlocked); // Change to blocked and give up mutator_lock_. 2572cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier // Reacquire monitor_lock_ without mutator_lock_ for Wait. 2582cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier MutexLock mu2(self, monitor_lock_); 259f0dc8b5519102b3d3e738aed846975ae4239421eMathieu Chartier if (owner_ != nullptr) { // Did the owner_ give the lock up? 260f0dc8b5519102b3d3e738aed846975ae4239421eMathieu Chartier if (ATRACE_ENABLED()) { 261f0dc8b5519102b3d3e738aed846975ae4239421eMathieu Chartier std::string name; 262f0dc8b5519102b3d3e738aed846975ae4239421eMathieu Chartier owner_->GetThreadName(name); 263f0dc8b5519102b3d3e738aed846975ae4239421eMathieu Chartier ATRACE_BEGIN(("Contended on monitor with owner " + name).c_str()); 264f0dc8b5519102b3d3e738aed846975ae4239421eMathieu Chartier } 265d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers monitor_contenders_.Wait(self); // Still contended so wait. 266d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers // Woken from contention. 267d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers if (log_contention) { 268d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers uint64_t wait_ms = MilliTime() - wait_start_ms; 269d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers uint32_t sample_percent; 270d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers if (wait_ms >= lock_profiling_threshold_) { 271d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers sample_percent = 100; 272d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } else { 273d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers sample_percent = 100 * wait_ms / lock_profiling_threshold_; 274d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } 275d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers if (sample_percent != 0 && (static_cast<uint32_t>(rand() % 100) < sample_percent)) { 276d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers const char* owners_filename; 277d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers uint32_t owners_line_number; 278d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers TranslateLocation(owners_method, owners_dex_pc, &owners_filename, &owners_line_number); 279b9001abff3a45f1ae90536da7dd1ec28a6ae0174Mathieu Chartier if (wait_ms > kLongWaitMs && owners_method != nullptr) { 280b9001abff3a45f1ae90536da7dd1ec28a6ae0174Mathieu Chartier LOG(WARNING) << "Long monitor contention event with owner method=" 281b9001abff3a45f1ae90536da7dd1ec28a6ae0174Mathieu Chartier << PrettyMethod(owners_method) << " from " << owners_filename << ":" 282b9001abff3a45f1ae90536da7dd1ec28a6ae0174Mathieu Chartier << owners_line_number << " waiters=" << num_waiters << " for " 283b9001abff3a45f1ae90536da7dd1ec28a6ae0174Mathieu Chartier << PrettyDuration(MsToNs(wait_ms)); 284b9001abff3a45f1ae90536da7dd1ec28a6ae0174Mathieu Chartier } 285d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers LogContentionEvent(self, wait_ms, sample_percent, owners_filename, owners_line_number); 286d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } 287d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } 288f0dc8b5519102b3d3e738aed846975ae4239421eMathieu Chartier ATRACE_END(); 289fc86162ce2a3467acb690e18cc8bd9b3daafc606Elliott Hughes } 2905f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 291a6e7f0872c42009ecbee82d7fbe452deef9ae65bMathieu Chartier self->SetMonitorEnterObject(nullptr); 292d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers monitor_lock_.Lock(self); // Reacquire locks in order. 293440e4ceb310349ee8eb569495bc04d3d7fbe71cbMathieu Chartier --num_waiters_; 294fc86162ce2a3467acb690e18cc8bd9b3daafc606Elliott Hughes } 2955f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes} 2965f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 2976d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogersstatic void ThrowIllegalMonitorStateExceptionF(const char* fmt, ...) 2986d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers __attribute__((format(printf, 1, 2))); 2996d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers 30000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogersstatic void ThrowIllegalMonitorStateExceptionF(const char* fmt, ...) 30190443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier SHARED_REQUIRES(Locks::mutator_lock_) { 3026d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers va_list args; 3036d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers va_start(args, fmt); 30462d6c772205b8859f0ebf7ad105402ec4c3e2e01Ian Rogers Thread* self = Thread::Current(); 3050aa50ce2fb75bfc2e815a0c33adf9b049561923bNicolas Geoffray self->ThrowNewExceptionV("Ljava/lang/IllegalMonitorStateException;", fmt, args); 306d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers if (!Runtime::Current()->IsStarted() || VLOG_IS_ON(monitor)) { 30764277f38032208a0c1081ff9e466c04009b96383Brian Carlstrom std::ostringstream ss; 30862d6c772205b8859f0ebf7ad105402ec4c3e2e01Ian Rogers self->Dump(ss); 309d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers LOG(Runtime::Current()->IsStarted() ? INFO : ERROR) 31014691c5e786e8c2c5734f687e4c96217340771beNicolas Geoffray << self->GetException()->Dump() << "\n" << ss.str(); 31164277f38032208a0c1081ff9e466c04009b96383Brian Carlstrom } 3126d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers va_end(args); 3136d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers} 3146d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers 315d423741f91526cada9d081c64ee295ec9863032dElliott Hughesstatic std::string ThreadToString(Thread* thread) { 3162cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier if (thread == nullptr) { 3172cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier return "nullptr"; 318d423741f91526cada9d081c64ee295ec9863032dElliott Hughes } 319d423741f91526cada9d081c64ee295ec9863032dElliott Hughes std::ostringstream oss; 320d423741f91526cada9d081c64ee295ec9863032dElliott Hughes // TODO: alternatively, we could just return the thread's name. 321d423741f91526cada9d081c64ee295ec9863032dElliott Hughes oss << *thread; 322d423741f91526cada9d081c64ee295ec9863032dElliott Hughes return oss.str(); 323d423741f91526cada9d081c64ee295ec9863032dElliott Hughes} 324d423741f91526cada9d081c64ee295ec9863032dElliott Hughes 3252dd0e2cea360bc9206eb88ecc40d259e796c239dIan Rogersvoid Monitor::FailedUnlock(mirror::Object* o, Thread* expected_owner, Thread* found_owner, 326ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes Monitor* monitor) { 3272cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier Thread* current_owner = nullptr; 328ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes std::string current_owner_string; 329ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes std::string expected_owner_string; 330ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes std::string found_owner_string; 331ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes { 332ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes // TODO: isn't this too late to prevent threads from disappearing? 333ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes // Acquire thread list lock so threads won't disappear from under us. 33450b35e2fd1a68cd1240e4a9d9f363e11764957d1Ian Rogers MutexLock mu(Thread::Current(), *Locks::thread_list_lock_); 335ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes // Re-read owner now that we hold lock. 3362cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier current_owner = (monitor != nullptr) ? monitor->GetOwner() : nullptr; 337ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes // Get short descriptions of the threads involved. 338ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes current_owner_string = ThreadToString(current_owner); 339ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes expected_owner_string = ThreadToString(expected_owner); 340ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes found_owner_string = ThreadToString(found_owner); 341ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes } 3422cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier if (current_owner == nullptr) { 3432cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier if (found_owner == nullptr) { 3446d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers ThrowIllegalMonitorStateExceptionF("unlock of unowned monitor on object of type '%s'" 3456d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers " on thread '%s'", 346ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes PrettyTypeOf(o).c_str(), 347ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes expected_owner_string.c_str()); 3486d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers } else { 3496d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers // Race: the original read found an owner but now there is none 3506d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers ThrowIllegalMonitorStateExceptionF("unlock of monitor owned by '%s' on object of type '%s'" 3516d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers " (where now the monitor appears unowned) on thread '%s'", 352ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes found_owner_string.c_str(), 353ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes PrettyTypeOf(o).c_str(), 354ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes expected_owner_string.c_str()); 3556d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers } 3566d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers } else { 3572cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier if (found_owner == nullptr) { 3586d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers // Race: originally there was no owner, there is now 3596d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers ThrowIllegalMonitorStateExceptionF("unlock of monitor owned by '%s' on object of type '%s'" 3606d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers " (originally believed to be unowned) on thread '%s'", 361ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes current_owner_string.c_str(), 362ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes PrettyTypeOf(o).c_str(), 363ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes expected_owner_string.c_str()); 3646d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers } else { 3656d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers if (found_owner != current_owner) { 3666d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers // Race: originally found and current owner have changed 3676d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers ThrowIllegalMonitorStateExceptionF("unlock of monitor originally owned by '%s' (now" 3686d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers " owned by '%s') on object of type '%s' on thread '%s'", 369ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes found_owner_string.c_str(), 370ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes current_owner_string.c_str(), 371ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes PrettyTypeOf(o).c_str(), 372ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes expected_owner_string.c_str()); 3736d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers } else { 3746d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers ThrowIllegalMonitorStateExceptionF("unlock of monitor owned by '%s' on object of type '%s'" 3756d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers " on thread '%s", 376ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes current_owner_string.c_str(), 377ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes PrettyTypeOf(o).c_str(), 378ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes expected_owner_string.c_str()); 3796d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers } 3806d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers } 3816d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers } 3825f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes} 3835f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 384d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogersbool Monitor::Unlock(Thread* self) { 3852cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier DCHECK(self != nullptr); 386d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers MutexLock mu(self, monitor_lock_); 3876d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers Thread* owner = owner_; 3886d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers if (owner == self) { 3895f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes // We own the monitor, so nobody else can be in here. 3905f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes if (lock_count_ == 0) { 3912cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier owner_ = nullptr; 3922cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier locking_method_ = nullptr; 3930399dde18753aa9bd2bd0d7cf60beef154d164a4Ian Rogers locking_dex_pc_ = 0; 394d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers // Wake a contender. 395d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers monitor_contenders_.Signal(self); 3965f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } else { 3975f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes --lock_count_; 3985f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 3995f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } else { 4005f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes // We don't own this, so we're not allowed to unlock it. 4015f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes // The JNI spec says that we should throw IllegalMonitorStateException 4025f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes // in this case. 4034cba0d979a11f955e6ec3c0f1bf61478af7aa810Hiroshi Yamauchi FailedUnlock(GetObject(), self, owner, this); 4045f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes return false; 4055f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 4065f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes return true; 4075f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes} 4085f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 4094cd121ef0cb35fced70c7d9de378277be7a727d9Elliott Hughesvoid Monitor::Wait(Thread* self, int64_t ms, int32_t ns, 4104cd121ef0cb35fced70c7d9de378277be7a727d9Elliott Hughes bool interruptShouldThrow, ThreadState why) { 4112cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier DCHECK(self != nullptr); 4124cd121ef0cb35fced70c7d9de378277be7a727d9Elliott Hughes DCHECK(why == kTimedWaiting || why == kWaiting || why == kSleeping); 4135f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 414d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers monitor_lock_.Lock(self); 415d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers 4165f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes // Make sure that we hold the lock. 4175f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes if (owner_ != self) { 418d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers monitor_lock_.Unlock(self); 4191af6a1fa35ff7dc0a5c653f19dbc8a91c914aa42Elena Sayapina ThrowIllegalMonitorStateExceptionF("object not locked by thread before wait()"); 4205f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes return; 4215f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 4224cd121ef0cb35fced70c7d9de378277be7a727d9Elliott Hughes 423df42c4815c30b9df15aacb88070c1e94f41d0226Elliott Hughes // We need to turn a zero-length timed wait into a regular wait because 424df42c4815c30b9df15aacb88070c1e94f41d0226Elliott Hughes // Object.wait(0, 0) is defined as Object.wait(0), which is defined as Object.wait(). 425df42c4815c30b9df15aacb88070c1e94f41d0226Elliott Hughes if (why == kTimedWaiting && (ms == 0 && ns == 0)) { 426df42c4815c30b9df15aacb88070c1e94f41d0226Elliott Hughes why = kWaiting; 427df42c4815c30b9df15aacb88070c1e94f41d0226Elliott Hughes } 428df42c4815c30b9df15aacb88070c1e94f41d0226Elliott Hughes 4295f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes // Enforce the timeout range. 4305f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes if (ms < 0 || ns < 0 || ns > 999999) { 4311af6a1fa35ff7dc0a5c653f19dbc8a91c914aa42Elena Sayapina monitor_lock_.Unlock(self); 4320aa50ce2fb75bfc2e815a0c33adf9b049561923bNicolas Geoffray self->ThrowNewExceptionF("Ljava/lang/IllegalArgumentException;", 433ef7d42fca18c16fbaf103822ad16f23246e2905dIan Rogers "timeout arguments out of range: ms=%" PRId64 " ns=%d", ms, ns); 4345f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes return; 4355f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 4365f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 4375f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes /* 4385f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * Add ourselves to the set of threads waiting on this monitor, and 4395f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * release our hold. We need to let it go even if we're a few levels 4405f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * deep in a recursive lock, and we need to restore that later. 4415f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * 4425f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * We append to the wait set ahead of clearing the count and owner 4435f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * fields so the subroutine can check that the calling thread owns 4445f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * the monitor. Aside from that, the order of member updates is 4455f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * not order sensitive as we hold the pthread mutex. 4465f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes */ 4475f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes AppendToWaitSet(self); 448440e4ceb310349ee8eb569495bc04d3d7fbe71cbMathieu Chartier ++num_waiters_; 4490399dde18753aa9bd2bd0d7cf60beef154d164a4Ian Rogers int prev_lock_count = lock_count_; 4505f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes lock_count_ = 0; 4512cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier owner_ = nullptr; 452e401d146407d61eeb99f8d6176b2ac13c4df1e33Mathieu Chartier ArtMethod* saved_method = locking_method_; 4532cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier locking_method_ = nullptr; 4540399dde18753aa9bd2bd0d7cf60beef154d164a4Ian Rogers uintptr_t saved_dex_pc = locking_dex_pc_; 4550399dde18753aa9bd2bd0d7cf60beef154d164a4Ian Rogers locking_dex_pc_ = 0; 4565f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 457b4e94fd380a84c755264e8668a16052442c7ec32Elliott Hughes bool was_interrupted = false; 45800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers { 459f1d666e1b48f8070ef1177fce156c08827f08eb8Mathieu Chartier // Update thread state. If the GC wakes up, it'll ignore us, knowing 460f1d666e1b48f8070ef1177fce156c08827f08eb8Mathieu Chartier // that we won't touch any references in this state, and we'll check 461f1d666e1b48f8070ef1177fce156c08827f08eb8Mathieu Chartier // our suspend mode before we transition out. 462f1d666e1b48f8070ef1177fce156c08827f08eb8Mathieu Chartier ScopedThreadSuspension sts(self, why); 463f1d666e1b48f8070ef1177fce156c08827f08eb8Mathieu Chartier 46400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Pseudo-atomically wait on self's wait_cond_ and release the monitor lock. 465dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers MutexLock mu(self, *self->GetWaitMutex()); 4665f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 46700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Set wait_monitor_ to the monitor object we will be waiting on. When wait_monitor_ is 4682cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier // non-null a notifying or interrupting thread must signal the thread's wait_cond_ to wake it 46900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // up. 470dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers DCHECK(self->GetWaitMonitor() == nullptr); 471dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers self->SetWaitMonitor(this); 4725f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 47300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Release the monitor lock. 474d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers monitor_contenders_.Signal(self); 475d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers monitor_lock_.Unlock(self); 47600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 477b4e94fd380a84c755264e8668a16052442c7ec32Elliott Hughes // Handle the case where the thread was interrupted before we called wait(). 478dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers if (self->IsInterruptedLocked()) { 479b4e94fd380a84c755264e8668a16052442c7ec32Elliott Hughes was_interrupted = true; 48000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } else { 48100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Wait for a notification or a timeout to occur. 4824cd121ef0cb35fced70c7d9de378277be7a727d9Elliott Hughes if (why == kWaiting) { 483dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers self->GetWaitConditionVariable()->Wait(self); 48400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } else { 4854cd121ef0cb35fced70c7d9de378277be7a727d9Elliott Hughes DCHECK(why == kTimedWaiting || why == kSleeping) << why; 486dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers self->GetWaitConditionVariable()->TimedWait(self, ms, ns); 48700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 488dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers if (self->IsInterruptedLocked()) { 489b4e94fd380a84c755264e8668a16052442c7ec32Elliott Hughes was_interrupted = true; 49000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 491dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers self->SetInterruptedLocked(false); 49200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 4935f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 4945f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 495b4e94fd380a84c755264e8668a16052442c7ec32Elliott Hughes { 496b4e94fd380a84c755264e8668a16052442c7ec32Elliott Hughes // We reset the thread's wait_monitor_ field after transitioning back to runnable so 497b4e94fd380a84c755264e8668a16052442c7ec32Elliott Hughes // that a thread in a waiting/sleeping state has a non-null wait_monitor_ for debugging 498b4e94fd380a84c755264e8668a16052442c7ec32Elliott Hughes // and diagnostic purposes. (If you reset this earlier, stack dumps will claim that threads 499b4e94fd380a84c755264e8668a16052442c7ec32Elliott Hughes // are waiting on "null".) 500dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers MutexLock mu(self, *self->GetWaitMutex()); 501dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers DCHECK(self->GetWaitMonitor() != nullptr); 502dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers self->SetWaitMonitor(nullptr); 503b4e94fd380a84c755264e8668a16052442c7ec32Elliott Hughes } 504b4e94fd380a84c755264e8668a16052442c7ec32Elliott Hughes 505d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers // Re-acquire the monitor and lock. 50600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers Lock(self); 507d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers monitor_lock_.Lock(self); 508dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers self->GetWaitMutex()->AssertNotHeld(self); 5095f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 5105f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes /* 5115f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * We remove our thread from wait set after restoring the count 5125f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * and owner fields so the subroutine can check that the calling 5135f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * thread owns the monitor. Aside from that, the order of member 5145f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * updates is not order sensitive as we hold the pthread mutex. 5155f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes */ 5165f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes owner_ = self; 5170399dde18753aa9bd2bd0d7cf60beef154d164a4Ian Rogers lock_count_ = prev_lock_count; 5180399dde18753aa9bd2bd0d7cf60beef154d164a4Ian Rogers locking_method_ = saved_method; 5190399dde18753aa9bd2bd0d7cf60beef154d164a4Ian Rogers locking_dex_pc_ = saved_dex_pc; 520440e4ceb310349ee8eb569495bc04d3d7fbe71cbMathieu Chartier --num_waiters_; 5215f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes RemoveFromWaitSet(self); 5225f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 5231af6a1fa35ff7dc0a5c653f19dbc8a91c914aa42Elena Sayapina monitor_lock_.Unlock(self); 5241af6a1fa35ff7dc0a5c653f19dbc8a91c914aa42Elena Sayapina 525b4e94fd380a84c755264e8668a16052442c7ec32Elliott Hughes if (was_interrupted) { 5265f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes /* 5275f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * We were interrupted while waiting, or somebody interrupted an 5285f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * un-interruptible thread earlier and we're bailing out immediately. 5295f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * 5305f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * The doc sayeth: "The interrupted status of the current thread is 5315f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes * cleared when this exception is thrown." 5325f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes */ 53300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers { 534dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers MutexLock mu(self, *self->GetWaitMutex()); 535dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers self->SetInterruptedLocked(false); 53600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 5375f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes if (interruptShouldThrow) { 5382cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier self->ThrowNewException("Ljava/lang/InterruptedException;", nullptr); 5395f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 5405f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 5415f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes} 5425f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 5435f79133a435ebcb20000370d56046fe01201dd80Elliott Hughesvoid Monitor::Notify(Thread* self) { 5442cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier DCHECK(self != nullptr); 545d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers MutexLock mu(self, monitor_lock_); 5465f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes // Make sure that we hold the lock. 5475f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes if (owner_ != self) { 5486d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers ThrowIllegalMonitorStateExceptionF("object not locked by thread before notify()"); 5495f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes return; 5505f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 5515f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes // Signal the first waiting thread in the wait set. 5522cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier while (wait_set_ != nullptr) { 5535f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes Thread* thread = wait_set_; 554dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers wait_set_ = thread->GetWaitNext(); 555dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers thread->SetWaitNext(nullptr); 5565f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 5575f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes // Check to see if the thread is still waiting. 558277ccbd200ea43590dfc06a93ae184a765327ad0Andreas Gampe MutexLock wait_mu(self, *thread->GetWaitMutex()); 559dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers if (thread->GetWaitMonitor() != nullptr) { 560dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers thread->GetWaitConditionVariable()->Signal(self); 5615f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes return; 5625f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 5635f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 5645f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes} 5655f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 5665f79133a435ebcb20000370d56046fe01201dd80Elliott Hughesvoid Monitor::NotifyAll(Thread* self) { 5672cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier DCHECK(self != nullptr); 568d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers MutexLock mu(self, monitor_lock_); 5695f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes // Make sure that we hold the lock. 5705f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes if (owner_ != self) { 5716d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers ThrowIllegalMonitorStateExceptionF("object not locked by thread before notifyAll()"); 5725f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes return; 5735f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 5745f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes // Signal all threads in the wait set. 5752cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier while (wait_set_ != nullptr) { 5765f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes Thread* thread = wait_set_; 577dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers wait_set_ = thread->GetWaitNext(); 578dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers thread->SetWaitNext(nullptr); 5795f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes thread->Notify(); 5805f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 5815f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes} 5825f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 583590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartierbool Monitor::Deflate(Thread* self, mirror::Object* obj) { 584590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier DCHECK(obj != nullptr); 5854d7f61d44a732cfbc8573e5d93364983fd746888Mathieu Chartier // Don't need volatile since we only deflate with mutators suspended. 5864d7f61d44a732cfbc8573e5d93364983fd746888Mathieu Chartier LockWord lw(obj->GetLockWord(false)); 587590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier // If the lock isn't an inflated monitor, then we don't need to deflate anything. 588590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier if (lw.GetState() == LockWord::kFatLocked) { 589590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier Monitor* monitor = lw.FatLockMonitor(); 590440e4ceb310349ee8eb569495bc04d3d7fbe71cbMathieu Chartier DCHECK(monitor != nullptr); 591590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier MutexLock mu(self, monitor->monitor_lock_); 592440e4ceb310349ee8eb569495bc04d3d7fbe71cbMathieu Chartier // Can't deflate if we have anybody waiting on the CV. 593440e4ceb310349ee8eb569495bc04d3d7fbe71cbMathieu Chartier if (monitor->num_waiters_ > 0) { 594440e4ceb310349ee8eb569495bc04d3d7fbe71cbMathieu Chartier return false; 595440e4ceb310349ee8eb569495bc04d3d7fbe71cbMathieu Chartier } 596590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier Thread* owner = monitor->owner_; 597590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier if (owner != nullptr) { 598590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier // Can't deflate if we are locked and have a hash code. 599590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier if (monitor->HasHashCode()) { 600590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier return false; 601590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier } 602590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier // Can't deflate if our lock count is too high. 603590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier if (monitor->lock_count_ > LockWord::kThinLockMaxCount) { 604590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier return false; 605590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier } 606590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier // Deflate to a thin lock. 607e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi LockWord new_lw = LockWord::FromThinLockId(owner->GetThreadId(), monitor->lock_count_, 608e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi lw.ReadBarrierState()); 609e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi // Assume no concurrent read barrier state changes as mutators are suspended. 610e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi obj->SetLockWord(new_lw, false); 6114d7f61d44a732cfbc8573e5d93364983fd746888Mathieu Chartier VLOG(monitor) << "Deflated " << obj << " to thin lock " << owner->GetTid() << " / " 6124d7f61d44a732cfbc8573e5d93364983fd746888Mathieu Chartier << monitor->lock_count_; 613590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier } else if (monitor->HasHashCode()) { 614e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi LockWord new_lw = LockWord::FromHashCode(monitor->GetHashCode(), lw.ReadBarrierState()); 615e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi // Assume no concurrent read barrier state changes as mutators are suspended. 616e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi obj->SetLockWord(new_lw, false); 617440e4ceb310349ee8eb569495bc04d3d7fbe71cbMathieu Chartier VLOG(monitor) << "Deflated " << obj << " to hash monitor " << monitor->GetHashCode(); 618590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier } else { 619590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier // No lock and no hash, just put an empty lock word inside the object. 620e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi LockWord new_lw = LockWord::FromDefault(lw.ReadBarrierState()); 621e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi // Assume no concurrent read barrier state changes as mutators are suspended. 622e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi obj->SetLockWord(new_lw, false); 623440e4ceb310349ee8eb569495bc04d3d7fbe71cbMathieu Chartier VLOG(monitor) << "Deflated" << obj << " to empty lock word"; 624590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier } 6252cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier // The monitor is deflated, mark the object as null so that we know to delete it during the 626590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier // next GC. 62794f7b49578b6aaa80de8ffed230648d601393905Hiroshi Yamauchi monitor->obj_ = GcRoot<mirror::Object>(nullptr); 628590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier } 629590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier return true; 630590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier} 631590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier 632ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartiervoid Monitor::Inflate(Thread* self, Thread* owner, mirror::Object* obj, int32_t hash_code) { 63374240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe DCHECK(self != nullptr); 63474240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe DCHECK(obj != nullptr); 6355f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes // Allocate and acquire a new monitor. 63674240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe Monitor* m = MonitorPool::CreateMonitor(self, owner, obj, hash_code); 63774240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe DCHECK(m != nullptr); 638d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers if (m->Install(self)) { 63986ab7912423f63541073af5c487b509e9b2b5420Haifeng Li if (owner != nullptr) { 64086ab7912423f63541073af5c487b509e9b2b5420Haifeng Li VLOG(monitor) << "monitor: thread" << owner->GetThreadId() 64174240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe << " created monitor " << m << " for object " << obj; 64286ab7912423f63541073af5c487b509e9b2b5420Haifeng Li } else { 64386ab7912423f63541073af5c487b509e9b2b5420Haifeng Li VLOG(monitor) << "monitor: Inflate with hashcode " << hash_code 64474240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe << " created monitor " << m << " for object " << obj; 64586ab7912423f63541073af5c487b509e9b2b5420Haifeng Li } 64674240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe Runtime::Current()->GetMonitorList()->Add(m); 6474d7f61d44a732cfbc8573e5d93364983fd746888Mathieu Chartier CHECK_EQ(obj->GetLockWord(true).GetState(), LockWord::kFatLocked); 64874240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe } else { 64974240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe MonitorPool::ReleaseMonitor(self, m); 650ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier } 651ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier} 652ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier 6530cd81352a7c06e381951cea1b104fd73516f4341Mathieu Chartiervoid Monitor::InflateThinLocked(Thread* self, Handle<mirror::Object> obj, LockWord lock_word, 654ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier uint32_t hash_code) { 655ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier DCHECK_EQ(lock_word.GetState(), LockWord::kThinLocked); 656ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier uint32_t owner_thread_id = lock_word.ThinLockOwner(); 657ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier if (owner_thread_id == self->GetThreadId()) { 658ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier // We own the monitor, we can easily inflate it. 659eb8167a4f4d27fce0530f6724ab8032610cd146bMathieu Chartier Inflate(self, self, obj.Get(), hash_code); 660ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier } else { 661ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier ThreadList* thread_list = Runtime::Current()->GetThreadList(); 662ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier // Suspend the owner, inflate. First change to blocked and give up mutator_lock_. 663eb8167a4f4d27fce0530f6724ab8032610cd146bMathieu Chartier self->SetMonitorEnterObject(obj.Get()); 664a1ee14fc66a3c99bb7d5744ace881ec93c46f59dMathieu Chartier bool timed_out; 665f1d666e1b48f8070ef1177fce156c08827f08eb8Mathieu Chartier Thread* owner; 666f1d666e1b48f8070ef1177fce156c08827f08eb8Mathieu Chartier { 667f1d666e1b48f8070ef1177fce156c08827f08eb8Mathieu Chartier ScopedThreadSuspension sts(self, kBlocked); 668f1d666e1b48f8070ef1177fce156c08827f08eb8Mathieu Chartier owner = thread_list->SuspendThreadByThreadId(owner_thread_id, false, &timed_out); 669f1d666e1b48f8070ef1177fce156c08827f08eb8Mathieu Chartier } 670a1ee14fc66a3c99bb7d5744ace881ec93c46f59dMathieu Chartier if (owner != nullptr) { 671a1ee14fc66a3c99bb7d5744ace881ec93c46f59dMathieu Chartier // We succeeded in suspending the thread, check the lock's status didn't change. 672a1ee14fc66a3c99bb7d5744ace881ec93c46f59dMathieu Chartier lock_word = obj->GetLockWord(true); 673a1ee14fc66a3c99bb7d5744ace881ec93c46f59dMathieu Chartier if (lock_word.GetState() == LockWord::kThinLocked && 674a1ee14fc66a3c99bb7d5744ace881ec93c46f59dMathieu Chartier lock_word.ThinLockOwner() == owner_thread_id) { 675a1ee14fc66a3c99bb7d5744ace881ec93c46f59dMathieu Chartier // Go ahead and inflate the lock. 676a1ee14fc66a3c99bb7d5744ace881ec93c46f59dMathieu Chartier Inflate(self, owner, obj.Get(), hash_code); 677ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier } 678a1ee14fc66a3c99bb7d5744ace881ec93c46f59dMathieu Chartier thread_list->Resume(owner, false); 679ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier } 680dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers self->SetMonitorEnterObject(nullptr); 681d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } 6825f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes} 6835f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 684719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers// Fool annotalysis into thinking that the lock on obj is acquired. 685719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogersstatic mirror::Object* FakeLock(mirror::Object* obj) 686719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers EXCLUSIVE_LOCK_FUNCTION(obj) NO_THREAD_SAFETY_ANALYSIS { 687719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers return obj; 688719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers} 689719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 690719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers// Fool annotalysis into thinking that the lock on obj is release. 691719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogersstatic mirror::Object* FakeUnlock(mirror::Object* obj) 692719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers UNLOCK_FUNCTION(obj) NO_THREAD_SAFETY_ANALYSIS { 693719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers return obj; 694719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers} 695719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 696e7e8a5fea2d852cccc840fa046151a16627f26cdMathieu Chartiermirror::Object* Monitor::MonitorEnter(Thread* self, mirror::Object* obj) { 6972cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier DCHECK(self != nullptr); 6982cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier DCHECK(obj != nullptr); 6992d096c94fbd3fd2470b8ac1a0da6f577b3f69f42Mathieu Chartier self->AssertThreadSuspensionIsAllowable(); 700719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers obj = FakeLock(obj); 701d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers uint32_t thread_id = self->GetThreadId(); 702d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers size_t contention_count = 0; 703eb8167a4f4d27fce0530f6724ab8032610cd146bMathieu Chartier StackHandleScope<1> hs(self); 704eb8167a4f4d27fce0530f6724ab8032610cd146bMathieu Chartier Handle<mirror::Object> h_obj(hs.NewHandle(obj)); 705d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers while (true) { 706eb8167a4f4d27fce0530f6724ab8032610cd146bMathieu Chartier LockWord lock_word = h_obj->GetLockWord(true); 707d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers switch (lock_word.GetState()) { 708d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers case LockWord::kUnlocked: { 709e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi LockWord thin_locked(LockWord::FromThinLockId(thread_id, 0, lock_word.ReadBarrierState())); 710228602f562f1d130d06e60a98752d99c2d467d6aIan Rogers if (h_obj->CasLockWordWeakSequentiallyConsistent(lock_word, thin_locked)) { 7113035961cb41865b80b927546be0c708b6389cec6Hans Boehm // CasLockWord enforces more than the acquire ordering we need here. 712eb8167a4f4d27fce0530f6724ab8032610cd146bMathieu Chartier return h_obj.Get(); // Success! 713d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } 714d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers continue; // Go again. 7155f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 716d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers case LockWord::kThinLocked: { 717d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers uint32_t owner_thread_id = lock_word.ThinLockOwner(); 718d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers if (owner_thread_id == thread_id) { 719d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers // We own the lock, increase the recursion count. 720d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers uint32_t new_count = lock_word.ThinLockCount() + 1; 721d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers if (LIKELY(new_count <= LockWord::kThinLockMaxCount)) { 722e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi LockWord thin_locked(LockWord::FromThinLockId(thread_id, new_count, 723e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi lock_word.ReadBarrierState())); 724e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi if (!kUseReadBarrier) { 725e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi h_obj->SetLockWord(thin_locked, true); 726e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi return h_obj.Get(); // Success! 727e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi } else { 728e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi // Use CAS to preserve the read barrier state. 729e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi if (h_obj->CasLockWordWeakSequentiallyConsistent(lock_word, thin_locked)) { 730e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi return h_obj.Get(); // Success! 731e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi } 732e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi } 733e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi continue; // Go again. 734d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } else { 735d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers // We'd overflow the recursion count, so inflate the monitor. 736eb8167a4f4d27fce0530f6724ab8032610cd146bMathieu Chartier InflateThinLocked(self, h_obj, lock_word, 0); 737d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } 738d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } else { 739d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers // Contention. 740d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers contention_count++; 741ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier Runtime* runtime = Runtime::Current(); 742ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier if (contention_count <= runtime->GetMaxSpinsBeforeThinkLockInflation()) { 743b363f666883860d40823d5528df3c98c897f74f4Mathieu Chartier // TODO: Consider switching the thread state to kBlocked when we are yielding. 744251755cd511463260e60be98bf138b6aa1c14bf3Mathieu Chartier // Use sched_yield instead of NanoSleep since NanoSleep can wait much longer than the 745251755cd511463260e60be98bf138b6aa1c14bf3Mathieu Chartier // parameter you pass in. This can cause thread suspension to take excessively long 746b363f666883860d40823d5528df3c98c897f74f4Mathieu Chartier // and make long pauses. See b/16307460. 747251755cd511463260e60be98bf138b6aa1c14bf3Mathieu Chartier sched_yield(); 7485f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } else { 749d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers contention_count = 0; 750eb8167a4f4d27fce0530f6724ab8032610cd146bMathieu Chartier InflateThinLocked(self, h_obj, lock_word, 0); 7515f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 7525f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 753d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers continue; // Start from the beginning. 754d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } 755d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers case LockWord::kFatLocked: { 756d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers Monitor* mon = lock_word.FatLockMonitor(); 757d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers mon->Lock(self); 758eb8167a4f4d27fce0530f6724ab8032610cd146bMathieu Chartier return h_obj.Get(); // Success! 7595f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 760719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers case LockWord::kHashCode: 761ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier // Inflate with the existing hashcode. 762eb8167a4f4d27fce0530f6724ab8032610cd146bMathieu Chartier Inflate(self, nullptr, h_obj.Get(), lock_word.GetHashCode()); 763719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers continue; // Start from the beginning. 764590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier default: { 765590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier LOG(FATAL) << "Invalid monitor state " << lock_word.GetState(); 766eb8167a4f4d27fce0530f6724ab8032610cd146bMathieu Chartier return h_obj.Get(); 767590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier } 7685f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 7695f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 7705f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes} 7715f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 7722dd0e2cea360bc9206eb88ecc40d259e796c239dIan Rogersbool Monitor::MonitorExit(Thread* self, mirror::Object* obj) { 7732cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier DCHECK(self != nullptr); 7742cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier DCHECK(obj != nullptr); 7752d096c94fbd3fd2470b8ac1a0da6f577b3f69f42Mathieu Chartier self->AssertThreadSuspensionIsAllowable(); 776719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers obj = FakeUnlock(obj); 777eb8167a4f4d27fce0530f6724ab8032610cd146bMathieu Chartier StackHandleScope<1> hs(self); 778eb8167a4f4d27fce0530f6724ab8032610cd146bMathieu Chartier Handle<mirror::Object> h_obj(hs.NewHandle(obj)); 779e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi while (true) { 780e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi LockWord lock_word = obj->GetLockWord(true); 781e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi switch (lock_word.GetState()) { 782e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi case LockWord::kHashCode: 783e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi // Fall-through. 784e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi case LockWord::kUnlocked: 785e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi FailedUnlock(h_obj.Get(), self, nullptr, nullptr); 786d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers return false; // Failure. 787e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi case LockWord::kThinLocked: { 788e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi uint32_t thread_id = self->GetThreadId(); 789e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi uint32_t owner_thread_id = lock_word.ThinLockOwner(); 790e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi if (owner_thread_id != thread_id) { 791e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi // TODO: there's a race here with the owner dying while we unlock. 792e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi Thread* owner = 793e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi Runtime::Current()->GetThreadList()->FindThreadByThreadId(lock_word.ThinLockOwner()); 794e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi FailedUnlock(h_obj.Get(), self, owner, nullptr); 795e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi return false; // Failure. 796d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } else { 797e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi // We own the lock, decrease the recursion count. 798e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi LockWord new_lw = LockWord::Default(); 799e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi if (lock_word.ThinLockCount() != 0) { 800e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi uint32_t new_count = lock_word.ThinLockCount() - 1; 801e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi new_lw = LockWord::FromThinLockId(thread_id, new_count, lock_word.ReadBarrierState()); 802e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi } else { 803e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi new_lw = LockWord::FromDefault(lock_word.ReadBarrierState()); 804e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi } 805e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi if (!kUseReadBarrier) { 806e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi DCHECK_EQ(new_lw.ReadBarrierState(), 0U); 807e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi h_obj->SetLockWord(new_lw, true); 808e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi // Success! 809e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi return true; 810e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi } else { 811e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi // Use CAS to preserve the read barrier state. 812e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi if (h_obj->CasLockWordWeakSequentiallyConsistent(lock_word, new_lw)) { 813e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi // Success! 814e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi return true; 815e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi } 816e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi } 817e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi continue; // Go again. 818d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } 8195f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 820e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi case LockWord::kFatLocked: { 821e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi Monitor* mon = lock_word.FatLockMonitor(); 822e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi return mon->Unlock(self); 823e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi } 824e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi default: { 825e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi LOG(FATAL) << "Invalid monitor state " << lock_word.GetState(); 826e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi return false; 827e15ea086439b41a805d164d2beb07b4ba96aaa97Hiroshi Yamauchi } 828590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier } 8295f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 8305f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes} 8315f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 8322dd0e2cea360bc9206eb88ecc40d259e796c239dIan Rogersvoid Monitor::Wait(Thread* self, mirror::Object *obj, int64_t ms, int32_t ns, 8334cd121ef0cb35fced70c7d9de378277be7a727d9Elliott Hughes bool interruptShouldThrow, ThreadState why) { 8344d7f61d44a732cfbc8573e5d93364983fd746888Mathieu Chartier DCHECK(self != nullptr); 8354d7f61d44a732cfbc8573e5d93364983fd746888Mathieu Chartier DCHECK(obj != nullptr); 8364d7f61d44a732cfbc8573e5d93364983fd746888Mathieu Chartier LockWord lock_word = obj->GetLockWord(true); 83743c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers while (lock_word.GetState() != LockWord::kFatLocked) { 83843c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers switch (lock_word.GetState()) { 83943c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers case LockWord::kHashCode: 84043c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers // Fall-through. 84143c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers case LockWord::kUnlocked: 842d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers ThrowIllegalMonitorStateExceptionF("object not locked by thread before wait()"); 843d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers return; // Failure. 84443c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers case LockWord::kThinLocked: { 84543c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers uint32_t thread_id = self->GetThreadId(); 84643c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers uint32_t owner_thread_id = lock_word.ThinLockOwner(); 84743c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers if (owner_thread_id != thread_id) { 84843c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers ThrowIllegalMonitorStateExceptionF("object not locked by thread before wait()"); 84943c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers return; // Failure. 85043c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers } else { 85143c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers // We own the lock, inflate to enqueue ourself on the Monitor. May fail spuriously so 85243c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers // re-load. 85343c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers Inflate(self, self, obj, 0); 85443c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers lock_word = obj->GetLockWord(true); 85543c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers } 85643c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers break; 85743c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers } 85843c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers case LockWord::kFatLocked: // Unreachable given the loop condition above. Fall-through. 85943c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers default: { 86043c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers LOG(FATAL) << "Invalid monitor state " << lock_word.GetState(); 86143c69cc4cea794cd4d89d9d0680b1e25c6d02accIan Rogers return; 862d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } 863590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier } 8645f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 865d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers Monitor* mon = lock_word.FatLockMonitor(); 866d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers mon->Wait(self, ms, ns, interruptShouldThrow, why); 8675f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes} 8685f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 86913c479e7e9b62115fe0409e5273c1e976a1c09f9Ian Rogersvoid Monitor::DoNotify(Thread* self, mirror::Object* obj, bool notify_all) { 8704d7f61d44a732cfbc8573e5d93364983fd746888Mathieu Chartier DCHECK(self != nullptr); 8714d7f61d44a732cfbc8573e5d93364983fd746888Mathieu Chartier DCHECK(obj != nullptr); 8724d7f61d44a732cfbc8573e5d93364983fd746888Mathieu Chartier LockWord lock_word = obj->GetLockWord(true); 873d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers switch (lock_word.GetState()) { 874ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier case LockWord::kHashCode: 875ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier // Fall-through. 876d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers case LockWord::kUnlocked: 8776d0b13e931fb73d5e964d14b0a7ecd1f3f5db547Ian Rogers ThrowIllegalMonitorStateExceptionF("object not locked by thread before notify()"); 878d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers return; // Failure. 879d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers case LockWord::kThinLocked: { 880d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers uint32_t thread_id = self->GetThreadId(); 881d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers uint32_t owner_thread_id = lock_word.ThinLockOwner(); 882d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers if (owner_thread_id != thread_id) { 883d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers ThrowIllegalMonitorStateExceptionF("object not locked by thread before notify()"); 884d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers return; // Failure. 885d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } else { 886d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers // We own the lock but there's no Monitor and therefore no waiters. 887d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers return; // Success. 888d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } 889d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } 890d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers case LockWord::kFatLocked: { 891d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers Monitor* mon = lock_word.FatLockMonitor(); 892d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers if (notify_all) { 893d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers mon->NotifyAll(self); 894d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } else { 895d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers mon->Notify(self); 896d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } 897d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers return; // Success. 8985f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 899590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier default: { 900590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier LOG(FATAL) << "Invalid monitor state " << lock_word.GetState(); 901590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier return; 902590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier } 9035f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 9045f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes} 9055f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 906d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogersuint32_t Monitor::GetLockOwnerThreadId(mirror::Object* obj) { 9074d7f61d44a732cfbc8573e5d93364983fd746888Mathieu Chartier DCHECK(obj != nullptr); 9084d7f61d44a732cfbc8573e5d93364983fd746888Mathieu Chartier LockWord lock_word = obj->GetLockWord(true); 909d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers switch (lock_word.GetState()) { 910ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier case LockWord::kHashCode: 911ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier // Fall-through. 912d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers case LockWord::kUnlocked: 913d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers return ThreadList::kInvalidThreadId; 914d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers case LockWord::kThinLocked: 915d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers return lock_word.ThinLockOwner(); 916d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers case LockWord::kFatLocked: { 917d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers Monitor* mon = lock_word.FatLockMonitor(); 918d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers return mon->GetOwnerThreadId(); 9195f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 920590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier default: { 921d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers LOG(FATAL) << "Unreachable"; 9222c4257be8191c5eefde744e8965fcefc80a0a97dIan Rogers UNREACHABLE(); 923590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier } 9245f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes } 9255f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes} 9265f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 9278e4aac52962d54cb4be2078b9cd95685e067133aElliott Hughesvoid Monitor::DescribeWait(std::ostream& os, const Thread* thread) { 928d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers // Determine the wait message and object we're waiting or blocked upon. 929d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers mirror::Object* pretty_object = nullptr; 930d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers const char* wait_message = nullptr; 931d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers uint32_t lock_owner = ThreadList::kInvalidThreadId; 932d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers ThreadState state = thread->GetState(); 933b4e94fd380a84c755264e8668a16052442c7ec32Elliott Hughes if (state == kWaiting || state == kTimedWaiting || state == kSleeping) { 934d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers wait_message = (state == kSleeping) ? " - sleeping on " : " - waiting on "; 935d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers Thread* self = Thread::Current(); 936d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers MutexLock mu(self, *thread->GetWaitMutex()); 937d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers Monitor* monitor = thread->GetWaitMonitor(); 938d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers if (monitor != nullptr) { 9394cba0d979a11f955e6ec3c0f1bf61478af7aa810Hiroshi Yamauchi pretty_object = monitor->GetObject(); 9408e4aac52962d54cb4be2078b9cd95685e067133aElliott Hughes } 94134e069606d6f1698cd3c33b39e72b79ae27e1c7bElliott Hughes } else if (state == kBlocked) { 942d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers wait_message = " - waiting to lock "; 943d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers pretty_object = thread->GetMonitorEnterObject(); 944d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers if (pretty_object != nullptr) { 945d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers lock_owner = pretty_object->GetLockOwnerThreadId(); 9468e4aac52962d54cb4be2078b9cd95685e067133aElliott Hughes } 9478e4aac52962d54cb4be2078b9cd95685e067133aElliott Hughes } 9488e4aac52962d54cb4be2078b9cd95685e067133aElliott Hughes 949d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers if (wait_message != nullptr) { 950d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers if (pretty_object == nullptr) { 951d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers os << wait_message << "an unknown object"; 952d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers } else { 9534d7f61d44a732cfbc8573e5d93364983fd746888Mathieu Chartier if ((pretty_object->GetLockWord(true).GetState() == LockWord::kThinLocked) && 954d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers Locks::mutator_lock_->IsExclusiveHeld(Thread::Current())) { 955d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers // Getting the identity hashcode here would result in lock inflation and suspension of the 956d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers // current thread, which isn't safe if this is the only runnable thread. 957d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers os << wait_message << StringPrintf("<@addr=0x%" PRIxPTR "> (a %s)", 958d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers reinterpret_cast<intptr_t>(pretty_object), 959d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers PrettyTypeOf(pretty_object).c_str()); 960d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers } else { 961d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers // - waiting on <0x6008c468> (a java.lang.Class<java.lang.ref.ReferenceQueue>) 9624936159997132d7706d9700c646f35ef0283df4bMathieu Chartier // Call PrettyTypeOf before IdentityHashCode since IdentityHashCode can cause thread 9634936159997132d7706d9700c646f35ef0283df4bMathieu Chartier // suspension and move pretty_object. 9644936159997132d7706d9700c646f35ef0283df4bMathieu Chartier const std::string pretty_type(PrettyTypeOf(pretty_object)); 965d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers os << wait_message << StringPrintf("<0x%08x> (a %s)", pretty_object->IdentityHashCode(), 9664936159997132d7706d9700c646f35ef0283df4bMathieu Chartier pretty_type.c_str()); 967d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers } 968d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers } 969d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers // - waiting to lock <0x613f83d8> (a java.lang.Object) held by thread 5 970d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers if (lock_owner != ThreadList::kInvalidThreadId) { 971d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers os << " held by thread " << lock_owner; 972d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers } 973d803bc7ce255be6c16eaf6a8a58a742515e9da9fIan Rogers os << "\n"; 9748e4aac52962d54cb4be2078b9cd95685e067133aElliott Hughes } 9758e4aac52962d54cb4be2078b9cd95685e067133aElliott Hughes} 9768e4aac52962d54cb4be2078b9cd95685e067133aElliott Hughes 9772dd0e2cea360bc9206eb88ecc40d259e796c239dIan Rogersmirror::Object* Monitor::GetContendedMonitor(Thread* thread) { 978f9501700f51586cb6ba7cc0ffcb5a920bd64adf1Elliott Hughes // This is used to implement JDWP's ThreadReference.CurrentContendedMonitor, and has a bizarre 979f9501700f51586cb6ba7cc0ffcb5a920bd64adf1Elliott Hughes // definition of contended that includes a monitor a thread is trying to enter... 980dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers mirror::Object* result = thread->GetMonitorEnterObject(); 9812cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier if (result == nullptr) { 982d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers // ...but also a monitor that the thread is waiting on. 983dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers MutexLock mu(Thread::Current(), *thread->GetWaitMutex()); 984dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers Monitor* monitor = thread->GetWaitMonitor(); 9852cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier if (monitor != nullptr) { 986d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers result = monitor->GetObject(); 987f9501700f51586cb6ba7cc0ffcb5a920bd64adf1Elliott Hughes } 988f9501700f51586cb6ba7cc0ffcb5a920bd64adf1Elliott Hughes } 989d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers return result; 990f9501700f51586cb6ba7cc0ffcb5a920bd64adf1Elliott Hughes} 991f9501700f51586cb6ba7cc0ffcb5a920bd64adf1Elliott Hughes 9922dd0e2cea360bc9206eb88ecc40d259e796c239dIan Rogersvoid Monitor::VisitLocks(StackVisitor* stack_visitor, void (*callback)(mirror::Object*, void*), 993760172c3ccd6e75f6f1a89d8006934e8ffb1303eAndreas Gampe void* callback_context, bool abort_on_failure) { 994e401d146407d61eeb99f8d6176b2ac13c4df1e33Mathieu Chartier ArtMethod* m = stack_visitor->GetMethod(); 9952cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier CHECK(m != nullptr); 99608fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes 99708fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes // Native methods are an easy special case. 99808fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes // TODO: use the JNI implementation's table of explicit MonitorEnter calls and dump those too. 99908fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes if (m->IsNative()) { 100008fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes if (m->IsSynchronized()) { 1001e401d146407d61eeb99f8d6176b2ac13c4df1e33Mathieu Chartier mirror::Object* jni_this = 1002e401d146407d61eeb99f8d6176b2ac13c4df1e33Mathieu Chartier stack_visitor->GetCurrentHandleScope(sizeof(void*))->GetReference(0); 10034993bbc8eda377804e585efd918f8ab9d9eab7d4Elliott Hughes callback(jni_this, callback_context); 100408fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes } 100508fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes return; 100608fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes } 100708fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes 100861f916cc4757610ce308bfdea9a00cf29afd2b02jeffhao // Proxy methods should not be synchronized. 100961f916cc4757610ce308bfdea9a00cf29afd2b02jeffhao if (m->IsProxyMethod()) { 101061f916cc4757610ce308bfdea9a00cf29afd2b02jeffhao CHECK(!m->IsSynchronized()); 101161f916cc4757610ce308bfdea9a00cf29afd2b02jeffhao return; 101261f916cc4757610ce308bfdea9a00cf29afd2b02jeffhao } 101361f916cc4757610ce308bfdea9a00cf29afd2b02jeffhao 101408fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes // Is there any reason to believe there's any synchronization in this method? 1015bfd9a4378eacaf2dc2bbe05ad48c5164fc93c9feMathieu Chartier const DexFile::CodeItem* code_item = m->GetCodeItem(); 10162cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier CHECK(code_item != nullptr) << PrettyMethod(m); 101708fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes if (code_item->tries_size_ == 0) { 10187934ac288acfb2552bb0b06ec1f61e5820d924a4Brian Carlstrom return; // No "tries" implies no synchronization, so no held locks to report. 101908fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes } 102008fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes 1021760172c3ccd6e75f6f1a89d8006934e8ffb1303eAndreas Gampe // Get the dex pc. If abort_on_failure is false, GetDexPc will not abort in the case it cannot 1022760172c3ccd6e75f6f1a89d8006934e8ffb1303eAndreas Gampe // find the dex pc, and instead return kDexNoIndex. Then bail out, as it indicates we have an 1023760172c3ccd6e75f6f1a89d8006934e8ffb1303eAndreas Gampe // inconsistent stack anyways. 1024760172c3ccd6e75f6f1a89d8006934e8ffb1303eAndreas Gampe uint32_t dex_pc = stack_visitor->GetDexPc(abort_on_failure); 1025760172c3ccd6e75f6f1a89d8006934e8ffb1303eAndreas Gampe if (!abort_on_failure && dex_pc == DexFile::kDexNoIndex) { 1026760172c3ccd6e75f6f1a89d8006934e8ffb1303eAndreas Gampe LOG(ERROR) << "Could not find dex_pc for " << PrettyMethod(m); 1027760172c3ccd6e75f6f1a89d8006934e8ffb1303eAndreas Gampe return; 1028760172c3ccd6e75f6f1a89d8006934e8ffb1303eAndreas Gampe } 1029760172c3ccd6e75f6f1a89d8006934e8ffb1303eAndreas Gampe 103080537bb742dff4ccdf6d04b1c0bb7d2179acc8cbElliott Hughes // Ask the verifier for the dex pcs of all the monitor-enter instructions corresponding to 103180537bb742dff4ccdf6d04b1c0bb7d2179acc8cbElliott Hughes // the locks held in this stack frame. 103280537bb742dff4ccdf6d04b1c0bb7d2179acc8cbElliott Hughes std::vector<uint32_t> monitor_enter_dex_pcs; 1033760172c3ccd6e75f6f1a89d8006934e8ffb1303eAndreas Gampe verifier::MethodVerifier::FindLocksAtDexPc(m, dex_pc, &monitor_enter_dex_pcs); 1034e6a8eec3a5db28de7d5db6d78e38033b80740e49Mathieu Chartier for (uint32_t monitor_dex_pc : monitor_enter_dex_pcs) { 103580537bb742dff4ccdf6d04b1c0bb7d2179acc8cbElliott Hughes // The verifier works in terms of the dex pcs of the monitor-enter instructions. 103680537bb742dff4ccdf6d04b1c0bb7d2179acc8cbElliott Hughes // We want the registers used by those instructions (so we can read the values out of them). 1037277ccbd200ea43590dfc06a93ae184a765327ad0Andreas Gampe uint16_t monitor_enter_instruction = code_item->insns_[monitor_dex_pc]; 103808fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes 103980537bb742dff4ccdf6d04b1c0bb7d2179acc8cbElliott Hughes // Quick sanity check. 104080537bb742dff4ccdf6d04b1c0bb7d2179acc8cbElliott Hughes if ((monitor_enter_instruction & 0xff) != Instruction::MONITOR_ENTER) { 1041277ccbd200ea43590dfc06a93ae184a765327ad0Andreas Gampe LOG(FATAL) << "expected monitor-enter @" << monitor_dex_pc << "; was " 104280537bb742dff4ccdf6d04b1c0bb7d2179acc8cbElliott Hughes << reinterpret_cast<void*>(monitor_enter_instruction); 104308fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes } 104480537bb742dff4ccdf6d04b1c0bb7d2179acc8cbElliott Hughes 104580537bb742dff4ccdf6d04b1c0bb7d2179acc8cbElliott Hughes uint16_t monitor_register = ((monitor_enter_instruction >> 8) & 0xff); 104615b9d5274399736ac09705f0507df24fac4f00c1Nicolas Geoffray uint32_t value; 104715b9d5274399736ac09705f0507df24fac4f00c1Nicolas Geoffray bool success = stack_visitor->GetVReg(m, monitor_register, kReferenceVReg, &value); 104815b9d5274399736ac09705f0507df24fac4f00c1Nicolas Geoffray CHECK(success) << "Failed to read v" << monitor_register << " of kind " 104915b9d5274399736ac09705f0507df24fac4f00c1Nicolas Geoffray << kReferenceVReg << " in method " << PrettyMethod(m); 105015b9d5274399736ac09705f0507df24fac4f00c1Nicolas Geoffray mirror::Object* o = reinterpret_cast<mirror::Object*>(value); 10514993bbc8eda377804e585efd918f8ab9d9eab7d4Elliott Hughes callback(o, callback_context); 105208fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes } 105308fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes} 105408fc03ae5dded4adc9b45b7014a4b9dfedbe95a6Elliott Hughes 1055d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogersbool Monitor::IsValidLockWord(LockWord lock_word) { 1056d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers switch (lock_word.GetState()) { 1057d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers case LockWord::kUnlocked: 1058d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers // Nothing to check. 1059d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers return true; 1060d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers case LockWord::kThinLocked: 1061d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers // Basic sanity check of owner. 1062d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers return lock_word.ThinLockOwner() != ThreadList::kInvalidThreadId; 1063d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers case LockWord::kFatLocked: { 1064d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers // Check the monitor appears in the monitor list. 1065d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers Monitor* mon = lock_word.FatLockMonitor(); 1066d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers MonitorList* list = Runtime::Current()->GetMonitorList(); 1067d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers MutexLock mu(Thread::Current(), list->monitor_list_lock_); 1068d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers for (Monitor* list_mon : list->list_) { 1069d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers if (mon == list_mon) { 1070d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers return true; // Found our monitor. 1071d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } 10727dfb28c066159e6cde8181720f0c451a700ef966Ian Rogers } 1073d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers return false; // Fail - unowned monitor in an object. 10747dfb28c066159e6cde8181720f0c451a700ef966Ian Rogers } 1075ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier case LockWord::kHashCode: 1076ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier return true; 1077d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers default: 1078d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers LOG(FATAL) << "Unreachable"; 10792c4257be8191c5eefde744e8965fcefc80a0a97dIan Rogers UNREACHABLE(); 10807dfb28c066159e6cde8181720f0c451a700ef966Ian Rogers } 10817dfb28c066159e6cde8181720f0c451a700ef966Ian Rogers} 10827dfb28c066159e6cde8181720f0c451a700ef966Ian Rogers 108390443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartierbool Monitor::IsLocked() SHARED_REQUIRES(Locks::mutator_lock_) { 1084ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier MutexLock mu(Thread::Current(), monitor_lock_); 1085ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier return owner_ != nullptr; 1086ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier} 1087ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier 1088e401d146407d61eeb99f8d6176b2ac13c4df1e33Mathieu Chartiervoid Monitor::TranslateLocation(ArtMethod* method, uint32_t dex_pc, 1089d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers const char** source_file, uint32_t* line_number) const { 109033dc7717cd16592bcc825350bea6305be9eb2ea1jeffhao // If method is null, location is unknown 10912cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier if (method == nullptr) { 1092d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers *source_file = ""; 1093d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers *line_number = 0; 109433dc7717cd16592bcc825350bea6305be9eb2ea1jeffhao return; 109533dc7717cd16592bcc825350bea6305be9eb2ea1jeffhao } 1096bfd9a4378eacaf2dc2bbe05ad48c5164fc93c9feMathieu Chartier *source_file = method->GetDeclaringClassSourceFile(); 10972cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier if (*source_file == nullptr) { 1098d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers *source_file = ""; 1099d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } 1100bfd9a4378eacaf2dc2bbe05ad48c5164fc93c9feMathieu Chartier *line_number = method->GetLineNumFromDexPC(dex_pc); 1101d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers} 1102d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers 1103d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogersuint32_t Monitor::GetOwnerThreadId() { 1104d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers MutexLock mu(Thread::Current(), monitor_lock_); 1105d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers Thread* owner = owner_; 11062cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier if (owner != nullptr) { 1107d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers return owner->GetThreadId(); 1108d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } else { 1109d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers return ThreadList::kInvalidThreadId; 111012c51e3e5a8b5655351539618f1cf2331f52d1abElliott Hughes } 111133dc7717cd16592bcc825350bea6305be9eb2ea1jeffhao} 111233dc7717cd16592bcc825350bea6305be9eb2ea1jeffhao 1113c11d9b8870de5f860b13c84003ade7b3f3125a52Mathieu ChartierMonitorList::MonitorList() 1114440e4ceb310349ee8eb569495bc04d3d7fbe71cbMathieu Chartier : allow_new_monitors_(true), monitor_list_lock_("MonitorList lock", kMonitorListLock), 1115c11d9b8870de5f860b13c84003ade7b3f3125a52Mathieu Chartier monitor_add_condition_("MonitorList disallow condition", monitor_list_lock_) { 1116c33a32bccc4c66ed82ce3a580b16636399385cb4Elliott Hughes} 1117c33a32bccc4c66ed82ce3a580b16636399385cb4Elliott Hughes 1118c33a32bccc4c66ed82ce3a580b16636399385cb4Elliott HughesMonitorList::~MonitorList() { 111974240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe Thread* self = Thread::Current(); 112074240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe MutexLock mu(self, monitor_list_lock_); 112174240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe // Release all monitors to the pool. 112274240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe // TODO: Is it an invariant that *all* open monitors are in the list? Then we could 112374240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe // clear faster in the pool. 112474240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe MonitorPool::ReleaseMonitors(self, &list_); 1125c33a32bccc4c66ed82ce3a580b16636399385cb4Elliott Hughes} 1126c33a32bccc4c66ed82ce3a580b16636399385cb4Elliott Hughes 1127c11d9b8870de5f860b13c84003ade7b3f3125a52Mathieu Chartiervoid MonitorList::DisallowNewMonitors() { 1128fdbd13c7af91a042eda753e436eeebf0e1937250Hiroshi Yamauchi CHECK(!kUseReadBarrier); 112950b35e2fd1a68cd1240e4a9d9f363e11764957d1Ian Rogers MutexLock mu(Thread::Current(), monitor_list_lock_); 1130c11d9b8870de5f860b13c84003ade7b3f3125a52Mathieu Chartier allow_new_monitors_ = false; 1131c11d9b8870de5f860b13c84003ade7b3f3125a52Mathieu Chartier} 1132c11d9b8870de5f860b13c84003ade7b3f3125a52Mathieu Chartier 1133c11d9b8870de5f860b13c84003ade7b3f3125a52Mathieu Chartiervoid MonitorList::AllowNewMonitors() { 1134fdbd13c7af91a042eda753e436eeebf0e1937250Hiroshi Yamauchi CHECK(!kUseReadBarrier); 1135c11d9b8870de5f860b13c84003ade7b3f3125a52Mathieu Chartier Thread* self = Thread::Current(); 1136c11d9b8870de5f860b13c84003ade7b3f3125a52Mathieu Chartier MutexLock mu(self, monitor_list_lock_); 1137c11d9b8870de5f860b13c84003ade7b3f3125a52Mathieu Chartier allow_new_monitors_ = true; 1138c11d9b8870de5f860b13c84003ade7b3f3125a52Mathieu Chartier monitor_add_condition_.Broadcast(self); 1139c11d9b8870de5f860b13c84003ade7b3f3125a52Mathieu Chartier} 1140c11d9b8870de5f860b13c84003ade7b3f3125a52Mathieu Chartier 11410b71357fb52be9bb06d35396a3042b4381b01041Hiroshi Yamauchivoid MonitorList::BroadcastForNewMonitors() { 11420b71357fb52be9bb06d35396a3042b4381b01041Hiroshi Yamauchi CHECK(kUseReadBarrier); 11430b71357fb52be9bb06d35396a3042b4381b01041Hiroshi Yamauchi Thread* self = Thread::Current(); 11440b71357fb52be9bb06d35396a3042b4381b01041Hiroshi Yamauchi MutexLock mu(self, monitor_list_lock_); 11450b71357fb52be9bb06d35396a3042b4381b01041Hiroshi Yamauchi monitor_add_condition_.Broadcast(self); 11460b71357fb52be9bb06d35396a3042b4381b01041Hiroshi Yamauchi} 11470b71357fb52be9bb06d35396a3042b4381b01041Hiroshi Yamauchi 1148c11d9b8870de5f860b13c84003ade7b3f3125a52Mathieu Chartiervoid MonitorList::Add(Monitor* m) { 1149c11d9b8870de5f860b13c84003ade7b3f3125a52Mathieu Chartier Thread* self = Thread::Current(); 1150c11d9b8870de5f860b13c84003ade7b3f3125a52Mathieu Chartier MutexLock mu(self, monitor_list_lock_); 11510b71357fb52be9bb06d35396a3042b4381b01041Hiroshi Yamauchi while (UNLIKELY((!kUseReadBarrier && !allow_new_monitors_) || 11520b71357fb52be9bb06d35396a3042b4381b01041Hiroshi Yamauchi (kUseReadBarrier && !self->GetWeakRefAccessEnabled()))) { 1153c11d9b8870de5f860b13c84003ade7b3f3125a52Mathieu Chartier monitor_add_condition_.WaitHoldingLocks(self); 1154c11d9b8870de5f860b13c84003ade7b3f3125a52Mathieu Chartier } 1155c33a32bccc4c66ed82ce3a580b16636399385cb4Elliott Hughes list_.push_front(m); 1156c33a32bccc4c66ed82ce3a580b16636399385cb4Elliott Hughes} 1157c33a32bccc4c66ed82ce3a580b16636399385cb4Elliott Hughes 115897509954404d031594b2ecbda607314d169d512eMathieu Chartiervoid MonitorList::SweepMonitorList(IsMarkedVisitor* visitor) { 115974240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe Thread* self = Thread::Current(); 116074240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe MutexLock mu(self, monitor_list_lock_); 116102e25119b15a6f619f17db99f5d05124a5807ff3Mathieu Chartier for (auto it = list_.begin(); it != list_.end(); ) { 1162c33a32bccc4c66ed82ce3a580b16636399385cb4Elliott Hughes Monitor* m = *it; 11634cba0d979a11f955e6ec3c0f1bf61478af7aa810Hiroshi Yamauchi // Disable the read barrier in GetObject() as this is called by GC. 11644cba0d979a11f955e6ec3c0f1bf61478af7aa810Hiroshi Yamauchi mirror::Object* obj = m->GetObject<kWithoutReadBarrier>(); 1165590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier // The object of a monitor can be null if we have deflated it. 116697509954404d031594b2ecbda607314d169d512eMathieu Chartier mirror::Object* new_obj = obj != nullptr ? visitor->IsMarked(obj) : nullptr; 11676aa3df965395566ed6a4fec4af37c2b7577992e9Mathieu Chartier if (new_obj == nullptr) { 11686aa3df965395566ed6a4fec4af37c2b7577992e9Mathieu Chartier VLOG(monitor) << "freeing monitor " << m << " belonging to unmarked object " 11694cba0d979a11f955e6ec3c0f1bf61478af7aa810Hiroshi Yamauchi << obj; 117074240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe MonitorPool::ReleaseMonitor(self, m); 1171c33a32bccc4c66ed82ce3a580b16636399385cb4Elliott Hughes it = list_.erase(it); 1172c33a32bccc4c66ed82ce3a580b16636399385cb4Elliott Hughes } else { 11736aa3df965395566ed6a4fec4af37c2b7577992e9Mathieu Chartier m->SetObject(new_obj); 1174c33a32bccc4c66ed82ce3a580b16636399385cb4Elliott Hughes ++it; 1175c33a32bccc4c66ed82ce3a580b16636399385cb4Elliott Hughes } 1176c33a32bccc4c66ed82ce3a580b16636399385cb4Elliott Hughes } 1177c33a32bccc4c66ed82ce3a580b16636399385cb4Elliott Hughes} 1178c33a32bccc4c66ed82ce3a580b16636399385cb4Elliott Hughes 117997509954404d031594b2ecbda607314d169d512eMathieu Chartierclass MonitorDeflateVisitor : public IsMarkedVisitor { 118097509954404d031594b2ecbda607314d169d512eMathieu Chartier public: 118197509954404d031594b2ecbda607314d169d512eMathieu Chartier MonitorDeflateVisitor() : self_(Thread::Current()), deflate_count_(0) {} 118297509954404d031594b2ecbda607314d169d512eMathieu Chartier 118397509954404d031594b2ecbda607314d169d512eMathieu Chartier virtual mirror::Object* IsMarked(mirror::Object* object) OVERRIDE 118490443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier SHARED_REQUIRES(Locks::mutator_lock_) { 118597509954404d031594b2ecbda607314d169d512eMathieu Chartier if (Monitor::Deflate(self_, object)) { 118697509954404d031594b2ecbda607314d169d512eMathieu Chartier DCHECK_NE(object->GetLockWord(true).GetState(), LockWord::kFatLocked); 118797509954404d031594b2ecbda607314d169d512eMathieu Chartier ++deflate_count_; 118897509954404d031594b2ecbda607314d169d512eMathieu Chartier // If we deflated, return null so that the monitor gets removed from the array. 118997509954404d031594b2ecbda607314d169d512eMathieu Chartier return nullptr; 119097509954404d031594b2ecbda607314d169d512eMathieu Chartier } 119197509954404d031594b2ecbda607314d169d512eMathieu Chartier return object; // Monitor was not deflated. 1192440e4ceb310349ee8eb569495bc04d3d7fbe71cbMathieu Chartier } 119397509954404d031594b2ecbda607314d169d512eMathieu Chartier 119497509954404d031594b2ecbda607314d169d512eMathieu Chartier Thread* const self_; 119597509954404d031594b2ecbda607314d169d512eMathieu Chartier size_t deflate_count_; 119697509954404d031594b2ecbda607314d169d512eMathieu Chartier}; 1197440e4ceb310349ee8eb569495bc04d3d7fbe71cbMathieu Chartier 119848ab687d1f864fec93c2682de6fdc44ab784e2f8Mathieu Chartiersize_t MonitorList::DeflateMonitors() { 119997509954404d031594b2ecbda607314d169d512eMathieu Chartier MonitorDeflateVisitor visitor; 120097509954404d031594b2ecbda607314d169d512eMathieu Chartier Locks::mutator_lock_->AssertExclusiveHeld(visitor.self_); 120197509954404d031594b2ecbda607314d169d512eMathieu Chartier SweepMonitorList(&visitor); 120297509954404d031594b2ecbda607314d169d512eMathieu Chartier return visitor.deflate_count_; 1203440e4ceb310349ee8eb569495bc04d3d7fbe71cbMathieu Chartier} 1204440e4ceb310349ee8eb569495bc04d3d7fbe71cbMathieu Chartier 12052cebb24bfc3247d3e9be138a3350106737455918Mathieu ChartierMonitorInfo::MonitorInfo(mirror::Object* obj) : owner_(nullptr), entry_count_(0) { 12064d7f61d44a732cfbc8573e5d93364983fd746888Mathieu Chartier DCHECK(obj != nullptr); 12074d7f61d44a732cfbc8573e5d93364983fd746888Mathieu Chartier LockWord lock_word = obj->GetLockWord(true); 1208d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers switch (lock_word.GetState()) { 1209d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers case LockWord::kUnlocked: 1210ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier // Fall-through. 1211590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier case LockWord::kForwardingAddress: 1212590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier // Fall-through. 1213ad2541a59c00c2c69e8973088891a2b5257c9780Mathieu Chartier case LockWord::kHashCode: 1214d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers break; 1215d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers case LockWord::kThinLocked: 1216d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers owner_ = Runtime::Current()->GetThreadList()->FindThreadByThreadId(lock_word.ThinLockOwner()); 1217d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers entry_count_ = 1 + lock_word.ThinLockCount(); 1218d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers // Thin locks have no waiters. 1219d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers break; 1220d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers case LockWord::kFatLocked: { 1221d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers Monitor* mon = lock_word.FatLockMonitor(); 1222d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers owner_ = mon->owner_; 1223d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers entry_count_ = 1 + mon->lock_count_; 12242cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier for (Thread* waiter = mon->wait_set_; waiter != nullptr; waiter = waiter->GetWaitNext()) { 1225d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers waiters_.push_back(waiter); 1226d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers } 1227d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogers break; 1228f327e07b37e349b1ec5eaad6dc294a9b7a081d20Elliott Hughes } 1229f327e07b37e349b1ec5eaad6dc294a9b7a081d20Elliott Hughes } 1230f327e07b37e349b1ec5eaad6dc294a9b7a081d20Elliott Hughes} 1231f327e07b37e349b1ec5eaad6dc294a9b7a081d20Elliott Hughes 12325f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes} // namespace art 1233