blob: 42d5c420075d73b7bc33c98e5df280f6457c4cae [file] [log] [blame]
Elliott Hughes8daa0922011-09-11 13:46:25 -07001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "thread_list.h"
18
Mathieu Chartier6f365cc2014-04-23 12:42:27 -070019#define ATRACE_TAG ATRACE_TAG_DALVIK
20
21#include <cutils/trace.h>
Elliott Hughesabbe07d2012-06-05 17:42:23 -070022#include <dirent.h>
Ian Rogersd9c4fc92013-10-01 19:45:43 -070023#include <ScopedLocalRef.h>
24#include <ScopedUtfChars.h>
Elliott Hughesabbe07d2012-06-05 17:42:23 -070025#include <sys/types.h>
Elliott Hughes038a8062011-09-18 14:12:41 -070026#include <unistd.h>
27
Ian Rogersc7dd2952014-10-21 23:31:19 -070028#include <sstream>
29
Mathieu Chartier70a596d2014-12-17 14:56:47 -080030#include "base/histogram-inl.h"
Elliott Hughes76b61672012-12-12 17:47:30 -080031#include "base/mutex.h"
Hiroshi Yamauchi967a0ad2013-09-10 16:24:21 -070032#include "base/mutex-inl.h"
Sameer Abu Asala8439542013-02-14 16:06:42 -080033#include "base/timing_logger.h"
Elliott Hughes475fc232011-10-25 15:00:35 -070034#include "debugger.h"
Ian Rogersd9c4fc92013-10-01 19:45:43 -070035#include "jni_internal.h"
36#include "lock_word.h"
37#include "monitor.h"
38#include "scoped_thread_state_change.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080039#include "thread.h"
Jeff Haoe094b872014-10-14 13:12:01 -070040#include "trace.h"
Elliott Hughesabbe07d2012-06-05 17:42:23 -070041#include "utils.h"
Ian Rogersd9c4fc92013-10-01 19:45:43 -070042#include "well_known_classes.h"
Elliott Hughes475fc232011-10-25 15:00:35 -070043
Elliott Hughes8daa0922011-09-11 13:46:25 -070044namespace art {
45
Mathieu Chartier251755c2014-07-15 18:10:25 -070046static constexpr uint64_t kLongThreadSuspendThreshold = MsToNs(5);
47
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -080048ThreadList::ThreadList()
Chao-ying Fu9e369312014-05-21 11:20:52 -070049 : suspend_all_count_(0), debug_suspend_all_count_(0),
Mathieu Chartier70a596d2014-12-17 14:56:47 -080050 thread_exit_cond_("thread exit condition variable", *Locks::thread_list_lock_),
51 suspend_all_historam_("suspend all histogram", 16, 64) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -070052 CHECK(Monitor::IsValidLockWord(LockWord::FromThinLockId(kMaxThreadId, 1)));
Elliott Hughes8daa0922011-09-11 13:46:25 -070053}
54
55ThreadList::~ThreadList() {
Elliott Hughese52e49b2012-04-02 16:05:44 -070056 // Detach the current thread if necessary. If we failed to start, there might not be any threads.
Elliott Hughes6a144332012-04-03 13:07:11 -070057 // We need to detach the current thread here in case there's another thread waiting to join with
58 // us.
Mathieu Chartierfec72f42014-10-09 12:57:58 -070059 bool contains = false;
60 {
61 Thread* self = Thread::Current();
62 MutexLock mu(self, *Locks::thread_list_lock_);
63 contains = Contains(self);
64 }
65 if (contains) {
Elliott Hughes8daa0922011-09-11 13:46:25 -070066 Runtime::Current()->DetachCurrentThread();
67 }
Elliott Hughes6a144332012-04-03 13:07:11 -070068
69 WaitForOtherNonDaemonThreadsToExit();
Ian Rogers00f7d0e2012-07-19 15:28:27 -070070 // TODO: there's an unaddressed race here where a thread may attach during shutdown, see
71 // Thread::Init.
Elliott Hughes6a144332012-04-03 13:07:11 -070072 SuspendAllDaemonThreads();
Elliott Hughes8daa0922011-09-11 13:46:25 -070073}
74
75bool ThreadList::Contains(Thread* thread) {
76 return find(list_.begin(), list_.end(), thread) != list_.end();
77}
78
Elliott Hughesabbe07d2012-06-05 17:42:23 -070079bool ThreadList::Contains(pid_t tid) {
Mathieu Chartier02e25112013-08-14 16:14:24 -070080 for (const auto& thread : list_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -070081 if (thread->GetTid() == tid) {
Elliott Hughesabbe07d2012-06-05 17:42:23 -070082 return true;
83 }
84 }
85 return false;
86}
87
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -070088pid_t ThreadList::GetLockOwner() {
Ian Rogersb726dcb2012-09-05 08:57:23 -070089 return Locks::thread_list_lock_->GetExclusiveOwnerTid();
Elliott Hughesaccd83d2011-10-17 14:25:58 -070090}
91
Mathieu Chartier590fee92013-09-13 13:46:47 -070092void ThreadList::DumpNativeStacks(std::ostream& os) {
93 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
94 for (const auto& thread : list_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -070095 os << "DUMPING THREAD " << thread->GetTid() << "\n";
Christopher Ferrisa2cee182014-04-16 19:13:59 -070096 DumpNativeStack(os, thread->GetTid(), "\t");
Mathieu Chartier590fee92013-09-13 13:46:47 -070097 os << "\n";
98 }
99}
100
Elliott Hughesc967f782012-04-16 10:23:15 -0700101void ThreadList::DumpForSigQuit(std::ostream& os) {
Mathieu Chartier70a596d2014-12-17 14:56:47 -0800102 {
103 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartier23f6e692014-12-18 18:24:39 -0800104 // Only print if we have samples.
105 if (suspend_all_historam_.SampleSize() > 0) {
106 Histogram<uint64_t>::CumulativeData data;
107 suspend_all_historam_.CreateHistogram(&data);
108 suspend_all_historam_.PrintConfidenceIntervals(os, 0.99, data); // Dump time to suspend.
109 }
Mathieu Chartier70a596d2014-12-17 14:56:47 -0800110 }
Ian Rogers7b078e82014-09-10 14:44:24 -0700111 Dump(os);
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700112 DumpUnattachedThreads(os);
113}
114
Ian Rogerscfaa4552012-11-26 21:00:08 -0800115static void DumpUnattachedThread(std::ostream& os, pid_t tid) NO_THREAD_SAFETY_ANALYSIS {
116 // TODO: No thread safety analysis as DumpState with a NULL thread won't access fields, should
117 // refactor DumpState to avoid skipping analysis.
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700118 Thread::DumpState(os, NULL, tid);
119 DumpKernelStack(os, tid, " kernel: ", false);
Brian Carlstromed8b7232012-06-27 17:54:47 -0700120 // TODO: Reenable this when the native code in system_server can handle it.
121 // Currently "adb shell kill -3 `pid system_server`" will cause it to exit.
122 if (false) {
Christopher Ferrisa2cee182014-04-16 19:13:59 -0700123 DumpNativeStack(os, tid, " native: ");
Brian Carlstromed8b7232012-06-27 17:54:47 -0700124 }
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700125 os << "\n";
126}
127
128void ThreadList::DumpUnattachedThreads(std::ostream& os) {
129 DIR* d = opendir("/proc/self/task");
130 if (!d) {
131 return;
132 }
133
Ian Rogers50b35e22012-10-04 10:09:15 -0700134 Thread* self = Thread::Current();
Elliott Hughes4696b5b2012-10-30 10:35:10 -0700135 dirent* e;
136 while ((e = readdir(d)) != NULL) {
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700137 char* end;
Elliott Hughes4696b5b2012-10-30 10:35:10 -0700138 pid_t tid = strtol(e->d_name, &end, 10);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700139 if (!*end) {
140 bool contains;
141 {
Ian Rogers50b35e22012-10-04 10:09:15 -0700142 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700143 contains = Contains(tid);
144 }
145 if (!contains) {
146 DumpUnattachedThread(os, tid);
147 }
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700148 }
149 }
150 closedir(d);
Elliott Hughesff738062012-02-03 15:00:42 -0800151}
152
Ian Rogers7b078e82014-09-10 14:44:24 -0700153// A closure used by Thread::Dump.
154class DumpCheckpoint FINAL : public Closure {
155 public:
156 explicit DumpCheckpoint(std::ostream* os) : os_(os), barrier_(0) {}
157
158 void Run(Thread* thread) OVERRIDE {
159 // Note thread and self may not be equal if thread was already suspended at the point of the
160 // request.
161 Thread* self = Thread::Current();
162 std::ostringstream local_os;
163 {
164 ScopedObjectAccess soa(self);
165 thread->Dump(local_os);
166 }
167 local_os << "\n";
168 {
169 // Use the logging lock to ensure serialization when writing to the common ostream.
170 MutexLock mu(self, *Locks::logging_lock_);
171 *os_ << local_os.str();
172 }
173 barrier_.Pass(self);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700174 }
Ian Rogers7b078e82014-09-10 14:44:24 -0700175
176 void WaitForThreadsToRunThroughCheckpoint(size_t threads_running_checkpoint) {
177 Thread* self = Thread::Current();
178 ScopedThreadStateChange tsc(self, kWaitingForCheckPointsToRun);
Ian Rogers2156ff12014-09-13 19:20:54 -0700179 const uint32_t kWaitTimeoutMs = 10000;
180 bool timed_out = barrier_.Increment(self, threads_running_checkpoint, kWaitTimeoutMs);
181 if (timed_out) {
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000182 // Avoid a recursive abort.
183 LOG((kIsDebugBuild && (gAborting == 0)) ? FATAL : ERROR)
184 << "Unexpected time out during dump checkpoint.";
Ian Rogers2156ff12014-09-13 19:20:54 -0700185 }
Ian Rogers7b078e82014-09-10 14:44:24 -0700186 }
187
188 private:
189 // The common stream that will accumulate all the dumps.
190 std::ostream* const os_;
191 // The barrier to be passed through and for the requestor to wait upon.
192 Barrier barrier_;
193};
194
195void ThreadList::Dump(std::ostream& os) {
196 {
197 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
198 os << "DALVIK THREADS (" << list_.size() << "):\n";
199 }
200 DumpCheckpoint checkpoint(&os);
201 size_t threads_running_checkpoint = RunCheckpoint(&checkpoint);
202 checkpoint.WaitForThreadsToRunThroughCheckpoint(threads_running_checkpoint);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700203}
204
Ian Rogers50b35e22012-10-04 10:09:15 -0700205void ThreadList::AssertThreadsAreSuspended(Thread* self, Thread* ignore1, Thread* ignore2) {
206 MutexLock mu(self, *Locks::thread_list_lock_);
207 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -0700208 for (const auto& thread : list_) {
jeffhao725a9572012-11-13 18:20:12 -0800209 if (thread != ignore1 && thread != ignore2) {
Ian Rogers01ae5802012-09-28 16:14:01 -0700210 CHECK(thread->IsSuspended())
211 << "\nUnsuspended thread: <<" << *thread << "\n"
212 << "self: <<" << *Thread::Current();
213 }
Elliott Hughes8d768a92011-09-14 16:35:25 -0700214 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700215}
216
Ian Rogers66aee5c2012-08-15 17:17:47 -0700217#if HAVE_TIMED_RWLOCK
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700218// Attempt to rectify locks so that we dump thread list with required locks before exiting.
Ian Rogers7b078e82014-09-10 14:44:24 -0700219static void UnsafeLogFatalForThreadSuspendAllTimeout() __attribute__((noreturn));
Sebastien Hertzbae182c2013-12-17 10:42:03 +0100220static void UnsafeLogFatalForThreadSuspendAllTimeout() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700221 Runtime* runtime = Runtime::Current();
222 std::ostringstream ss;
223 ss << "Thread suspend timeout\n";
Mathieu Chartier5869a2c2014-10-08 14:26:23 -0700224 Locks::mutator_lock_->Dump(ss);
225 ss << "\n";
Ian Rogers7b078e82014-09-10 14:44:24 -0700226 runtime->GetThreadList()->Dump(ss);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700227 LOG(FATAL) << ss.str();
Ian Rogers719d1a32014-03-06 12:13:39 -0800228 exit(0);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700229}
Ian Rogers66aee5c2012-08-15 17:17:47 -0700230#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700231
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800232// Unlike suspending all threads where we can wait to acquire the mutator_lock_, suspending an
233// individual thread requires polling. delay_us is the requested sleep and total_delay_us
234// accumulates the total time spent sleeping for timeouts. The first sleep is just a yield,
235// subsequently sleeps increase delay_us from 1ms to 500ms by doubling.
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700236static void ThreadSuspendSleep(useconds_t* delay_us, useconds_t* total_delay_us) {
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800237 useconds_t new_delay_us = (*delay_us) * 2;
238 CHECK_GE(new_delay_us, *delay_us);
239 if (new_delay_us < 500000) { // Don't allow sleeping to be more than 0.5s.
240 *delay_us = new_delay_us;
241 }
242 if (*delay_us == 0) {
243 sched_yield();
244 // Default to 1 milliseconds (note that this gets multiplied by 2 before the first sleep).
245 *delay_us = 500;
246 } else {
247 usleep(*delay_us);
248 *total_delay_us += *delay_us;
249 }
250}
251
Mathieu Chartier0e4627e2012-10-23 16:13:36 -0700252size_t ThreadList::RunCheckpoint(Closure* checkpoint_function) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700253 Thread* self = Thread::Current();
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800254 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
255 Locks::thread_list_lock_->AssertNotHeld(self);
256 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000257 if (kDebugLocking && gAborting == 0) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700258 CHECK_NE(self->GetState(), kRunnable);
259 }
260
261 std::vector<Thread*> suspended_count_modified_threads;
262 size_t count = 0;
263 {
264 // Call a checkpoint function for each thread, threads which are suspend get their checkpoint
265 // manually called.
266 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700267 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -0700268 for (const auto& thread : list_) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700269 if (thread != self) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700270 while (true) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700271 if (thread->RequestCheckpoint(checkpoint_function)) {
Dave Allison0aded082013-11-07 13:15:11 -0800272 // This thread will run its checkpoint some time in the near future.
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700273 count++;
274 break;
275 } else {
276 // We are probably suspended, try to make sure that we stay suspended.
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700277 // The thread switched back to runnable.
278 if (thread->GetState() == kRunnable) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700279 // Spurious fail, try again.
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700280 continue;
281 }
282 thread->ModifySuspendCount(self, +1, false);
283 suspended_count_modified_threads.push_back(thread);
284 break;
285 }
286 }
287 }
288 }
289 }
290
291 // Run the checkpoint on ourself while we wait for threads to suspend.
292 checkpoint_function->Run(self);
293
294 // Run the checkpoint on the suspended threads.
Mathieu Chartier02e25112013-08-14 16:14:24 -0700295 for (const auto& thread : suspended_count_modified_threads) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700296 if (!thread->IsSuspended()) {
297 // Wait until the thread is suspended.
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800298 useconds_t total_delay_us = 0;
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700299 do {
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800300 useconds_t delay_us = 100;
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700301 ThreadSuspendSleep(&delay_us, &total_delay_us);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700302 } while (!thread->IsSuspended());
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800303 // Shouldn't need to wait for longer than 1000 microseconds.
304 constexpr useconds_t kLongWaitThresholdUS = 1000;
305 if (UNLIKELY(total_delay_us > kLongWaitThresholdUS)) {
306 LOG(WARNING) << "Waited " << total_delay_us << " us for thread suspend!";
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700307 }
308 }
309 // We know for sure that the thread is suspended at this point.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700310 checkpoint_function->Run(thread);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700311 {
312 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
313 thread->ModifySuspendCount(self, -1, false);
314 }
315 }
316
Mathieu Chartier664bebf2012-11-12 16:54:11 -0800317 {
318 // Imitate ResumeAll, threads may be waiting on Thread::resume_cond_ since we raised their
319 // suspend count. Now the suspend_count_ is lowered so we must do the broadcast.
320 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
321 Thread::resume_cond_->Broadcast(self);
322 }
323
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700324 // Add one for self.
325 return count + suspended_count_modified_threads.size() + 1;
326}
327
Dave Allison39c3bfb2014-01-28 18:33:52 -0800328// Request that a checkpoint function be run on all active (non-suspended)
329// threads. Returns the number of successful requests.
330size_t ThreadList::RunCheckpointOnRunnableThreads(Closure* checkpoint_function) {
331 Thread* self = Thread::Current();
Ian Rogers7b078e82014-09-10 14:44:24 -0700332 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
333 Locks::thread_list_lock_->AssertNotHeld(self);
334 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
335 CHECK_NE(self->GetState(), kRunnable);
Dave Allison39c3bfb2014-01-28 18:33:52 -0800336
337 size_t count = 0;
338 {
339 // Call a checkpoint function for each non-suspended thread.
340 MutexLock mu(self, *Locks::thread_list_lock_);
341 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
342 for (const auto& thread : list_) {
343 if (thread != self) {
344 if (thread->RequestCheckpoint(checkpoint_function)) {
345 // This thread will run its checkpoint some time in the near future.
346 count++;
347 }
348 }
349 }
350 }
351
352 // Return the number of threads that will run the checkpoint function.
353 return count;
354}
355
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700356void ThreadList::SuspendAll() {
357 Thread* self = Thread::Current();
358
Jeff Haoc5d824a2014-07-28 18:35:38 -0700359 if (self != nullptr) {
360 VLOG(threads) << *self << " SuspendAll starting...";
361 } else {
362 VLOG(threads) << "Thread[null] SuspendAll starting...";
363 }
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700364 ATRACE_BEGIN("Suspending mutator threads");
Mathieu Chartier70a596d2014-12-17 14:56:47 -0800365 const uint64_t start_time = NanoTime();
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700366
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800367 Locks::mutator_lock_->AssertNotHeld(self);
368 Locks::thread_list_lock_->AssertNotHeld(self);
369 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
Jeff Haoc5d824a2014-07-28 18:35:38 -0700370 if (kDebugLocking && self != nullptr) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700371 CHECK_NE(self->GetState(), kRunnable);
372 }
373 {
Ian Rogers81d425b2012-09-27 16:03:43 -0700374 MutexLock mu(self, *Locks::thread_list_lock_);
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800375 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
376 // Update global suspend all state for attaching threads.
377 ++suspend_all_count_;
378 // Increment everybody's suspend count (except our own).
379 for (const auto& thread : list_) {
380 if (thread == self) {
381 continue;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700382 }
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800383 VLOG(threads) << "requesting thread suspend: " << *thread;
384 thread->ModifySuspendCount(self, +1, false);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700385 }
386 }
387
Ian Rogers66aee5c2012-08-15 17:17:47 -0700388 // Block on the mutator lock until all Runnable threads release their share of access.
389#if HAVE_TIMED_RWLOCK
390 // Timeout if we wait more than 30 seconds.
Ian Rogers719d1a32014-03-06 12:13:39 -0800391 if (!Locks::mutator_lock_->ExclusiveLockWithTimeout(self, 30 * 1000, 0)) {
Sebastien Hertzbae182c2013-12-17 10:42:03 +0100392 UnsafeLogFatalForThreadSuspendAllTimeout();
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700393 }
Ian Rogers66aee5c2012-08-15 17:17:47 -0700394#else
Ian Rogers81d425b2012-09-27 16:03:43 -0700395 Locks::mutator_lock_->ExclusiveLock(self);
Ian Rogers66aee5c2012-08-15 17:17:47 -0700396#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700397
Mathieu Chartier70a596d2014-12-17 14:56:47 -0800398 const uint64_t end_time = NanoTime();
399 const uint64_t suspend_time = end_time - start_time;
400 suspend_all_historam_.AdjustAndAddValue(suspend_time);
401 if (suspend_time > kLongThreadSuspendThreshold) {
402 LOG(WARNING) << "Suspending all threads took: " << PrettyDuration(suspend_time);
Mathieu Chartier251755c2014-07-15 18:10:25 -0700403 }
404
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800405 if (kDebugLocking) {
406 // Debug check that all threads are suspended.
407 AssertThreadsAreSuspended(self, self);
408 }
Elliott Hughes8d768a92011-09-14 16:35:25 -0700409
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700410 ATRACE_END();
411 ATRACE_BEGIN("Mutator threads suspended");
412
Jeff Haoc5d824a2014-07-28 18:35:38 -0700413 if (self != nullptr) {
414 VLOG(threads) << *self << " SuspendAll complete";
415 } else {
416 VLOG(threads) << "Thread[null] SuspendAll complete";
417 }
Elliott Hughes8d768a92011-09-14 16:35:25 -0700418}
419
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700420void ThreadList::ResumeAll() {
421 Thread* self = Thread::Current();
422
Jeff Haoc5d824a2014-07-28 18:35:38 -0700423 if (self != nullptr) {
424 VLOG(threads) << *self << " ResumeAll starting";
425 } else {
426 VLOG(threads) << "Thread[null] ResumeAll starting";
427 }
Ian Rogers01ae5802012-09-28 16:14:01 -0700428
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700429 ATRACE_END();
430 ATRACE_BEGIN("Resuming mutator threads");
431
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800432 if (kDebugLocking) {
433 // Debug check that all threads are suspended.
434 AssertThreadsAreSuspended(self, self);
435 }
Ian Rogers01ae5802012-09-28 16:14:01 -0700436
Ian Rogers81d425b2012-09-27 16:03:43 -0700437 Locks::mutator_lock_->ExclusiveUnlock(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700438 {
Ian Rogers81d425b2012-09-27 16:03:43 -0700439 MutexLock mu(self, *Locks::thread_list_lock_);
440 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700441 // Update global suspend all state for attaching threads.
442 --suspend_all_count_;
443 // Decrement the suspend counts for all threads.
Mathieu Chartier02e25112013-08-14 16:14:24 -0700444 for (const auto& thread : list_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700445 if (thread == self) {
446 continue;
447 }
Ian Rogers01ae5802012-09-28 16:14:01 -0700448 thread->ModifySuspendCount(self, -1, false);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700449 }
450
451 // Broadcast a notification to all suspended threads, some or all of
452 // which may choose to wake up. No need to wait for them.
Jeff Haoc5d824a2014-07-28 18:35:38 -0700453 if (self != nullptr) {
454 VLOG(threads) << *self << " ResumeAll waking others";
455 } else {
456 VLOG(threads) << "Thread[null] ResumeAll waking others";
457 }
Ian Rogersc604d732012-10-14 16:09:54 -0700458 Thread::resume_cond_->Broadcast(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700459 }
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700460 ATRACE_END();
Jeff Haoc5d824a2014-07-28 18:35:38 -0700461
462 if (self != nullptr) {
463 VLOG(threads) << *self << " ResumeAll complete";
464 } else {
465 VLOG(threads) << "Thread[null] ResumeAll complete";
466 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700467}
468
469void ThreadList::Resume(Thread* thread, bool for_debugger) {
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -0800470 // This assumes there was an ATRACE_BEGIN when we suspended the thread.
471 ATRACE_END();
472
Ian Rogers81d425b2012-09-27 16:03:43 -0700473 Thread* self = Thread::Current();
474 DCHECK_NE(thread, self);
Brian Carlstromba32de42014-08-27 23:43:46 -0700475 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") starting..."
476 << (for_debugger ? " (debugger)" : "");
Elliott Hughes01158d72011-09-19 19:47:10 -0700477
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700478 {
479 // To check Contains.
Ian Rogers81d425b2012-09-27 16:03:43 -0700480 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700481 // To check IsSuspended.
Ian Rogers81d425b2012-09-27 16:03:43 -0700482 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
483 DCHECK(thread->IsSuspended());
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700484 if (!Contains(thread)) {
Brian Carlstromba32de42014-08-27 23:43:46 -0700485 // We only expect threads within the thread-list to have been suspended otherwise we can't
486 // stop such threads from delete-ing themselves.
487 LOG(ERROR) << "Resume(" << reinterpret_cast<void*>(thread)
488 << ") thread not within thread list";
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700489 return;
490 }
Ian Rogers01ae5802012-09-28 16:14:01 -0700491 thread->ModifySuspendCount(self, -1, for_debugger);
Elliott Hughes01158d72011-09-19 19:47:10 -0700492 }
493
494 {
Brian Carlstromba32de42014-08-27 23:43:46 -0700495 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") waking others";
Ian Rogers81d425b2012-09-27 16:03:43 -0700496 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersc604d732012-10-14 16:09:54 -0700497 Thread::resume_cond_->Broadcast(self);
Elliott Hughes01158d72011-09-19 19:47:10 -0700498 }
499
Brian Carlstromba32de42014-08-27 23:43:46 -0700500 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") complete";
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700501}
Elliott Hughes01158d72011-09-19 19:47:10 -0700502
Ian Rogersc7dd2952014-10-21 23:31:19 -0700503static void ThreadSuspendByPeerWarning(Thread* self, LogSeverity severity, const char* message,
504 jobject peer) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700505 JNIEnvExt* env = self->GetJniEnv();
506 ScopedLocalRef<jstring>
507 scoped_name_string(env, (jstring)env->GetObjectField(peer,
508 WellKnownClasses::java_lang_Thread_name));
509 ScopedUtfChars scoped_name_chars(env, scoped_name_string.get());
510 if (scoped_name_chars.c_str() == NULL) {
Ian Rogersc7dd2952014-10-21 23:31:19 -0700511 LOG(severity) << message << ": " << peer;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700512 env->ExceptionClear();
513 } else {
Ian Rogersc7dd2952014-10-21 23:31:19 -0700514 LOG(severity) << message << ": " << peer << ":" << scoped_name_chars.c_str();
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700515 }
516}
517
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700518Thread* ThreadList::SuspendThreadByPeer(jobject peer, bool request_suspension,
519 bool debug_suspension, bool* timed_out) {
520 static const useconds_t kTimeoutUs = 30 * 1000000; // 30s.
521 useconds_t total_delay_us = 0;
522 useconds_t delay_us = 0;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700523 *timed_out = false;
524 Thread* self = Thread::Current();
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800525 Thread* suspended_thread = nullptr;
Brian Carlstromba32de42014-08-27 23:43:46 -0700526 VLOG(threads) << "SuspendThreadByPeer starting";
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700527 while (true) {
528 Thread* thread;
529 {
Ian Rogersf3d874c2014-07-17 18:52:42 -0700530 // Note: this will transition to runnable and potentially suspend. We ensure only one thread
531 // is requesting another suspend, to avoid deadlock, by requiring this function be called
532 // holding Locks::thread_list_suspend_thread_lock_. Its important this thread suspend rather
533 // than request thread suspension, to avoid potential cycles in threads requesting each other
534 // suspend.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700535 ScopedObjectAccess soa(self);
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800536 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700537 thread = Thread::FromManagedThread(soa, peer);
Brian Carlstromba32de42014-08-27 23:43:46 -0700538 if (thread == nullptr) {
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800539 if (suspended_thread != nullptr) {
540 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
541 // If we incremented the suspend count but the thread reset its peer, we need to
542 // re-decrement it since it is shutting down and may deadlock the runtime in
543 // ThreadList::WaitForOtherNonDaemonThreadsToExit.
544 suspended_thread->ModifySuspendCount(soa.Self(), -1, debug_suspension);
545 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700546 ThreadSuspendByPeerWarning(self, WARNING, "No such thread for suspend", peer);
Brian Carlstromba32de42014-08-27 23:43:46 -0700547 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700548 }
Brian Carlstromba32de42014-08-27 23:43:46 -0700549 if (!Contains(thread)) {
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800550 CHECK(suspended_thread == nullptr);
Brian Carlstromba32de42014-08-27 23:43:46 -0700551 VLOG(threads) << "SuspendThreadByPeer failed for unattached thread: "
552 << reinterpret_cast<void*>(thread);
553 return nullptr;
554 }
555 VLOG(threads) << "SuspendThreadByPeer found thread: " << *thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700556 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800557 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700558 if (request_suspension) {
Ian Rogers4ad5cd32014-11-11 23:08:07 -0800559 if (self->GetSuspendCount() > 0) {
560 // We hold the suspend count lock but another thread is trying to suspend us. Its not
561 // safe to try to suspend another thread in case we get a cycle. Start the loop again
562 // which will allow this thread to be suspended.
563 continue;
564 }
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800565 CHECK(suspended_thread == nullptr);
566 suspended_thread = thread;
567 suspended_thread->ModifySuspendCount(self, +1, debug_suspension);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700568 request_suspension = false;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700569 } else {
570 // If the caller isn't requesting suspension, a suspension should have already occurred.
571 CHECK_GT(thread->GetSuspendCount(), 0);
572 }
573 // IsSuspended on the current thread will fail as the current thread is changed into
574 // Runnable above. As the suspend count is now raised if this is the current thread
575 // it will self suspend on transition to Runnable, making it hard to work with. It's simpler
576 // to just explicitly handle the current thread in the callers to this code.
577 CHECK_NE(thread, self) << "Attempt to suspend the current thread for the debugger";
578 // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend
579 // count, or else we've waited and it has self suspended) or is the current thread, we're
580 // done.
581 if (thread->IsSuspended()) {
Brian Carlstromba32de42014-08-27 23:43:46 -0700582 VLOG(threads) << "SuspendThreadByPeer thread suspended: " << *thread;
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -0800583 if (ATRACE_ENABLED()) {
584 std::string name;
585 thread->GetThreadName(name);
586 ATRACE_BEGIN(StringPrintf("SuspendThreadByPeer suspended %s for peer=%p", name.c_str(),
587 peer).c_str());
588 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700589 return thread;
590 }
591 if (total_delay_us >= kTimeoutUs) {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700592 ThreadSuspendByPeerWarning(self, FATAL, "Thread suspension timed out", peer);
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800593 if (suspended_thread != nullptr) {
594 CHECK_EQ(suspended_thread, thread);
595 suspended_thread->ModifySuspendCount(soa.Self(), -1, debug_suspension);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700596 }
597 *timed_out = true;
Brian Carlstromba32de42014-08-27 23:43:46 -0700598 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700599 }
600 }
601 // Release locks and come out of runnable state.
602 }
Brian Carlstromba32de42014-08-27 23:43:46 -0700603 VLOG(threads) << "SuspendThreadByPeer sleeping to allow thread chance to suspend";
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700604 ThreadSuspendSleep(&delay_us, &total_delay_us);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700605 }
606}
607
Ian Rogersc7dd2952014-10-21 23:31:19 -0700608static void ThreadSuspendByThreadIdWarning(LogSeverity severity, const char* message,
609 uint32_t thread_id) {
610 LOG(severity) << StringPrintf("%s: %d", message, thread_id);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700611}
612
613Thread* ThreadList::SuspendThreadByThreadId(uint32_t thread_id, bool debug_suspension,
614 bool* timed_out) {
615 static const useconds_t kTimeoutUs = 30 * 1000000; // 30s.
616 useconds_t total_delay_us = 0;
617 useconds_t delay_us = 0;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700618 *timed_out = false;
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800619 Thread* suspended_thread = nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700620 Thread* self = Thread::Current();
621 CHECK_NE(thread_id, kInvalidThreadId);
Brian Carlstromba32de42014-08-27 23:43:46 -0700622 VLOG(threads) << "SuspendThreadByThreadId starting";
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700623 while (true) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700624 {
Ian Rogersf3d874c2014-07-17 18:52:42 -0700625 // Note: this will transition to runnable and potentially suspend. We ensure only one thread
626 // is requesting another suspend, to avoid deadlock, by requiring this function be called
627 // holding Locks::thread_list_suspend_thread_lock_. Its important this thread suspend rather
628 // than request thread suspension, to avoid potential cycles in threads requesting each other
629 // suspend.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700630 ScopedObjectAccess soa(self);
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800631 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Ian Rogersf3d874c2014-07-17 18:52:42 -0700632 Thread* thread = nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700633 for (const auto& it : list_) {
634 if (it->GetThreadId() == thread_id) {
635 thread = it;
636 break;
637 }
638 }
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800639 if (thread == nullptr) {
640 CHECK(suspended_thread == nullptr) << "Suspended thread " << suspended_thread
641 << " no longer in thread list";
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700642 // There's a race in inflating a lock and the owner giving up ownership and then dying.
643 ThreadSuspendByThreadIdWarning(WARNING, "No such thread id for suspend", thread_id);
Brian Carlstromba32de42014-08-27 23:43:46 -0700644 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700645 }
Brian Carlstromba32de42014-08-27 23:43:46 -0700646 VLOG(threads) << "SuspendThreadByThreadId found thread: " << *thread;
647 DCHECK(Contains(thread));
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700648 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800649 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800650 if (suspended_thread == nullptr) {
Ian Rogers4ad5cd32014-11-11 23:08:07 -0800651 if (self->GetSuspendCount() > 0) {
652 // We hold the suspend count lock but another thread is trying to suspend us. Its not
653 // safe to try to suspend another thread in case we get a cycle. Start the loop again
654 // which will allow this thread to be suspended.
655 continue;
656 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700657 thread->ModifySuspendCount(self, +1, debug_suspension);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800658 suspended_thread = thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700659 } else {
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800660 CHECK_EQ(suspended_thread, thread);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700661 // If the caller isn't requesting suspension, a suspension should have already occurred.
662 CHECK_GT(thread->GetSuspendCount(), 0);
663 }
664 // IsSuspended on the current thread will fail as the current thread is changed into
665 // Runnable above. As the suspend count is now raised if this is the current thread
666 // it will self suspend on transition to Runnable, making it hard to work with. It's simpler
667 // to just explicitly handle the current thread in the callers to this code.
668 CHECK_NE(thread, self) << "Attempt to suspend the current thread for the debugger";
669 // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend
670 // count, or else we've waited and it has self suspended) or is the current thread, we're
671 // done.
672 if (thread->IsSuspended()) {
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -0800673 if (ATRACE_ENABLED()) {
674 std::string name;
675 thread->GetThreadName(name);
676 ATRACE_BEGIN(StringPrintf("SuspendThreadByThreadId suspended %s id=%d",
677 name.c_str(), thread_id).c_str());
678 }
Brian Carlstromba32de42014-08-27 23:43:46 -0700679 VLOG(threads) << "SuspendThreadByThreadId thread suspended: " << *thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700680 return thread;
681 }
682 if (total_delay_us >= kTimeoutUs) {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700683 ThreadSuspendByThreadIdWarning(WARNING, "Thread suspension timed out", thread_id);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800684 if (suspended_thread != nullptr) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700685 thread->ModifySuspendCount(soa.Self(), -1, debug_suspension);
686 }
687 *timed_out = true;
Brian Carlstromba32de42014-08-27 23:43:46 -0700688 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700689 }
690 }
691 // Release locks and come out of runnable state.
692 }
Brian Carlstromba32de42014-08-27 23:43:46 -0700693 VLOG(threads) << "SuspendThreadByThreadId sleeping to allow thread chance to suspend";
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700694 ThreadSuspendSleep(&delay_us, &total_delay_us);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700695 }
696}
697
698Thread* ThreadList::FindThreadByThreadId(uint32_t thin_lock_id) {
699 Thread* self = Thread::Current();
700 MutexLock mu(self, *Locks::thread_list_lock_);
701 for (const auto& thread : list_) {
702 if (thread->GetThreadId() == thin_lock_id) {
703 CHECK(thread == self || thread->IsSuspended());
704 return thread;
705 }
706 }
707 return NULL;
708}
709
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700710void ThreadList::SuspendAllForDebugger() {
711 Thread* self = Thread::Current();
712 Thread* debug_thread = Dbg::GetDebugThread();
713
714 VLOG(threads) << *self << " SuspendAllForDebugger starting...";
715
716 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800717 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700718 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800719 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700720 // Update global suspend all state for attaching threads.
Sebastien Hertz253fa552014-10-14 17:27:15 +0200721 DCHECK_GE(suspend_all_count_, debug_suspend_all_count_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700722 ++suspend_all_count_;
723 ++debug_suspend_all_count_;
724 // Increment everybody's suspend count (except our own).
Mathieu Chartier02e25112013-08-14 16:14:24 -0700725 for (const auto& thread : list_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700726 if (thread == self || thread == debug_thread) {
727 continue;
728 }
729 VLOG(threads) << "requesting thread suspend: " << *thread;
Ian Rogers01ae5802012-09-28 16:14:01 -0700730 thread->ModifySuspendCount(self, +1, true);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700731 }
732 }
733 }
734
Ian Rogers66aee5c2012-08-15 17:17:47 -0700735 // Block on the mutator lock until all Runnable threads release their share of access then
736 // immediately unlock again.
737#if HAVE_TIMED_RWLOCK
738 // Timeout if we wait more than 30 seconds.
Ian Rogersc604d732012-10-14 16:09:54 -0700739 if (!Locks::mutator_lock_->ExclusiveLockWithTimeout(self, 30 * 1000, 0)) {
Sebastien Hertzbae182c2013-12-17 10:42:03 +0100740 UnsafeLogFatalForThreadSuspendAllTimeout();
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700741 } else {
Ian Rogers81d425b2012-09-27 16:03:43 -0700742 Locks::mutator_lock_->ExclusiveUnlock(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700743 }
Ian Rogers66aee5c2012-08-15 17:17:47 -0700744#else
Ian Rogers81d425b2012-09-27 16:03:43 -0700745 Locks::mutator_lock_->ExclusiveLock(self);
746 Locks::mutator_lock_->ExclusiveUnlock(self);
Ian Rogers66aee5c2012-08-15 17:17:47 -0700747#endif
Ian Rogers50b35e22012-10-04 10:09:15 -0700748 AssertThreadsAreSuspended(self, self, debug_thread);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700749
Sebastien Hertzed2be172014-08-19 15:33:43 +0200750 VLOG(threads) << *self << " SuspendAllForDebugger complete";
Elliott Hughes01158d72011-09-19 19:47:10 -0700751}
752
Elliott Hughes475fc232011-10-25 15:00:35 -0700753void ThreadList::SuspendSelfForDebugger() {
754 Thread* self = Thread::Current();
Elliott Hughes01158d72011-09-19 19:47:10 -0700755
Elliott Hughes475fc232011-10-25 15:00:35 -0700756 // The debugger thread must not suspend itself due to debugger activity!
757 Thread* debug_thread = Dbg::GetDebugThread();
758 CHECK(debug_thread != NULL);
759 CHECK(self != debug_thread);
jeffhaoa77f0f62012-12-05 17:19:31 -0800760 CHECK_NE(self->GetState(), kRunnable);
761 Locks::mutator_lock_->AssertNotHeld(self);
Elliott Hughes475fc232011-10-25 15:00:35 -0700762
jeffhaoa77f0f62012-12-05 17:19:31 -0800763 {
764 // Collisions with other suspends aren't really interesting. We want
765 // to ensure that we're the only one fiddling with the suspend count
766 // though.
767 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
768 self->ModifySuspendCount(self, +1, true);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700769 CHECK_GT(self->GetSuspendCount(), 0);
jeffhaoa77f0f62012-12-05 17:19:31 -0800770 }
Elliott Hughes475fc232011-10-25 15:00:35 -0700771
Elliott Hughes1f729aa2012-03-02 13:55:41 -0800772 VLOG(threads) << *self << " self-suspending (debugger)";
Elliott Hughes475fc232011-10-25 15:00:35 -0700773
Sebastien Hertz21e729c2014-02-18 14:16:00 +0100774 // Tell JDWP we've completed invocation and are ready to suspend.
775 DebugInvokeReq* pReq = self->GetInvokeReq();
776 DCHECK(pReq != NULL);
777 if (pReq->invoke_needed) {
778 // Clear this before signaling.
Sebastien Hertzbb43b432014-04-14 11:59:08 +0200779 pReq->Clear();
Sebastien Hertz21e729c2014-02-18 14:16:00 +0100780
781 VLOG(jdwp) << "invoke complete, signaling";
782 MutexLock mu(self, pReq->lock);
783 pReq->cond.Signal(self);
784 }
785
Elliott Hughes475fc232011-10-25 15:00:35 -0700786 // Tell JDWP that we've completed suspension. The JDWP thread can't
787 // tell us to resume before we're fully asleep because we hold the
788 // suspend count lock.
789 Dbg::ClearWaitForEventThread();
790
jeffhaoa77f0f62012-12-05 17:19:31 -0800791 {
792 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700793 while (self->GetSuspendCount() != 0) {
jeffhaoa77f0f62012-12-05 17:19:31 -0800794 Thread::resume_cond_->Wait(self);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700795 if (self->GetSuspendCount() != 0) {
jeffhaoa77f0f62012-12-05 17:19:31 -0800796 // The condition was signaled but we're still suspended. This
Sebastien Hertzf272af42014-09-18 10:20:42 +0200797 // can happen when we suspend then resume all threads to
798 // update instrumentation or compute monitor info. This can
799 // also happen if the debugger lets go while a SIGQUIT thread
jeffhaoa77f0f62012-12-05 17:19:31 -0800800 // dump event is pending (assuming SignalCatcher was resumed for
801 // just long enough to try to grab the thread-suspend lock).
Sebastien Hertzf272af42014-09-18 10:20:42 +0200802 VLOG(jdwp) << *self << " still suspended after undo "
803 << "(suspend count=" << self->GetSuspendCount() << ", "
804 << "debug suspend count=" << self->GetDebugSuspendCount() << ")";
jeffhaoa77f0f62012-12-05 17:19:31 -0800805 }
Elliott Hughes475fc232011-10-25 15:00:35 -0700806 }
Ian Rogersdd7624d2014-03-14 17:43:00 -0700807 CHECK_EQ(self->GetSuspendCount(), 0);
Elliott Hughes475fc232011-10-25 15:00:35 -0700808 }
jeffhaoa77f0f62012-12-05 17:19:31 -0800809
Elliott Hughes1f729aa2012-03-02 13:55:41 -0800810 VLOG(threads) << *self << " self-reviving (debugger)";
Elliott Hughes475fc232011-10-25 15:00:35 -0700811}
812
Sebastien Hertz253fa552014-10-14 17:27:15 +0200813void ThreadList::ResumeAllForDebugger() {
814 Thread* self = Thread::Current();
815 Thread* debug_thread = Dbg::GetDebugThread();
Sebastien Hertz253fa552014-10-14 17:27:15 +0200816
817 VLOG(threads) << *self << " ResumeAllForDebugger starting...";
818
819 // Threads can't resume if we exclusively hold the mutator lock.
820 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
821
822 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800823 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Sebastien Hertz253fa552014-10-14 17:27:15 +0200824 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800825 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Sebastien Hertz253fa552014-10-14 17:27:15 +0200826 // Update global suspend all state for attaching threads.
827 DCHECK_GE(suspend_all_count_, debug_suspend_all_count_);
Sebastien Hertzf9d233d2015-01-09 14:51:41 +0100828 if (debug_suspend_all_count_ > 0) {
Sebastien Hertz253fa552014-10-14 17:27:15 +0200829 --suspend_all_count_;
830 --debug_suspend_all_count_;
Sebastien Hertz253fa552014-10-14 17:27:15 +0200831 } else {
832 // We've been asked to resume all threads without being asked to
Sebastien Hertzf9d233d2015-01-09 14:51:41 +0100833 // suspend them all before. That may happen if a debugger tries
834 // to resume some suspended threads (with suspend count == 1)
835 // at once with a VirtualMachine.Resume command. Let's print a
836 // warning.
Sebastien Hertz253fa552014-10-14 17:27:15 +0200837 LOG(WARNING) << "Debugger attempted to resume all threads without "
838 << "having suspended them all before.";
839 }
Sebastien Hertzf9d233d2015-01-09 14:51:41 +0100840 // Decrement everybody's suspend count (except our own).
841 for (const auto& thread : list_) {
842 if (thread == self || thread == debug_thread) {
843 continue;
844 }
845 if (thread->GetDebugSuspendCount() == 0) {
846 // This thread may have been individually resumed with ThreadReference.Resume.
847 continue;
848 }
849 VLOG(threads) << "requesting thread resume: " << *thread;
850 thread->ModifySuspendCount(self, -1, true);
851 }
Sebastien Hertz253fa552014-10-14 17:27:15 +0200852 }
853 }
854
Sebastien Hertzf9d233d2015-01-09 14:51:41 +0100855 {
Sebastien Hertz253fa552014-10-14 17:27:15 +0200856 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
857 Thread::resume_cond_->Broadcast(self);
858 }
859
860 VLOG(threads) << *self << " ResumeAllForDebugger complete";
861}
862
Elliott Hughes234ab152011-10-26 14:02:26 -0700863void ThreadList::UndoDebuggerSuspensions() {
864 Thread* self = Thread::Current();
865
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800866 VLOG(threads) << *self << " UndoDebuggerSuspensions starting";
Elliott Hughes234ab152011-10-26 14:02:26 -0700867
868 {
Ian Rogers81d425b2012-09-27 16:03:43 -0700869 MutexLock mu(self, *Locks::thread_list_lock_);
870 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700871 // Update global suspend all state for attaching threads.
872 suspend_all_count_ -= debug_suspend_all_count_;
873 debug_suspend_all_count_ = 0;
874 // Update running threads.
Mathieu Chartier02e25112013-08-14 16:14:24 -0700875 for (const auto& thread : list_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700876 if (thread == self || thread->GetDebugSuspendCount() == 0) {
Elliott Hughes234ab152011-10-26 14:02:26 -0700877 continue;
878 }
Ian Rogersdd7624d2014-03-14 17:43:00 -0700879 thread->ModifySuspendCount(self, -thread->GetDebugSuspendCount(), true);
Elliott Hughes234ab152011-10-26 14:02:26 -0700880 }
881 }
882
883 {
Ian Rogers81d425b2012-09-27 16:03:43 -0700884 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersc604d732012-10-14 16:09:54 -0700885 Thread::resume_cond_->Broadcast(self);
Elliott Hughes234ab152011-10-26 14:02:26 -0700886 }
887
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800888 VLOG(threads) << "UndoDebuggerSuspensions(" << *self << ") complete";
Elliott Hughes234ab152011-10-26 14:02:26 -0700889}
890
Elliott Hughese52e49b2012-04-02 16:05:44 -0700891void ThreadList::WaitForOtherNonDaemonThreadsToExit() {
Ian Rogers81d425b2012-09-27 16:03:43 -0700892 Thread* self = Thread::Current();
893 Locks::mutator_lock_->AssertNotHeld(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700894 bool all_threads_are_daemons;
895 do {
Ian Rogers120f1c72012-09-28 17:17:10 -0700896 {
897 // No more threads can be born after we start to shutdown.
898 MutexLock mu(self, *Locks::runtime_shutdown_lock_);
Mathieu Chartier590fee92013-09-13 13:46:47 -0700899 CHECK(Runtime::Current()->IsShuttingDownLocked());
Ian Rogers120f1c72012-09-28 17:17:10 -0700900 CHECK_EQ(Runtime::Current()->NumberOfThreadsBeingBorn(), 0U);
901 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700902 all_threads_are_daemons = true;
Ian Rogers120f1c72012-09-28 17:17:10 -0700903 MutexLock mu(self, *Locks::thread_list_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -0700904 for (const auto& thread : list_) {
Anwar Ghuloum97543682013-06-14 12:58:16 -0700905 if (thread != self && !thread->IsDaemon()) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700906 all_threads_are_daemons = false;
907 break;
908 }
909 }
910 if (!all_threads_are_daemons) {
911 // Wait for another thread to exit before re-checking.
Ian Rogersc604d732012-10-14 16:09:54 -0700912 thread_exit_cond_.Wait(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700913 }
Brian Carlstromdf629502013-07-17 22:39:56 -0700914 } while (!all_threads_are_daemons);
Elliott Hughes038a8062011-09-18 14:12:41 -0700915}
916
917void ThreadList::SuspendAllDaemonThreads() {
Ian Rogers81d425b2012-09-27 16:03:43 -0700918 Thread* self = Thread::Current();
919 MutexLock mu(self, *Locks::thread_list_lock_);
Brian Carlstrom7934ac22013-07-26 10:54:15 -0700920 { // Tell all the daemons it's time to suspend.
Ian Rogers81d425b2012-09-27 16:03:43 -0700921 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -0700922 for (const auto& thread : list_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700923 // This is only run after all non-daemon threads have exited, so the remainder should all be
924 // daemons.
Ian Rogers7e762862012-10-22 15:45:08 -0700925 CHECK(thread->IsDaemon()) << *thread;
Ian Rogers81d425b2012-09-27 16:03:43 -0700926 if (thread != self) {
Ian Rogers01ae5802012-09-28 16:14:01 -0700927 thread->ModifySuspendCount(self, +1, false);
Elliott Hughese52e49b2012-04-02 16:05:44 -0700928 }
Elliott Hughes038a8062011-09-18 14:12:41 -0700929 }
930 }
Elliott Hughes038a8062011-09-18 14:12:41 -0700931 // Give the threads a chance to suspend, complaining if they're slow.
932 bool have_complained = false;
933 for (int i = 0; i < 10; ++i) {
934 usleep(200 * 1000);
935 bool all_suspended = true;
Mathieu Chartier02e25112013-08-14 16:14:24 -0700936 for (const auto& thread : list_) {
Ian Rogers81d425b2012-09-27 16:03:43 -0700937 if (thread != self && thread->GetState() == kRunnable) {
Elliott Hughes038a8062011-09-18 14:12:41 -0700938 if (!have_complained) {
939 LOG(WARNING) << "daemon thread not yet suspended: " << *thread;
940 have_complained = true;
941 }
942 all_suspended = false;
943 }
944 }
945 if (all_suspended) {
946 return;
947 }
948 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700949 LOG(ERROR) << "suspend all daemons failed";
950}
951void ThreadList::Register(Thread* self) {
952 DCHECK_EQ(self, Thread::Current());
953
954 if (VLOG_IS_ON(threads)) {
955 std::ostringstream oss;
956 self->ShortDump(oss); // We don't hold the mutator_lock_ yet and so cannot call Dump.
Ian Rogers5a9ba012014-05-19 13:28:52 -0700957 LOG(INFO) << "ThreadList::Register() " << *self << "\n" << oss.str();
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700958 }
959
960 // Atomically add self to the thread list and make its thread_suspend_count_ reflect ongoing
961 // SuspendAll requests.
Ian Rogers81d425b2012-09-27 16:03:43 -0700962 MutexLock mu(self, *Locks::thread_list_lock_);
963 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700964 CHECK_GE(suspend_all_count_, debug_suspend_all_count_);
Ian Rogers2966e132014-04-02 08:34:36 -0700965 // Modify suspend count in increments of 1 to maintain invariants in ModifySuspendCount. While
966 // this isn't particularly efficient the suspend counts are most commonly 0 or 1.
967 for (int delta = debug_suspend_all_count_; delta > 0; delta--) {
968 self->ModifySuspendCount(self, +1, true);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700969 }
Ian Rogers2966e132014-04-02 08:34:36 -0700970 for (int delta = suspend_all_count_ - debug_suspend_all_count_; delta > 0; delta--) {
971 self->ModifySuspendCount(self, +1, false);
Ian Rogers01ae5802012-09-28 16:14:01 -0700972 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700973 CHECK(!Contains(self));
974 list_.push_back(self);
975}
976
977void ThreadList::Unregister(Thread* self) {
978 DCHECK_EQ(self, Thread::Current());
Ian Rogers68d8b422014-07-17 11:09:10 -0700979 CHECK_NE(self->GetState(), kRunnable);
980 Locks::mutator_lock_->AssertNotHeld(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700981
982 VLOG(threads) << "ThreadList::Unregister() " << *self;
983
984 // Any time-consuming destruction, plus anything that can call back into managed code or
985 // suspend and so on, must happen at this point, and not in ~Thread.
986 self->Destroy();
987
Jeff Haoe094b872014-10-14 13:12:01 -0700988 // If tracing, remember thread id and name before thread exits.
989 Trace::StoreExitingThreadInfo(self);
990
Ian Rogersdd7624d2014-03-14 17:43:00 -0700991 uint32_t thin_lock_id = self->GetThreadId();
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800992 while (self != nullptr) {
Ian Rogerscfaa4552012-11-26 21:00:08 -0800993 // Remove and delete the Thread* while holding the thread_list_lock_ and
994 // thread_suspend_count_lock_ so that the unregistering thread cannot be suspended.
Ian Rogers0878d652013-04-18 17:38:35 -0700995 // Note: deliberately not using MutexLock that could hold a stale self pointer.
996 Locks::thread_list_lock_->ExclusiveLock(self);
Ian Rogersa2af5c72014-09-15 15:17:07 -0700997 bool removed = true;
998 if (!Contains(self)) {
999 std::ostringstream os;
1000 DumpNativeStack(os, GetTid(), " native: ", nullptr);
1001 LOG(ERROR) << "Request to unregister unattached thread\n" << os.str();
1002 } else {
1003 Locks::thread_suspend_count_lock_->ExclusiveLock(self);
1004 if (!self->IsSuspended()) {
1005 list_.remove(self);
1006 } else {
1007 // We failed to remove the thread due to a suspend request, loop and try again.
1008 removed = false;
1009 }
1010 Locks::thread_suspend_count_lock_->ExclusiveUnlock(self);
Ian Rogers68d8b422014-07-17 11:09:10 -07001011 }
Ian Rogers68d8b422014-07-17 11:09:10 -07001012 Locks::thread_list_lock_->ExclusiveUnlock(self);
1013 if (removed) {
Ian Rogerscfaa4552012-11-26 21:00:08 -08001014 delete self;
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -08001015 self = nullptr;
Ian Rogerscfaa4552012-11-26 21:00:08 -08001016 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001017 }
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -08001018 // Release the thread ID after the thread is finished and deleted to avoid cases where we can
1019 // temporarily have multiple threads with the same thread id. When this occurs, it causes
1020 // problems in FindThreadByThreadId / SuspendThreadByThreadId.
1021 ReleaseThreadId(nullptr, thin_lock_id);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001022
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001023 // Clear the TLS data, so that the underlying native thread is recognizably detached.
1024 // (It may wish to reattach later.)
1025 CHECK_PTHREAD_CALL(pthread_setspecific, (Thread::pthread_key_self_, NULL), "detach self");
1026
1027 // Signal that a thread just detached.
Ian Rogers81d425b2012-09-27 16:03:43 -07001028 MutexLock mu(NULL, *Locks::thread_list_lock_);
Ian Rogersc604d732012-10-14 16:09:54 -07001029 thread_exit_cond_.Signal(NULL);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001030}
1031
1032void ThreadList::ForEach(void (*callback)(Thread*, void*), void* context) {
Mathieu Chartier02e25112013-08-14 16:14:24 -07001033 for (const auto& thread : list_) {
1034 callback(thread, context);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001035 }
1036}
1037
Mathieu Chartier83c8ee02014-01-28 14:50:23 -08001038void ThreadList::VisitRoots(RootCallback* callback, void* arg) const {
Ian Rogers81d425b2012-09-27 16:03:43 -07001039 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001040 for (const auto& thread : list_) {
Mathieu Chartier83c8ee02014-01-28 14:50:23 -08001041 thread->VisitRoots(callback, arg);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001042 }
Elliott Hughes038a8062011-09-18 14:12:41 -07001043}
1044
Mathieu Chartier83c8ee02014-01-28 14:50:23 -08001045class VerifyRootWrapperArg {
1046 public:
1047 VerifyRootWrapperArg(VerifyRootCallback* callback, void* arg) : callback_(callback), arg_(arg) {
1048 }
1049 VerifyRootCallback* const callback_;
1050 void* const arg_;
Mathieu Chartier423d2a32013-09-12 17:33:56 -07001051};
1052
Mathieu Chartier815873e2014-02-13 18:02:13 -08001053static void VerifyRootWrapperCallback(mirror::Object** root, void* arg, uint32_t /*thread_id*/,
Mathieu Chartier7bf9f192014-04-04 11:09:41 -07001054 RootType root_type) {
Mathieu Chartier423d2a32013-09-12 17:33:56 -07001055 VerifyRootWrapperArg* wrapperArg = reinterpret_cast<VerifyRootWrapperArg*>(arg);
Mathieu Chartier7bf9f192014-04-04 11:09:41 -07001056 wrapperArg->callback_(*root, wrapperArg->arg_, 0, NULL, root_type);
Mathieu Chartier423d2a32013-09-12 17:33:56 -07001057}
1058
Mathieu Chartier83c8ee02014-01-28 14:50:23 -08001059void ThreadList::VerifyRoots(VerifyRootCallback* callback, void* arg) const {
1060 VerifyRootWrapperArg wrapper(callback, arg);
Mathieu Chartier6f1c9492012-10-15 12:08:41 -07001061 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001062 for (const auto& thread : list_) {
Mathieu Chartier423d2a32013-09-12 17:33:56 -07001063 thread->VisitRoots(VerifyRootWrapperCallback, &wrapper);
Mathieu Chartier6f1c9492012-10-15 12:08:41 -07001064 }
1065}
1066
Ian Rogerscfaa4552012-11-26 21:00:08 -08001067uint32_t ThreadList::AllocThreadId(Thread* self) {
Chao-ying Fu9e369312014-05-21 11:20:52 -07001068 MutexLock mu(self, *Locks::allocated_thread_ids_lock_);
Elliott Hughes8daa0922011-09-11 13:46:25 -07001069 for (size_t i = 0; i < allocated_ids_.size(); ++i) {
1070 if (!allocated_ids_[i]) {
1071 allocated_ids_.set(i);
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001072 return i + 1; // Zero is reserved to mean "invalid".
Elliott Hughes8daa0922011-09-11 13:46:25 -07001073 }
1074 }
1075 LOG(FATAL) << "Out of internal thread ids";
1076 return 0;
1077}
1078
Ian Rogerscfaa4552012-11-26 21:00:08 -08001079void ThreadList::ReleaseThreadId(Thread* self, uint32_t id) {
Chao-ying Fu9e369312014-05-21 11:20:52 -07001080 MutexLock mu(self, *Locks::allocated_thread_ids_lock_);
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001081 --id; // Zero is reserved to mean "invalid".
Elliott Hughes8daa0922011-09-11 13:46:25 -07001082 DCHECK(allocated_ids_[id]) << id;
1083 allocated_ids_.reset(id);
1084}
1085
Elliott Hughes8daa0922011-09-11 13:46:25 -07001086} // namespace art