blob: da6ee259b5ab19ef24a0bbfb7aa10ec48fb33ffe [file] [log] [blame]
Elliott Hughes5f791332011-09-15 17:45:30 -07001/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Elliott Hughes54e7df12011-09-16 11:47:04 -070017#include "monitor.h"
Elliott Hughes5f791332011-09-15 17:45:30 -070018
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -080019#define ATRACE_TAG ATRACE_TAG_DALVIK
20
21#include <cutils/trace.h>
Elliott Hughes08fc03a2012-06-26 17:34:00 -070022#include <vector>
23
Mathieu Chartiere401d142015-04-22 13:56:20 -070024#include "art_method-inl.h"
Elliott Hughes76b61672012-12-12 17:47:30 -080025#include "base/mutex.h"
Elliott Hughes1aa246d2012-12-13 09:29:36 -080026#include "base/stl_util.h"
Vladimir Marko80afd022015-05-19 18:08:00 +010027#include "base/time_utils.h"
jeffhao33dc7712011-11-09 17:54:24 -080028#include "class_linker.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070029#include "dex_file-inl.h"
Elliott Hughes08fc03a2012-06-26 17:34:00 -070030#include "dex_instruction.h"
Ian Rogersd9c4fc92013-10-01 19:45:43 -070031#include "lock_word-inl.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070032#include "mirror/class-inl.h"
Ian Rogers05f30572013-02-20 12:13:11 -080033#include "mirror/object-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080034#include "mirror/object_array-inl.h"
Ian Rogers00f7d0e2012-07-19 15:28:27 -070035#include "scoped_thread_state_change.h"
Elliott Hughes5f791332011-09-15 17:45:30 -070036#include "thread.h"
Elliott Hughes8e4aac52011-09-26 17:03:36 -070037#include "thread_list.h"
Elliott Hughes08fc03a2012-06-26 17:34:00 -070038#include "verifier/method_verifier.h"
Elliott Hughes044288f2012-06-25 14:46:39 -070039#include "well_known_classes.h"
Elliott Hughes5f791332011-09-15 17:45:30 -070040
41namespace art {
42
Mathieu Chartierb9001ab2014-10-03 13:28:46 -070043static constexpr uint64_t kLongWaitMs = 100;
44
Elliott Hughes5f791332011-09-15 17:45:30 -070045/*
Ian Rogersd9c4fc92013-10-01 19:45:43 -070046 * Every Object has a monitor associated with it, but not every Object is actually locked. Even
47 * the ones that are locked do not need a full-fledged monitor until a) there is actual contention
48 * or b) wait() is called on the Object.
Elliott Hughes5f791332011-09-15 17:45:30 -070049 *
Ian Rogersd9c4fc92013-10-01 19:45:43 -070050 * For Android, we have implemented a scheme similar to the one described in Bacon et al.'s
51 * "Thin locks: featherweight synchronization for Java" (ACM 1998). Things are even easier for us,
52 * though, because we have a full 32 bits to work with.
Elliott Hughes5f791332011-09-15 17:45:30 -070053 *
Ian Rogersd9c4fc92013-10-01 19:45:43 -070054 * The two states of an Object's lock are referred to as "thin" and "fat". A lock may transition
55 * from the "thin" state to the "fat" state and this transition is referred to as inflation. Once
56 * a lock has been inflated it remains in the "fat" state indefinitely.
Elliott Hughes5f791332011-09-15 17:45:30 -070057 *
Ian Rogersd9c4fc92013-10-01 19:45:43 -070058 * The lock value itself is stored in mirror::Object::monitor_ and the representation is described
59 * in the LockWord value type.
Elliott Hughes54e7df12011-09-16 11:47:04 -070060 *
Elliott Hughes5f791332011-09-15 17:45:30 -070061 * Monitors provide:
62 * - mutually exclusive access to resources
63 * - a way for multiple threads to wait for notification
64 *
65 * In effect, they fill the role of both mutexes and condition variables.
66 *
Ian Rogersd9c4fc92013-10-01 19:45:43 -070067 * Only one thread can own the monitor at any time. There may be several threads waiting on it
68 * (the wait call unlocks it). One or more waiting threads may be getting interrupted or notified
69 * at any given time.
Elliott Hughes5f791332011-09-15 17:45:30 -070070 */
Elliott Hughes54e7df12011-09-16 11:47:04 -070071
Mathieu Chartier2cebb242015-04-21 16:50:40 -070072bool (*Monitor::is_sensitive_thread_hook_)() = nullptr;
Elliott Hughesfc861622011-10-17 17:57:47 -070073uint32_t Monitor::lock_profiling_threshold_ = 0;
Elliott Hughes32d6e1e2011-10-11 14:47:44 -070074
Elliott Hughesfc861622011-10-17 17:57:47 -070075bool Monitor::IsSensitiveThread() {
Mathieu Chartier2cebb242015-04-21 16:50:40 -070076 if (is_sensitive_thread_hook_ != nullptr) {
Elliott Hughesfc861622011-10-17 17:57:47 -070077 return (*is_sensitive_thread_hook_)();
78 }
79 return false;
80}
81
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -080082void Monitor::Init(uint32_t lock_profiling_threshold, bool (*is_sensitive_thread_hook)()) {
Elliott Hughesfc861622011-10-17 17:57:47 -070083 lock_profiling_threshold_ = lock_profiling_threshold;
84 is_sensitive_thread_hook_ = is_sensitive_thread_hook;
Elliott Hughes32d6e1e2011-10-11 14:47:44 -070085}
86
Ian Rogersef7d42f2014-01-06 12:55:46 -080087Monitor::Monitor(Thread* self, Thread* owner, mirror::Object* obj, int32_t hash_code)
Ian Rogers00f7d0e2012-07-19 15:28:27 -070088 : monitor_lock_("a monitor lock", kMonitorLock),
Ian Rogersd9c4fc92013-10-01 19:45:43 -070089 monitor_contenders_("monitor contenders", monitor_lock_),
Mathieu Chartier46bc7782013-11-12 17:03:02 -080090 num_waiters_(0),
Ian Rogers00f7d0e2012-07-19 15:28:27 -070091 owner_(owner),
Elliott Hughes5f791332011-09-15 17:45:30 -070092 lock_count_(0),
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -070093 obj_(GcRoot<mirror::Object>(obj)),
Mathieu Chartier2cebb242015-04-21 16:50:40 -070094 wait_set_(nullptr),
Mathieu Chartierad2541a2013-10-25 10:05:23 -070095 hash_code_(hash_code),
Mathieu Chartier2cebb242015-04-21 16:50:40 -070096 locking_method_(nullptr),
Ian Rogersef7d42f2014-01-06 12:55:46 -080097 locking_dex_pc_(0),
Andreas Gampe74240812014-04-17 10:35:09 -070098 monitor_id_(MonitorPool::ComputeMonitorId(this, self)) {
99#ifdef __LP64__
100 DCHECK(false) << "Should not be reached in 64b";
101 next_free_ = nullptr;
102#endif
103 // We should only inflate a lock if the owner is ourselves or suspended. This avoids a race
104 // with the owner unlocking the thin-lock.
105 CHECK(owner == nullptr || owner == self || owner->IsSuspended());
106 // The identity hash code is set for the life time of the monitor.
107}
108
109Monitor::Monitor(Thread* self, Thread* owner, mirror::Object* obj, int32_t hash_code,
110 MonitorId id)
111 : monitor_lock_("a monitor lock", kMonitorLock),
112 monitor_contenders_("monitor contenders", monitor_lock_),
113 num_waiters_(0),
114 owner_(owner),
115 lock_count_(0),
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700116 obj_(GcRoot<mirror::Object>(obj)),
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700117 wait_set_(nullptr),
Andreas Gampe74240812014-04-17 10:35:09 -0700118 hash_code_(hash_code),
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700119 locking_method_(nullptr),
Andreas Gampe74240812014-04-17 10:35:09 -0700120 locking_dex_pc_(0),
121 monitor_id_(id) {
122#ifdef __LP64__
123 next_free_ = nullptr;
124#endif
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700125 // We should only inflate a lock if the owner is ourselves or suspended. This avoids a race
126 // with the owner unlocking the thin-lock.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800127 CHECK(owner == nullptr || owner == self || owner->IsSuspended());
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700128 // The identity hash code is set for the life time of the monitor.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700129}
130
Mathieu Chartier4e6a31e2013-10-31 10:35:05 -0700131int32_t Monitor::GetHashCode() {
132 while (!HasHashCode()) {
Ian Rogers3e5cf302014-05-20 16:40:37 -0700133 if (hash_code_.CompareExchangeWeakRelaxed(0, mirror::Object::GenerateIdentityHashCode())) {
Mathieu Chartier4e6a31e2013-10-31 10:35:05 -0700134 break;
135 }
136 }
137 DCHECK(HasHashCode());
Ian Rogers3e5cf302014-05-20 16:40:37 -0700138 return hash_code_.LoadRelaxed();
Mathieu Chartier4e6a31e2013-10-31 10:35:05 -0700139}
140
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700141bool Monitor::Install(Thread* self) {
142 MutexLock mu(self, monitor_lock_); // Uncontended mutex acquisition as monitor isn't yet public.
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700143 CHECK(owner_ == nullptr || owner_ == self || owner_->IsSuspended());
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700144 // Propagate the lock state.
Hiroshi Yamauchi4cba0d92014-05-21 21:10:23 -0700145 LockWord lw(GetObject()->GetLockWord(false));
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700146 switch (lw.GetState()) {
147 case LockWord::kThinLocked: {
148 CHECK_EQ(owner_->GetThreadId(), lw.ThinLockOwner());
149 lock_count_ = lw.ThinLockCount();
150 break;
151 }
152 case LockWord::kHashCode: {
Ian Rogers3e5cf302014-05-20 16:40:37 -0700153 CHECK_EQ(hash_code_.LoadRelaxed(), static_cast<int32_t>(lw.GetHashCode()));
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700154 break;
155 }
156 case LockWord::kFatLocked: {
157 // The owner_ is suspended but another thread beat us to install a monitor.
158 return false;
159 }
160 case LockWord::kUnlocked: {
161 LOG(FATAL) << "Inflating unlocked lock word";
162 break;
163 }
Mathieu Chartier590fee92013-09-13 13:46:47 -0700164 default: {
165 LOG(FATAL) << "Invalid monitor state " << lw.GetState();
166 return false;
167 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700168 }
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -0800169 LockWord fat(this, lw.ReadBarrierState());
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700170 // Publish the updated lock word, which may race with other threads.
Ian Rogers228602f2014-07-10 02:07:54 -0700171 bool success = GetObject()->CasLockWordWeakSequentiallyConsistent(lw, fat);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700172 // Lock profiling.
Mathieu Chartier9728f912013-10-30 09:45:13 -0700173 if (success && owner_ != nullptr && lock_profiling_threshold_ != 0) {
Andreas Gampe6ec8ebd2014-07-25 13:36:56 -0700174 // Do not abort on dex pc errors. This can easily happen when we want to dump a stack trace on
175 // abort.
176 locking_method_ = owner_->GetCurrentMethod(&locking_dex_pc_, false);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700177 }
178 return success;
Elliott Hughes5f791332011-09-15 17:45:30 -0700179}
180
181Monitor::~Monitor() {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700182 // Deflated monitors have a null object.
Elliott Hughes5f791332011-09-15 17:45:30 -0700183}
184
Elliott Hughes5f791332011-09-15 17:45:30 -0700185void Monitor::AppendToWaitSet(Thread* thread) {
186 DCHECK(owner_ == Thread::Current());
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700187 DCHECK(thread != nullptr);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700188 DCHECK(thread->GetWaitNext() == nullptr) << thread->GetWaitNext();
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700189 if (wait_set_ == nullptr) {
Elliott Hughes5f791332011-09-15 17:45:30 -0700190 wait_set_ = thread;
191 return;
192 }
193
194 // push_back.
195 Thread* t = wait_set_;
Ian Rogersdd7624d2014-03-14 17:43:00 -0700196 while (t->GetWaitNext() != nullptr) {
197 t = t->GetWaitNext();
Elliott Hughes5f791332011-09-15 17:45:30 -0700198 }
Ian Rogersdd7624d2014-03-14 17:43:00 -0700199 t->SetWaitNext(thread);
Elliott Hughes5f791332011-09-15 17:45:30 -0700200}
201
Elliott Hughes5f791332011-09-15 17:45:30 -0700202void Monitor::RemoveFromWaitSet(Thread *thread) {
203 DCHECK(owner_ == Thread::Current());
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700204 DCHECK(thread != nullptr);
205 if (wait_set_ == nullptr) {
Elliott Hughes5f791332011-09-15 17:45:30 -0700206 return;
207 }
208 if (wait_set_ == thread) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700209 wait_set_ = thread->GetWaitNext();
210 thread->SetWaitNext(nullptr);
Elliott Hughes5f791332011-09-15 17:45:30 -0700211 return;
212 }
213
214 Thread* t = wait_set_;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700215 while (t->GetWaitNext() != nullptr) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700216 if (t->GetWaitNext() == thread) {
217 t->SetWaitNext(thread->GetWaitNext());
218 thread->SetWaitNext(nullptr);
Elliott Hughes5f791332011-09-15 17:45:30 -0700219 return;
220 }
Ian Rogersdd7624d2014-03-14 17:43:00 -0700221 t = t->GetWaitNext();
Elliott Hughes5f791332011-09-15 17:45:30 -0700222 }
223}
224
Mathieu Chartier6aa3df92013-09-17 15:17:28 -0700225void Monitor::SetObject(mirror::Object* object) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700226 obj_ = GcRoot<mirror::Object>(object);
Mathieu Chartier6aa3df92013-09-17 15:17:28 -0700227}
228
Elliott Hughes5f791332011-09-15 17:45:30 -0700229void Monitor::Lock(Thread* self) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700230 MutexLock mu(self, monitor_lock_);
231 while (true) {
Mathieu Chartier440e4ce2014-03-31 16:36:35 -0700232 if (owner_ == nullptr) { // Unowned.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700233 owner_ = self;
234 CHECK_EQ(lock_count_, 0);
235 // When debugging, save the current monitor holder for future
236 // acquisition failures to use in sampled logging.
237 if (lock_profiling_threshold_ != 0) {
238 locking_method_ = self->GetCurrentMethod(&locking_dex_pc_);
239 }
240 return;
241 } else if (owner_ == self) { // Recursive.
242 lock_count_++;
243 return;
244 }
245 // Contended.
246 const bool log_contention = (lock_profiling_threshold_ != 0);
Xin Guanb894a192014-08-22 11:55:37 -0500247 uint64_t wait_start_ms = log_contention ? MilliTime() : 0;
Mathieu Chartiere401d142015-04-22 13:56:20 -0700248 ArtMethod* owners_method = locking_method_;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700249 uint32_t owners_dex_pc = locking_dex_pc_;
Mathieu Chartier440e4ce2014-03-31 16:36:35 -0700250 // Do this before releasing the lock so that we don't get deflated.
Mathieu Chartierb9001ab2014-10-03 13:28:46 -0700251 size_t num_waiters = num_waiters_;
Mathieu Chartier440e4ce2014-03-31 16:36:35 -0700252 ++num_waiters_;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700253 monitor_lock_.Unlock(self); // Let go of locks in order.
Mathieu Chartiera6e7f082014-05-22 14:43:37 -0700254 self->SetMonitorEnterObject(GetObject());
Elliott Hughes5f791332011-09-15 17:45:30 -0700255 {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700256 ScopedThreadStateChange tsc(self, kBlocked); // Change to blocked and give up mutator_lock_.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700257 // Reacquire monitor_lock_ without mutator_lock_ for Wait.
258 MutexLock mu2(self, monitor_lock_);
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -0800259 if (owner_ != nullptr) { // Did the owner_ give the lock up?
260 if (ATRACE_ENABLED()) {
261 std::string name;
262 owner_->GetThreadName(name);
263 ATRACE_BEGIN(("Contended on monitor with owner " + name).c_str());
264 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700265 monitor_contenders_.Wait(self); // Still contended so wait.
266 // Woken from contention.
267 if (log_contention) {
268 uint64_t wait_ms = MilliTime() - wait_start_ms;
269 uint32_t sample_percent;
270 if (wait_ms >= lock_profiling_threshold_) {
271 sample_percent = 100;
272 } else {
273 sample_percent = 100 * wait_ms / lock_profiling_threshold_;
274 }
275 if (sample_percent != 0 && (static_cast<uint32_t>(rand() % 100) < sample_percent)) {
276 const char* owners_filename;
277 uint32_t owners_line_number;
278 TranslateLocation(owners_method, owners_dex_pc, &owners_filename, &owners_line_number);
Mathieu Chartierb9001ab2014-10-03 13:28:46 -0700279 if (wait_ms > kLongWaitMs && owners_method != nullptr) {
280 LOG(WARNING) << "Long monitor contention event with owner method="
281 << PrettyMethod(owners_method) << " from " << owners_filename << ":"
282 << owners_line_number << " waiters=" << num_waiters << " for "
283 << PrettyDuration(MsToNs(wait_ms));
284 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700285 LogContentionEvent(self, wait_ms, sample_percent, owners_filename, owners_line_number);
286 }
287 }
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -0800288 ATRACE_END();
Elliott Hughesfc861622011-10-17 17:57:47 -0700289 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700290 }
Mathieu Chartiera6e7f082014-05-22 14:43:37 -0700291 self->SetMonitorEnterObject(nullptr);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700292 monitor_lock_.Lock(self); // Reacquire locks in order.
Mathieu Chartier440e4ce2014-03-31 16:36:35 -0700293 --num_waiters_;
Elliott Hughesfc861622011-10-17 17:57:47 -0700294 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700295}
296
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800297static void ThrowIllegalMonitorStateExceptionF(const char* fmt, ...)
298 __attribute__((format(printf, 1, 2)));
299
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700300static void ThrowIllegalMonitorStateExceptionF(const char* fmt, ...)
Mathieu Chartier90443472015-07-16 20:32:27 -0700301 SHARED_REQUIRES(Locks::mutator_lock_) {
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800302 va_list args;
303 va_start(args, fmt);
Ian Rogers62d6c772013-02-27 08:32:07 -0800304 Thread* self = Thread::Current();
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000305 self->ThrowNewExceptionV("Ljava/lang/IllegalMonitorStateException;", fmt, args);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700306 if (!Runtime::Current()->IsStarted() || VLOG_IS_ON(monitor)) {
Brian Carlstrom64277f32012-03-26 23:53:34 -0700307 std::ostringstream ss;
Ian Rogers62d6c772013-02-27 08:32:07 -0800308 self->Dump(ss);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700309 LOG(Runtime::Current()->IsStarted() ? INFO : ERROR)
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000310 << self->GetException()->Dump() << "\n" << ss.str();
Brian Carlstrom64277f32012-03-26 23:53:34 -0700311 }
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800312 va_end(args);
313}
314
Elliott Hughesd4237412012-02-21 11:24:45 -0800315static std::string ThreadToString(Thread* thread) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700316 if (thread == nullptr) {
317 return "nullptr";
Elliott Hughesd4237412012-02-21 11:24:45 -0800318 }
319 std::ostringstream oss;
320 // TODO: alternatively, we could just return the thread's name.
321 oss << *thread;
322 return oss.str();
323}
324
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800325void Monitor::FailedUnlock(mirror::Object* o, Thread* expected_owner, Thread* found_owner,
Elliott Hughesffb465f2012-03-01 18:46:05 -0800326 Monitor* monitor) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700327 Thread* current_owner = nullptr;
Elliott Hughesffb465f2012-03-01 18:46:05 -0800328 std::string current_owner_string;
329 std::string expected_owner_string;
330 std::string found_owner_string;
331 {
332 // TODO: isn't this too late to prevent threads from disappearing?
333 // Acquire thread list lock so threads won't disappear from under us.
Ian Rogers50b35e22012-10-04 10:09:15 -0700334 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
Elliott Hughesffb465f2012-03-01 18:46:05 -0800335 // Re-read owner now that we hold lock.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700336 current_owner = (monitor != nullptr) ? monitor->GetOwner() : nullptr;
Elliott Hughesffb465f2012-03-01 18:46:05 -0800337 // Get short descriptions of the threads involved.
338 current_owner_string = ThreadToString(current_owner);
339 expected_owner_string = ThreadToString(expected_owner);
340 found_owner_string = ThreadToString(found_owner);
341 }
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700342 if (current_owner == nullptr) {
343 if (found_owner == nullptr) {
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800344 ThrowIllegalMonitorStateExceptionF("unlock of unowned monitor on object of type '%s'"
345 " on thread '%s'",
Elliott Hughesffb465f2012-03-01 18:46:05 -0800346 PrettyTypeOf(o).c_str(),
347 expected_owner_string.c_str());
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800348 } else {
349 // Race: the original read found an owner but now there is none
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800350 ThrowIllegalMonitorStateExceptionF("unlock of monitor owned by '%s' on object of type '%s'"
351 " (where now the monitor appears unowned) on thread '%s'",
Elliott Hughesffb465f2012-03-01 18:46:05 -0800352 found_owner_string.c_str(),
353 PrettyTypeOf(o).c_str(),
354 expected_owner_string.c_str());
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800355 }
356 } else {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700357 if (found_owner == nullptr) {
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800358 // Race: originally there was no owner, there is now
359 ThrowIllegalMonitorStateExceptionF("unlock of monitor owned by '%s' on object of type '%s'"
360 " (originally believed to be unowned) on thread '%s'",
Elliott Hughesffb465f2012-03-01 18:46:05 -0800361 current_owner_string.c_str(),
362 PrettyTypeOf(o).c_str(),
363 expected_owner_string.c_str());
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800364 } else {
365 if (found_owner != current_owner) {
366 // Race: originally found and current owner have changed
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800367 ThrowIllegalMonitorStateExceptionF("unlock of monitor originally owned by '%s' (now"
368 " owned by '%s') on object of type '%s' on thread '%s'",
Elliott Hughesffb465f2012-03-01 18:46:05 -0800369 found_owner_string.c_str(),
370 current_owner_string.c_str(),
371 PrettyTypeOf(o).c_str(),
372 expected_owner_string.c_str());
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800373 } else {
374 ThrowIllegalMonitorStateExceptionF("unlock of monitor owned by '%s' on object of type '%s'"
375 " on thread '%s",
Elliott Hughesffb465f2012-03-01 18:46:05 -0800376 current_owner_string.c_str(),
377 PrettyTypeOf(o).c_str(),
378 expected_owner_string.c_str());
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800379 }
380 }
381 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700382}
383
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700384bool Monitor::Unlock(Thread* self) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700385 DCHECK(self != nullptr);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700386 MutexLock mu(self, monitor_lock_);
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800387 Thread* owner = owner_;
388 if (owner == self) {
Elliott Hughes5f791332011-09-15 17:45:30 -0700389 // We own the monitor, so nobody else can be in here.
390 if (lock_count_ == 0) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700391 owner_ = nullptr;
392 locking_method_ = nullptr;
Ian Rogers0399dde2012-06-06 17:09:28 -0700393 locking_dex_pc_ = 0;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700394 // Wake a contender.
395 monitor_contenders_.Signal(self);
Elliott Hughes5f791332011-09-15 17:45:30 -0700396 } else {
397 --lock_count_;
398 }
399 } else {
400 // We don't own this, so we're not allowed to unlock it.
401 // The JNI spec says that we should throw IllegalMonitorStateException
402 // in this case.
Hiroshi Yamauchi4cba0d92014-05-21 21:10:23 -0700403 FailedUnlock(GetObject(), self, owner, this);
Elliott Hughes5f791332011-09-15 17:45:30 -0700404 return false;
405 }
406 return true;
407}
408
Elliott Hughes4cd121e2013-01-07 17:35:41 -0800409void Monitor::Wait(Thread* self, int64_t ms, int32_t ns,
410 bool interruptShouldThrow, ThreadState why) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700411 DCHECK(self != nullptr);
Elliott Hughes4cd121e2013-01-07 17:35:41 -0800412 DCHECK(why == kTimedWaiting || why == kWaiting || why == kSleeping);
Elliott Hughes5f791332011-09-15 17:45:30 -0700413
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700414 monitor_lock_.Lock(self);
415
Elliott Hughes5f791332011-09-15 17:45:30 -0700416 // Make sure that we hold the lock.
417 if (owner_ != self) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700418 monitor_lock_.Unlock(self);
Elena Sayapina1af6a1f2014-06-20 16:58:37 +0700419 ThrowIllegalMonitorStateExceptionF("object not locked by thread before wait()");
Elliott Hughes5f791332011-09-15 17:45:30 -0700420 return;
421 }
Elliott Hughes4cd121e2013-01-07 17:35:41 -0800422
Elliott Hughesdf42c482013-01-09 12:49:02 -0800423 // We need to turn a zero-length timed wait into a regular wait because
424 // Object.wait(0, 0) is defined as Object.wait(0), which is defined as Object.wait().
425 if (why == kTimedWaiting && (ms == 0 && ns == 0)) {
426 why = kWaiting;
427 }
428
Elliott Hughes5f791332011-09-15 17:45:30 -0700429 // Enforce the timeout range.
430 if (ms < 0 || ns < 0 || ns > 999999) {
Elena Sayapina1af6a1f2014-06-20 16:58:37 +0700431 monitor_lock_.Unlock(self);
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000432 self->ThrowNewExceptionF("Ljava/lang/IllegalArgumentException;",
Ian Rogersef7d42f2014-01-06 12:55:46 -0800433 "timeout arguments out of range: ms=%" PRId64 " ns=%d", ms, ns);
Elliott Hughes5f791332011-09-15 17:45:30 -0700434 return;
435 }
436
Elliott Hughes5f791332011-09-15 17:45:30 -0700437 /*
438 * Add ourselves to the set of threads waiting on this monitor, and
439 * release our hold. We need to let it go even if we're a few levels
440 * deep in a recursive lock, and we need to restore that later.
441 *
442 * We append to the wait set ahead of clearing the count and owner
443 * fields so the subroutine can check that the calling thread owns
444 * the monitor. Aside from that, the order of member updates is
445 * not order sensitive as we hold the pthread mutex.
446 */
447 AppendToWaitSet(self);
Mathieu Chartier440e4ce2014-03-31 16:36:35 -0700448 ++num_waiters_;
Ian Rogers0399dde2012-06-06 17:09:28 -0700449 int prev_lock_count = lock_count_;
Elliott Hughes5f791332011-09-15 17:45:30 -0700450 lock_count_ = 0;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700451 owner_ = nullptr;
Mathieu Chartiere401d142015-04-22 13:56:20 -0700452 ArtMethod* saved_method = locking_method_;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700453 locking_method_ = nullptr;
Ian Rogers0399dde2012-06-06 17:09:28 -0700454 uintptr_t saved_dex_pc = locking_dex_pc_;
455 locking_dex_pc_ = 0;
Elliott Hughes5f791332011-09-15 17:45:30 -0700456
457 /*
Elliott Hughes4cd121e2013-01-07 17:35:41 -0800458 * Update thread state. If the GC wakes up, it'll ignore us, knowing
Elliott Hughes5f791332011-09-15 17:45:30 -0700459 * that we won't touch any references in this state, and we'll check
460 * our suspend mode before we transition out.
461 */
Elliott Hughes4cd121e2013-01-07 17:35:41 -0800462 self->TransitionFromRunnableToSuspended(why);
Elliott Hughes5f791332011-09-15 17:45:30 -0700463
Elliott Hughesb4e94fd2013-01-08 14:41:26 -0800464 bool was_interrupted = false;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700465 {
466 // Pseudo-atomically wait on self's wait_cond_ and release the monitor lock.
Ian Rogersdd7624d2014-03-14 17:43:00 -0700467 MutexLock mu(self, *self->GetWaitMutex());
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700468
469 // Set wait_monitor_ to the monitor object we will be waiting on. When wait_monitor_ is
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700470 // non-null a notifying or interrupting thread must signal the thread's wait_cond_ to wake it
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700471 // up.
Ian Rogersdd7624d2014-03-14 17:43:00 -0700472 DCHECK(self->GetWaitMonitor() == nullptr);
473 self->SetWaitMonitor(this);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700474
475 // Release the monitor lock.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700476 monitor_contenders_.Signal(self);
477 monitor_lock_.Unlock(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700478
Elliott Hughesb4e94fd2013-01-08 14:41:26 -0800479 // Handle the case where the thread was interrupted before we called wait().
Ian Rogersdd7624d2014-03-14 17:43:00 -0700480 if (self->IsInterruptedLocked()) {
Elliott Hughesb4e94fd2013-01-08 14:41:26 -0800481 was_interrupted = true;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700482 } else {
483 // Wait for a notification or a timeout to occur.
Elliott Hughes4cd121e2013-01-07 17:35:41 -0800484 if (why == kWaiting) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700485 self->GetWaitConditionVariable()->Wait(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700486 } else {
Elliott Hughes4cd121e2013-01-07 17:35:41 -0800487 DCHECK(why == kTimedWaiting || why == kSleeping) << why;
Ian Rogersdd7624d2014-03-14 17:43:00 -0700488 self->GetWaitConditionVariable()->TimedWait(self, ms, ns);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700489 }
Ian Rogersdd7624d2014-03-14 17:43:00 -0700490 if (self->IsInterruptedLocked()) {
Elliott Hughesb4e94fd2013-01-08 14:41:26 -0800491 was_interrupted = true;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700492 }
Ian Rogersdd7624d2014-03-14 17:43:00 -0700493 self->SetInterruptedLocked(false);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700494 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700495 }
496
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700497 // Set self->status back to kRunnable, and self-suspend if needed.
498 self->TransitionFromSuspendedToRunnable();
Elliott Hughes5f791332011-09-15 17:45:30 -0700499
Elliott Hughesb4e94fd2013-01-08 14:41:26 -0800500 {
501 // We reset the thread's wait_monitor_ field after transitioning back to runnable so
502 // that a thread in a waiting/sleeping state has a non-null wait_monitor_ for debugging
503 // and diagnostic purposes. (If you reset this earlier, stack dumps will claim that threads
504 // are waiting on "null".)
Ian Rogersdd7624d2014-03-14 17:43:00 -0700505 MutexLock mu(self, *self->GetWaitMutex());
506 DCHECK(self->GetWaitMonitor() != nullptr);
507 self->SetWaitMonitor(nullptr);
Elliott Hughesb4e94fd2013-01-08 14:41:26 -0800508 }
509
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700510 // Re-acquire the monitor and lock.
Elliott Hughes5f791332011-09-15 17:45:30 -0700511 Lock(self);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700512 monitor_lock_.Lock(self);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700513 self->GetWaitMutex()->AssertNotHeld(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700514
Elliott Hughes5f791332011-09-15 17:45:30 -0700515 /*
516 * We remove our thread from wait set after restoring the count
517 * and owner fields so the subroutine can check that the calling
518 * thread owns the monitor. Aside from that, the order of member
519 * updates is not order sensitive as we hold the pthread mutex.
520 */
521 owner_ = self;
Ian Rogers0399dde2012-06-06 17:09:28 -0700522 lock_count_ = prev_lock_count;
523 locking_method_ = saved_method;
524 locking_dex_pc_ = saved_dex_pc;
Mathieu Chartier440e4ce2014-03-31 16:36:35 -0700525 --num_waiters_;
Elliott Hughes5f791332011-09-15 17:45:30 -0700526 RemoveFromWaitSet(self);
527
Elena Sayapina1af6a1f2014-06-20 16:58:37 +0700528 monitor_lock_.Unlock(self);
529
Elliott Hughesb4e94fd2013-01-08 14:41:26 -0800530 if (was_interrupted) {
Elliott Hughes5f791332011-09-15 17:45:30 -0700531 /*
532 * We were interrupted while waiting, or somebody interrupted an
533 * un-interruptible thread earlier and we're bailing out immediately.
534 *
535 * The doc sayeth: "The interrupted status of the current thread is
536 * cleared when this exception is thrown."
537 */
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700538 {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700539 MutexLock mu(self, *self->GetWaitMutex());
540 self->SetInterruptedLocked(false);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700541 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700542 if (interruptShouldThrow) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700543 self->ThrowNewException("Ljava/lang/InterruptedException;", nullptr);
Elliott Hughes5f791332011-09-15 17:45:30 -0700544 }
545 }
546}
547
548void Monitor::Notify(Thread* self) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700549 DCHECK(self != nullptr);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700550 MutexLock mu(self, monitor_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700551 // Make sure that we hold the lock.
552 if (owner_ != self) {
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800553 ThrowIllegalMonitorStateExceptionF("object not locked by thread before notify()");
Elliott Hughes5f791332011-09-15 17:45:30 -0700554 return;
555 }
556 // Signal the first waiting thread in the wait set.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700557 while (wait_set_ != nullptr) {
Elliott Hughes5f791332011-09-15 17:45:30 -0700558 Thread* thread = wait_set_;
Ian Rogersdd7624d2014-03-14 17:43:00 -0700559 wait_set_ = thread->GetWaitNext();
560 thread->SetWaitNext(nullptr);
Elliott Hughes5f791332011-09-15 17:45:30 -0700561
562 // Check to see if the thread is still waiting.
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800563 MutexLock wait_mu(self, *thread->GetWaitMutex());
Ian Rogersdd7624d2014-03-14 17:43:00 -0700564 if (thread->GetWaitMonitor() != nullptr) {
565 thread->GetWaitConditionVariable()->Signal(self);
Elliott Hughes5f791332011-09-15 17:45:30 -0700566 return;
567 }
568 }
569}
570
571void Monitor::NotifyAll(Thread* self) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700572 DCHECK(self != nullptr);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700573 MutexLock mu(self, monitor_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700574 // Make sure that we hold the lock.
575 if (owner_ != self) {
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800576 ThrowIllegalMonitorStateExceptionF("object not locked by thread before notifyAll()");
Elliott Hughes5f791332011-09-15 17:45:30 -0700577 return;
578 }
579 // Signal all threads in the wait set.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700580 while (wait_set_ != nullptr) {
Elliott Hughes5f791332011-09-15 17:45:30 -0700581 Thread* thread = wait_set_;
Ian Rogersdd7624d2014-03-14 17:43:00 -0700582 wait_set_ = thread->GetWaitNext();
583 thread->SetWaitNext(nullptr);
Elliott Hughes5f791332011-09-15 17:45:30 -0700584 thread->Notify();
585 }
586}
587
Mathieu Chartier590fee92013-09-13 13:46:47 -0700588bool Monitor::Deflate(Thread* self, mirror::Object* obj) {
589 DCHECK(obj != nullptr);
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -0700590 // Don't need volatile since we only deflate with mutators suspended.
591 LockWord lw(obj->GetLockWord(false));
Mathieu Chartier590fee92013-09-13 13:46:47 -0700592 // If the lock isn't an inflated monitor, then we don't need to deflate anything.
593 if (lw.GetState() == LockWord::kFatLocked) {
594 Monitor* monitor = lw.FatLockMonitor();
Mathieu Chartier440e4ce2014-03-31 16:36:35 -0700595 DCHECK(monitor != nullptr);
Mathieu Chartier590fee92013-09-13 13:46:47 -0700596 MutexLock mu(self, monitor->monitor_lock_);
Mathieu Chartier440e4ce2014-03-31 16:36:35 -0700597 // Can't deflate if we have anybody waiting on the CV.
598 if (monitor->num_waiters_ > 0) {
599 return false;
600 }
Mathieu Chartier590fee92013-09-13 13:46:47 -0700601 Thread* owner = monitor->owner_;
602 if (owner != nullptr) {
603 // Can't deflate if we are locked and have a hash code.
604 if (monitor->HasHashCode()) {
605 return false;
606 }
607 // Can't deflate if our lock count is too high.
608 if (monitor->lock_count_ > LockWord::kThinLockMaxCount) {
609 return false;
610 }
Mathieu Chartier590fee92013-09-13 13:46:47 -0700611 // Deflate to a thin lock.
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -0800612 LockWord new_lw = LockWord::FromThinLockId(owner->GetThreadId(), monitor->lock_count_,
613 lw.ReadBarrierState());
614 // Assume no concurrent read barrier state changes as mutators are suspended.
615 obj->SetLockWord(new_lw, false);
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -0700616 VLOG(monitor) << "Deflated " << obj << " to thin lock " << owner->GetTid() << " / "
617 << monitor->lock_count_;
Mathieu Chartier590fee92013-09-13 13:46:47 -0700618 } else if (monitor->HasHashCode()) {
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -0800619 LockWord new_lw = LockWord::FromHashCode(monitor->GetHashCode(), lw.ReadBarrierState());
620 // Assume no concurrent read barrier state changes as mutators are suspended.
621 obj->SetLockWord(new_lw, false);
Mathieu Chartier440e4ce2014-03-31 16:36:35 -0700622 VLOG(monitor) << "Deflated " << obj << " to hash monitor " << monitor->GetHashCode();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700623 } else {
624 // No lock and no hash, just put an empty lock word inside the object.
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -0800625 LockWord new_lw = LockWord::FromDefault(lw.ReadBarrierState());
626 // Assume no concurrent read barrier state changes as mutators are suspended.
627 obj->SetLockWord(new_lw, false);
Mathieu Chartier440e4ce2014-03-31 16:36:35 -0700628 VLOG(monitor) << "Deflated" << obj << " to empty lock word";
Mathieu Chartier590fee92013-09-13 13:46:47 -0700629 }
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700630 // The monitor is deflated, mark the object as null so that we know to delete it during the
Mathieu Chartier590fee92013-09-13 13:46:47 -0700631 // next GC.
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700632 monitor->obj_ = GcRoot<mirror::Object>(nullptr);
Mathieu Chartier590fee92013-09-13 13:46:47 -0700633 }
634 return true;
635}
636
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700637void Monitor::Inflate(Thread* self, Thread* owner, mirror::Object* obj, int32_t hash_code) {
Andreas Gampe74240812014-04-17 10:35:09 -0700638 DCHECK(self != nullptr);
639 DCHECK(obj != nullptr);
Elliott Hughes5f791332011-09-15 17:45:30 -0700640 // Allocate and acquire a new monitor.
Andreas Gampe74240812014-04-17 10:35:09 -0700641 Monitor* m = MonitorPool::CreateMonitor(self, owner, obj, hash_code);
642 DCHECK(m != nullptr);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700643 if (m->Install(self)) {
Haifeng Li86ab7912014-05-16 10:47:59 +0800644 if (owner != nullptr) {
645 VLOG(monitor) << "monitor: thread" << owner->GetThreadId()
Andreas Gampe74240812014-04-17 10:35:09 -0700646 << " created monitor " << m << " for object " << obj;
Haifeng Li86ab7912014-05-16 10:47:59 +0800647 } else {
648 VLOG(monitor) << "monitor: Inflate with hashcode " << hash_code
Andreas Gampe74240812014-04-17 10:35:09 -0700649 << " created monitor " << m << " for object " << obj;
Haifeng Li86ab7912014-05-16 10:47:59 +0800650 }
Andreas Gampe74240812014-04-17 10:35:09 -0700651 Runtime::Current()->GetMonitorList()->Add(m);
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -0700652 CHECK_EQ(obj->GetLockWord(true).GetState(), LockWord::kFatLocked);
Andreas Gampe74240812014-04-17 10:35:09 -0700653 } else {
654 MonitorPool::ReleaseMonitor(self, m);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700655 }
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700656}
657
Mathieu Chartier0cd81352014-05-22 16:48:55 -0700658void Monitor::InflateThinLocked(Thread* self, Handle<mirror::Object> obj, LockWord lock_word,
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700659 uint32_t hash_code) {
660 DCHECK_EQ(lock_word.GetState(), LockWord::kThinLocked);
661 uint32_t owner_thread_id = lock_word.ThinLockOwner();
662 if (owner_thread_id == self->GetThreadId()) {
663 // We own the monitor, we can easily inflate it.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700664 Inflate(self, self, obj.Get(), hash_code);
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700665 } else {
666 ThreadList* thread_list = Runtime::Current()->GetThreadList();
667 // Suspend the owner, inflate. First change to blocked and give up mutator_lock_.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700668 self->SetMonitorEnterObject(obj.Get());
Mathieu Chartiera1ee14f2014-05-14 16:51:03 -0700669 bool timed_out;
Mathieu Chartier90443472015-07-16 20:32:27 -0700670 self->TransitionFromRunnableToSuspended(kBlocked);
671 Thread* owner = thread_list->SuspendThreadByThreadId(owner_thread_id, false, &timed_out);
672 self->TransitionFromSuspendedToRunnable();
Mathieu Chartiera1ee14f2014-05-14 16:51:03 -0700673 if (owner != nullptr) {
674 // We succeeded in suspending the thread, check the lock's status didn't change.
675 lock_word = obj->GetLockWord(true);
676 if (lock_word.GetState() == LockWord::kThinLocked &&
677 lock_word.ThinLockOwner() == owner_thread_id) {
678 // Go ahead and inflate the lock.
679 Inflate(self, owner, obj.Get(), hash_code);
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700680 }
Mathieu Chartiera1ee14f2014-05-14 16:51:03 -0700681 thread_list->Resume(owner, false);
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700682 }
Ian Rogersdd7624d2014-03-14 17:43:00 -0700683 self->SetMonitorEnterObject(nullptr);
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700684 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700685}
686
Ian Rogers719d1a32014-03-06 12:13:39 -0800687// Fool annotalysis into thinking that the lock on obj is acquired.
688static mirror::Object* FakeLock(mirror::Object* obj)
689 EXCLUSIVE_LOCK_FUNCTION(obj) NO_THREAD_SAFETY_ANALYSIS {
690 return obj;
691}
692
693// Fool annotalysis into thinking that the lock on obj is release.
694static mirror::Object* FakeUnlock(mirror::Object* obj)
695 UNLOCK_FUNCTION(obj) NO_THREAD_SAFETY_ANALYSIS {
696 return obj;
697}
698
Mathieu Chartiere7e8a5f2014-02-14 16:59:41 -0800699mirror::Object* Monitor::MonitorEnter(Thread* self, mirror::Object* obj) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700700 DCHECK(self != nullptr);
701 DCHECK(obj != nullptr);
Ian Rogers719d1a32014-03-06 12:13:39 -0800702 obj = FakeLock(obj);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700703 uint32_t thread_id = self->GetThreadId();
704 size_t contention_count = 0;
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700705 StackHandleScope<1> hs(self);
706 Handle<mirror::Object> h_obj(hs.NewHandle(obj));
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700707 while (true) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700708 LockWord lock_word = h_obj->GetLockWord(true);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700709 switch (lock_word.GetState()) {
710 case LockWord::kUnlocked: {
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -0800711 LockWord thin_locked(LockWord::FromThinLockId(thread_id, 0, lock_word.ReadBarrierState()));
Ian Rogers228602f2014-07-10 02:07:54 -0700712 if (h_obj->CasLockWordWeakSequentiallyConsistent(lock_word, thin_locked)) {
Hans Boehm30359612014-05-21 17:46:23 -0700713 // CasLockWord enforces more than the acquire ordering we need here.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700714 return h_obj.Get(); // Success!
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700715 }
716 continue; // Go again.
Elliott Hughes5f791332011-09-15 17:45:30 -0700717 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700718 case LockWord::kThinLocked: {
719 uint32_t owner_thread_id = lock_word.ThinLockOwner();
720 if (owner_thread_id == thread_id) {
721 // We own the lock, increase the recursion count.
722 uint32_t new_count = lock_word.ThinLockCount() + 1;
723 if (LIKELY(new_count <= LockWord::kThinLockMaxCount)) {
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -0800724 LockWord thin_locked(LockWord::FromThinLockId(thread_id, new_count,
725 lock_word.ReadBarrierState()));
726 if (!kUseReadBarrier) {
727 h_obj->SetLockWord(thin_locked, true);
728 return h_obj.Get(); // Success!
729 } else {
730 // Use CAS to preserve the read barrier state.
731 if (h_obj->CasLockWordWeakSequentiallyConsistent(lock_word, thin_locked)) {
732 return h_obj.Get(); // Success!
733 }
734 }
735 continue; // Go again.
Elliott Hughes5f791332011-09-15 17:45:30 -0700736 } else {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700737 // We'd overflow the recursion count, so inflate the monitor.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700738 InflateThinLocked(self, h_obj, lock_word, 0);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700739 }
740 } else {
741 // Contention.
742 contention_count++;
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700743 Runtime* runtime = Runtime::Current();
744 if (contention_count <= runtime->GetMaxSpinsBeforeThinkLockInflation()) {
Mathieu Chartierb363f662014-07-16 13:28:58 -0700745 // TODO: Consider switching the thread state to kBlocked when we are yielding.
Mathieu Chartier251755c2014-07-15 18:10:25 -0700746 // Use sched_yield instead of NanoSleep since NanoSleep can wait much longer than the
747 // parameter you pass in. This can cause thread suspension to take excessively long
Mathieu Chartierb363f662014-07-16 13:28:58 -0700748 // and make long pauses. See b/16307460.
Mathieu Chartier251755c2014-07-15 18:10:25 -0700749 sched_yield();
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700750 } else {
751 contention_count = 0;
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700752 InflateThinLocked(self, h_obj, lock_word, 0);
Elliott Hughes5f791332011-09-15 17:45:30 -0700753 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700754 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700755 continue; // Start from the beginning.
Elliott Hughes5f791332011-09-15 17:45:30 -0700756 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700757 case LockWord::kFatLocked: {
758 Monitor* mon = lock_word.FatLockMonitor();
759 mon->Lock(self);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700760 return h_obj.Get(); // Success!
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700761 }
Ian Rogers719d1a32014-03-06 12:13:39 -0800762 case LockWord::kHashCode:
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700763 // Inflate with the existing hashcode.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700764 Inflate(self, nullptr, h_obj.Get(), lock_word.GetHashCode());
Ian Rogers719d1a32014-03-06 12:13:39 -0800765 continue; // Start from the beginning.
Mathieu Chartier590fee92013-09-13 13:46:47 -0700766 default: {
767 LOG(FATAL) << "Invalid monitor state " << lock_word.GetState();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700768 return h_obj.Get();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700769 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700770 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700771 }
772}
773
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800774bool Monitor::MonitorExit(Thread* self, mirror::Object* obj) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700775 DCHECK(self != nullptr);
776 DCHECK(obj != nullptr);
Ian Rogers719d1a32014-03-06 12:13:39 -0800777 obj = FakeUnlock(obj);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700778 StackHandleScope<1> hs(self);
779 Handle<mirror::Object> h_obj(hs.NewHandle(obj));
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -0800780 while (true) {
781 LockWord lock_word = obj->GetLockWord(true);
782 switch (lock_word.GetState()) {
783 case LockWord::kHashCode:
784 // Fall-through.
785 case LockWord::kUnlocked:
786 FailedUnlock(h_obj.Get(), self, nullptr, nullptr);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700787 return false; // Failure.
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -0800788 case LockWord::kThinLocked: {
789 uint32_t thread_id = self->GetThreadId();
790 uint32_t owner_thread_id = lock_word.ThinLockOwner();
791 if (owner_thread_id != thread_id) {
792 // TODO: there's a race here with the owner dying while we unlock.
793 Thread* owner =
794 Runtime::Current()->GetThreadList()->FindThreadByThreadId(lock_word.ThinLockOwner());
795 FailedUnlock(h_obj.Get(), self, owner, nullptr);
796 return false; // Failure.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700797 } else {
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -0800798 // We own the lock, decrease the recursion count.
799 LockWord new_lw = LockWord::Default();
800 if (lock_word.ThinLockCount() != 0) {
801 uint32_t new_count = lock_word.ThinLockCount() - 1;
802 new_lw = LockWord::FromThinLockId(thread_id, new_count, lock_word.ReadBarrierState());
803 } else {
804 new_lw = LockWord::FromDefault(lock_word.ReadBarrierState());
805 }
806 if (!kUseReadBarrier) {
807 DCHECK_EQ(new_lw.ReadBarrierState(), 0U);
808 h_obj->SetLockWord(new_lw, true);
809 // Success!
810 return true;
811 } else {
812 // Use CAS to preserve the read barrier state.
813 if (h_obj->CasLockWordWeakSequentiallyConsistent(lock_word, new_lw)) {
814 // Success!
815 return true;
816 }
817 }
818 continue; // Go again.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700819 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700820 }
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -0800821 case LockWord::kFatLocked: {
822 Monitor* mon = lock_word.FatLockMonitor();
823 return mon->Unlock(self);
824 }
825 default: {
826 LOG(FATAL) << "Invalid monitor state " << lock_word.GetState();
827 return false;
828 }
Mathieu Chartier590fee92013-09-13 13:46:47 -0700829 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700830 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700831}
832
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800833void Monitor::Wait(Thread* self, mirror::Object *obj, int64_t ms, int32_t ns,
Elliott Hughes4cd121e2013-01-07 17:35:41 -0800834 bool interruptShouldThrow, ThreadState why) {
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -0700835 DCHECK(self != nullptr);
836 DCHECK(obj != nullptr);
837 LockWord lock_word = obj->GetLockWord(true);
Ian Rogers43c69cc2014-08-15 11:09:28 -0700838 while (lock_word.GetState() != LockWord::kFatLocked) {
839 switch (lock_word.GetState()) {
840 case LockWord::kHashCode:
841 // Fall-through.
842 case LockWord::kUnlocked:
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700843 ThrowIllegalMonitorStateExceptionF("object not locked by thread before wait()");
844 return; // Failure.
Ian Rogers43c69cc2014-08-15 11:09:28 -0700845 case LockWord::kThinLocked: {
846 uint32_t thread_id = self->GetThreadId();
847 uint32_t owner_thread_id = lock_word.ThinLockOwner();
848 if (owner_thread_id != thread_id) {
849 ThrowIllegalMonitorStateExceptionF("object not locked by thread before wait()");
850 return; // Failure.
851 } else {
852 // We own the lock, inflate to enqueue ourself on the Monitor. May fail spuriously so
853 // re-load.
854 Inflate(self, self, obj, 0);
855 lock_word = obj->GetLockWord(true);
856 }
857 break;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700858 }
Ian Rogers43c69cc2014-08-15 11:09:28 -0700859 case LockWord::kFatLocked: // Unreachable given the loop condition above. Fall-through.
860 default: {
861 LOG(FATAL) << "Invalid monitor state " << lock_word.GetState();
862 return;
863 }
Mathieu Chartier590fee92013-09-13 13:46:47 -0700864 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700865 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700866 Monitor* mon = lock_word.FatLockMonitor();
867 mon->Wait(self, ms, ns, interruptShouldThrow, why);
Elliott Hughes5f791332011-09-15 17:45:30 -0700868}
869
Ian Rogers13c479e2013-10-11 07:59:01 -0700870void Monitor::DoNotify(Thread* self, mirror::Object* obj, bool notify_all) {
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -0700871 DCHECK(self != nullptr);
872 DCHECK(obj != nullptr);
873 LockWord lock_word = obj->GetLockWord(true);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700874 switch (lock_word.GetState()) {
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700875 case LockWord::kHashCode:
876 // Fall-through.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700877 case LockWord::kUnlocked:
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800878 ThrowIllegalMonitorStateExceptionF("object not locked by thread before notify()");
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700879 return; // Failure.
880 case LockWord::kThinLocked: {
881 uint32_t thread_id = self->GetThreadId();
882 uint32_t owner_thread_id = lock_word.ThinLockOwner();
883 if (owner_thread_id != thread_id) {
884 ThrowIllegalMonitorStateExceptionF("object not locked by thread before notify()");
885 return; // Failure.
886 } else {
887 // We own the lock but there's no Monitor and therefore no waiters.
888 return; // Success.
889 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700890 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700891 case LockWord::kFatLocked: {
892 Monitor* mon = lock_word.FatLockMonitor();
893 if (notify_all) {
894 mon->NotifyAll(self);
895 } else {
896 mon->Notify(self);
897 }
898 return; // Success.
899 }
Mathieu Chartier590fee92013-09-13 13:46:47 -0700900 default: {
901 LOG(FATAL) << "Invalid monitor state " << lock_word.GetState();
902 return;
903 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700904 }
905}
906
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700907uint32_t Monitor::GetLockOwnerThreadId(mirror::Object* obj) {
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -0700908 DCHECK(obj != nullptr);
909 LockWord lock_word = obj->GetLockWord(true);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700910 switch (lock_word.GetState()) {
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700911 case LockWord::kHashCode:
912 // Fall-through.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700913 case LockWord::kUnlocked:
914 return ThreadList::kInvalidThreadId;
915 case LockWord::kThinLocked:
916 return lock_word.ThinLockOwner();
917 case LockWord::kFatLocked: {
918 Monitor* mon = lock_word.FatLockMonitor();
919 return mon->GetOwnerThreadId();
Elliott Hughes5f791332011-09-15 17:45:30 -0700920 }
Mathieu Chartier590fee92013-09-13 13:46:47 -0700921 default: {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700922 LOG(FATAL) << "Unreachable";
Ian Rogers2c4257b2014-10-24 14:20:06 -0700923 UNREACHABLE();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700924 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700925 }
926}
927
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700928void Monitor::DescribeWait(std::ostream& os, const Thread* thread) {
Ian Rogersd803bc72014-04-01 15:33:03 -0700929 // Determine the wait message and object we're waiting or blocked upon.
930 mirror::Object* pretty_object = nullptr;
931 const char* wait_message = nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700932 uint32_t lock_owner = ThreadList::kInvalidThreadId;
Ian Rogersd803bc72014-04-01 15:33:03 -0700933 ThreadState state = thread->GetState();
Elliott Hughesb4e94fd2013-01-08 14:41:26 -0800934 if (state == kWaiting || state == kTimedWaiting || state == kSleeping) {
Ian Rogersd803bc72014-04-01 15:33:03 -0700935 wait_message = (state == kSleeping) ? " - sleeping on " : " - waiting on ";
936 Thread* self = Thread::Current();
937 MutexLock mu(self, *thread->GetWaitMutex());
938 Monitor* monitor = thread->GetWaitMonitor();
939 if (monitor != nullptr) {
Hiroshi Yamauchi4cba0d92014-05-21 21:10:23 -0700940 pretty_object = monitor->GetObject();
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700941 }
Elliott Hughes34e06962012-04-09 13:55:55 -0700942 } else if (state == kBlocked) {
Ian Rogersd803bc72014-04-01 15:33:03 -0700943 wait_message = " - waiting to lock ";
944 pretty_object = thread->GetMonitorEnterObject();
945 if (pretty_object != nullptr) {
946 lock_owner = pretty_object->GetLockOwnerThreadId();
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700947 }
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700948 }
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700949
Ian Rogersd803bc72014-04-01 15:33:03 -0700950 if (wait_message != nullptr) {
951 if (pretty_object == nullptr) {
952 os << wait_message << "an unknown object";
953 } else {
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -0700954 if ((pretty_object->GetLockWord(true).GetState() == LockWord::kThinLocked) &&
Ian Rogersd803bc72014-04-01 15:33:03 -0700955 Locks::mutator_lock_->IsExclusiveHeld(Thread::Current())) {
956 // Getting the identity hashcode here would result in lock inflation and suspension of the
957 // current thread, which isn't safe if this is the only runnable thread.
958 os << wait_message << StringPrintf("<@addr=0x%" PRIxPTR "> (a %s)",
959 reinterpret_cast<intptr_t>(pretty_object),
960 PrettyTypeOf(pretty_object).c_str());
961 } else {
962 // - waiting on <0x6008c468> (a java.lang.Class<java.lang.ref.ReferenceQueue>)
Mathieu Chartier49361592015-01-22 16:36:10 -0800963 // Call PrettyTypeOf before IdentityHashCode since IdentityHashCode can cause thread
964 // suspension and move pretty_object.
965 const std::string pretty_type(PrettyTypeOf(pretty_object));
Ian Rogersd803bc72014-04-01 15:33:03 -0700966 os << wait_message << StringPrintf("<0x%08x> (a %s)", pretty_object->IdentityHashCode(),
Mathieu Chartier49361592015-01-22 16:36:10 -0800967 pretty_type.c_str());
Ian Rogersd803bc72014-04-01 15:33:03 -0700968 }
969 }
970 // - waiting to lock <0x613f83d8> (a java.lang.Object) held by thread 5
971 if (lock_owner != ThreadList::kInvalidThreadId) {
972 os << " held by thread " << lock_owner;
973 }
974 os << "\n";
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700975 }
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700976}
977
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800978mirror::Object* Monitor::GetContendedMonitor(Thread* thread) {
Elliott Hughesf9501702013-01-11 11:22:27 -0800979 // This is used to implement JDWP's ThreadReference.CurrentContendedMonitor, and has a bizarre
980 // definition of contended that includes a monitor a thread is trying to enter...
Ian Rogersdd7624d2014-03-14 17:43:00 -0700981 mirror::Object* result = thread->GetMonitorEnterObject();
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700982 if (result == nullptr) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700983 // ...but also a monitor that the thread is waiting on.
Ian Rogersdd7624d2014-03-14 17:43:00 -0700984 MutexLock mu(Thread::Current(), *thread->GetWaitMutex());
985 Monitor* monitor = thread->GetWaitMonitor();
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700986 if (monitor != nullptr) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700987 result = monitor->GetObject();
Elliott Hughesf9501702013-01-11 11:22:27 -0800988 }
989 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700990 return result;
Elliott Hughesf9501702013-01-11 11:22:27 -0800991}
992
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800993void Monitor::VisitLocks(StackVisitor* stack_visitor, void (*callback)(mirror::Object*, void*),
Andreas Gampe760172c2014-08-16 13:41:10 -0700994 void* callback_context, bool abort_on_failure) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700995 ArtMethod* m = stack_visitor->GetMethod();
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700996 CHECK(m != nullptr);
Elliott Hughes08fc03a2012-06-26 17:34:00 -0700997
998 // Native methods are an easy special case.
999 // TODO: use the JNI implementation's table of explicit MonitorEnter calls and dump those too.
1000 if (m->IsNative()) {
1001 if (m->IsSynchronized()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001002 mirror::Object* jni_this =
1003 stack_visitor->GetCurrentHandleScope(sizeof(void*))->GetReference(0);
Elliott Hughes4993bbc2013-01-10 15:41:25 -08001004 callback(jni_this, callback_context);
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001005 }
1006 return;
1007 }
1008
jeffhao61f916c2012-10-25 17:48:51 -07001009 // Proxy methods should not be synchronized.
1010 if (m->IsProxyMethod()) {
1011 CHECK(!m->IsSynchronized());
1012 return;
1013 }
1014
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001015 // Is there any reason to believe there's any synchronization in this method?
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07001016 const DexFile::CodeItem* code_item = m->GetCodeItem();
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001017 CHECK(code_item != nullptr) << PrettyMethod(m);
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001018 if (code_item->tries_size_ == 0) {
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001019 return; // No "tries" implies no synchronization, so no held locks to report.
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001020 }
1021
Andreas Gampe760172c2014-08-16 13:41:10 -07001022 // Get the dex pc. If abort_on_failure is false, GetDexPc will not abort in the case it cannot
1023 // find the dex pc, and instead return kDexNoIndex. Then bail out, as it indicates we have an
1024 // inconsistent stack anyways.
1025 uint32_t dex_pc = stack_visitor->GetDexPc(abort_on_failure);
1026 if (!abort_on_failure && dex_pc == DexFile::kDexNoIndex) {
1027 LOG(ERROR) << "Could not find dex_pc for " << PrettyMethod(m);
1028 return;
1029 }
1030
Elliott Hughes80537bb2013-01-04 16:37:26 -08001031 // Ask the verifier for the dex pcs of all the monitor-enter instructions corresponding to
1032 // the locks held in this stack frame.
1033 std::vector<uint32_t> monitor_enter_dex_pcs;
Andreas Gampe760172c2014-08-16 13:41:10 -07001034 verifier::MethodVerifier::FindLocksAtDexPc(m, dex_pc, &monitor_enter_dex_pcs);
Mathieu Chartiere6a8eec2015-01-06 14:17:57 -08001035 for (uint32_t monitor_dex_pc : monitor_enter_dex_pcs) {
Elliott Hughes80537bb2013-01-04 16:37:26 -08001036 // The verifier works in terms of the dex pcs of the monitor-enter instructions.
1037 // We want the registers used by those instructions (so we can read the values out of them).
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001038 uint16_t monitor_enter_instruction = code_item->insns_[monitor_dex_pc];
Elliott Hughes80537bb2013-01-04 16:37:26 -08001039
1040 // Quick sanity check.
1041 if ((monitor_enter_instruction & 0xff) != Instruction::MONITOR_ENTER) {
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001042 LOG(FATAL) << "expected monitor-enter @" << monitor_dex_pc << "; was "
Elliott Hughes80537bb2013-01-04 16:37:26 -08001043 << reinterpret_cast<void*>(monitor_enter_instruction);
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001044 }
1045
Elliott Hughes80537bb2013-01-04 16:37:26 -08001046 uint16_t monitor_register = ((monitor_enter_instruction >> 8) & 0xff);
Nicolas Geoffray15b9d522015-03-12 15:05:13 +00001047 uint32_t value;
1048 bool success = stack_visitor->GetVReg(m, monitor_register, kReferenceVReg, &value);
1049 CHECK(success) << "Failed to read v" << monitor_register << " of kind "
1050 << kReferenceVReg << " in method " << PrettyMethod(m);
1051 mirror::Object* o = reinterpret_cast<mirror::Object*>(value);
Elliott Hughes4993bbc2013-01-10 15:41:25 -08001052 callback(o, callback_context);
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001053 }
1054}
1055
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001056bool Monitor::IsValidLockWord(LockWord lock_word) {
1057 switch (lock_word.GetState()) {
1058 case LockWord::kUnlocked:
1059 // Nothing to check.
1060 return true;
1061 case LockWord::kThinLocked:
1062 // Basic sanity check of owner.
1063 return lock_word.ThinLockOwner() != ThreadList::kInvalidThreadId;
1064 case LockWord::kFatLocked: {
1065 // Check the monitor appears in the monitor list.
1066 Monitor* mon = lock_word.FatLockMonitor();
1067 MonitorList* list = Runtime::Current()->GetMonitorList();
1068 MutexLock mu(Thread::Current(), list->monitor_list_lock_);
1069 for (Monitor* list_mon : list->list_) {
1070 if (mon == list_mon) {
1071 return true; // Found our monitor.
1072 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001073 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001074 return false; // Fail - unowned monitor in an object.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001075 }
Mathieu Chartierad2541a2013-10-25 10:05:23 -07001076 case LockWord::kHashCode:
1077 return true;
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001078 default:
1079 LOG(FATAL) << "Unreachable";
Ian Rogers2c4257b2014-10-24 14:20:06 -07001080 UNREACHABLE();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001081 }
1082}
1083
Mathieu Chartier90443472015-07-16 20:32:27 -07001084bool Monitor::IsLocked() SHARED_REQUIRES(Locks::mutator_lock_) {
Mathieu Chartierad2541a2013-10-25 10:05:23 -07001085 MutexLock mu(Thread::Current(), monitor_lock_);
1086 return owner_ != nullptr;
1087}
1088
Mathieu Chartiere401d142015-04-22 13:56:20 -07001089void Monitor::TranslateLocation(ArtMethod* method, uint32_t dex_pc,
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001090 const char** source_file, uint32_t* line_number) const {
jeffhao33dc7712011-11-09 17:54:24 -08001091 // If method is null, location is unknown
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001092 if (method == nullptr) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001093 *source_file = "";
1094 *line_number = 0;
jeffhao33dc7712011-11-09 17:54:24 -08001095 return;
1096 }
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07001097 *source_file = method->GetDeclaringClassSourceFile();
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001098 if (*source_file == nullptr) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001099 *source_file = "";
Elliott Hughes12c51e32012-01-17 20:25:05 -08001100 }
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07001101 *line_number = method->GetLineNumFromDexPC(dex_pc);
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001102}
1103
1104uint32_t Monitor::GetOwnerThreadId() {
1105 MutexLock mu(Thread::Current(), monitor_lock_);
1106 Thread* owner = owner_;
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001107 if (owner != nullptr) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001108 return owner->GetThreadId();
1109 } else {
1110 return ThreadList::kInvalidThreadId;
1111 }
jeffhao33dc7712011-11-09 17:54:24 -08001112}
1113
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07001114MonitorList::MonitorList()
Mathieu Chartier440e4ce2014-03-31 16:36:35 -07001115 : allow_new_monitors_(true), monitor_list_lock_("MonitorList lock", kMonitorListLock),
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07001116 monitor_add_condition_("MonitorList disallow condition", monitor_list_lock_) {
Elliott Hughesc33a32b2011-10-11 18:18:07 -07001117}
1118
1119MonitorList::~MonitorList() {
Andreas Gampe74240812014-04-17 10:35:09 -07001120 Thread* self = Thread::Current();
1121 MutexLock mu(self, monitor_list_lock_);
1122 // Release all monitors to the pool.
1123 // TODO: Is it an invariant that *all* open monitors are in the list? Then we could
1124 // clear faster in the pool.
1125 MonitorPool::ReleaseMonitors(self, &list_);
Elliott Hughesc33a32b2011-10-11 18:18:07 -07001126}
1127
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07001128void MonitorList::DisallowNewMonitors() {
Ian Rogers50b35e22012-10-04 10:09:15 -07001129 MutexLock mu(Thread::Current(), monitor_list_lock_);
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07001130 allow_new_monitors_ = false;
1131}
1132
1133void MonitorList::AllowNewMonitors() {
1134 Thread* self = Thread::Current();
1135 MutexLock mu(self, monitor_list_lock_);
1136 allow_new_monitors_ = true;
1137 monitor_add_condition_.Broadcast(self);
1138}
1139
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -08001140void MonitorList::EnsureNewMonitorsDisallowed() {
1141 // Lock and unlock once to ensure that no threads are still in the
1142 // middle of adding new monitors.
1143 MutexLock mu(Thread::Current(), monitor_list_lock_);
1144 CHECK(!allow_new_monitors_);
1145}
1146
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001147void MonitorList::BroadcastForNewMonitors() {
1148 CHECK(kUseReadBarrier);
1149 Thread* self = Thread::Current();
1150 MutexLock mu(self, monitor_list_lock_);
1151 monitor_add_condition_.Broadcast(self);
1152}
1153
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07001154void MonitorList::Add(Monitor* m) {
1155 Thread* self = Thread::Current();
1156 MutexLock mu(self, monitor_list_lock_);
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001157 while (UNLIKELY((!kUseReadBarrier && !allow_new_monitors_) ||
1158 (kUseReadBarrier && !self->GetWeakRefAccessEnabled()))) {
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07001159 monitor_add_condition_.WaitHoldingLocks(self);
1160 }
Elliott Hughesc33a32b2011-10-11 18:18:07 -07001161 list_.push_front(m);
1162}
1163
Mathieu Chartier97509952015-07-13 14:35:43 -07001164void MonitorList::SweepMonitorList(IsMarkedVisitor* visitor) {
Andreas Gampe74240812014-04-17 10:35:09 -07001165 Thread* self = Thread::Current();
1166 MutexLock mu(self, monitor_list_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001167 for (auto it = list_.begin(); it != list_.end(); ) {
Elliott Hughesc33a32b2011-10-11 18:18:07 -07001168 Monitor* m = *it;
Hiroshi Yamauchi4cba0d92014-05-21 21:10:23 -07001169 // Disable the read barrier in GetObject() as this is called by GC.
1170 mirror::Object* obj = m->GetObject<kWithoutReadBarrier>();
Mathieu Chartier590fee92013-09-13 13:46:47 -07001171 // The object of a monitor can be null if we have deflated it.
Mathieu Chartier97509952015-07-13 14:35:43 -07001172 mirror::Object* new_obj = obj != nullptr ? visitor->IsMarked(obj) : nullptr;
Mathieu Chartier6aa3df92013-09-17 15:17:28 -07001173 if (new_obj == nullptr) {
1174 VLOG(monitor) << "freeing monitor " << m << " belonging to unmarked object "
Hiroshi Yamauchi4cba0d92014-05-21 21:10:23 -07001175 << obj;
Andreas Gampe74240812014-04-17 10:35:09 -07001176 MonitorPool::ReleaseMonitor(self, m);
Elliott Hughesc33a32b2011-10-11 18:18:07 -07001177 it = list_.erase(it);
1178 } else {
Mathieu Chartier6aa3df92013-09-17 15:17:28 -07001179 m->SetObject(new_obj);
Elliott Hughesc33a32b2011-10-11 18:18:07 -07001180 ++it;
1181 }
1182 }
1183}
1184
Mathieu Chartier97509952015-07-13 14:35:43 -07001185class MonitorDeflateVisitor : public IsMarkedVisitor {
1186 public:
1187 MonitorDeflateVisitor() : self_(Thread::Current()), deflate_count_(0) {}
1188
1189 virtual mirror::Object* IsMarked(mirror::Object* object) OVERRIDE
Mathieu Chartier90443472015-07-16 20:32:27 -07001190 SHARED_REQUIRES(Locks::mutator_lock_) {
Mathieu Chartier97509952015-07-13 14:35:43 -07001191 if (Monitor::Deflate(self_, object)) {
1192 DCHECK_NE(object->GetLockWord(true).GetState(), LockWord::kFatLocked);
1193 ++deflate_count_;
1194 // If we deflated, return null so that the monitor gets removed from the array.
1195 return nullptr;
1196 }
1197 return object; // Monitor was not deflated.
1198 }
1199
1200 Thread* const self_;
1201 size_t deflate_count_;
Mathieu Chartier48ab6872014-06-24 11:21:59 -07001202};
1203
Mathieu Chartier48ab6872014-06-24 11:21:59 -07001204size_t MonitorList::DeflateMonitors() {
Mathieu Chartier97509952015-07-13 14:35:43 -07001205 MonitorDeflateVisitor visitor;
1206 Locks::mutator_lock_->AssertExclusiveHeld(visitor.self_);
1207 SweepMonitorList(&visitor);
1208 return visitor.deflate_count_;
Mathieu Chartier440e4ce2014-03-31 16:36:35 -07001209}
1210
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001211MonitorInfo::MonitorInfo(mirror::Object* obj) : owner_(nullptr), entry_count_(0) {
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -07001212 DCHECK(obj != nullptr);
1213 LockWord lock_word = obj->GetLockWord(true);
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001214 switch (lock_word.GetState()) {
1215 case LockWord::kUnlocked:
Mathieu Chartierad2541a2013-10-25 10:05:23 -07001216 // Fall-through.
Mathieu Chartier590fee92013-09-13 13:46:47 -07001217 case LockWord::kForwardingAddress:
1218 // Fall-through.
Mathieu Chartierad2541a2013-10-25 10:05:23 -07001219 case LockWord::kHashCode:
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001220 break;
1221 case LockWord::kThinLocked:
1222 owner_ = Runtime::Current()->GetThreadList()->FindThreadByThreadId(lock_word.ThinLockOwner());
1223 entry_count_ = 1 + lock_word.ThinLockCount();
1224 // Thin locks have no waiters.
1225 break;
1226 case LockWord::kFatLocked: {
1227 Monitor* mon = lock_word.FatLockMonitor();
1228 owner_ = mon->owner_;
1229 entry_count_ = 1 + mon->lock_count_;
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001230 for (Thread* waiter = mon->wait_set_; waiter != nullptr; waiter = waiter->GetWaitNext()) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001231 waiters_.push_back(waiter);
1232 }
1233 break;
Elliott Hughesf327e072013-01-09 16:01:26 -08001234 }
1235 }
1236}
1237
Elliott Hughes5f791332011-09-15 17:45:30 -07001238} // namespace art