blob: d63781bdba5ab143ddf07b0036c7d5a264b39c43 [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"
Hiroshi Yamauchi967a0ad2013-09-10 16:24:21 -070031#include "base/mutex-inl.h"
Vladimir Marko80afd022015-05-19 18:08:00 +010032#include "base/time_utils.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"
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -070035#include "gc/collector/concurrent_copying.h"
Ian Rogersd9c4fc92013-10-01 19:45:43 -070036#include "jni_internal.h"
37#include "lock_word.h"
38#include "monitor.h"
39#include "scoped_thread_state_change.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080040#include "thread.h"
Jeff Haoe094b872014-10-14 13:12:01 -070041#include "trace.h"
Ian Rogersd9c4fc92013-10-01 19:45:43 -070042#include "well_known_classes.h"
Elliott Hughes475fc232011-10-25 15:00:35 -070043
Yu Lieac44242015-06-29 10:50:03 +080044#if ART_USE_FUTEXES
45#include "linux/futex.h"
46#include "sys/syscall.h"
47#ifndef SYS_futex
48#define SYS_futex __NR_futex
49#endif
50#endif // ART_USE_FUTEXES
51
Elliott Hughes8daa0922011-09-11 13:46:25 -070052namespace art {
53
Mathieu Chartier251755c2014-07-15 18:10:25 -070054static constexpr uint64_t kLongThreadSuspendThreshold = MsToNs(5);
Mathieu Chartier99143862015-02-03 14:26:46 -080055static constexpr uint64_t kThreadSuspendTimeoutMs = 30 * 1000; // 30s.
56// Use 0 since we want to yield to prevent blocking for an unpredictable amount of time.
57static constexpr useconds_t kThreadSuspendInitialSleepUs = 0;
58static constexpr useconds_t kThreadSuspendMaxYieldUs = 3000;
59static constexpr useconds_t kThreadSuspendMaxSleepUs = 5000;
Mathieu Chartier251755c2014-07-15 18:10:25 -070060
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -080061ThreadList::ThreadList()
Mathieu Chartier91e56692015-03-03 13:51:04 -080062 : suspend_all_count_(0), debug_suspend_all_count_(0), unregistering_count_(0),
Mathieu Chartierbf44d422015-06-02 11:42:18 -070063 suspend_all_historam_("suspend all histogram", 16, 64), long_suspend_(false) {
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -080064 CHECK(Monitor::IsValidLockWord(LockWord::FromThinLockId(kMaxThreadId, 1, 0U)));
Elliott Hughes8daa0922011-09-11 13:46:25 -070065}
66
67ThreadList::~ThreadList() {
Elliott Hughese52e49b2012-04-02 16:05:44 -070068 // Detach the current thread if necessary. If we failed to start, there might not be any threads.
Elliott Hughes6a144332012-04-03 13:07:11 -070069 // We need to detach the current thread here in case there's another thread waiting to join with
70 // us.
Mathieu Chartierfec72f42014-10-09 12:57:58 -070071 bool contains = false;
72 {
73 Thread* self = Thread::Current();
74 MutexLock mu(self, *Locks::thread_list_lock_);
75 contains = Contains(self);
76 }
77 if (contains) {
Elliott Hughes8daa0922011-09-11 13:46:25 -070078 Runtime::Current()->DetachCurrentThread();
79 }
Elliott Hughes6a144332012-04-03 13:07:11 -070080 WaitForOtherNonDaemonThreadsToExit();
Mathieu Chartier51168372015-08-12 16:40:32 -070081 // Disable GC and wait for GC to complete in case there are still daemon threads doing
82 // allocations.
83 gc::Heap* const heap = Runtime::Current()->GetHeap();
84 heap->DisableGCForShutdown();
85 // In case a GC is in progress, wait for it to finish.
86 heap->WaitForGcToComplete(gc::kGcCauseBackground, Thread::Current());
87
Ian Rogers00f7d0e2012-07-19 15:28:27 -070088 // TODO: there's an unaddressed race here where a thread may attach during shutdown, see
89 // Thread::Init.
Elliott Hughes6a144332012-04-03 13:07:11 -070090 SuspendAllDaemonThreads();
Elliott Hughes8daa0922011-09-11 13:46:25 -070091}
92
93bool ThreadList::Contains(Thread* thread) {
94 return find(list_.begin(), list_.end(), thread) != list_.end();
95}
96
Elliott Hughesabbe07d2012-06-05 17:42:23 -070097bool ThreadList::Contains(pid_t tid) {
Mathieu Chartier02e25112013-08-14 16:14:24 -070098 for (const auto& thread : list_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -070099 if (thread->GetTid() == tid) {
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700100 return true;
101 }
102 }
103 return false;
104}
105
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -0700106pid_t ThreadList::GetLockOwner() {
Ian Rogersb726dcb2012-09-05 08:57:23 -0700107 return Locks::thread_list_lock_->GetExclusiveOwnerTid();
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700108}
109
Mathieu Chartier590fee92013-09-13 13:46:47 -0700110void ThreadList::DumpNativeStacks(std::ostream& os) {
111 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
112 for (const auto& thread : list_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700113 os << "DUMPING THREAD " << thread->GetTid() << "\n";
Christopher Ferrisa2cee182014-04-16 19:13:59 -0700114 DumpNativeStack(os, thread->GetTid(), "\t");
Mathieu Chartier590fee92013-09-13 13:46:47 -0700115 os << "\n";
116 }
117}
118
Elliott Hughesc967f782012-04-16 10:23:15 -0700119void ThreadList::DumpForSigQuit(std::ostream& os) {
Mathieu Chartier70a596d2014-12-17 14:56:47 -0800120 {
121 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartier23f6e692014-12-18 18:24:39 -0800122 // Only print if we have samples.
123 if (suspend_all_historam_.SampleSize() > 0) {
124 Histogram<uint64_t>::CumulativeData data;
125 suspend_all_historam_.CreateHistogram(&data);
126 suspend_all_historam_.PrintConfidenceIntervals(os, 0.99, data); // Dump time to suspend.
127 }
Mathieu Chartier70a596d2014-12-17 14:56:47 -0800128 }
Ian Rogers7b078e82014-09-10 14:44:24 -0700129 Dump(os);
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700130 DumpUnattachedThreads(os);
131}
132
Ian Rogerscfaa4552012-11-26 21:00:08 -0800133static void DumpUnattachedThread(std::ostream& os, pid_t tid) NO_THREAD_SAFETY_ANALYSIS {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700134 // TODO: No thread safety analysis as DumpState with a null thread won't access fields, should
Ian Rogerscfaa4552012-11-26 21:00:08 -0800135 // refactor DumpState to avoid skipping analysis.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700136 Thread::DumpState(os, nullptr, tid);
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700137 DumpKernelStack(os, tid, " kernel: ", false);
Brian Carlstromed8b7232012-06-27 17:54:47 -0700138 // TODO: Reenable this when the native code in system_server can handle it.
139 // Currently "adb shell kill -3 `pid system_server`" will cause it to exit.
140 if (false) {
Christopher Ferrisa2cee182014-04-16 19:13:59 -0700141 DumpNativeStack(os, tid, " native: ");
Brian Carlstromed8b7232012-06-27 17:54:47 -0700142 }
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700143 os << "\n";
144}
145
146void ThreadList::DumpUnattachedThreads(std::ostream& os) {
147 DIR* d = opendir("/proc/self/task");
148 if (!d) {
149 return;
150 }
151
Ian Rogers50b35e22012-10-04 10:09:15 -0700152 Thread* self = Thread::Current();
Elliott Hughes4696b5b2012-10-30 10:35:10 -0700153 dirent* e;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700154 while ((e = readdir(d)) != nullptr) {
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700155 char* end;
Elliott Hughes4696b5b2012-10-30 10:35:10 -0700156 pid_t tid = strtol(e->d_name, &end, 10);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700157 if (!*end) {
158 bool contains;
159 {
Ian Rogers50b35e22012-10-04 10:09:15 -0700160 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700161 contains = Contains(tid);
162 }
163 if (!contains) {
164 DumpUnattachedThread(os, tid);
165 }
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700166 }
167 }
168 closedir(d);
Elliott Hughesff738062012-02-03 15:00:42 -0800169}
170
Andreas Gampe4a3d19b2015-01-09 17:54:51 -0800171// Dump checkpoint timeout in milliseconds. Larger amount on the host, as dumping will invoke
172// addr2line when available.
Andreas Gampe1e4b0ca2015-01-14 09:06:32 -0800173static constexpr uint32_t kDumpWaitTimeout = kIsTargetBuild ? 10000 : 20000;
Andreas Gampe4a3d19b2015-01-09 17:54:51 -0800174
Ian Rogers7b078e82014-09-10 14:44:24 -0700175// A closure used by Thread::Dump.
176class DumpCheckpoint FINAL : public Closure {
177 public:
178 explicit DumpCheckpoint(std::ostream* os) : os_(os), barrier_(0) {}
179
180 void Run(Thread* thread) OVERRIDE {
181 // Note thread and self may not be equal if thread was already suspended at the point of the
182 // request.
183 Thread* self = Thread::Current();
184 std::ostringstream local_os;
185 {
186 ScopedObjectAccess soa(self);
187 thread->Dump(local_os);
188 }
189 local_os << "\n";
190 {
191 // Use the logging lock to ensure serialization when writing to the common ostream.
192 MutexLock mu(self, *Locks::logging_lock_);
193 *os_ << local_os.str();
194 }
Lei Lidd9943d2015-02-02 14:24:44 +0800195 if (thread->GetState() == kRunnable) {
196 barrier_.Pass(self);
197 }
Elliott Hughes8daa0922011-09-11 13:46:25 -0700198 }
Ian Rogers7b078e82014-09-10 14:44:24 -0700199
200 void WaitForThreadsToRunThroughCheckpoint(size_t threads_running_checkpoint) {
201 Thread* self = Thread::Current();
202 ScopedThreadStateChange tsc(self, kWaitingForCheckPointsToRun);
Andreas Gampe1e4b0ca2015-01-14 09:06:32 -0800203 bool timed_out = barrier_.Increment(self, threads_running_checkpoint, kDumpWaitTimeout);
Ian Rogers2156ff12014-09-13 19:20:54 -0700204 if (timed_out) {
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000205 // Avoid a recursive abort.
206 LOG((kIsDebugBuild && (gAborting == 0)) ? FATAL : ERROR)
207 << "Unexpected time out during dump checkpoint.";
Ian Rogers2156ff12014-09-13 19:20:54 -0700208 }
Ian Rogers7b078e82014-09-10 14:44:24 -0700209 }
210
211 private:
212 // The common stream that will accumulate all the dumps.
213 std::ostream* const os_;
214 // The barrier to be passed through and for the requestor to wait upon.
215 Barrier barrier_;
216};
217
218void ThreadList::Dump(std::ostream& os) {
219 {
220 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
221 os << "DALVIK THREADS (" << list_.size() << "):\n";
222 }
223 DumpCheckpoint checkpoint(&os);
224 size_t threads_running_checkpoint = RunCheckpoint(&checkpoint);
Lei Lidd9943d2015-02-02 14:24:44 +0800225 if (threads_running_checkpoint != 0) {
226 checkpoint.WaitForThreadsToRunThroughCheckpoint(threads_running_checkpoint);
227 }
Elliott Hughes8daa0922011-09-11 13:46:25 -0700228}
229
Ian Rogers50b35e22012-10-04 10:09:15 -0700230void ThreadList::AssertThreadsAreSuspended(Thread* self, Thread* ignore1, Thread* ignore2) {
231 MutexLock mu(self, *Locks::thread_list_lock_);
232 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -0700233 for (const auto& thread : list_) {
jeffhao725a9572012-11-13 18:20:12 -0800234 if (thread != ignore1 && thread != ignore2) {
Ian Rogers01ae5802012-09-28 16:14:01 -0700235 CHECK(thread->IsSuspended())
236 << "\nUnsuspended thread: <<" << *thread << "\n"
237 << "self: <<" << *Thread::Current();
238 }
Elliott Hughes8d768a92011-09-14 16:35:25 -0700239 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700240}
241
Ian Rogers66aee5c2012-08-15 17:17:47 -0700242#if HAVE_TIMED_RWLOCK
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700243// Attempt to rectify locks so that we dump thread list with required locks before exiting.
Andreas Gampe794ad762015-02-23 08:12:24 -0800244NO_RETURN static void UnsafeLogFatalForThreadSuspendAllTimeout() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700245 Runtime* runtime = Runtime::Current();
246 std::ostringstream ss;
247 ss << "Thread suspend timeout\n";
Mathieu Chartier5869a2c2014-10-08 14:26:23 -0700248 Locks::mutator_lock_->Dump(ss);
249 ss << "\n";
Ian Rogers7b078e82014-09-10 14:44:24 -0700250 runtime->GetThreadList()->Dump(ss);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700251 LOG(FATAL) << ss.str();
Ian Rogers719d1a32014-03-06 12:13:39 -0800252 exit(0);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700253}
Ian Rogers66aee5c2012-08-15 17:17:47 -0700254#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700255
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800256// Unlike suspending all threads where we can wait to acquire the mutator_lock_, suspending an
Mathieu Chartier99143862015-02-03 14:26:46 -0800257// individual thread requires polling. delay_us is the requested sleep wait. If delay_us is 0 then
258// we use sched_yield instead of calling usleep.
259static void ThreadSuspendSleep(useconds_t delay_us) {
260 if (delay_us == 0) {
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800261 sched_yield();
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800262 } else {
Mathieu Chartier99143862015-02-03 14:26:46 -0800263 usleep(delay_us);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800264 }
265}
266
Mathieu Chartier0e4627e2012-10-23 16:13:36 -0700267size_t ThreadList::RunCheckpoint(Closure* checkpoint_function) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700268 Thread* self = Thread::Current();
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800269 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
270 Locks::thread_list_lock_->AssertNotHeld(self);
271 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000272 if (kDebugLocking && gAborting == 0) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700273 CHECK_NE(self->GetState(), kRunnable);
274 }
275
276 std::vector<Thread*> suspended_count_modified_threads;
277 size_t count = 0;
278 {
279 // Call a checkpoint function for each thread, threads which are suspend get their checkpoint
280 // manually called.
281 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700282 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -0700283 for (const auto& thread : list_) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700284 if (thread != self) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700285 while (true) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700286 if (thread->RequestCheckpoint(checkpoint_function)) {
Dave Allison0aded082013-11-07 13:15:11 -0800287 // This thread will run its checkpoint some time in the near future.
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700288 count++;
289 break;
290 } else {
291 // We are probably suspended, try to make sure that we stay suspended.
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700292 // The thread switched back to runnable.
293 if (thread->GetState() == kRunnable) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700294 // Spurious fail, try again.
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700295 continue;
296 }
Yu Lieac44242015-06-29 10:50:03 +0800297 thread->ModifySuspendCount(self, +1, nullptr, false);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700298 suspended_count_modified_threads.push_back(thread);
299 break;
300 }
301 }
302 }
303 }
304 }
305
306 // Run the checkpoint on ourself while we wait for threads to suspend.
307 checkpoint_function->Run(self);
308
309 // Run the checkpoint on the suspended threads.
Mathieu Chartier02e25112013-08-14 16:14:24 -0700310 for (const auto& thread : suspended_count_modified_threads) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700311 if (!thread->IsSuspended()) {
Mathieu Chartier99143862015-02-03 14:26:46 -0800312 if (ATRACE_ENABLED()) {
313 std::ostringstream oss;
314 thread->ShortDump(oss);
315 ATRACE_BEGIN((std::string("Waiting for suspension of thread ") + oss.str()).c_str());
316 }
317 // Busy wait until the thread is suspended.
318 const uint64_t start_time = NanoTime();
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700319 do {
Mathieu Chartier99143862015-02-03 14:26:46 -0800320 ThreadSuspendSleep(kThreadSuspendInitialSleepUs);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700321 } while (!thread->IsSuspended());
Mathieu Chartier99143862015-02-03 14:26:46 -0800322 const uint64_t total_delay = NanoTime() - start_time;
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800323 // Shouldn't need to wait for longer than 1000 microseconds.
Mathieu Chartier99143862015-02-03 14:26:46 -0800324 constexpr uint64_t kLongWaitThreshold = MsToNs(1);
325 ATRACE_END();
326 if (UNLIKELY(total_delay > kLongWaitThreshold)) {
327 LOG(WARNING) << "Long wait of " << PrettyDuration(total_delay) << " for "
328 << *thread << " suspension!";
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700329 }
330 }
331 // We know for sure that the thread is suspended at this point.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700332 checkpoint_function->Run(thread);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700333 {
334 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Yu Lieac44242015-06-29 10:50:03 +0800335 thread->ModifySuspendCount(self, -1, nullptr, false);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700336 }
337 }
338
Mathieu Chartier664bebf2012-11-12 16:54:11 -0800339 {
340 // Imitate ResumeAll, threads may be waiting on Thread::resume_cond_ since we raised their
341 // suspend count. Now the suspend_count_ is lowered so we must do the broadcast.
342 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
343 Thread::resume_cond_->Broadcast(self);
344 }
345
Lei Lidd9943d2015-02-02 14:24:44 +0800346 return count;
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700347}
348
Dave Allison39c3bfb2014-01-28 18:33:52 -0800349// Request that a checkpoint function be run on all active (non-suspended)
350// threads. Returns the number of successful requests.
351size_t ThreadList::RunCheckpointOnRunnableThreads(Closure* checkpoint_function) {
352 Thread* self = Thread::Current();
Ian Rogers7b078e82014-09-10 14:44:24 -0700353 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
354 Locks::thread_list_lock_->AssertNotHeld(self);
355 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
356 CHECK_NE(self->GetState(), kRunnable);
Dave Allison39c3bfb2014-01-28 18:33:52 -0800357
358 size_t count = 0;
359 {
360 // Call a checkpoint function for each non-suspended thread.
361 MutexLock mu(self, *Locks::thread_list_lock_);
362 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
363 for (const auto& thread : list_) {
364 if (thread != self) {
365 if (thread->RequestCheckpoint(checkpoint_function)) {
366 // This thread will run its checkpoint some time in the near future.
367 count++;
368 }
369 }
370 }
371 }
372
373 // Return the number of threads that will run the checkpoint function.
374 return count;
375}
376
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800377// A checkpoint/suspend-all hybrid to switch thread roots from
378// from-space to to-space refs. Used to synchronize threads at a point
379// to mark the initiation of marking while maintaining the to-space
380// invariant.
381size_t ThreadList::FlipThreadRoots(Closure* thread_flip_visitor, Closure* flip_callback,
382 gc::collector::GarbageCollector* collector) {
383 TimingLogger::ScopedTiming split("ThreadListFlip", collector->GetTimings());
384 const uint64_t start_time = NanoTime();
385 Thread* self = Thread::Current();
386 Locks::mutator_lock_->AssertNotHeld(self);
387 Locks::thread_list_lock_->AssertNotHeld(self);
388 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
389 CHECK_NE(self->GetState(), kRunnable);
390
Mathieu Chartierb19ccb12015-07-15 10:24:16 -0700391 SuspendAllInternal(self, self, nullptr);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800392
393 // Run the flip callback for the collector.
394 Locks::mutator_lock_->ExclusiveLock(self);
395 flip_callback->Run(self);
396 Locks::mutator_lock_->ExclusiveUnlock(self);
397 collector->RegisterPause(NanoTime() - start_time);
398
399 // Resume runnable threads.
Mathieu Chartierb19ccb12015-07-15 10:24:16 -0700400 std::vector<Thread*> runnable_threads;
401 std::vector<Thread*> other_threads;
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800402 {
403 MutexLock mu(self, *Locks::thread_list_lock_);
404 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
405 --suspend_all_count_;
406 for (const auto& thread : list_) {
407 if (thread == self) {
408 continue;
409 }
410 // Set the flip function for both runnable and suspended threads
411 // because Thread::DumpState/DumpJavaStack() (invoked by a
412 // checkpoint) may cause the flip function to be run for a
413 // runnable/suspended thread before a runnable threads runs it
414 // for itself or we run it for a suspended thread below.
415 thread->SetFlipFunction(thread_flip_visitor);
416 if (thread->IsSuspendedAtSuspendCheck()) {
417 // The thread will resume right after the broadcast.
Yu Lieac44242015-06-29 10:50:03 +0800418 thread->ModifySuspendCount(self, -1, nullptr, false);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800419 runnable_threads.push_back(thread);
420 } else {
421 other_threads.push_back(thread);
422 }
423 }
424 Thread::resume_cond_->Broadcast(self);
425 }
426
427 // Run the closure on the other threads and let them resume.
428 {
429 ReaderMutexLock mu(self, *Locks::mutator_lock_);
430 for (const auto& thread : other_threads) {
431 Closure* flip_func = thread->GetFlipFunction();
432 if (flip_func != nullptr) {
433 flip_func->Run(thread);
434 }
435 }
436 // Run it for self.
437 thread_flip_visitor->Run(self);
438 }
439
440 // Resume other threads.
441 {
442 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
443 for (const auto& thread : other_threads) {
Yu Lieac44242015-06-29 10:50:03 +0800444 thread->ModifySuspendCount(self, -1, nullptr, false);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800445 }
446 Thread::resume_cond_->Broadcast(self);
447 }
448
449 return runnable_threads.size() + other_threads.size() + 1; // +1 for self.
450}
451
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700452void ThreadList::SuspendAll(const char* cause, bool long_suspend) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700453 Thread* self = Thread::Current();
454
Jeff Haoc5d824a2014-07-28 18:35:38 -0700455 if (self != nullptr) {
Mathieu Chartierbf9fc582015-03-13 17:21:25 -0700456 VLOG(threads) << *self << " SuspendAll for " << cause << " starting...";
Jeff Haoc5d824a2014-07-28 18:35:38 -0700457 } else {
Mathieu Chartierbf9fc582015-03-13 17:21:25 -0700458 VLOG(threads) << "Thread[null] SuspendAll for " << cause << " starting...";
Jeff Haoc5d824a2014-07-28 18:35:38 -0700459 }
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700460 ATRACE_BEGIN("Suspending mutator threads");
Mathieu Chartier70a596d2014-12-17 14:56:47 -0800461 const uint64_t start_time = NanoTime();
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700462
Yu Lieac44242015-06-29 10:50:03 +0800463 SuspendAllInternal(self, self);
464 // All threads are known to have suspended (but a thread may still own the mutator lock)
465 // Make sure this thread grabs exclusive access to the mutator lock and its protected data.
Ian Rogers66aee5c2012-08-15 17:17:47 -0700466#if HAVE_TIMED_RWLOCK
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700467 while (true) {
468 if (Locks::mutator_lock_->ExclusiveLockWithTimeout(self, kThreadSuspendTimeoutMs, 0)) {
469 break;
470 } else if (!long_suspend_) {
471 // Reading long_suspend without the mutator lock is slightly racy, in some rare cases, this
472 // could result in a thread suspend timeout.
473 // Timeout if we wait more than kThreadSuspendTimeoutMs seconds.
474 UnsafeLogFatalForThreadSuspendAllTimeout();
475 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700476 }
Ian Rogers66aee5c2012-08-15 17:17:47 -0700477#else
Ian Rogers81d425b2012-09-27 16:03:43 -0700478 Locks::mutator_lock_->ExclusiveLock(self);
Ian Rogers66aee5c2012-08-15 17:17:47 -0700479#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700480
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700481 long_suspend_ = long_suspend;
482
Mathieu Chartier70a596d2014-12-17 14:56:47 -0800483 const uint64_t end_time = NanoTime();
484 const uint64_t suspend_time = end_time - start_time;
485 suspend_all_historam_.AdjustAndAddValue(suspend_time);
486 if (suspend_time > kLongThreadSuspendThreshold) {
487 LOG(WARNING) << "Suspending all threads took: " << PrettyDuration(suspend_time);
Mathieu Chartier251755c2014-07-15 18:10:25 -0700488 }
489
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800490 if (kDebugLocking) {
491 // Debug check that all threads are suspended.
492 AssertThreadsAreSuspended(self, self);
493 }
Elliott Hughes8d768a92011-09-14 16:35:25 -0700494
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700495 ATRACE_END();
Mathieu Chartierbf9fc582015-03-13 17:21:25 -0700496 ATRACE_BEGIN((std::string("Mutator threads suspended for ") + cause).c_str());
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700497
Jeff Haoc5d824a2014-07-28 18:35:38 -0700498 if (self != nullptr) {
499 VLOG(threads) << *self << " SuspendAll complete";
500 } else {
501 VLOG(threads) << "Thread[null] SuspendAll complete";
502 }
Elliott Hughes8d768a92011-09-14 16:35:25 -0700503}
504
Yu Lieac44242015-06-29 10:50:03 +0800505// Ensures all threads running Java suspend and that those not running Java don't start.
506// Debugger thread might be set to kRunnable for a short period of time after the
507// SuspendAllInternal. This is safe because it will be set back to suspended state before
508// the SuspendAll returns.
509void ThreadList::SuspendAllInternal(Thread* self, Thread* ignore1, Thread* ignore2,
510 bool debug_suspend) {
511 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
512 Locks::thread_list_lock_->AssertNotHeld(self);
513 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
514 if (kDebugLocking && self != nullptr) {
515 CHECK_NE(self->GetState(), kRunnable);
516 }
517
518 // First request that all threads suspend, then wait for them to suspend before
519 // returning. This suspension scheme also relies on other behaviour:
520 // 1. Threads cannot be deleted while they are suspended or have a suspend-
521 // request flag set - (see Unregister() below).
522 // 2. When threads are created, they are created in a suspended state (actually
523 // kNative) and will never begin executing Java code without first checking
524 // the suspend-request flag.
525
526 // The atomic counter for number of threads that need to pass the barrier.
527 AtomicInteger pending_threads;
528 uint32_t num_ignored = 0;
529 if (ignore1 != nullptr) {
530 ++num_ignored;
531 }
532 if (ignore2 != nullptr && ignore1 != ignore2) {
533 ++num_ignored;
534 }
535 {
536 MutexLock mu(self, *Locks::thread_list_lock_);
537 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
538 // Update global suspend all state for attaching threads.
539 ++suspend_all_count_;
540 if (debug_suspend)
541 ++debug_suspend_all_count_;
542 pending_threads.StoreRelaxed(list_.size() - num_ignored);
543 // Increment everybody's suspend count (except those that should be ignored).
544 for (const auto& thread : list_) {
545 if (thread == ignore1 || thread == ignore2) {
546 continue;
547 }
548 VLOG(threads) << "requesting thread suspend: " << *thread;
549 while (true) {
550 if (LIKELY(thread->ModifySuspendCount(self, +1, &pending_threads, debug_suspend))) {
551 break;
552 } else {
553 // Failure means the list of active_suspend_barriers is full, we should release the
554 // thread_suspend_count_lock_ (to avoid deadlock) and wait till the target thread has
555 // executed Thread::PassActiveSuspendBarriers(). Note that we could not simply wait for
556 // the thread to change to a suspended state, because it might need to run checkpoint
557 // function before the state change, which also needs thread_suspend_count_lock_.
558
559 // This is very unlikely to happen since more than kMaxSuspendBarriers threads need to
560 // execute SuspendAllInternal() simultaneously, and target thread stays in kRunnable
561 // in the mean time.
562 Locks::thread_suspend_count_lock_->ExclusiveUnlock(self);
563 NanoSleep(100000);
564 Locks::thread_suspend_count_lock_->ExclusiveLock(self);
565 }
566 }
567
568 // Must install the pending_threads counter first, then check thread->IsSuspend() and clear
569 // the counter. Otherwise there's a race with Thread::TransitionFromRunnableToSuspended()
570 // that can lead a thread to miss a call to PassActiveSuspendBarriers().
571 if (thread->IsSuspended()) {
572 // Only clear the counter for the current thread.
573 thread->ClearSuspendBarrier(&pending_threads);
574 pending_threads.FetchAndSubSequentiallyConsistent(1);
575 }
576 }
577 }
578
579 // Wait for the barrier to be passed by all runnable threads. This wait
580 // is done with a timeout so that we can detect problems.
Mathieu Chartier19af1172015-07-14 10:05:45 -0700581#if ART_USE_FUTEXES
Yu Lieac44242015-06-29 10:50:03 +0800582 timespec wait_timeout;
583 InitTimeSpec(true, CLOCK_MONOTONIC, 10000, 0, &wait_timeout);
Mathieu Chartier19af1172015-07-14 10:05:45 -0700584#endif
Yu Lieac44242015-06-29 10:50:03 +0800585 while (true) {
586 int32_t cur_val = pending_threads.LoadRelaxed();
587 if (LIKELY(cur_val > 0)) {
588#if ART_USE_FUTEXES
589 if (futex(pending_threads.Address(), FUTEX_WAIT, cur_val, &wait_timeout, nullptr, 0) != 0) {
590 // EAGAIN and EINTR both indicate a spurious failure, try again from the beginning.
591 if ((errno != EAGAIN) && (errno != EINTR)) {
592 if (errno == ETIMEDOUT) {
593 LOG(kIsDebugBuild ? FATAL : ERROR) << "Unexpected time out during suspend all.";
594 } else {
595 PLOG(FATAL) << "futex wait failed for SuspendAllInternal()";
596 }
597 }
598 } else {
599 cur_val = pending_threads.LoadRelaxed();
600 CHECK_EQ(cur_val, 0);
601 break;
602 }
603#else
604 // Spin wait. This is likely to be slow, but on most architecture ART_USE_FUTEXES is set.
605#endif
606 } else {
607 CHECK_EQ(cur_val, 0);
608 break;
609 }
610 }
611}
612
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700613void ThreadList::ResumeAll() {
614 Thread* self = Thread::Current();
615
Jeff Haoc5d824a2014-07-28 18:35:38 -0700616 if (self != nullptr) {
617 VLOG(threads) << *self << " ResumeAll starting";
618 } else {
619 VLOG(threads) << "Thread[null] ResumeAll starting";
620 }
Ian Rogers01ae5802012-09-28 16:14:01 -0700621
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700622 ATRACE_END();
623 ATRACE_BEGIN("Resuming mutator threads");
624
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800625 if (kDebugLocking) {
626 // Debug check that all threads are suspended.
627 AssertThreadsAreSuspended(self, self);
628 }
Ian Rogers01ae5802012-09-28 16:14:01 -0700629
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700630 long_suspend_ = false;
631
Ian Rogers81d425b2012-09-27 16:03:43 -0700632 Locks::mutator_lock_->ExclusiveUnlock(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700633 {
Ian Rogers81d425b2012-09-27 16:03:43 -0700634 MutexLock mu(self, *Locks::thread_list_lock_);
635 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700636 // Update global suspend all state for attaching threads.
637 --suspend_all_count_;
638 // Decrement the suspend counts for all threads.
Mathieu Chartier02e25112013-08-14 16:14:24 -0700639 for (const auto& thread : list_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700640 if (thread == self) {
641 continue;
642 }
Yu Lieac44242015-06-29 10:50:03 +0800643 thread->ModifySuspendCount(self, -1, nullptr, false);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700644 }
645
646 // Broadcast a notification to all suspended threads, some or all of
647 // which may choose to wake up. No need to wait for them.
Jeff Haoc5d824a2014-07-28 18:35:38 -0700648 if (self != nullptr) {
649 VLOG(threads) << *self << " ResumeAll waking others";
650 } else {
651 VLOG(threads) << "Thread[null] ResumeAll waking others";
652 }
Ian Rogersc604d732012-10-14 16:09:54 -0700653 Thread::resume_cond_->Broadcast(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700654 }
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700655 ATRACE_END();
Jeff Haoc5d824a2014-07-28 18:35:38 -0700656
657 if (self != nullptr) {
658 VLOG(threads) << *self << " ResumeAll complete";
659 } else {
660 VLOG(threads) << "Thread[null] ResumeAll complete";
661 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700662}
663
664void ThreadList::Resume(Thread* thread, bool for_debugger) {
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -0800665 // This assumes there was an ATRACE_BEGIN when we suspended the thread.
666 ATRACE_END();
667
Ian Rogers81d425b2012-09-27 16:03:43 -0700668 Thread* self = Thread::Current();
669 DCHECK_NE(thread, self);
Brian Carlstromba32de42014-08-27 23:43:46 -0700670 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") starting..."
671 << (for_debugger ? " (debugger)" : "");
Elliott Hughes01158d72011-09-19 19:47:10 -0700672
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700673 {
674 // To check Contains.
Ian Rogers81d425b2012-09-27 16:03:43 -0700675 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700676 // To check IsSuspended.
Ian Rogers81d425b2012-09-27 16:03:43 -0700677 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
678 DCHECK(thread->IsSuspended());
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700679 if (!Contains(thread)) {
Brian Carlstromba32de42014-08-27 23:43:46 -0700680 // We only expect threads within the thread-list to have been suspended otherwise we can't
681 // stop such threads from delete-ing themselves.
682 LOG(ERROR) << "Resume(" << reinterpret_cast<void*>(thread)
683 << ") thread not within thread list";
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700684 return;
685 }
Yu Lieac44242015-06-29 10:50:03 +0800686 thread->ModifySuspendCount(self, -1, nullptr, for_debugger);
Elliott Hughes01158d72011-09-19 19:47:10 -0700687 }
688
689 {
Brian Carlstromba32de42014-08-27 23:43:46 -0700690 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") waking others";
Ian Rogers81d425b2012-09-27 16:03:43 -0700691 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersc604d732012-10-14 16:09:54 -0700692 Thread::resume_cond_->Broadcast(self);
Elliott Hughes01158d72011-09-19 19:47:10 -0700693 }
694
Brian Carlstromba32de42014-08-27 23:43:46 -0700695 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") complete";
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700696}
Elliott Hughes01158d72011-09-19 19:47:10 -0700697
Ian Rogersc7dd2952014-10-21 23:31:19 -0700698static void ThreadSuspendByPeerWarning(Thread* self, LogSeverity severity, const char* message,
699 jobject peer) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700700 JNIEnvExt* env = self->GetJniEnv();
701 ScopedLocalRef<jstring>
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700702 scoped_name_string(env, (jstring)env->GetObjectField(
703 peer, WellKnownClasses::java_lang_Thread_name));
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700704 ScopedUtfChars scoped_name_chars(env, scoped_name_string.get());
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700705 if (scoped_name_chars.c_str() == nullptr) {
Ian Rogersc7dd2952014-10-21 23:31:19 -0700706 LOG(severity) << message << ": " << peer;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700707 env->ExceptionClear();
708 } else {
Ian Rogersc7dd2952014-10-21 23:31:19 -0700709 LOG(severity) << message << ": " << peer << ":" << scoped_name_chars.c_str();
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700710 }
711}
712
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700713Thread* ThreadList::SuspendThreadByPeer(jobject peer, bool request_suspension,
714 bool debug_suspension, bool* timed_out) {
Mathieu Chartier3a958aa2015-02-04 12:52:34 -0800715 const uint64_t start_time = NanoTime();
Mathieu Chartier99143862015-02-03 14:26:46 -0800716 useconds_t sleep_us = kThreadSuspendInitialSleepUs;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700717 *timed_out = false;
Mathieu Chartier99143862015-02-03 14:26:46 -0800718 Thread* const self = Thread::Current();
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800719 Thread* suspended_thread = nullptr;
Brian Carlstromba32de42014-08-27 23:43:46 -0700720 VLOG(threads) << "SuspendThreadByPeer starting";
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700721 while (true) {
722 Thread* thread;
723 {
Ian Rogersf3d874c2014-07-17 18:52:42 -0700724 // Note: this will transition to runnable and potentially suspend. We ensure only one thread
725 // is requesting another suspend, to avoid deadlock, by requiring this function be called
726 // holding Locks::thread_list_suspend_thread_lock_. Its important this thread suspend rather
727 // than request thread suspension, to avoid potential cycles in threads requesting each other
728 // suspend.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700729 ScopedObjectAccess soa(self);
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800730 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700731 thread = Thread::FromManagedThread(soa, peer);
Brian Carlstromba32de42014-08-27 23:43:46 -0700732 if (thread == nullptr) {
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800733 if (suspended_thread != nullptr) {
734 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
735 // If we incremented the suspend count but the thread reset its peer, we need to
736 // re-decrement it since it is shutting down and may deadlock the runtime in
737 // ThreadList::WaitForOtherNonDaemonThreadsToExit.
Yu Lieac44242015-06-29 10:50:03 +0800738 suspended_thread->ModifySuspendCount(soa.Self(), -1, nullptr, debug_suspension);
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800739 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700740 ThreadSuspendByPeerWarning(self, WARNING, "No such thread for suspend", peer);
Brian Carlstromba32de42014-08-27 23:43:46 -0700741 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700742 }
Brian Carlstromba32de42014-08-27 23:43:46 -0700743 if (!Contains(thread)) {
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800744 CHECK(suspended_thread == nullptr);
Brian Carlstromba32de42014-08-27 23:43:46 -0700745 VLOG(threads) << "SuspendThreadByPeer failed for unattached thread: "
746 << reinterpret_cast<void*>(thread);
747 return nullptr;
748 }
749 VLOG(threads) << "SuspendThreadByPeer found thread: " << *thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700750 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800751 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700752 if (request_suspension) {
Ian Rogers4ad5cd32014-11-11 23:08:07 -0800753 if (self->GetSuspendCount() > 0) {
754 // We hold the suspend count lock but another thread is trying to suspend us. Its not
755 // safe to try to suspend another thread in case we get a cycle. Start the loop again
756 // which will allow this thread to be suspended.
757 continue;
758 }
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800759 CHECK(suspended_thread == nullptr);
760 suspended_thread = thread;
Yu Lieac44242015-06-29 10:50:03 +0800761 suspended_thread->ModifySuspendCount(self, +1, nullptr, debug_suspension);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700762 request_suspension = false;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700763 } else {
764 // If the caller isn't requesting suspension, a suspension should have already occurred.
765 CHECK_GT(thread->GetSuspendCount(), 0);
766 }
767 // IsSuspended on the current thread will fail as the current thread is changed into
768 // Runnable above. As the suspend count is now raised if this is the current thread
769 // it will self suspend on transition to Runnable, making it hard to work with. It's simpler
770 // to just explicitly handle the current thread in the callers to this code.
771 CHECK_NE(thread, self) << "Attempt to suspend the current thread for the debugger";
772 // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend
773 // count, or else we've waited and it has self suspended) or is the current thread, we're
774 // done.
775 if (thread->IsSuspended()) {
Brian Carlstromba32de42014-08-27 23:43:46 -0700776 VLOG(threads) << "SuspendThreadByPeer thread suspended: " << *thread;
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -0800777 if (ATRACE_ENABLED()) {
778 std::string name;
779 thread->GetThreadName(name);
780 ATRACE_BEGIN(StringPrintf("SuspendThreadByPeer suspended %s for peer=%p", name.c_str(),
781 peer).c_str());
782 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700783 return thread;
784 }
Mathieu Chartier99143862015-02-03 14:26:46 -0800785 const uint64_t total_delay = NanoTime() - start_time;
786 if (total_delay >= MsToNs(kThreadSuspendTimeoutMs)) {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700787 ThreadSuspendByPeerWarning(self, FATAL, "Thread suspension timed out", peer);
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800788 if (suspended_thread != nullptr) {
789 CHECK_EQ(suspended_thread, thread);
Yu Lieac44242015-06-29 10:50:03 +0800790 suspended_thread->ModifySuspendCount(soa.Self(), -1, nullptr, debug_suspension);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700791 }
792 *timed_out = true;
Brian Carlstromba32de42014-08-27 23:43:46 -0700793 return nullptr;
Mathieu Chartier99143862015-02-03 14:26:46 -0800794 } else if (sleep_us == 0 &&
795 total_delay > static_cast<uint64_t>(kThreadSuspendMaxYieldUs) * 1000) {
796 // We have spun for kThreadSuspendMaxYieldUs time, switch to sleeps to prevent
797 // excessive CPU usage.
798 sleep_us = kThreadSuspendMaxYieldUs / 2;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700799 }
800 }
801 // Release locks and come out of runnable state.
802 }
Mathieu Chartier99143862015-02-03 14:26:46 -0800803 VLOG(threads) << "SuspendThreadByPeer waiting to allow thread chance to suspend";
804 ThreadSuspendSleep(sleep_us);
805 // This may stay at 0 if sleep_us == 0, but this is WAI since we want to avoid using usleep at
806 // all if possible. This shouldn't be an issue since time to suspend should always be small.
807 sleep_us = std::min(sleep_us * 2, kThreadSuspendMaxSleepUs);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700808 }
809}
810
Ian Rogersc7dd2952014-10-21 23:31:19 -0700811static void ThreadSuspendByThreadIdWarning(LogSeverity severity, const char* message,
812 uint32_t thread_id) {
813 LOG(severity) << StringPrintf("%s: %d", message, thread_id);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700814}
815
816Thread* ThreadList::SuspendThreadByThreadId(uint32_t thread_id, bool debug_suspension,
817 bool* timed_out) {
Mathieu Chartier3a958aa2015-02-04 12:52:34 -0800818 const uint64_t start_time = NanoTime();
Mathieu Chartier99143862015-02-03 14:26:46 -0800819 useconds_t sleep_us = kThreadSuspendInitialSleepUs;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700820 *timed_out = false;
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800821 Thread* suspended_thread = nullptr;
Mathieu Chartier99143862015-02-03 14:26:46 -0800822 Thread* const self = Thread::Current();
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700823 CHECK_NE(thread_id, kInvalidThreadId);
Brian Carlstromba32de42014-08-27 23:43:46 -0700824 VLOG(threads) << "SuspendThreadByThreadId starting";
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700825 while (true) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700826 {
Ian Rogersf3d874c2014-07-17 18:52:42 -0700827 // Note: this will transition to runnable and potentially suspend. We ensure only one thread
828 // is requesting another suspend, to avoid deadlock, by requiring this function be called
829 // holding Locks::thread_list_suspend_thread_lock_. Its important this thread suspend rather
830 // than request thread suspension, to avoid potential cycles in threads requesting each other
831 // suspend.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700832 ScopedObjectAccess soa(self);
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800833 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Ian Rogersf3d874c2014-07-17 18:52:42 -0700834 Thread* thread = nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700835 for (const auto& it : list_) {
836 if (it->GetThreadId() == thread_id) {
837 thread = it;
838 break;
839 }
840 }
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800841 if (thread == nullptr) {
842 CHECK(suspended_thread == nullptr) << "Suspended thread " << suspended_thread
843 << " no longer in thread list";
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700844 // There's a race in inflating a lock and the owner giving up ownership and then dying.
845 ThreadSuspendByThreadIdWarning(WARNING, "No such thread id for suspend", thread_id);
Brian Carlstromba32de42014-08-27 23:43:46 -0700846 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700847 }
Brian Carlstromba32de42014-08-27 23:43:46 -0700848 VLOG(threads) << "SuspendThreadByThreadId found thread: " << *thread;
849 DCHECK(Contains(thread));
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700850 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800851 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800852 if (suspended_thread == nullptr) {
Ian Rogers4ad5cd32014-11-11 23:08:07 -0800853 if (self->GetSuspendCount() > 0) {
854 // We hold the suspend count lock but another thread is trying to suspend us. Its not
855 // safe to try to suspend another thread in case we get a cycle. Start the loop again
856 // which will allow this thread to be suspended.
857 continue;
858 }
Yu Lieac44242015-06-29 10:50:03 +0800859 thread->ModifySuspendCount(self, +1, nullptr, debug_suspension);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800860 suspended_thread = thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700861 } else {
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800862 CHECK_EQ(suspended_thread, thread);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700863 // If the caller isn't requesting suspension, a suspension should have already occurred.
864 CHECK_GT(thread->GetSuspendCount(), 0);
865 }
866 // IsSuspended on the current thread will fail as the current thread is changed into
867 // Runnable above. As the suspend count is now raised if this is the current thread
868 // it will self suspend on transition to Runnable, making it hard to work with. It's simpler
869 // to just explicitly handle the current thread in the callers to this code.
870 CHECK_NE(thread, self) << "Attempt to suspend the current thread for the debugger";
871 // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend
872 // count, or else we've waited and it has self suspended) or is the current thread, we're
873 // done.
874 if (thread->IsSuspended()) {
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -0800875 if (ATRACE_ENABLED()) {
876 std::string name;
877 thread->GetThreadName(name);
878 ATRACE_BEGIN(StringPrintf("SuspendThreadByThreadId suspended %s id=%d",
879 name.c_str(), thread_id).c_str());
880 }
Brian Carlstromba32de42014-08-27 23:43:46 -0700881 VLOG(threads) << "SuspendThreadByThreadId thread suspended: " << *thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700882 return thread;
883 }
Mathieu Chartier99143862015-02-03 14:26:46 -0800884 const uint64_t total_delay = NanoTime() - start_time;
885 if (total_delay >= MsToNs(kThreadSuspendTimeoutMs)) {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700886 ThreadSuspendByThreadIdWarning(WARNING, "Thread suspension timed out", thread_id);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800887 if (suspended_thread != nullptr) {
Yu Lieac44242015-06-29 10:50:03 +0800888 thread->ModifySuspendCount(soa.Self(), -1, nullptr, debug_suspension);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700889 }
890 *timed_out = true;
Brian Carlstromba32de42014-08-27 23:43:46 -0700891 return nullptr;
Mathieu Chartier99143862015-02-03 14:26:46 -0800892 } else if (sleep_us == 0 &&
893 total_delay > static_cast<uint64_t>(kThreadSuspendMaxYieldUs) * 1000) {
894 // We have spun for kThreadSuspendMaxYieldUs time, switch to sleeps to prevent
895 // excessive CPU usage.
896 sleep_us = kThreadSuspendMaxYieldUs / 2;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700897 }
898 }
899 // Release locks and come out of runnable state.
900 }
Mathieu Chartier99143862015-02-03 14:26:46 -0800901 VLOG(threads) << "SuspendThreadByThreadId waiting to allow thread chance to suspend";
902 ThreadSuspendSleep(sleep_us);
903 sleep_us = std::min(sleep_us * 2, kThreadSuspendMaxSleepUs);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700904 }
905}
906
907Thread* ThreadList::FindThreadByThreadId(uint32_t thin_lock_id) {
908 Thread* self = Thread::Current();
909 MutexLock mu(self, *Locks::thread_list_lock_);
910 for (const auto& thread : list_) {
911 if (thread->GetThreadId() == thin_lock_id) {
912 CHECK(thread == self || thread->IsSuspended());
913 return thread;
914 }
915 }
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700916 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700917}
918
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700919void ThreadList::SuspendAllForDebugger() {
920 Thread* self = Thread::Current();
921 Thread* debug_thread = Dbg::GetDebugThread();
922
923 VLOG(threads) << *self << " SuspendAllForDebugger starting...";
924
Yu Lieac44242015-06-29 10:50:03 +0800925 SuspendAllInternal(self, self, debug_thread, true);
Ian Rogers66aee5c2012-08-15 17:17:47 -0700926 // Block on the mutator lock until all Runnable threads release their share of access then
927 // immediately unlock again.
928#if HAVE_TIMED_RWLOCK
929 // Timeout if we wait more than 30 seconds.
Ian Rogersc604d732012-10-14 16:09:54 -0700930 if (!Locks::mutator_lock_->ExclusiveLockWithTimeout(self, 30 * 1000, 0)) {
Sebastien Hertzbae182c2013-12-17 10:42:03 +0100931 UnsafeLogFatalForThreadSuspendAllTimeout();
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700932 } else {
Ian Rogers81d425b2012-09-27 16:03:43 -0700933 Locks::mutator_lock_->ExclusiveUnlock(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700934 }
Ian Rogers66aee5c2012-08-15 17:17:47 -0700935#else
Ian Rogers81d425b2012-09-27 16:03:43 -0700936 Locks::mutator_lock_->ExclusiveLock(self);
937 Locks::mutator_lock_->ExclusiveUnlock(self);
Ian Rogers66aee5c2012-08-15 17:17:47 -0700938#endif
Ian Rogers50b35e22012-10-04 10:09:15 -0700939 AssertThreadsAreSuspended(self, self, debug_thread);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700940
Sebastien Hertzed2be172014-08-19 15:33:43 +0200941 VLOG(threads) << *self << " SuspendAllForDebugger complete";
Elliott Hughes01158d72011-09-19 19:47:10 -0700942}
943
Elliott Hughes475fc232011-10-25 15:00:35 -0700944void ThreadList::SuspendSelfForDebugger() {
Sebastien Hertz1558b572015-02-25 15:05:59 +0100945 Thread* const self = Thread::Current();
946 self->SetReadyForDebugInvoke(true);
Elliott Hughes01158d72011-09-19 19:47:10 -0700947
Elliott Hughes475fc232011-10-25 15:00:35 -0700948 // The debugger thread must not suspend itself due to debugger activity!
949 Thread* debug_thread = Dbg::GetDebugThread();
Elliott Hughes475fc232011-10-25 15:00:35 -0700950 CHECK(self != debug_thread);
jeffhaoa77f0f62012-12-05 17:19:31 -0800951 CHECK_NE(self->GetState(), kRunnable);
952 Locks::mutator_lock_->AssertNotHeld(self);
Elliott Hughes475fc232011-10-25 15:00:35 -0700953
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200954 // The debugger may have detached while we were executing an invoke request. In that case, we
955 // must not suspend ourself.
956 DebugInvokeReq* pReq = self->GetInvokeReq();
957 const bool skip_thread_suspension = (pReq != nullptr && !Dbg::IsDebuggerActive());
958 if (!skip_thread_suspension) {
jeffhaoa77f0f62012-12-05 17:19:31 -0800959 // Collisions with other suspends aren't really interesting. We want
960 // to ensure that we're the only one fiddling with the suspend count
961 // though.
962 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Yu Lieac44242015-06-29 10:50:03 +0800963 self->ModifySuspendCount(self, +1, nullptr, true);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700964 CHECK_GT(self->GetSuspendCount(), 0);
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200965
966 VLOG(threads) << *self << " self-suspending (debugger)";
967 } else {
968 // We must no longer be subject to debugger suspension.
969 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
970 CHECK_EQ(self->GetDebugSuspendCount(), 0) << "Debugger detached without resuming us";
971
972 VLOG(threads) << *self << " not self-suspending because debugger detached during invoke";
jeffhaoa77f0f62012-12-05 17:19:31 -0800973 }
Elliott Hughes475fc232011-10-25 15:00:35 -0700974
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200975 // If the debugger requested an invoke, we need to send the reply and clear the request.
Sebastien Hertz1558b572015-02-25 15:05:59 +0100976 if (pReq != nullptr) {
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200977 Dbg::FinishInvokeMethod(pReq);
Sebastien Hertz1558b572015-02-25 15:05:59 +0100978 self->ClearDebugInvokeReq();
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200979 pReq = nullptr; // object has been deleted, clear it for safety.
Sebastien Hertz21e729c2014-02-18 14:16:00 +0100980 }
981
Elliott Hughes475fc232011-10-25 15:00:35 -0700982 // Tell JDWP that we've completed suspension. The JDWP thread can't
983 // tell us to resume before we're fully asleep because we hold the
984 // suspend count lock.
985 Dbg::ClearWaitForEventThread();
986
jeffhaoa77f0f62012-12-05 17:19:31 -0800987 {
988 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700989 while (self->GetSuspendCount() != 0) {
jeffhaoa77f0f62012-12-05 17:19:31 -0800990 Thread::resume_cond_->Wait(self);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700991 if (self->GetSuspendCount() != 0) {
jeffhaoa77f0f62012-12-05 17:19:31 -0800992 // The condition was signaled but we're still suspended. This
Sebastien Hertzf272af42014-09-18 10:20:42 +0200993 // can happen when we suspend then resume all threads to
994 // update instrumentation or compute monitor info. This can
995 // also happen if the debugger lets go while a SIGQUIT thread
jeffhaoa77f0f62012-12-05 17:19:31 -0800996 // dump event is pending (assuming SignalCatcher was resumed for
997 // just long enough to try to grab the thread-suspend lock).
Sebastien Hertzf272af42014-09-18 10:20:42 +0200998 VLOG(jdwp) << *self << " still suspended after undo "
999 << "(suspend count=" << self->GetSuspendCount() << ", "
1000 << "debug suspend count=" << self->GetDebugSuspendCount() << ")";
jeffhaoa77f0f62012-12-05 17:19:31 -08001001 }
Elliott Hughes475fc232011-10-25 15:00:35 -07001002 }
Ian Rogersdd7624d2014-03-14 17:43:00 -07001003 CHECK_EQ(self->GetSuspendCount(), 0);
Elliott Hughes475fc232011-10-25 15:00:35 -07001004 }
jeffhaoa77f0f62012-12-05 17:19:31 -08001005
Sebastien Hertz1558b572015-02-25 15:05:59 +01001006 self->SetReadyForDebugInvoke(false);
Elliott Hughes1f729aa2012-03-02 13:55:41 -08001007 VLOG(threads) << *self << " self-reviving (debugger)";
Elliott Hughes475fc232011-10-25 15:00:35 -07001008}
1009
Sebastien Hertz253fa552014-10-14 17:27:15 +02001010void ThreadList::ResumeAllForDebugger() {
1011 Thread* self = Thread::Current();
1012 Thread* debug_thread = Dbg::GetDebugThread();
Sebastien Hertz253fa552014-10-14 17:27:15 +02001013
1014 VLOG(threads) << *self << " ResumeAllForDebugger starting...";
1015
1016 // Threads can't resume if we exclusively hold the mutator lock.
1017 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
1018
1019 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001020 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Sebastien Hertz253fa552014-10-14 17:27:15 +02001021 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001022 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Sebastien Hertz253fa552014-10-14 17:27:15 +02001023 // Update global suspend all state for attaching threads.
1024 DCHECK_GE(suspend_all_count_, debug_suspend_all_count_);
Sebastien Hertzf9d233d2015-01-09 14:51:41 +01001025 if (debug_suspend_all_count_ > 0) {
Sebastien Hertz253fa552014-10-14 17:27:15 +02001026 --suspend_all_count_;
1027 --debug_suspend_all_count_;
Sebastien Hertz253fa552014-10-14 17:27:15 +02001028 } else {
1029 // We've been asked to resume all threads without being asked to
Sebastien Hertzf9d233d2015-01-09 14:51:41 +01001030 // suspend them all before. That may happen if a debugger tries
1031 // to resume some suspended threads (with suspend count == 1)
1032 // at once with a VirtualMachine.Resume command. Let's print a
1033 // warning.
Sebastien Hertz253fa552014-10-14 17:27:15 +02001034 LOG(WARNING) << "Debugger attempted to resume all threads without "
1035 << "having suspended them all before.";
1036 }
Sebastien Hertzf9d233d2015-01-09 14:51:41 +01001037 // Decrement everybody's suspend count (except our own).
1038 for (const auto& thread : list_) {
1039 if (thread == self || thread == debug_thread) {
1040 continue;
1041 }
1042 if (thread->GetDebugSuspendCount() == 0) {
1043 // This thread may have been individually resumed with ThreadReference.Resume.
1044 continue;
1045 }
1046 VLOG(threads) << "requesting thread resume: " << *thread;
Yu Lieac44242015-06-29 10:50:03 +08001047 thread->ModifySuspendCount(self, -1, nullptr, true);
Sebastien Hertzf9d233d2015-01-09 14:51:41 +01001048 }
Sebastien Hertz253fa552014-10-14 17:27:15 +02001049 }
1050 }
1051
Sebastien Hertzf9d233d2015-01-09 14:51:41 +01001052 {
Sebastien Hertz253fa552014-10-14 17:27:15 +02001053 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
1054 Thread::resume_cond_->Broadcast(self);
1055 }
1056
1057 VLOG(threads) << *self << " ResumeAllForDebugger complete";
1058}
1059
Elliott Hughes234ab152011-10-26 14:02:26 -07001060void ThreadList::UndoDebuggerSuspensions() {
1061 Thread* self = Thread::Current();
1062
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001063 VLOG(threads) << *self << " UndoDebuggerSuspensions starting";
Elliott Hughes234ab152011-10-26 14:02:26 -07001064
1065 {
Ian Rogers81d425b2012-09-27 16:03:43 -07001066 MutexLock mu(self, *Locks::thread_list_lock_);
1067 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001068 // Update global suspend all state for attaching threads.
1069 suspend_all_count_ -= debug_suspend_all_count_;
1070 debug_suspend_all_count_ = 0;
1071 // Update running threads.
Mathieu Chartier02e25112013-08-14 16:14:24 -07001072 for (const auto& thread : list_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001073 if (thread == self || thread->GetDebugSuspendCount() == 0) {
Elliott Hughes234ab152011-10-26 14:02:26 -07001074 continue;
1075 }
Yu Lieac44242015-06-29 10:50:03 +08001076 thread->ModifySuspendCount(self, -thread->GetDebugSuspendCount(), nullptr, true);
Elliott Hughes234ab152011-10-26 14:02:26 -07001077 }
1078 }
1079
1080 {
Ian Rogers81d425b2012-09-27 16:03:43 -07001081 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersc604d732012-10-14 16:09:54 -07001082 Thread::resume_cond_->Broadcast(self);
Elliott Hughes234ab152011-10-26 14:02:26 -07001083 }
1084
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001085 VLOG(threads) << "UndoDebuggerSuspensions(" << *self << ") complete";
Elliott Hughes234ab152011-10-26 14:02:26 -07001086}
1087
Elliott Hughese52e49b2012-04-02 16:05:44 -07001088void ThreadList::WaitForOtherNonDaemonThreadsToExit() {
Ian Rogers81d425b2012-09-27 16:03:43 -07001089 Thread* self = Thread::Current();
1090 Locks::mutator_lock_->AssertNotHeld(self);
Mathieu Chartier91e56692015-03-03 13:51:04 -08001091 while (true) {
Ian Rogers120f1c72012-09-28 17:17:10 -07001092 {
1093 // No more threads can be born after we start to shutdown.
1094 MutexLock mu(self, *Locks::runtime_shutdown_lock_);
Mathieu Chartier590fee92013-09-13 13:46:47 -07001095 CHECK(Runtime::Current()->IsShuttingDownLocked());
Ian Rogers120f1c72012-09-28 17:17:10 -07001096 CHECK_EQ(Runtime::Current()->NumberOfThreadsBeingBorn(), 0U);
1097 }
Ian Rogers120f1c72012-09-28 17:17:10 -07001098 MutexLock mu(self, *Locks::thread_list_lock_);
Mathieu Chartier91e56692015-03-03 13:51:04 -08001099 // Also wait for any threads that are unregistering to finish. This is required so that no
1100 // threads access the thread list after it is deleted. TODO: This may not work for user daemon
1101 // threads since they could unregister at the wrong time.
1102 bool done = unregistering_count_ == 0;
1103 if (done) {
1104 for (const auto& thread : list_) {
1105 if (thread != self && !thread->IsDaemon()) {
1106 done = false;
1107 break;
1108 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001109 }
1110 }
Mathieu Chartier91e56692015-03-03 13:51:04 -08001111 if (done) {
1112 break;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001113 }
Mathieu Chartier91e56692015-03-03 13:51:04 -08001114 // Wait for another thread to exit before re-checking.
1115 Locks::thread_exit_cond_->Wait(self);
1116 }
Elliott Hughes038a8062011-09-18 14:12:41 -07001117}
1118
1119void ThreadList::SuspendAllDaemonThreads() {
Ian Rogers81d425b2012-09-27 16:03:43 -07001120 Thread* self = Thread::Current();
1121 MutexLock mu(self, *Locks::thread_list_lock_);
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001122 { // Tell all the daemons it's time to suspend.
Ian Rogers81d425b2012-09-27 16:03:43 -07001123 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001124 for (const auto& thread : list_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001125 // This is only run after all non-daemon threads have exited, so the remainder should all be
1126 // daemons.
Ian Rogers7e762862012-10-22 15:45:08 -07001127 CHECK(thread->IsDaemon()) << *thread;
Ian Rogers81d425b2012-09-27 16:03:43 -07001128 if (thread != self) {
Yu Lieac44242015-06-29 10:50:03 +08001129 thread->ModifySuspendCount(self, +1, nullptr, false);
Elliott Hughese52e49b2012-04-02 16:05:44 -07001130 }
Elliott Hughes038a8062011-09-18 14:12:41 -07001131 }
1132 }
Elliott Hughes038a8062011-09-18 14:12:41 -07001133 // Give the threads a chance to suspend, complaining if they're slow.
1134 bool have_complained = false;
1135 for (int i = 0; i < 10; ++i) {
1136 usleep(200 * 1000);
1137 bool all_suspended = true;
Mathieu Chartier02e25112013-08-14 16:14:24 -07001138 for (const auto& thread : list_) {
Ian Rogers81d425b2012-09-27 16:03:43 -07001139 if (thread != self && thread->GetState() == kRunnable) {
Elliott Hughes038a8062011-09-18 14:12:41 -07001140 if (!have_complained) {
1141 LOG(WARNING) << "daemon thread not yet suspended: " << *thread;
1142 have_complained = true;
1143 }
1144 all_suspended = false;
1145 }
1146 }
1147 if (all_suspended) {
1148 return;
1149 }
1150 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001151 LOG(ERROR) << "suspend all daemons failed";
1152}
1153void ThreadList::Register(Thread* self) {
1154 DCHECK_EQ(self, Thread::Current());
1155
1156 if (VLOG_IS_ON(threads)) {
1157 std::ostringstream oss;
1158 self->ShortDump(oss); // We don't hold the mutator_lock_ yet and so cannot call Dump.
Ian Rogers5a9ba012014-05-19 13:28:52 -07001159 LOG(INFO) << "ThreadList::Register() " << *self << "\n" << oss.str();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001160 }
1161
1162 // Atomically add self to the thread list and make its thread_suspend_count_ reflect ongoing
1163 // SuspendAll requests.
Ian Rogers81d425b2012-09-27 16:03:43 -07001164 MutexLock mu(self, *Locks::thread_list_lock_);
1165 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001166 CHECK_GE(suspend_all_count_, debug_suspend_all_count_);
Ian Rogers2966e132014-04-02 08:34:36 -07001167 // Modify suspend count in increments of 1 to maintain invariants in ModifySuspendCount. While
1168 // this isn't particularly efficient the suspend counts are most commonly 0 or 1.
1169 for (int delta = debug_suspend_all_count_; delta > 0; delta--) {
Yu Lieac44242015-06-29 10:50:03 +08001170 self->ModifySuspendCount(self, +1, nullptr, true);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001171 }
Ian Rogers2966e132014-04-02 08:34:36 -07001172 for (int delta = suspend_all_count_ - debug_suspend_all_count_; delta > 0; delta--) {
Yu Lieac44242015-06-29 10:50:03 +08001173 self->ModifySuspendCount(self, +1, nullptr, false);
Ian Rogers01ae5802012-09-28 16:14:01 -07001174 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001175 CHECK(!Contains(self));
1176 list_.push_back(self);
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001177 if (kUseReadBarrier) {
Hiroshi Yamauchi00370822015-08-18 14:47:25 -07001178 // Initialize according to the state of the CC collector.
1179 bool is_gc_marking =
1180 Runtime::Current()->GetHeap()->ConcurrentCopyingCollector()->IsMarking();
1181 self->SetIsGcMarking(is_gc_marking);
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001182 bool weak_ref_access_enabled =
1183 Runtime::Current()->GetHeap()->ConcurrentCopyingCollector()->IsWeakRefAccessEnabled();
1184 self->SetWeakRefAccessEnabled(weak_ref_access_enabled);
1185 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001186}
1187
1188void ThreadList::Unregister(Thread* self) {
1189 DCHECK_EQ(self, Thread::Current());
Ian Rogers68d8b422014-07-17 11:09:10 -07001190 CHECK_NE(self->GetState(), kRunnable);
1191 Locks::mutator_lock_->AssertNotHeld(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001192
1193 VLOG(threads) << "ThreadList::Unregister() " << *self;
1194
Mathieu Chartier91e56692015-03-03 13:51:04 -08001195 {
1196 MutexLock mu(self, *Locks::thread_list_lock_);
1197 ++unregistering_count_;
1198 }
1199
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001200 // Any time-consuming destruction, plus anything that can call back into managed code or
Mathieu Chartier91e56692015-03-03 13:51:04 -08001201 // suspend and so on, must happen at this point, and not in ~Thread. The self->Destroy is what
1202 // causes the threads to join. It is important to do this after incrementing unregistering_count_
1203 // since we want the runtime to wait for the daemon threads to exit before deleting the thread
1204 // list.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001205 self->Destroy();
1206
Jeff Haoe094b872014-10-14 13:12:01 -07001207 // If tracing, remember thread id and name before thread exits.
1208 Trace::StoreExitingThreadInfo(self);
1209
Ian Rogersdd7624d2014-03-14 17:43:00 -07001210 uint32_t thin_lock_id = self->GetThreadId();
Mathieu Chartier91e56692015-03-03 13:51:04 -08001211 while (true) {
Ian Rogerscfaa4552012-11-26 21:00:08 -08001212 // Remove and delete the Thread* while holding the thread_list_lock_ and
1213 // thread_suspend_count_lock_ so that the unregistering thread cannot be suspended.
Ian Rogers0878d652013-04-18 17:38:35 -07001214 // Note: deliberately not using MutexLock that could hold a stale self pointer.
Mathieu Chartier91e56692015-03-03 13:51:04 -08001215 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogersa2af5c72014-09-15 15:17:07 -07001216 if (!Contains(self)) {
Mathieu Chartier9db831a2015-02-24 17:20:30 -08001217 std::string thread_name;
1218 self->GetThreadName(thread_name);
Ian Rogersa2af5c72014-09-15 15:17:07 -07001219 std::ostringstream os;
1220 DumpNativeStack(os, GetTid(), " native: ", nullptr);
Mathieu Chartier9db831a2015-02-24 17:20:30 -08001221 LOG(ERROR) << "Request to unregister unattached thread " << thread_name << "\n" << os.str();
Mathieu Chartier91e56692015-03-03 13:51:04 -08001222 break;
Ian Rogersa2af5c72014-09-15 15:17:07 -07001223 } else {
Mathieu Chartier91e56692015-03-03 13:51:04 -08001224 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogersa2af5c72014-09-15 15:17:07 -07001225 if (!self->IsSuspended()) {
1226 list_.remove(self);
Mathieu Chartier91e56692015-03-03 13:51:04 -08001227 break;
Ian Rogersa2af5c72014-09-15 15:17:07 -07001228 }
Ian Rogers68d8b422014-07-17 11:09:10 -07001229 }
Mathieu Chartier91e56692015-03-03 13:51:04 -08001230 // We failed to remove the thread due to a suspend request, loop and try again.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001231 }
Mathieu Chartier91e56692015-03-03 13:51:04 -08001232 delete self;
1233
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -08001234 // Release the thread ID after the thread is finished and deleted to avoid cases where we can
1235 // temporarily have multiple threads with the same thread id. When this occurs, it causes
1236 // problems in FindThreadByThreadId / SuspendThreadByThreadId.
1237 ReleaseThreadId(nullptr, thin_lock_id);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001238
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001239 // Clear the TLS data, so that the underlying native thread is recognizably detached.
1240 // (It may wish to reattach later.)
Andreas Gampe4382f1e2015-08-05 01:08:53 +00001241#ifdef __ANDROID__
1242 __get_tls()[TLS_SLOT_ART_THREAD_SELF] = nullptr;
1243#else
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001244 CHECK_PTHREAD_CALL(pthread_setspecific, (Thread::pthread_key_self_, nullptr), "detach self");
Andreas Gampe4382f1e2015-08-05 01:08:53 +00001245#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001246
1247 // Signal that a thread just detached.
Mathieu Chartier91e56692015-03-03 13:51:04 -08001248 MutexLock mu(nullptr, *Locks::thread_list_lock_);
1249 --unregistering_count_;
1250 Locks::thread_exit_cond_->Broadcast(nullptr);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001251}
1252
1253void ThreadList::ForEach(void (*callback)(Thread*, void*), void* context) {
Mathieu Chartier02e25112013-08-14 16:14:24 -07001254 for (const auto& thread : list_) {
1255 callback(thread, context);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001256 }
1257}
1258
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001259void ThreadList::VisitRoots(RootVisitor* visitor) const {
Ian Rogers81d425b2012-09-27 16:03:43 -07001260 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001261 for (const auto& thread : list_) {
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001262 thread->VisitRoots(visitor);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001263 }
Elliott Hughes038a8062011-09-18 14:12:41 -07001264}
1265
Ian Rogerscfaa4552012-11-26 21:00:08 -08001266uint32_t ThreadList::AllocThreadId(Thread* self) {
Chao-ying Fu9e369312014-05-21 11:20:52 -07001267 MutexLock mu(self, *Locks::allocated_thread_ids_lock_);
Elliott Hughes8daa0922011-09-11 13:46:25 -07001268 for (size_t i = 0; i < allocated_ids_.size(); ++i) {
1269 if (!allocated_ids_[i]) {
1270 allocated_ids_.set(i);
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001271 return i + 1; // Zero is reserved to mean "invalid".
Elliott Hughes8daa0922011-09-11 13:46:25 -07001272 }
1273 }
1274 LOG(FATAL) << "Out of internal thread ids";
1275 return 0;
1276}
1277
Ian Rogerscfaa4552012-11-26 21:00:08 -08001278void ThreadList::ReleaseThreadId(Thread* self, uint32_t id) {
Chao-ying Fu9e369312014-05-21 11:20:52 -07001279 MutexLock mu(self, *Locks::allocated_thread_ids_lock_);
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001280 --id; // Zero is reserved to mean "invalid".
Elliott Hughes8daa0922011-09-11 13:46:25 -07001281 DCHECK(allocated_ids_[id]) << id;
1282 allocated_ids_.reset(id);
1283}
1284
Elliott Hughes8daa0922011-09-11 13:46:25 -07001285} // namespace art