blob: 5ff90d6392c0334195134750f4f5172921437b14 [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
Elliott Hughes76b61672012-12-12 17:47:30 -080030#include "base/mutex.h"
Hiroshi Yamauchi967a0ad2013-09-10 16:24:21 -070031#include "base/mutex-inl.h"
Sameer Abu Asala8439542013-02-14 16:06:42 -080032#include "base/timing_logger.h"
Elliott Hughes475fc232011-10-25 15:00:35 -070033#include "debugger.h"
Ian Rogersd9c4fc92013-10-01 19:45:43 -070034#include "jni_internal.h"
35#include "lock_word.h"
36#include "monitor.h"
37#include "scoped_thread_state_change.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080038#include "thread.h"
Jeff Haoe094b872014-10-14 13:12:01 -070039#include "trace.h"
Elliott Hughesabbe07d2012-06-05 17:42:23 -070040#include "utils.h"
Ian Rogersd9c4fc92013-10-01 19:45:43 -070041#include "well_known_classes.h"
Elliott Hughes475fc232011-10-25 15:00:35 -070042
Elliott Hughes8daa0922011-09-11 13:46:25 -070043namespace art {
44
Mathieu Chartier251755c2014-07-15 18:10:25 -070045static constexpr uint64_t kLongThreadSuspendThreshold = MsToNs(5);
46
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -080047ThreadList::ThreadList()
Chao-ying Fu9e369312014-05-21 11:20:52 -070048 : suspend_all_count_(0), debug_suspend_all_count_(0),
Ian Rogersc604d732012-10-14 16:09:54 -070049 thread_exit_cond_("thread exit condition variable", *Locks::thread_list_lock_) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -070050 CHECK(Monitor::IsValidLockWord(LockWord::FromThinLockId(kMaxThreadId, 1)));
Elliott Hughes8daa0922011-09-11 13:46:25 -070051}
52
53ThreadList::~ThreadList() {
Elliott Hughese52e49b2012-04-02 16:05:44 -070054 // Detach the current thread if necessary. If we failed to start, there might not be any threads.
Elliott Hughes6a144332012-04-03 13:07:11 -070055 // We need to detach the current thread here in case there's another thread waiting to join with
56 // us.
Mathieu Chartierfec72f42014-10-09 12:57:58 -070057 bool contains = false;
58 {
59 Thread* self = Thread::Current();
60 MutexLock mu(self, *Locks::thread_list_lock_);
61 contains = Contains(self);
62 }
63 if (contains) {
Elliott Hughes8daa0922011-09-11 13:46:25 -070064 Runtime::Current()->DetachCurrentThread();
65 }
Elliott Hughes6a144332012-04-03 13:07:11 -070066
67 WaitForOtherNonDaemonThreadsToExit();
Ian Rogers00f7d0e2012-07-19 15:28:27 -070068 // TODO: there's an unaddressed race here where a thread may attach during shutdown, see
69 // Thread::Init.
Elliott Hughes6a144332012-04-03 13:07:11 -070070 SuspendAllDaemonThreads();
Elliott Hughes8daa0922011-09-11 13:46:25 -070071}
72
73bool ThreadList::Contains(Thread* thread) {
74 return find(list_.begin(), list_.end(), thread) != list_.end();
75}
76
Elliott Hughesabbe07d2012-06-05 17:42:23 -070077bool ThreadList::Contains(pid_t tid) {
Mathieu Chartier02e25112013-08-14 16:14:24 -070078 for (const auto& thread : list_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -070079 if (thread->GetTid() == tid) {
Elliott Hughesabbe07d2012-06-05 17:42:23 -070080 return true;
81 }
82 }
83 return false;
84}
85
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -070086pid_t ThreadList::GetLockOwner() {
Ian Rogersb726dcb2012-09-05 08:57:23 -070087 return Locks::thread_list_lock_->GetExclusiveOwnerTid();
Elliott Hughesaccd83d2011-10-17 14:25:58 -070088}
89
Mathieu Chartier590fee92013-09-13 13:46:47 -070090void ThreadList::DumpNativeStacks(std::ostream& os) {
91 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
92 for (const auto& thread : list_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -070093 os << "DUMPING THREAD " << thread->GetTid() << "\n";
Christopher Ferrisa2cee182014-04-16 19:13:59 -070094 DumpNativeStack(os, thread->GetTid(), "\t");
Mathieu Chartier590fee92013-09-13 13:46:47 -070095 os << "\n";
96 }
97}
98
Elliott Hughesc967f782012-04-16 10:23:15 -070099void ThreadList::DumpForSigQuit(std::ostream& os) {
Ian Rogers7b078e82014-09-10 14:44:24 -0700100 Dump(os);
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700101 DumpUnattachedThreads(os);
102}
103
Ian Rogerscfaa4552012-11-26 21:00:08 -0800104static void DumpUnattachedThread(std::ostream& os, pid_t tid) NO_THREAD_SAFETY_ANALYSIS {
105 // TODO: No thread safety analysis as DumpState with a NULL thread won't access fields, should
106 // refactor DumpState to avoid skipping analysis.
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700107 Thread::DumpState(os, NULL, tid);
108 DumpKernelStack(os, tid, " kernel: ", false);
Brian Carlstromed8b7232012-06-27 17:54:47 -0700109 // TODO: Reenable this when the native code in system_server can handle it.
110 // Currently "adb shell kill -3 `pid system_server`" will cause it to exit.
111 if (false) {
Christopher Ferrisa2cee182014-04-16 19:13:59 -0700112 DumpNativeStack(os, tid, " native: ");
Brian Carlstromed8b7232012-06-27 17:54:47 -0700113 }
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700114 os << "\n";
115}
116
117void ThreadList::DumpUnattachedThreads(std::ostream& os) {
118 DIR* d = opendir("/proc/self/task");
119 if (!d) {
120 return;
121 }
122
Ian Rogers50b35e22012-10-04 10:09:15 -0700123 Thread* self = Thread::Current();
Elliott Hughes4696b5b2012-10-30 10:35:10 -0700124 dirent* e;
125 while ((e = readdir(d)) != NULL) {
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700126 char* end;
Elliott Hughes4696b5b2012-10-30 10:35:10 -0700127 pid_t tid = strtol(e->d_name, &end, 10);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700128 if (!*end) {
129 bool contains;
130 {
Ian Rogers50b35e22012-10-04 10:09:15 -0700131 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700132 contains = Contains(tid);
133 }
134 if (!contains) {
135 DumpUnattachedThread(os, tid);
136 }
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700137 }
138 }
139 closedir(d);
Elliott Hughesff738062012-02-03 15:00:42 -0800140}
141
Ian Rogers7b078e82014-09-10 14:44:24 -0700142// A closure used by Thread::Dump.
143class DumpCheckpoint FINAL : public Closure {
144 public:
145 explicit DumpCheckpoint(std::ostream* os) : os_(os), barrier_(0) {}
146
147 void Run(Thread* thread) OVERRIDE {
148 // Note thread and self may not be equal if thread was already suspended at the point of the
149 // request.
150 Thread* self = Thread::Current();
151 std::ostringstream local_os;
152 {
153 ScopedObjectAccess soa(self);
154 thread->Dump(local_os);
155 }
156 local_os << "\n";
157 {
158 // Use the logging lock to ensure serialization when writing to the common ostream.
159 MutexLock mu(self, *Locks::logging_lock_);
160 *os_ << local_os.str();
161 }
162 barrier_.Pass(self);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700163 }
Ian Rogers7b078e82014-09-10 14:44:24 -0700164
165 void WaitForThreadsToRunThroughCheckpoint(size_t threads_running_checkpoint) {
166 Thread* self = Thread::Current();
167 ScopedThreadStateChange tsc(self, kWaitingForCheckPointsToRun);
Ian Rogers2156ff12014-09-13 19:20:54 -0700168 const uint32_t kWaitTimeoutMs = 10000;
169 bool timed_out = barrier_.Increment(self, threads_running_checkpoint, kWaitTimeoutMs);
170 if (timed_out) {
171 LOG(kIsDebugBuild ? FATAL : ERROR) << "Unexpected time out during dump checkpoint.";
172 }
Ian Rogers7b078e82014-09-10 14:44:24 -0700173 }
174
175 private:
176 // The common stream that will accumulate all the dumps.
177 std::ostream* const os_;
178 // The barrier to be passed through and for the requestor to wait upon.
179 Barrier barrier_;
180};
181
182void ThreadList::Dump(std::ostream& os) {
183 {
184 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
185 os << "DALVIK THREADS (" << list_.size() << "):\n";
186 }
187 DumpCheckpoint checkpoint(&os);
188 size_t threads_running_checkpoint = RunCheckpoint(&checkpoint);
189 checkpoint.WaitForThreadsToRunThroughCheckpoint(threads_running_checkpoint);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700190}
191
Ian Rogers50b35e22012-10-04 10:09:15 -0700192void ThreadList::AssertThreadsAreSuspended(Thread* self, Thread* ignore1, Thread* ignore2) {
193 MutexLock mu(self, *Locks::thread_list_lock_);
194 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -0700195 for (const auto& thread : list_) {
jeffhao725a9572012-11-13 18:20:12 -0800196 if (thread != ignore1 && thread != ignore2) {
Ian Rogers01ae5802012-09-28 16:14:01 -0700197 CHECK(thread->IsSuspended())
198 << "\nUnsuspended thread: <<" << *thread << "\n"
199 << "self: <<" << *Thread::Current();
200 }
Elliott Hughes8d768a92011-09-14 16:35:25 -0700201 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700202}
203
Ian Rogers66aee5c2012-08-15 17:17:47 -0700204#if HAVE_TIMED_RWLOCK
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700205// Attempt to rectify locks so that we dump thread list with required locks before exiting.
Ian Rogers7b078e82014-09-10 14:44:24 -0700206static void UnsafeLogFatalForThreadSuspendAllTimeout() __attribute__((noreturn));
Sebastien Hertzbae182c2013-12-17 10:42:03 +0100207static void UnsafeLogFatalForThreadSuspendAllTimeout() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700208 Runtime* runtime = Runtime::Current();
209 std::ostringstream ss;
210 ss << "Thread suspend timeout\n";
Mathieu Chartier5869a2c2014-10-08 14:26:23 -0700211 Locks::mutator_lock_->Dump(ss);
212 ss << "\n";
Ian Rogers7b078e82014-09-10 14:44:24 -0700213 runtime->GetThreadList()->Dump(ss);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700214 LOG(FATAL) << ss.str();
Ian Rogers719d1a32014-03-06 12:13:39 -0800215 exit(0);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700216}
Ian Rogers66aee5c2012-08-15 17:17:47 -0700217#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700218
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800219// Unlike suspending all threads where we can wait to acquire the mutator_lock_, suspending an
220// individual thread requires polling. delay_us is the requested sleep and total_delay_us
221// accumulates the total time spent sleeping for timeouts. The first sleep is just a yield,
222// subsequently sleeps increase delay_us from 1ms to 500ms by doubling.
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700223static void ThreadSuspendSleep(useconds_t* delay_us, useconds_t* total_delay_us) {
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800224 useconds_t new_delay_us = (*delay_us) * 2;
225 CHECK_GE(new_delay_us, *delay_us);
226 if (new_delay_us < 500000) { // Don't allow sleeping to be more than 0.5s.
227 *delay_us = new_delay_us;
228 }
229 if (*delay_us == 0) {
230 sched_yield();
231 // Default to 1 milliseconds (note that this gets multiplied by 2 before the first sleep).
232 *delay_us = 500;
233 } else {
234 usleep(*delay_us);
235 *total_delay_us += *delay_us;
236 }
237}
238
Mathieu Chartier0e4627e2012-10-23 16:13:36 -0700239size_t ThreadList::RunCheckpoint(Closure* checkpoint_function) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700240 Thread* self = Thread::Current();
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800241 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
242 Locks::thread_list_lock_->AssertNotHeld(self);
243 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
Ian Rogers8409ec42014-11-04 17:57:02 -0800244 if (kDebugLocking && gAborting == 0) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700245 CHECK_NE(self->GetState(), kRunnable);
246 }
247
248 std::vector<Thread*> suspended_count_modified_threads;
249 size_t count = 0;
250 {
251 // Call a checkpoint function for each thread, threads which are suspend get their checkpoint
252 // manually called.
253 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700254 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -0700255 for (const auto& thread : list_) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700256 if (thread != self) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700257 while (true) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700258 if (thread->RequestCheckpoint(checkpoint_function)) {
Dave Allison0aded082013-11-07 13:15:11 -0800259 // This thread will run its checkpoint some time in the near future.
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700260 count++;
261 break;
262 } else {
263 // We are probably suspended, try to make sure that we stay suspended.
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700264 // The thread switched back to runnable.
265 if (thread->GetState() == kRunnable) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700266 // Spurious fail, try again.
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700267 continue;
268 }
269 thread->ModifySuspendCount(self, +1, false);
270 suspended_count_modified_threads.push_back(thread);
271 break;
272 }
273 }
274 }
275 }
276 }
277
278 // Run the checkpoint on ourself while we wait for threads to suspend.
279 checkpoint_function->Run(self);
280
281 // Run the checkpoint on the suspended threads.
Mathieu Chartier02e25112013-08-14 16:14:24 -0700282 for (const auto& thread : suspended_count_modified_threads) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700283 if (!thread->IsSuspended()) {
284 // Wait until the thread is suspended.
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800285 useconds_t total_delay_us = 0;
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700286 do {
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800287 useconds_t delay_us = 100;
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700288 ThreadSuspendSleep(&delay_us, &total_delay_us);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700289 } while (!thread->IsSuspended());
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800290 // Shouldn't need to wait for longer than 1000 microseconds.
291 constexpr useconds_t kLongWaitThresholdUS = 1000;
292 if (UNLIKELY(total_delay_us > kLongWaitThresholdUS)) {
293 LOG(WARNING) << "Waited " << total_delay_us << " us for thread suspend!";
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700294 }
295 }
296 // We know for sure that the thread is suspended at this point.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700297 checkpoint_function->Run(thread);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700298 {
299 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
300 thread->ModifySuspendCount(self, -1, false);
301 }
302 }
303
Mathieu Chartier664bebf2012-11-12 16:54:11 -0800304 {
305 // Imitate ResumeAll, threads may be waiting on Thread::resume_cond_ since we raised their
306 // suspend count. Now the suspend_count_ is lowered so we must do the broadcast.
307 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
308 Thread::resume_cond_->Broadcast(self);
309 }
310
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700311 // Add one for self.
312 return count + suspended_count_modified_threads.size() + 1;
313}
314
Dave Allison39c3bfb2014-01-28 18:33:52 -0800315// Request that a checkpoint function be run on all active (non-suspended)
316// threads. Returns the number of successful requests.
317size_t ThreadList::RunCheckpointOnRunnableThreads(Closure* checkpoint_function) {
318 Thread* self = Thread::Current();
Ian Rogers7b078e82014-09-10 14:44:24 -0700319 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
320 Locks::thread_list_lock_->AssertNotHeld(self);
321 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
322 CHECK_NE(self->GetState(), kRunnable);
Dave Allison39c3bfb2014-01-28 18:33:52 -0800323
324 size_t count = 0;
325 {
326 // Call a checkpoint function for each non-suspended thread.
327 MutexLock mu(self, *Locks::thread_list_lock_);
328 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
329 for (const auto& thread : list_) {
330 if (thread != self) {
331 if (thread->RequestCheckpoint(checkpoint_function)) {
332 // This thread will run its checkpoint some time in the near future.
333 count++;
334 }
335 }
336 }
337 }
338
339 // Return the number of threads that will run the checkpoint function.
340 return count;
341}
342
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700343void ThreadList::SuspendAll() {
344 Thread* self = Thread::Current();
345
Jeff Haoc5d824a2014-07-28 18:35:38 -0700346 if (self != nullptr) {
347 VLOG(threads) << *self << " SuspendAll starting...";
348 } else {
349 VLOG(threads) << "Thread[null] SuspendAll starting...";
350 }
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700351 ATRACE_BEGIN("Suspending mutator threads");
Mathieu Chartier251755c2014-07-15 18:10:25 -0700352 uint64_t start_time = NanoTime();
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700353
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800354 Locks::mutator_lock_->AssertNotHeld(self);
355 Locks::thread_list_lock_->AssertNotHeld(self);
356 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
Jeff Haoc5d824a2014-07-28 18:35:38 -0700357 if (kDebugLocking && self != nullptr) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700358 CHECK_NE(self->GetState(), kRunnable);
359 }
360 {
Ian Rogers81d425b2012-09-27 16:03:43 -0700361 MutexLock mu(self, *Locks::thread_list_lock_);
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800362 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
363 // Update global suspend all state for attaching threads.
364 ++suspend_all_count_;
365 // Increment everybody's suspend count (except our own).
366 for (const auto& thread : list_) {
367 if (thread == self) {
368 continue;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700369 }
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800370 VLOG(threads) << "requesting thread suspend: " << *thread;
371 thread->ModifySuspendCount(self, +1, false);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700372 }
373 }
374
Ian Rogers66aee5c2012-08-15 17:17:47 -0700375 // Block on the mutator lock until all Runnable threads release their share of access.
376#if HAVE_TIMED_RWLOCK
377 // Timeout if we wait more than 30 seconds.
Ian Rogers719d1a32014-03-06 12:13:39 -0800378 if (!Locks::mutator_lock_->ExclusiveLockWithTimeout(self, 30 * 1000, 0)) {
Sebastien Hertzbae182c2013-12-17 10:42:03 +0100379 UnsafeLogFatalForThreadSuspendAllTimeout();
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700380 }
Ian Rogers66aee5c2012-08-15 17:17:47 -0700381#else
Ian Rogers81d425b2012-09-27 16:03:43 -0700382 Locks::mutator_lock_->ExclusiveLock(self);
Ian Rogers66aee5c2012-08-15 17:17:47 -0700383#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700384
Mathieu Chartier251755c2014-07-15 18:10:25 -0700385 uint64_t end_time = NanoTime();
386 if (end_time - start_time > kLongThreadSuspendThreshold) {
387 LOG(WARNING) << "Suspending all threads took: " << PrettyDuration(end_time - start_time);
388 }
389
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800390 if (kDebugLocking) {
391 // Debug check that all threads are suspended.
392 AssertThreadsAreSuspended(self, self);
393 }
Elliott Hughes8d768a92011-09-14 16:35:25 -0700394
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700395 ATRACE_END();
396 ATRACE_BEGIN("Mutator threads suspended");
397
Jeff Haoc5d824a2014-07-28 18:35:38 -0700398 if (self != nullptr) {
399 VLOG(threads) << *self << " SuspendAll complete";
400 } else {
401 VLOG(threads) << "Thread[null] SuspendAll complete";
402 }
Elliott Hughes8d768a92011-09-14 16:35:25 -0700403}
404
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700405void ThreadList::ResumeAll() {
406 Thread* self = Thread::Current();
407
Jeff Haoc5d824a2014-07-28 18:35:38 -0700408 if (self != nullptr) {
409 VLOG(threads) << *self << " ResumeAll starting";
410 } else {
411 VLOG(threads) << "Thread[null] ResumeAll starting";
412 }
Ian Rogers01ae5802012-09-28 16:14:01 -0700413
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700414 ATRACE_END();
415 ATRACE_BEGIN("Resuming mutator threads");
416
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800417 if (kDebugLocking) {
418 // Debug check that all threads are suspended.
419 AssertThreadsAreSuspended(self, self);
420 }
Ian Rogers01ae5802012-09-28 16:14:01 -0700421
Ian Rogers81d425b2012-09-27 16:03:43 -0700422 Locks::mutator_lock_->ExclusiveUnlock(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700423 {
Ian Rogers81d425b2012-09-27 16:03:43 -0700424 MutexLock mu(self, *Locks::thread_list_lock_);
425 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700426 // Update global suspend all state for attaching threads.
427 --suspend_all_count_;
428 // Decrement the suspend counts for all threads.
Mathieu Chartier02e25112013-08-14 16:14:24 -0700429 for (const auto& thread : list_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700430 if (thread == self) {
431 continue;
432 }
Ian Rogers01ae5802012-09-28 16:14:01 -0700433 thread->ModifySuspendCount(self, -1, false);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700434 }
435
436 // Broadcast a notification to all suspended threads, some or all of
437 // which may choose to wake up. No need to wait for them.
Jeff Haoc5d824a2014-07-28 18:35:38 -0700438 if (self != nullptr) {
439 VLOG(threads) << *self << " ResumeAll waking others";
440 } else {
441 VLOG(threads) << "Thread[null] ResumeAll waking others";
442 }
Ian Rogersc604d732012-10-14 16:09:54 -0700443 Thread::resume_cond_->Broadcast(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700444 }
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700445 ATRACE_END();
Jeff Haoc5d824a2014-07-28 18:35:38 -0700446
447 if (self != nullptr) {
448 VLOG(threads) << *self << " ResumeAll complete";
449 } else {
450 VLOG(threads) << "Thread[null] ResumeAll complete";
451 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700452}
453
454void ThreadList::Resume(Thread* thread, bool for_debugger) {
Ian Rogers81d425b2012-09-27 16:03:43 -0700455 Thread* self = Thread::Current();
456 DCHECK_NE(thread, self);
Brian Carlstromba32de42014-08-27 23:43:46 -0700457 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") starting..."
458 << (for_debugger ? " (debugger)" : "");
Elliott Hughes01158d72011-09-19 19:47:10 -0700459
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700460 {
461 // To check Contains.
Ian Rogers81d425b2012-09-27 16:03:43 -0700462 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700463 // To check IsSuspended.
Ian Rogers81d425b2012-09-27 16:03:43 -0700464 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
465 DCHECK(thread->IsSuspended());
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700466 if (!Contains(thread)) {
Brian Carlstromba32de42014-08-27 23:43:46 -0700467 // We only expect threads within the thread-list to have been suspended otherwise we can't
468 // stop such threads from delete-ing themselves.
469 LOG(ERROR) << "Resume(" << reinterpret_cast<void*>(thread)
470 << ") thread not within thread list";
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700471 return;
472 }
Ian Rogers01ae5802012-09-28 16:14:01 -0700473 thread->ModifySuspendCount(self, -1, for_debugger);
Elliott Hughes01158d72011-09-19 19:47:10 -0700474 }
475
476 {
Brian Carlstromba32de42014-08-27 23:43:46 -0700477 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") waking others";
Ian Rogers81d425b2012-09-27 16:03:43 -0700478 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersc604d732012-10-14 16:09:54 -0700479 Thread::resume_cond_->Broadcast(self);
Elliott Hughes01158d72011-09-19 19:47:10 -0700480 }
481
Brian Carlstromba32de42014-08-27 23:43:46 -0700482 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") complete";
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700483}
Elliott Hughes01158d72011-09-19 19:47:10 -0700484
Ian Rogersc7dd2952014-10-21 23:31:19 -0700485static void ThreadSuspendByPeerWarning(Thread* self, LogSeverity severity, const char* message,
486 jobject peer) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700487 JNIEnvExt* env = self->GetJniEnv();
488 ScopedLocalRef<jstring>
489 scoped_name_string(env, (jstring)env->GetObjectField(peer,
490 WellKnownClasses::java_lang_Thread_name));
491 ScopedUtfChars scoped_name_chars(env, scoped_name_string.get());
492 if (scoped_name_chars.c_str() == NULL) {
Ian Rogersc7dd2952014-10-21 23:31:19 -0700493 LOG(severity) << message << ": " << peer;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700494 env->ExceptionClear();
495 } else {
Ian Rogersc7dd2952014-10-21 23:31:19 -0700496 LOG(severity) << message << ": " << peer << ":" << scoped_name_chars.c_str();
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700497 }
498}
499
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700500Thread* ThreadList::SuspendThreadByPeer(jobject peer, bool request_suspension,
501 bool debug_suspension, bool* timed_out) {
502 static const useconds_t kTimeoutUs = 30 * 1000000; // 30s.
503 useconds_t total_delay_us = 0;
504 useconds_t delay_us = 0;
505 bool did_suspend_request = false;
506 *timed_out = false;
507 Thread* self = Thread::Current();
Brian Carlstromba32de42014-08-27 23:43:46 -0700508 VLOG(threads) << "SuspendThreadByPeer starting";
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700509 while (true) {
510 Thread* thread;
511 {
Ian Rogersf3d874c2014-07-17 18:52:42 -0700512 // Note: this will transition to runnable and potentially suspend. We ensure only one thread
513 // is requesting another suspend, to avoid deadlock, by requiring this function be called
514 // holding Locks::thread_list_suspend_thread_lock_. Its important this thread suspend rather
515 // than request thread suspension, to avoid potential cycles in threads requesting each other
516 // suspend.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700517 ScopedObjectAccess soa(self);
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800518 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700519 thread = Thread::FromManagedThread(soa, peer);
Brian Carlstromba32de42014-08-27 23:43:46 -0700520 if (thread == nullptr) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700521 ThreadSuspendByPeerWarning(self, WARNING, "No such thread for suspend", peer);
Brian Carlstromba32de42014-08-27 23:43:46 -0700522 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700523 }
Brian Carlstromba32de42014-08-27 23:43:46 -0700524 if (!Contains(thread)) {
525 VLOG(threads) << "SuspendThreadByPeer failed for unattached thread: "
526 << reinterpret_cast<void*>(thread);
527 return nullptr;
528 }
529 VLOG(threads) << "SuspendThreadByPeer found thread: " << *thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700530 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800531 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700532 if (request_suspension) {
Ian Rogers4ad5cd32014-11-11 23:08:07 -0800533 if (self->GetSuspendCount() > 0) {
534 // We hold the suspend count lock but another thread is trying to suspend us. Its not
535 // safe to try to suspend another thread in case we get a cycle. Start the loop again
536 // which will allow this thread to be suspended.
537 continue;
538 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700539 thread->ModifySuspendCount(self, +1, debug_suspension);
540 request_suspension = false;
541 did_suspend_request = true;
542 } else {
543 // If the caller isn't requesting suspension, a suspension should have already occurred.
544 CHECK_GT(thread->GetSuspendCount(), 0);
545 }
546 // IsSuspended on the current thread will fail as the current thread is changed into
547 // Runnable above. As the suspend count is now raised if this is the current thread
548 // it will self suspend on transition to Runnable, making it hard to work with. It's simpler
549 // to just explicitly handle the current thread in the callers to this code.
550 CHECK_NE(thread, self) << "Attempt to suspend the current thread for the debugger";
551 // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend
552 // count, or else we've waited and it has self suspended) or is the current thread, we're
553 // done.
554 if (thread->IsSuspended()) {
Brian Carlstromba32de42014-08-27 23:43:46 -0700555 VLOG(threads) << "SuspendThreadByPeer thread suspended: " << *thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700556 return thread;
557 }
558 if (total_delay_us >= kTimeoutUs) {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700559 ThreadSuspendByPeerWarning(self, FATAL, "Thread suspension timed out", peer);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700560 if (did_suspend_request) {
561 thread->ModifySuspendCount(soa.Self(), -1, debug_suspension);
562 }
563 *timed_out = true;
Brian Carlstromba32de42014-08-27 23:43:46 -0700564 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700565 }
566 }
567 // Release locks and come out of runnable state.
568 }
Brian Carlstromba32de42014-08-27 23:43:46 -0700569 VLOG(threads) << "SuspendThreadByPeer sleeping to allow thread chance to suspend";
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700570 ThreadSuspendSleep(&delay_us, &total_delay_us);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700571 }
572}
573
Ian Rogersc7dd2952014-10-21 23:31:19 -0700574static void ThreadSuspendByThreadIdWarning(LogSeverity severity, const char* message,
575 uint32_t thread_id) {
576 LOG(severity) << StringPrintf("%s: %d", message, thread_id);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700577}
578
579Thread* ThreadList::SuspendThreadByThreadId(uint32_t thread_id, bool debug_suspension,
580 bool* timed_out) {
581 static const useconds_t kTimeoutUs = 30 * 1000000; // 30s.
582 useconds_t total_delay_us = 0;
583 useconds_t delay_us = 0;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700584 *timed_out = false;
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800585 Thread* suspended_thread = nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700586 Thread* self = Thread::Current();
587 CHECK_NE(thread_id, kInvalidThreadId);
Brian Carlstromba32de42014-08-27 23:43:46 -0700588 VLOG(threads) << "SuspendThreadByThreadId starting";
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700589 while (true) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700590 {
Ian Rogersf3d874c2014-07-17 18:52:42 -0700591 // Note: this will transition to runnable and potentially suspend. We ensure only one thread
592 // is requesting another suspend, to avoid deadlock, by requiring this function be called
593 // holding Locks::thread_list_suspend_thread_lock_. Its important this thread suspend rather
594 // than request thread suspension, to avoid potential cycles in threads requesting each other
595 // suspend.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700596 ScopedObjectAccess soa(self);
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800597 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Ian Rogersf3d874c2014-07-17 18:52:42 -0700598 Thread* thread = nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700599 for (const auto& it : list_) {
600 if (it->GetThreadId() == thread_id) {
601 thread = it;
602 break;
603 }
604 }
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800605 if (thread == nullptr) {
606 CHECK(suspended_thread == nullptr) << "Suspended thread " << suspended_thread
607 << " no longer in thread list";
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700608 // There's a race in inflating a lock and the owner giving up ownership and then dying.
609 ThreadSuspendByThreadIdWarning(WARNING, "No such thread id for suspend", thread_id);
Brian Carlstromba32de42014-08-27 23:43:46 -0700610 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700611 }
Brian Carlstromba32de42014-08-27 23:43:46 -0700612 VLOG(threads) << "SuspendThreadByThreadId found thread: " << *thread;
613 DCHECK(Contains(thread));
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700614 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800615 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800616 if (suspended_thread == nullptr) {
Ian Rogers4ad5cd32014-11-11 23:08:07 -0800617 if (self->GetSuspendCount() > 0) {
618 // We hold the suspend count lock but another thread is trying to suspend us. Its not
619 // safe to try to suspend another thread in case we get a cycle. Start the loop again
620 // which will allow this thread to be suspended.
621 continue;
622 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700623 thread->ModifySuspendCount(self, +1, debug_suspension);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800624 suspended_thread = thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700625 } else {
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800626 CHECK_EQ(suspended_thread, thread);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700627 // If the caller isn't requesting suspension, a suspension should have already occurred.
628 CHECK_GT(thread->GetSuspendCount(), 0);
629 }
630 // IsSuspended on the current thread will fail as the current thread is changed into
631 // Runnable above. As the suspend count is now raised if this is the current thread
632 // it will self suspend on transition to Runnable, making it hard to work with. It's simpler
633 // to just explicitly handle the current thread in the callers to this code.
634 CHECK_NE(thread, self) << "Attempt to suspend the current thread for the debugger";
635 // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend
636 // count, or else we've waited and it has self suspended) or is the current thread, we're
637 // done.
638 if (thread->IsSuspended()) {
Brian Carlstromba32de42014-08-27 23:43:46 -0700639 VLOG(threads) << "SuspendThreadByThreadId thread suspended: " << *thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700640 return thread;
641 }
642 if (total_delay_us >= kTimeoutUs) {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700643 ThreadSuspendByThreadIdWarning(WARNING, "Thread suspension timed out", thread_id);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800644 if (suspended_thread != nullptr) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700645 thread->ModifySuspendCount(soa.Self(), -1, debug_suspension);
646 }
647 *timed_out = true;
Brian Carlstromba32de42014-08-27 23:43:46 -0700648 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700649 }
650 }
651 // Release locks and come out of runnable state.
652 }
Brian Carlstromba32de42014-08-27 23:43:46 -0700653 VLOG(threads) << "SuspendThreadByThreadId sleeping to allow thread chance to suspend";
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700654 ThreadSuspendSleep(&delay_us, &total_delay_us);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700655 }
656}
657
658Thread* ThreadList::FindThreadByThreadId(uint32_t thin_lock_id) {
659 Thread* self = Thread::Current();
660 MutexLock mu(self, *Locks::thread_list_lock_);
661 for (const auto& thread : list_) {
662 if (thread->GetThreadId() == thin_lock_id) {
663 CHECK(thread == self || thread->IsSuspended());
664 return thread;
665 }
666 }
667 return NULL;
668}
669
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700670void ThreadList::SuspendAllForDebugger() {
671 Thread* self = Thread::Current();
672 Thread* debug_thread = Dbg::GetDebugThread();
673
674 VLOG(threads) << *self << " SuspendAllForDebugger starting...";
675
676 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800677 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700678 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800679 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700680 // Update global suspend all state for attaching threads.
Sebastien Hertz253fa552014-10-14 17:27:15 +0200681 DCHECK_GE(suspend_all_count_, debug_suspend_all_count_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700682 ++suspend_all_count_;
683 ++debug_suspend_all_count_;
684 // Increment everybody's suspend count (except our own).
Mathieu Chartier02e25112013-08-14 16:14:24 -0700685 for (const auto& thread : list_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700686 if (thread == self || thread == debug_thread) {
687 continue;
688 }
689 VLOG(threads) << "requesting thread suspend: " << *thread;
Ian Rogers01ae5802012-09-28 16:14:01 -0700690 thread->ModifySuspendCount(self, +1, true);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700691 }
692 }
693 }
694
Ian Rogers66aee5c2012-08-15 17:17:47 -0700695 // Block on the mutator lock until all Runnable threads release their share of access then
696 // immediately unlock again.
697#if HAVE_TIMED_RWLOCK
698 // Timeout if we wait more than 30 seconds.
Ian Rogersc604d732012-10-14 16:09:54 -0700699 if (!Locks::mutator_lock_->ExclusiveLockWithTimeout(self, 30 * 1000, 0)) {
Sebastien Hertzbae182c2013-12-17 10:42:03 +0100700 UnsafeLogFatalForThreadSuspendAllTimeout();
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700701 } else {
Ian Rogers81d425b2012-09-27 16:03:43 -0700702 Locks::mutator_lock_->ExclusiveUnlock(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700703 }
Ian Rogers66aee5c2012-08-15 17:17:47 -0700704#else
Ian Rogers81d425b2012-09-27 16:03:43 -0700705 Locks::mutator_lock_->ExclusiveLock(self);
706 Locks::mutator_lock_->ExclusiveUnlock(self);
Ian Rogers66aee5c2012-08-15 17:17:47 -0700707#endif
Ian Rogers50b35e22012-10-04 10:09:15 -0700708 AssertThreadsAreSuspended(self, self, debug_thread);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700709
Sebastien Hertzed2be172014-08-19 15:33:43 +0200710 VLOG(threads) << *self << " SuspendAllForDebugger complete";
Elliott Hughes01158d72011-09-19 19:47:10 -0700711}
712
Elliott Hughes475fc232011-10-25 15:00:35 -0700713void ThreadList::SuspendSelfForDebugger() {
714 Thread* self = Thread::Current();
Elliott Hughes01158d72011-09-19 19:47:10 -0700715
Elliott Hughes475fc232011-10-25 15:00:35 -0700716 // The debugger thread must not suspend itself due to debugger activity!
717 Thread* debug_thread = Dbg::GetDebugThread();
718 CHECK(debug_thread != NULL);
719 CHECK(self != debug_thread);
jeffhaoa77f0f62012-12-05 17:19:31 -0800720 CHECK_NE(self->GetState(), kRunnable);
721 Locks::mutator_lock_->AssertNotHeld(self);
Elliott Hughes475fc232011-10-25 15:00:35 -0700722
jeffhaoa77f0f62012-12-05 17:19:31 -0800723 {
724 // Collisions with other suspends aren't really interesting. We want
725 // to ensure that we're the only one fiddling with the suspend count
726 // though.
727 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
728 self->ModifySuspendCount(self, +1, true);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700729 CHECK_GT(self->GetSuspendCount(), 0);
jeffhaoa77f0f62012-12-05 17:19:31 -0800730 }
Elliott Hughes475fc232011-10-25 15:00:35 -0700731
Elliott Hughes1f729aa2012-03-02 13:55:41 -0800732 VLOG(threads) << *self << " self-suspending (debugger)";
Elliott Hughes475fc232011-10-25 15:00:35 -0700733
Sebastien Hertz21e729c2014-02-18 14:16:00 +0100734 // Tell JDWP we've completed invocation and are ready to suspend.
735 DebugInvokeReq* pReq = self->GetInvokeReq();
736 DCHECK(pReq != NULL);
737 if (pReq->invoke_needed) {
738 // Clear this before signaling.
Sebastien Hertzbb43b432014-04-14 11:59:08 +0200739 pReq->Clear();
Sebastien Hertz21e729c2014-02-18 14:16:00 +0100740
741 VLOG(jdwp) << "invoke complete, signaling";
742 MutexLock mu(self, pReq->lock);
743 pReq->cond.Signal(self);
744 }
745
Elliott Hughes475fc232011-10-25 15:00:35 -0700746 // Tell JDWP that we've completed suspension. The JDWP thread can't
747 // tell us to resume before we're fully asleep because we hold the
748 // suspend count lock.
749 Dbg::ClearWaitForEventThread();
750
jeffhaoa77f0f62012-12-05 17:19:31 -0800751 {
752 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700753 while (self->GetSuspendCount() != 0) {
jeffhaoa77f0f62012-12-05 17:19:31 -0800754 Thread::resume_cond_->Wait(self);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700755 if (self->GetSuspendCount() != 0) {
jeffhaoa77f0f62012-12-05 17:19:31 -0800756 // The condition was signaled but we're still suspended. This
Sebastien Hertzf272af42014-09-18 10:20:42 +0200757 // can happen when we suspend then resume all threads to
758 // update instrumentation or compute monitor info. This can
759 // also happen if the debugger lets go while a SIGQUIT thread
jeffhaoa77f0f62012-12-05 17:19:31 -0800760 // dump event is pending (assuming SignalCatcher was resumed for
761 // just long enough to try to grab the thread-suspend lock).
Sebastien Hertzf272af42014-09-18 10:20:42 +0200762 VLOG(jdwp) << *self << " still suspended after undo "
763 << "(suspend count=" << self->GetSuspendCount() << ", "
764 << "debug suspend count=" << self->GetDebugSuspendCount() << ")";
jeffhaoa77f0f62012-12-05 17:19:31 -0800765 }
Elliott Hughes475fc232011-10-25 15:00:35 -0700766 }
Ian Rogersdd7624d2014-03-14 17:43:00 -0700767 CHECK_EQ(self->GetSuspendCount(), 0);
Elliott Hughes475fc232011-10-25 15:00:35 -0700768 }
jeffhaoa77f0f62012-12-05 17:19:31 -0800769
Elliott Hughes1f729aa2012-03-02 13:55:41 -0800770 VLOG(threads) << *self << " self-reviving (debugger)";
Elliott Hughes475fc232011-10-25 15:00:35 -0700771}
772
Sebastien Hertz253fa552014-10-14 17:27:15 +0200773void ThreadList::ResumeAllForDebugger() {
774 Thread* self = Thread::Current();
775 Thread* debug_thread = Dbg::GetDebugThread();
776 bool needs_resume = false;
777
778 VLOG(threads) << *self << " ResumeAllForDebugger starting...";
779
780 // Threads can't resume if we exclusively hold the mutator lock.
781 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
782
783 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800784 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Sebastien Hertz253fa552014-10-14 17:27:15 +0200785 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800786 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Sebastien Hertz253fa552014-10-14 17:27:15 +0200787 // Update global suspend all state for attaching threads.
788 DCHECK_GE(suspend_all_count_, debug_suspend_all_count_);
789 needs_resume = (debug_suspend_all_count_ > 0);
790 if (needs_resume) {
791 --suspend_all_count_;
792 --debug_suspend_all_count_;
793 // Decrement everybody's suspend count (except our own).
794 for (const auto& thread : list_) {
795 if (thread == self || thread == debug_thread) {
796 continue;
797 }
798 if (thread->GetDebugSuspendCount() == 0) {
799 // This thread may have been individually resumed with ThreadReference.Resume.
800 continue;
801 }
802 VLOG(threads) << "requesting thread resume: " << *thread;
803 thread->ModifySuspendCount(self, -1, true);
804 }
805 } else {
806 // We've been asked to resume all threads without being asked to
807 // suspend them all before. Let's print a warning.
808 LOG(WARNING) << "Debugger attempted to resume all threads without "
809 << "having suspended them all before.";
810 }
811 }
812 }
813
814 if (needs_resume) {
815 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
816 Thread::resume_cond_->Broadcast(self);
817 }
818
819 VLOG(threads) << *self << " ResumeAllForDebugger complete";
820}
821
Elliott Hughes234ab152011-10-26 14:02:26 -0700822void ThreadList::UndoDebuggerSuspensions() {
823 Thread* self = Thread::Current();
824
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800825 VLOG(threads) << *self << " UndoDebuggerSuspensions starting";
Elliott Hughes234ab152011-10-26 14:02:26 -0700826
827 {
Ian Rogers81d425b2012-09-27 16:03:43 -0700828 MutexLock mu(self, *Locks::thread_list_lock_);
829 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700830 // Update global suspend all state for attaching threads.
831 suspend_all_count_ -= debug_suspend_all_count_;
832 debug_suspend_all_count_ = 0;
833 // Update running threads.
Mathieu Chartier02e25112013-08-14 16:14:24 -0700834 for (const auto& thread : list_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700835 if (thread == self || thread->GetDebugSuspendCount() == 0) {
Elliott Hughes234ab152011-10-26 14:02:26 -0700836 continue;
837 }
Ian Rogersdd7624d2014-03-14 17:43:00 -0700838 thread->ModifySuspendCount(self, -thread->GetDebugSuspendCount(), true);
Elliott Hughes234ab152011-10-26 14:02:26 -0700839 }
840 }
841
842 {
Ian Rogers81d425b2012-09-27 16:03:43 -0700843 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersc604d732012-10-14 16:09:54 -0700844 Thread::resume_cond_->Broadcast(self);
Elliott Hughes234ab152011-10-26 14:02:26 -0700845 }
846
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800847 VLOG(threads) << "UndoDebuggerSuspensions(" << *self << ") complete";
Elliott Hughes234ab152011-10-26 14:02:26 -0700848}
849
Elliott Hughese52e49b2012-04-02 16:05:44 -0700850void ThreadList::WaitForOtherNonDaemonThreadsToExit() {
Ian Rogers81d425b2012-09-27 16:03:43 -0700851 Thread* self = Thread::Current();
852 Locks::mutator_lock_->AssertNotHeld(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700853 bool all_threads_are_daemons;
854 do {
Ian Rogers120f1c72012-09-28 17:17:10 -0700855 {
856 // No more threads can be born after we start to shutdown.
857 MutexLock mu(self, *Locks::runtime_shutdown_lock_);
Mathieu Chartier590fee92013-09-13 13:46:47 -0700858 CHECK(Runtime::Current()->IsShuttingDownLocked());
Ian Rogers120f1c72012-09-28 17:17:10 -0700859 CHECK_EQ(Runtime::Current()->NumberOfThreadsBeingBorn(), 0U);
860 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700861 all_threads_are_daemons = true;
Ian Rogers120f1c72012-09-28 17:17:10 -0700862 MutexLock mu(self, *Locks::thread_list_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -0700863 for (const auto& thread : list_) {
Anwar Ghuloum97543682013-06-14 12:58:16 -0700864 if (thread != self && !thread->IsDaemon()) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700865 all_threads_are_daemons = false;
866 break;
867 }
868 }
869 if (!all_threads_are_daemons) {
870 // Wait for another thread to exit before re-checking.
Ian Rogersc604d732012-10-14 16:09:54 -0700871 thread_exit_cond_.Wait(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700872 }
Brian Carlstromdf629502013-07-17 22:39:56 -0700873 } while (!all_threads_are_daemons);
Elliott Hughes038a8062011-09-18 14:12:41 -0700874}
875
876void ThreadList::SuspendAllDaemonThreads() {
Ian Rogers81d425b2012-09-27 16:03:43 -0700877 Thread* self = Thread::Current();
878 MutexLock mu(self, *Locks::thread_list_lock_);
Brian Carlstrom7934ac22013-07-26 10:54:15 -0700879 { // Tell all the daemons it's time to suspend.
Ian Rogers81d425b2012-09-27 16:03:43 -0700880 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -0700881 for (const auto& thread : list_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700882 // This is only run after all non-daemon threads have exited, so the remainder should all be
883 // daemons.
Ian Rogers7e762862012-10-22 15:45:08 -0700884 CHECK(thread->IsDaemon()) << *thread;
Ian Rogers81d425b2012-09-27 16:03:43 -0700885 if (thread != self) {
Ian Rogers01ae5802012-09-28 16:14:01 -0700886 thread->ModifySuspendCount(self, +1, false);
Elliott Hughese52e49b2012-04-02 16:05:44 -0700887 }
Elliott Hughes038a8062011-09-18 14:12:41 -0700888 }
889 }
Elliott Hughes038a8062011-09-18 14:12:41 -0700890 // Give the threads a chance to suspend, complaining if they're slow.
891 bool have_complained = false;
892 for (int i = 0; i < 10; ++i) {
893 usleep(200 * 1000);
894 bool all_suspended = true;
Mathieu Chartier02e25112013-08-14 16:14:24 -0700895 for (const auto& thread : list_) {
Ian Rogers81d425b2012-09-27 16:03:43 -0700896 if (thread != self && thread->GetState() == kRunnable) {
Elliott Hughes038a8062011-09-18 14:12:41 -0700897 if (!have_complained) {
898 LOG(WARNING) << "daemon thread not yet suspended: " << *thread;
899 have_complained = true;
900 }
901 all_suspended = false;
902 }
903 }
904 if (all_suspended) {
905 return;
906 }
907 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700908 LOG(ERROR) << "suspend all daemons failed";
909}
910void ThreadList::Register(Thread* self) {
911 DCHECK_EQ(self, Thread::Current());
912
913 if (VLOG_IS_ON(threads)) {
914 std::ostringstream oss;
915 self->ShortDump(oss); // We don't hold the mutator_lock_ yet and so cannot call Dump.
Ian Rogers5a9ba012014-05-19 13:28:52 -0700916 LOG(INFO) << "ThreadList::Register() " << *self << "\n" << oss.str();
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700917 }
918
919 // Atomically add self to the thread list and make its thread_suspend_count_ reflect ongoing
920 // SuspendAll requests.
Ian Rogers81d425b2012-09-27 16:03:43 -0700921 MutexLock mu(self, *Locks::thread_list_lock_);
922 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700923 CHECK_GE(suspend_all_count_, debug_suspend_all_count_);
Ian Rogers2966e132014-04-02 08:34:36 -0700924 // Modify suspend count in increments of 1 to maintain invariants in ModifySuspendCount. While
925 // this isn't particularly efficient the suspend counts are most commonly 0 or 1.
926 for (int delta = debug_suspend_all_count_; delta > 0; delta--) {
927 self->ModifySuspendCount(self, +1, true);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700928 }
Ian Rogers2966e132014-04-02 08:34:36 -0700929 for (int delta = suspend_all_count_ - debug_suspend_all_count_; delta > 0; delta--) {
930 self->ModifySuspendCount(self, +1, false);
Ian Rogers01ae5802012-09-28 16:14:01 -0700931 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700932 CHECK(!Contains(self));
933 list_.push_back(self);
934}
935
936void ThreadList::Unregister(Thread* self) {
937 DCHECK_EQ(self, Thread::Current());
Ian Rogers68d8b422014-07-17 11:09:10 -0700938 CHECK_NE(self->GetState(), kRunnable);
939 Locks::mutator_lock_->AssertNotHeld(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700940
941 VLOG(threads) << "ThreadList::Unregister() " << *self;
942
943 // Any time-consuming destruction, plus anything that can call back into managed code or
944 // suspend and so on, must happen at this point, and not in ~Thread.
945 self->Destroy();
946
Jeff Haoe094b872014-10-14 13:12:01 -0700947 // If tracing, remember thread id and name before thread exits.
948 Trace::StoreExitingThreadInfo(self);
949
Ian Rogersdd7624d2014-03-14 17:43:00 -0700950 uint32_t thin_lock_id = self->GetThreadId();
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800951 while (self != nullptr) {
Ian Rogerscfaa4552012-11-26 21:00:08 -0800952 // Remove and delete the Thread* while holding the thread_list_lock_ and
953 // thread_suspend_count_lock_ so that the unregistering thread cannot be suspended.
Ian Rogers0878d652013-04-18 17:38:35 -0700954 // Note: deliberately not using MutexLock that could hold a stale self pointer.
955 Locks::thread_list_lock_->ExclusiveLock(self);
Ian Rogersa2af5c72014-09-15 15:17:07 -0700956 bool removed = true;
957 if (!Contains(self)) {
958 std::ostringstream os;
959 DumpNativeStack(os, GetTid(), " native: ", nullptr);
960 LOG(ERROR) << "Request to unregister unattached thread\n" << os.str();
961 } else {
962 Locks::thread_suspend_count_lock_->ExclusiveLock(self);
963 if (!self->IsSuspended()) {
964 list_.remove(self);
965 } else {
966 // We failed to remove the thread due to a suspend request, loop and try again.
967 removed = false;
968 }
969 Locks::thread_suspend_count_lock_->ExclusiveUnlock(self);
Ian Rogers68d8b422014-07-17 11:09:10 -0700970 }
Ian Rogers68d8b422014-07-17 11:09:10 -0700971 Locks::thread_list_lock_->ExclusiveUnlock(self);
972 if (removed) {
Ian Rogerscfaa4552012-11-26 21:00:08 -0800973 delete self;
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800974 self = nullptr;
Ian Rogerscfaa4552012-11-26 21:00:08 -0800975 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700976 }
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800977 // Release the thread ID after the thread is finished and deleted to avoid cases where we can
978 // temporarily have multiple threads with the same thread id. When this occurs, it causes
979 // problems in FindThreadByThreadId / SuspendThreadByThreadId.
980 ReleaseThreadId(nullptr, thin_lock_id);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700981
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700982 // Clear the TLS data, so that the underlying native thread is recognizably detached.
983 // (It may wish to reattach later.)
984 CHECK_PTHREAD_CALL(pthread_setspecific, (Thread::pthread_key_self_, NULL), "detach self");
985
986 // Signal that a thread just detached.
Ian Rogers81d425b2012-09-27 16:03:43 -0700987 MutexLock mu(NULL, *Locks::thread_list_lock_);
Ian Rogersc604d732012-10-14 16:09:54 -0700988 thread_exit_cond_.Signal(NULL);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700989}
990
991void ThreadList::ForEach(void (*callback)(Thread*, void*), void* context) {
Mathieu Chartier02e25112013-08-14 16:14:24 -0700992 for (const auto& thread : list_) {
993 callback(thread, context);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700994 }
995}
996
Mathieu Chartier83c8ee02014-01-28 14:50:23 -0800997void ThreadList::VisitRoots(RootCallback* callback, void* arg) const {
Ian Rogers81d425b2012-09-27 16:03:43 -0700998 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -0700999 for (const auto& thread : list_) {
Mathieu Chartier83c8ee02014-01-28 14:50:23 -08001000 thread->VisitRoots(callback, arg);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001001 }
Elliott Hughes038a8062011-09-18 14:12:41 -07001002}
1003
Mathieu Chartier83c8ee02014-01-28 14:50:23 -08001004class VerifyRootWrapperArg {
1005 public:
1006 VerifyRootWrapperArg(VerifyRootCallback* callback, void* arg) : callback_(callback), arg_(arg) {
1007 }
1008 VerifyRootCallback* const callback_;
1009 void* const arg_;
Mathieu Chartier423d2a32013-09-12 17:33:56 -07001010};
1011
Mathieu Chartier815873e2014-02-13 18:02:13 -08001012static void VerifyRootWrapperCallback(mirror::Object** root, void* arg, uint32_t /*thread_id*/,
Mathieu Chartier7bf9f192014-04-04 11:09:41 -07001013 RootType root_type) {
Mathieu Chartier423d2a32013-09-12 17:33:56 -07001014 VerifyRootWrapperArg* wrapperArg = reinterpret_cast<VerifyRootWrapperArg*>(arg);
Mathieu Chartier7bf9f192014-04-04 11:09:41 -07001015 wrapperArg->callback_(*root, wrapperArg->arg_, 0, NULL, root_type);
Mathieu Chartier423d2a32013-09-12 17:33:56 -07001016}
1017
Mathieu Chartier83c8ee02014-01-28 14:50:23 -08001018void ThreadList::VerifyRoots(VerifyRootCallback* callback, void* arg) const {
1019 VerifyRootWrapperArg wrapper(callback, arg);
Mathieu Chartier6f1c9492012-10-15 12:08:41 -07001020 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001021 for (const auto& thread : list_) {
Mathieu Chartier423d2a32013-09-12 17:33:56 -07001022 thread->VisitRoots(VerifyRootWrapperCallback, &wrapper);
Mathieu Chartier6f1c9492012-10-15 12:08:41 -07001023 }
1024}
1025
Ian Rogerscfaa4552012-11-26 21:00:08 -08001026uint32_t ThreadList::AllocThreadId(Thread* self) {
Chao-ying Fu9e369312014-05-21 11:20:52 -07001027 MutexLock mu(self, *Locks::allocated_thread_ids_lock_);
Elliott Hughes8daa0922011-09-11 13:46:25 -07001028 for (size_t i = 0; i < allocated_ids_.size(); ++i) {
1029 if (!allocated_ids_[i]) {
1030 allocated_ids_.set(i);
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001031 return i + 1; // Zero is reserved to mean "invalid".
Elliott Hughes8daa0922011-09-11 13:46:25 -07001032 }
1033 }
1034 LOG(FATAL) << "Out of internal thread ids";
1035 return 0;
1036}
1037
Ian Rogerscfaa4552012-11-26 21:00:08 -08001038void ThreadList::ReleaseThreadId(Thread* self, uint32_t id) {
Chao-ying Fu9e369312014-05-21 11:20:52 -07001039 MutexLock mu(self, *Locks::allocated_thread_ids_lock_);
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001040 --id; // Zero is reserved to mean "invalid".
Elliott Hughes8daa0922011-09-11 13:46:25 -07001041 DCHECK(allocated_ids_[id]) << id;
1042 allocated_ids_.reset(id);
1043}
1044
Elliott Hughes8daa0922011-09-11 13:46:25 -07001045} // namespace art