blob: 1e5264c9cd6a243d5b677710da5122fe8b6e9793 [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
Christopher Ferris6cff48f2014-01-26 21:36:13 -080019#include <backtrace/BacktraceMap.h>
Elliott Hughesabbe07d2012-06-05 17:42:23 -070020#include <dirent.h>
Ian Rogersd9c4fc92013-10-01 19:45:43 -070021#include <ScopedLocalRef.h>
22#include <ScopedUtfChars.h>
Elliott Hughesabbe07d2012-06-05 17:42:23 -070023#include <sys/types.h>
Elliott Hughes038a8062011-09-18 14:12:41 -070024#include <unistd.h>
25
Ian Rogersc7dd2952014-10-21 23:31:19 -070026#include <sstream>
27
Mathieu Chartier70a596d2014-12-17 14:56:47 -080028#include "base/histogram-inl.h"
Hiroshi Yamauchi967a0ad2013-09-10 16:24:21 -070029#include "base/mutex-inl.h"
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -080030#include "base/systrace.h"
Vladimir Marko80afd022015-05-19 18:08:00 +010031#include "base/time_utils.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"
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -070034#include "gc/collector/concurrent_copying.h"
Ian Rogersd9c4fc92013-10-01 19:45:43 -070035#include "jni_internal.h"
36#include "lock_word.h"
37#include "monitor.h"
38#include "scoped_thread_state_change.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080039#include "thread.h"
Jeff Haoe094b872014-10-14 13:12:01 -070040#include "trace.h"
Ian Rogersd9c4fc92013-10-01 19:45:43 -070041#include "well_known_classes.h"
Elliott Hughes475fc232011-10-25 15:00:35 -070042
Yu Lieac44242015-06-29 10:50:03 +080043#if ART_USE_FUTEXES
44#include "linux/futex.h"
45#include "sys/syscall.h"
46#ifndef SYS_futex
47#define SYS_futex __NR_futex
48#endif
49#endif // ART_USE_FUTEXES
50
Elliott Hughes8daa0922011-09-11 13:46:25 -070051namespace art {
52
Mathieu Chartier251755c2014-07-15 18:10:25 -070053static constexpr uint64_t kLongThreadSuspendThreshold = MsToNs(5);
Mathieu Chartier99143862015-02-03 14:26:46 -080054static constexpr uint64_t kThreadSuspendTimeoutMs = 30 * 1000; // 30s.
55// Use 0 since we want to yield to prevent blocking for an unpredictable amount of time.
56static constexpr useconds_t kThreadSuspendInitialSleepUs = 0;
57static constexpr useconds_t kThreadSuspendMaxYieldUs = 3000;
58static constexpr useconds_t kThreadSuspendMaxSleepUs = 5000;
Mathieu Chartier251755c2014-07-15 18:10:25 -070059
Andreas Gampe8d1594d2016-03-01 14:38:37 -080060// Whether we should try to dump the native stack of unattached threads. See commit ed8b723 for
61// some history.
62static constexpr bool kDumpUnattachedThreadNativeStack = true;
63
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -080064ThreadList::ThreadList()
Mathieu Chartierb56200b2015-10-29 10:41:51 -070065 : suspend_all_count_(0),
66 debug_suspend_all_count_(0),
67 unregistering_count_(0),
68 suspend_all_historam_("suspend all histogram", 16, 64),
69 long_suspend_(false) {
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -080070 CHECK(Monitor::IsValidLockWord(LockWord::FromThinLockId(kMaxThreadId, 1, 0U)));
Elliott Hughes8daa0922011-09-11 13:46:25 -070071}
72
73ThreadList::~ThreadList() {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -080074 ScopedTrace trace(__PRETTY_FUNCTION__);
Elliott Hughese52e49b2012-04-02 16:05:44 -070075 // Detach the current thread if necessary. If we failed to start, there might not be any threads.
Elliott Hughes6a144332012-04-03 13:07:11 -070076 // We need to detach the current thread here in case there's another thread waiting to join with
77 // us.
Mathieu Chartierfec72f42014-10-09 12:57:58 -070078 bool contains = false;
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -080079 Thread* self = Thread::Current();
Mathieu Chartierfec72f42014-10-09 12:57:58 -070080 {
Mathieu Chartierfec72f42014-10-09 12:57:58 -070081 MutexLock mu(self, *Locks::thread_list_lock_);
82 contains = Contains(self);
83 }
84 if (contains) {
Elliott Hughes8daa0922011-09-11 13:46:25 -070085 Runtime::Current()->DetachCurrentThread();
86 }
Elliott Hughes6a144332012-04-03 13:07:11 -070087 WaitForOtherNonDaemonThreadsToExit();
Mathieu Chartier51168372015-08-12 16:40:32 -070088 // Disable GC and wait for GC to complete in case there are still daemon threads doing
89 // allocations.
90 gc::Heap* const heap = Runtime::Current()->GetHeap();
91 heap->DisableGCForShutdown();
92 // In case a GC is in progress, wait for it to finish.
93 heap->WaitForGcToComplete(gc::kGcCauseBackground, Thread::Current());
Ian Rogers00f7d0e2012-07-19 15:28:27 -070094 // TODO: there's an unaddressed race here where a thread may attach during shutdown, see
95 // Thread::Init.
Mathieu Chartier4d87df62016-01-07 15:14:19 -080096 SuspendAllDaemonThreadsForShutdown();
Elliott Hughes8daa0922011-09-11 13:46:25 -070097}
98
99bool ThreadList::Contains(Thread* thread) {
100 return find(list_.begin(), list_.end(), thread) != list_.end();
101}
102
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700103bool ThreadList::Contains(pid_t tid) {
Mathieu Chartier02e25112013-08-14 16:14:24 -0700104 for (const auto& thread : list_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700105 if (thread->GetTid() == tid) {
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700106 return true;
107 }
108 }
109 return false;
110}
111
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -0700112pid_t ThreadList::GetLockOwner() {
Ian Rogersb726dcb2012-09-05 08:57:23 -0700113 return Locks::thread_list_lock_->GetExclusiveOwnerTid();
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700114}
115
Mathieu Chartier590fee92013-09-13 13:46:47 -0700116void ThreadList::DumpNativeStacks(std::ostream& os) {
117 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
Christopher Ferris6cff48f2014-01-26 21:36:13 -0800118 std::unique_ptr<BacktraceMap> map(BacktraceMap::Create(getpid()));
Mathieu Chartier590fee92013-09-13 13:46:47 -0700119 for (const auto& thread : list_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700120 os << "DUMPING THREAD " << thread->GetTid() << "\n";
Christopher Ferris6cff48f2014-01-26 21:36:13 -0800121 DumpNativeStack(os, thread->GetTid(), map.get(), "\t");
Mathieu Chartier590fee92013-09-13 13:46:47 -0700122 os << "\n";
123 }
124}
125
Elliott Hughesc967f782012-04-16 10:23:15 -0700126void ThreadList::DumpForSigQuit(std::ostream& os) {
Mathieu Chartier70a596d2014-12-17 14:56:47 -0800127 {
128 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartier23f6e692014-12-18 18:24:39 -0800129 // Only print if we have samples.
130 if (suspend_all_historam_.SampleSize() > 0) {
131 Histogram<uint64_t>::CumulativeData data;
132 suspend_all_historam_.CreateHistogram(&data);
133 suspend_all_historam_.PrintConfidenceIntervals(os, 0.99, data); // Dump time to suspend.
134 }
Mathieu Chartier70a596d2014-12-17 14:56:47 -0800135 }
Nicolas Geoffrayd3c59652016-03-17 09:35:04 +0000136 bool dump_native_stack = Runtime::Current()->GetDumpNativeStackOnSigQuit();
137 Dump(os, dump_native_stack);
138 DumpUnattachedThreads(os, dump_native_stack);
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700139}
140
Nicolas Geoffrayd3c59652016-03-17 09:35:04 +0000141static void DumpUnattachedThread(std::ostream& os, pid_t tid, bool dump_native_stack)
142 NO_THREAD_SAFETY_ANALYSIS {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700143 // TODO: No thread safety analysis as DumpState with a null thread won't access fields, should
Ian Rogerscfaa4552012-11-26 21:00:08 -0800144 // refactor DumpState to avoid skipping analysis.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700145 Thread::DumpState(os, nullptr, tid);
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700146 DumpKernelStack(os, tid, " kernel: ", false);
Nicolas Geoffrayd3c59652016-03-17 09:35:04 +0000147 if (dump_native_stack && kDumpUnattachedThreadNativeStack) {
Christopher Ferris6cff48f2014-01-26 21:36:13 -0800148 DumpNativeStack(os, tid, nullptr, " native: ");
Brian Carlstromed8b7232012-06-27 17:54:47 -0700149 }
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700150 os << "\n";
151}
152
Nicolas Geoffrayd3c59652016-03-17 09:35:04 +0000153void ThreadList::DumpUnattachedThreads(std::ostream& os, bool dump_native_stack) {
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700154 DIR* d = opendir("/proc/self/task");
155 if (!d) {
156 return;
157 }
158
Ian Rogers50b35e22012-10-04 10:09:15 -0700159 Thread* self = Thread::Current();
Elliott Hughes4696b5b2012-10-30 10:35:10 -0700160 dirent* e;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700161 while ((e = readdir(d)) != nullptr) {
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700162 char* end;
Elliott Hughes4696b5b2012-10-30 10:35:10 -0700163 pid_t tid = strtol(e->d_name, &end, 10);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700164 if (!*end) {
165 bool contains;
166 {
Ian Rogers50b35e22012-10-04 10:09:15 -0700167 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700168 contains = Contains(tid);
169 }
170 if (!contains) {
Nicolas Geoffrayd3c59652016-03-17 09:35:04 +0000171 DumpUnattachedThread(os, tid, dump_native_stack);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700172 }
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700173 }
174 }
175 closedir(d);
Elliott Hughesff738062012-02-03 15:00:42 -0800176}
177
Mathieu Chartier47c19592016-03-07 11:59:01 -0800178// Dump checkpoint timeout in milliseconds. Larger amount on the target, since the device could be
179// overloaded with ANR dumps.
180static constexpr uint32_t kDumpWaitTimeout = kIsTargetBuild ? 100000 : 20000;
Andreas Gampe4a3d19b2015-01-09 17:54:51 -0800181
Ian Rogers7b078e82014-09-10 14:44:24 -0700182// A closure used by Thread::Dump.
183class DumpCheckpoint FINAL : public Closure {
184 public:
Nicolas Geoffraya73280d2016-02-15 13:05:16 +0000185 DumpCheckpoint(std::ostream* os, bool dump_native_stack)
186 : os_(os),
187 barrier_(0),
188 backtrace_map_(dump_native_stack ? BacktraceMap::Create(getpid()) : nullptr),
189 dump_native_stack_(dump_native_stack) {}
Ian Rogers7b078e82014-09-10 14:44:24 -0700190
191 void Run(Thread* thread) OVERRIDE {
192 // Note thread and self may not be equal if thread was already suspended at the point of the
193 // request.
194 Thread* self = Thread::Current();
195 std::ostringstream local_os;
196 {
197 ScopedObjectAccess soa(self);
Nicolas Geoffraya73280d2016-02-15 13:05:16 +0000198 thread->Dump(local_os, dump_native_stack_, backtrace_map_.get());
Ian Rogers7b078e82014-09-10 14:44:24 -0700199 }
200 local_os << "\n";
201 {
202 // Use the logging lock to ensure serialization when writing to the common ostream.
203 MutexLock mu(self, *Locks::logging_lock_);
204 *os_ << local_os.str();
205 }
Mathieu Chartier10d25082015-10-28 18:36:09 -0700206 barrier_.Pass(self);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700207 }
Ian Rogers7b078e82014-09-10 14:44:24 -0700208
209 void WaitForThreadsToRunThroughCheckpoint(size_t threads_running_checkpoint) {
210 Thread* self = Thread::Current();
211 ScopedThreadStateChange tsc(self, kWaitingForCheckPointsToRun);
Andreas Gampe1e4b0ca2015-01-14 09:06:32 -0800212 bool timed_out = barrier_.Increment(self, threads_running_checkpoint, kDumpWaitTimeout);
Ian Rogers2156ff12014-09-13 19:20:54 -0700213 if (timed_out) {
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000214 // Avoid a recursive abort.
215 LOG((kIsDebugBuild && (gAborting == 0)) ? FATAL : ERROR)
216 << "Unexpected time out during dump checkpoint.";
Ian Rogers2156ff12014-09-13 19:20:54 -0700217 }
Ian Rogers7b078e82014-09-10 14:44:24 -0700218 }
219
220 private:
221 // The common stream that will accumulate all the dumps.
222 std::ostream* const os_;
223 // The barrier to be passed through and for the requestor to wait upon.
224 Barrier barrier_;
Christopher Ferris6cff48f2014-01-26 21:36:13 -0800225 // A backtrace map, so that all threads use a shared info and don't reacquire/parse separately.
226 std::unique_ptr<BacktraceMap> backtrace_map_;
Nicolas Geoffraya73280d2016-02-15 13:05:16 +0000227 // Whether we should dump the native stack.
228 const bool dump_native_stack_;
Ian Rogers7b078e82014-09-10 14:44:24 -0700229};
230
Nicolas Geoffraya73280d2016-02-15 13:05:16 +0000231void ThreadList::Dump(std::ostream& os, bool dump_native_stack) {
Ian Rogers7b078e82014-09-10 14:44:24 -0700232 {
233 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
234 os << "DALVIK THREADS (" << list_.size() << "):\n";
235 }
Nicolas Geoffraya73280d2016-02-15 13:05:16 +0000236 DumpCheckpoint checkpoint(&os, dump_native_stack);
Ian Rogers7b078e82014-09-10 14:44:24 -0700237 size_t threads_running_checkpoint = RunCheckpoint(&checkpoint);
Lei Lidd9943d2015-02-02 14:24:44 +0800238 if (threads_running_checkpoint != 0) {
239 checkpoint.WaitForThreadsToRunThroughCheckpoint(threads_running_checkpoint);
240 }
Elliott Hughes8daa0922011-09-11 13:46:25 -0700241}
242
Ian Rogers50b35e22012-10-04 10:09:15 -0700243void ThreadList::AssertThreadsAreSuspended(Thread* self, Thread* ignore1, Thread* ignore2) {
244 MutexLock mu(self, *Locks::thread_list_lock_);
245 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -0700246 for (const auto& thread : list_) {
jeffhao725a9572012-11-13 18:20:12 -0800247 if (thread != ignore1 && thread != ignore2) {
Ian Rogers01ae5802012-09-28 16:14:01 -0700248 CHECK(thread->IsSuspended())
249 << "\nUnsuspended thread: <<" << *thread << "\n"
250 << "self: <<" << *Thread::Current();
251 }
Elliott Hughes8d768a92011-09-14 16:35:25 -0700252 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700253}
254
Ian Rogers66aee5c2012-08-15 17:17:47 -0700255#if HAVE_TIMED_RWLOCK
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700256// Attempt to rectify locks so that we dump thread list with required locks before exiting.
Andreas Gampe794ad762015-02-23 08:12:24 -0800257NO_RETURN static void UnsafeLogFatalForThreadSuspendAllTimeout() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700258 Runtime* runtime = Runtime::Current();
259 std::ostringstream ss;
260 ss << "Thread suspend timeout\n";
Mathieu Chartier5869a2c2014-10-08 14:26:23 -0700261 Locks::mutator_lock_->Dump(ss);
262 ss << "\n";
Ian Rogers7b078e82014-09-10 14:44:24 -0700263 runtime->GetThreadList()->Dump(ss);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700264 LOG(FATAL) << ss.str();
Ian Rogers719d1a32014-03-06 12:13:39 -0800265 exit(0);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700266}
Ian Rogers66aee5c2012-08-15 17:17:47 -0700267#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700268
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800269// Unlike suspending all threads where we can wait to acquire the mutator_lock_, suspending an
Mathieu Chartier99143862015-02-03 14:26:46 -0800270// individual thread requires polling. delay_us is the requested sleep wait. If delay_us is 0 then
271// we use sched_yield instead of calling usleep.
272static void ThreadSuspendSleep(useconds_t delay_us) {
273 if (delay_us == 0) {
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800274 sched_yield();
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800275 } else {
Mathieu Chartier99143862015-02-03 14:26:46 -0800276 usleep(delay_us);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800277 }
278}
279
Mathieu Chartier0e4627e2012-10-23 16:13:36 -0700280size_t ThreadList::RunCheckpoint(Closure* checkpoint_function) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700281 Thread* self = Thread::Current();
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800282 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
283 Locks::thread_list_lock_->AssertNotHeld(self);
284 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700285
286 std::vector<Thread*> suspended_count_modified_threads;
287 size_t count = 0;
288 {
289 // Call a checkpoint function for each thread, threads which are suspend get their checkpoint
290 // manually called.
291 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700292 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier10d25082015-10-28 18:36:09 -0700293 count = list_.size();
Mathieu Chartier02e25112013-08-14 16:14:24 -0700294 for (const auto& thread : list_) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700295 if (thread != self) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700296 while (true) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700297 if (thread->RequestCheckpoint(checkpoint_function)) {
Dave Allison0aded082013-11-07 13:15:11 -0800298 // This thread will run its checkpoint some time in the near future.
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700299 break;
300 } else {
301 // We are probably suspended, try to make sure that we stay suspended.
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700302 // The thread switched back to runnable.
303 if (thread->GetState() == kRunnable) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700304 // Spurious fail, try again.
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700305 continue;
306 }
Yu Lieac44242015-06-29 10:50:03 +0800307 thread->ModifySuspendCount(self, +1, nullptr, false);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700308 suspended_count_modified_threads.push_back(thread);
309 break;
310 }
311 }
312 }
313 }
314 }
315
316 // Run the checkpoint on ourself while we wait for threads to suspend.
317 checkpoint_function->Run(self);
318
319 // Run the checkpoint on the suspended threads.
Mathieu Chartier02e25112013-08-14 16:14:24 -0700320 for (const auto& thread : suspended_count_modified_threads) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700321 if (!thread->IsSuspended()) {
Mathieu Chartier99143862015-02-03 14:26:46 -0800322 if (ATRACE_ENABLED()) {
323 std::ostringstream oss;
324 thread->ShortDump(oss);
325 ATRACE_BEGIN((std::string("Waiting for suspension of thread ") + oss.str()).c_str());
326 }
327 // Busy wait until the thread is suspended.
328 const uint64_t start_time = NanoTime();
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700329 do {
Mathieu Chartier99143862015-02-03 14:26:46 -0800330 ThreadSuspendSleep(kThreadSuspendInitialSleepUs);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700331 } while (!thread->IsSuspended());
Mathieu Chartier99143862015-02-03 14:26:46 -0800332 const uint64_t total_delay = NanoTime() - start_time;
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800333 // Shouldn't need to wait for longer than 1000 microseconds.
Mathieu Chartier99143862015-02-03 14:26:46 -0800334 constexpr uint64_t kLongWaitThreshold = MsToNs(1);
335 ATRACE_END();
336 if (UNLIKELY(total_delay > kLongWaitThreshold)) {
337 LOG(WARNING) << "Long wait of " << PrettyDuration(total_delay) << " for "
338 << *thread << " suspension!";
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700339 }
340 }
341 // We know for sure that the thread is suspended at this point.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700342 checkpoint_function->Run(thread);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700343 {
344 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Yu Lieac44242015-06-29 10:50:03 +0800345 thread->ModifySuspendCount(self, -1, nullptr, false);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700346 }
347 }
348
Mathieu Chartier664bebf2012-11-12 16:54:11 -0800349 {
350 // Imitate ResumeAll, threads may be waiting on Thread::resume_cond_ since we raised their
351 // suspend count. Now the suspend_count_ is lowered so we must do the broadcast.
352 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
353 Thread::resume_cond_->Broadcast(self);
354 }
355
Lei Lidd9943d2015-02-02 14:24:44 +0800356 return count;
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700357}
358
Dave Allison39c3bfb2014-01-28 18:33:52 -0800359// Request that a checkpoint function be run on all active (non-suspended)
360// threads. Returns the number of successful requests.
361size_t ThreadList::RunCheckpointOnRunnableThreads(Closure* checkpoint_function) {
362 Thread* self = Thread::Current();
Ian Rogers7b078e82014-09-10 14:44:24 -0700363 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
364 Locks::thread_list_lock_->AssertNotHeld(self);
365 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
366 CHECK_NE(self->GetState(), kRunnable);
Dave Allison39c3bfb2014-01-28 18:33:52 -0800367
368 size_t count = 0;
369 {
370 // Call a checkpoint function for each non-suspended thread.
371 MutexLock mu(self, *Locks::thread_list_lock_);
372 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
373 for (const auto& thread : list_) {
374 if (thread != self) {
375 if (thread->RequestCheckpoint(checkpoint_function)) {
376 // This thread will run its checkpoint some time in the near future.
377 count++;
378 }
379 }
380 }
381 }
382
383 // Return the number of threads that will run the checkpoint function.
384 return count;
385}
386
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800387// A checkpoint/suspend-all hybrid to switch thread roots from
388// from-space to to-space refs. Used to synchronize threads at a point
389// to mark the initiation of marking while maintaining the to-space
390// invariant.
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700391size_t ThreadList::FlipThreadRoots(Closure* thread_flip_visitor,
392 Closure* flip_callback,
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800393 gc::collector::GarbageCollector* collector) {
394 TimingLogger::ScopedTiming split("ThreadListFlip", collector->GetTimings());
395 const uint64_t start_time = NanoTime();
396 Thread* self = Thread::Current();
397 Locks::mutator_lock_->AssertNotHeld(self);
398 Locks::thread_list_lock_->AssertNotHeld(self);
399 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
400 CHECK_NE(self->GetState(), kRunnable);
401
Mathieu Chartierb19ccb12015-07-15 10:24:16 -0700402 SuspendAllInternal(self, self, nullptr);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800403
404 // Run the flip callback for the collector.
405 Locks::mutator_lock_->ExclusiveLock(self);
406 flip_callback->Run(self);
407 Locks::mutator_lock_->ExclusiveUnlock(self);
408 collector->RegisterPause(NanoTime() - start_time);
409
410 // Resume runnable threads.
Mathieu Chartierb19ccb12015-07-15 10:24:16 -0700411 std::vector<Thread*> runnable_threads;
412 std::vector<Thread*> other_threads;
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800413 {
414 MutexLock mu(self, *Locks::thread_list_lock_);
415 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
416 --suspend_all_count_;
417 for (const auto& thread : list_) {
418 if (thread == self) {
419 continue;
420 }
421 // Set the flip function for both runnable and suspended threads
422 // because Thread::DumpState/DumpJavaStack() (invoked by a
423 // checkpoint) may cause the flip function to be run for a
424 // runnable/suspended thread before a runnable threads runs it
425 // for itself or we run it for a suspended thread below.
426 thread->SetFlipFunction(thread_flip_visitor);
427 if (thread->IsSuspendedAtSuspendCheck()) {
428 // The thread will resume right after the broadcast.
Yu Lieac44242015-06-29 10:50:03 +0800429 thread->ModifySuspendCount(self, -1, nullptr, false);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800430 runnable_threads.push_back(thread);
431 } else {
432 other_threads.push_back(thread);
433 }
434 }
435 Thread::resume_cond_->Broadcast(self);
436 }
437
438 // Run the closure on the other threads and let them resume.
439 {
440 ReaderMutexLock mu(self, *Locks::mutator_lock_);
441 for (const auto& thread : other_threads) {
442 Closure* flip_func = thread->GetFlipFunction();
443 if (flip_func != nullptr) {
444 flip_func->Run(thread);
445 }
446 }
447 // Run it for self.
448 thread_flip_visitor->Run(self);
449 }
450
451 // Resume other threads.
452 {
453 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
454 for (const auto& thread : other_threads) {
Yu Lieac44242015-06-29 10:50:03 +0800455 thread->ModifySuspendCount(self, -1, nullptr, false);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800456 }
457 Thread::resume_cond_->Broadcast(self);
458 }
459
460 return runnable_threads.size() + other_threads.size() + 1; // +1 for self.
461}
462
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700463void ThreadList::SuspendAll(const char* cause, bool long_suspend) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700464 Thread* self = Thread::Current();
465
Jeff Haoc5d824a2014-07-28 18:35:38 -0700466 if (self != nullptr) {
Mathieu Chartierbf9fc582015-03-13 17:21:25 -0700467 VLOG(threads) << *self << " SuspendAll for " << cause << " starting...";
Jeff Haoc5d824a2014-07-28 18:35:38 -0700468 } else {
Mathieu Chartierbf9fc582015-03-13 17:21:25 -0700469 VLOG(threads) << "Thread[null] SuspendAll for " << cause << " starting...";
Jeff Haoc5d824a2014-07-28 18:35:38 -0700470 }
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800471 {
472 ScopedTrace trace("Suspending mutator threads");
473 const uint64_t start_time = NanoTime();
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700474
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800475 SuspendAllInternal(self, self);
476 // All threads are known to have suspended (but a thread may still own the mutator lock)
477 // Make sure this thread grabs exclusive access to the mutator lock and its protected data.
Ian Rogers66aee5c2012-08-15 17:17:47 -0700478#if HAVE_TIMED_RWLOCK
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800479 while (true) {
480 if (Locks::mutator_lock_->ExclusiveLockWithTimeout(self, kThreadSuspendTimeoutMs, 0)) {
481 break;
482 } else if (!long_suspend_) {
483 // Reading long_suspend without the mutator lock is slightly racy, in some rare cases, this
484 // could result in a thread suspend timeout.
485 // Timeout if we wait more than kThreadSuspendTimeoutMs seconds.
486 UnsafeLogFatalForThreadSuspendAllTimeout();
487 }
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700488 }
Ian Rogers66aee5c2012-08-15 17:17:47 -0700489#else
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800490 Locks::mutator_lock_->ExclusiveLock(self);
Ian Rogers66aee5c2012-08-15 17:17:47 -0700491#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700492
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800493 long_suspend_ = long_suspend;
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700494
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800495 const uint64_t end_time = NanoTime();
496 const uint64_t suspend_time = end_time - start_time;
497 suspend_all_historam_.AdjustAndAddValue(suspend_time);
498 if (suspend_time > kLongThreadSuspendThreshold) {
499 LOG(WARNING) << "Suspending all threads took: " << PrettyDuration(suspend_time);
500 }
501
502 if (kDebugLocking) {
503 // Debug check that all threads are suspended.
504 AssertThreadsAreSuspended(self, self);
505 }
Mathieu Chartier251755c2014-07-15 18:10:25 -0700506 }
Mathieu Chartierbf9fc582015-03-13 17:21:25 -0700507 ATRACE_BEGIN((std::string("Mutator threads suspended for ") + cause).c_str());
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700508
Jeff Haoc5d824a2014-07-28 18:35:38 -0700509 if (self != nullptr) {
510 VLOG(threads) << *self << " SuspendAll complete";
511 } else {
512 VLOG(threads) << "Thread[null] SuspendAll complete";
513 }
Elliott Hughes8d768a92011-09-14 16:35:25 -0700514}
515
Yu Lieac44242015-06-29 10:50:03 +0800516// Ensures all threads running Java suspend and that those not running Java don't start.
517// Debugger thread might be set to kRunnable for a short period of time after the
518// SuspendAllInternal. This is safe because it will be set back to suspended state before
519// the SuspendAll returns.
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700520void ThreadList::SuspendAllInternal(Thread* self,
521 Thread* ignore1,
522 Thread* ignore2,
Yu Lieac44242015-06-29 10:50:03 +0800523 bool debug_suspend) {
524 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
525 Locks::thread_list_lock_->AssertNotHeld(self);
526 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
527 if (kDebugLocking && self != nullptr) {
528 CHECK_NE(self->GetState(), kRunnable);
529 }
530
531 // First request that all threads suspend, then wait for them to suspend before
532 // returning. This suspension scheme also relies on other behaviour:
533 // 1. Threads cannot be deleted while they are suspended or have a suspend-
534 // request flag set - (see Unregister() below).
535 // 2. When threads are created, they are created in a suspended state (actually
536 // kNative) and will never begin executing Java code without first checking
537 // the suspend-request flag.
538
539 // The atomic counter for number of threads that need to pass the barrier.
540 AtomicInteger pending_threads;
541 uint32_t num_ignored = 0;
542 if (ignore1 != nullptr) {
543 ++num_ignored;
544 }
545 if (ignore2 != nullptr && ignore1 != ignore2) {
546 ++num_ignored;
547 }
548 {
549 MutexLock mu(self, *Locks::thread_list_lock_);
550 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
551 // Update global suspend all state for attaching threads.
552 ++suspend_all_count_;
553 if (debug_suspend)
554 ++debug_suspend_all_count_;
555 pending_threads.StoreRelaxed(list_.size() - num_ignored);
556 // Increment everybody's suspend count (except those that should be ignored).
557 for (const auto& thread : list_) {
558 if (thread == ignore1 || thread == ignore2) {
559 continue;
560 }
561 VLOG(threads) << "requesting thread suspend: " << *thread;
562 while (true) {
563 if (LIKELY(thread->ModifySuspendCount(self, +1, &pending_threads, debug_suspend))) {
564 break;
565 } else {
566 // Failure means the list of active_suspend_barriers is full, we should release the
567 // thread_suspend_count_lock_ (to avoid deadlock) and wait till the target thread has
568 // executed Thread::PassActiveSuspendBarriers(). Note that we could not simply wait for
569 // the thread to change to a suspended state, because it might need to run checkpoint
570 // function before the state change, which also needs thread_suspend_count_lock_.
571
572 // This is very unlikely to happen since more than kMaxSuspendBarriers threads need to
573 // execute SuspendAllInternal() simultaneously, and target thread stays in kRunnable
574 // in the mean time.
575 Locks::thread_suspend_count_lock_->ExclusiveUnlock(self);
576 NanoSleep(100000);
577 Locks::thread_suspend_count_lock_->ExclusiveLock(self);
578 }
579 }
580
581 // Must install the pending_threads counter first, then check thread->IsSuspend() and clear
582 // the counter. Otherwise there's a race with Thread::TransitionFromRunnableToSuspended()
583 // that can lead a thread to miss a call to PassActiveSuspendBarriers().
584 if (thread->IsSuspended()) {
585 // Only clear the counter for the current thread.
586 thread->ClearSuspendBarrier(&pending_threads);
587 pending_threads.FetchAndSubSequentiallyConsistent(1);
588 }
589 }
590 }
591
592 // Wait for the barrier to be passed by all runnable threads. This wait
593 // is done with a timeout so that we can detect problems.
Mathieu Chartier19af1172015-07-14 10:05:45 -0700594#if ART_USE_FUTEXES
Yu Lieac44242015-06-29 10:50:03 +0800595 timespec wait_timeout;
596 InitTimeSpec(true, CLOCK_MONOTONIC, 10000, 0, &wait_timeout);
Mathieu Chartier19af1172015-07-14 10:05:45 -0700597#endif
Yu Lieac44242015-06-29 10:50:03 +0800598 while (true) {
599 int32_t cur_val = pending_threads.LoadRelaxed();
600 if (LIKELY(cur_val > 0)) {
601#if ART_USE_FUTEXES
602 if (futex(pending_threads.Address(), FUTEX_WAIT, cur_val, &wait_timeout, nullptr, 0) != 0) {
603 // EAGAIN and EINTR both indicate a spurious failure, try again from the beginning.
604 if ((errno != EAGAIN) && (errno != EINTR)) {
605 if (errno == ETIMEDOUT) {
606 LOG(kIsDebugBuild ? FATAL : ERROR) << "Unexpected time out during suspend all.";
607 } else {
608 PLOG(FATAL) << "futex wait failed for SuspendAllInternal()";
609 }
610 }
611 } else {
612 cur_val = pending_threads.LoadRelaxed();
613 CHECK_EQ(cur_val, 0);
614 break;
615 }
616#else
617 // Spin wait. This is likely to be slow, but on most architecture ART_USE_FUTEXES is set.
618#endif
619 } else {
620 CHECK_EQ(cur_val, 0);
621 break;
622 }
623 }
624}
625
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700626void ThreadList::ResumeAll() {
627 Thread* self = Thread::Current();
628
Jeff Haoc5d824a2014-07-28 18:35:38 -0700629 if (self != nullptr) {
630 VLOG(threads) << *self << " ResumeAll starting";
631 } else {
632 VLOG(threads) << "Thread[null] ResumeAll starting";
633 }
Ian Rogers01ae5802012-09-28 16:14:01 -0700634
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700635 ATRACE_END();
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800636
637 ScopedTrace trace("Resuming mutator threads");
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700638
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800639 if (kDebugLocking) {
640 // Debug check that all threads are suspended.
641 AssertThreadsAreSuspended(self, self);
642 }
Ian Rogers01ae5802012-09-28 16:14:01 -0700643
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700644 long_suspend_ = false;
645
Ian Rogers81d425b2012-09-27 16:03:43 -0700646 Locks::mutator_lock_->ExclusiveUnlock(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700647 {
Ian Rogers81d425b2012-09-27 16:03:43 -0700648 MutexLock mu(self, *Locks::thread_list_lock_);
649 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700650 // Update global suspend all state for attaching threads.
651 --suspend_all_count_;
652 // Decrement the suspend counts for all threads.
Mathieu Chartier02e25112013-08-14 16:14:24 -0700653 for (const auto& thread : list_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700654 if (thread == self) {
655 continue;
656 }
Yu Lieac44242015-06-29 10:50:03 +0800657 thread->ModifySuspendCount(self, -1, nullptr, false);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700658 }
659
660 // Broadcast a notification to all suspended threads, some or all of
661 // which may choose to wake up. No need to wait for them.
Jeff Haoc5d824a2014-07-28 18:35:38 -0700662 if (self != nullptr) {
663 VLOG(threads) << *self << " ResumeAll waking others";
664 } else {
665 VLOG(threads) << "Thread[null] ResumeAll waking others";
666 }
Ian Rogersc604d732012-10-14 16:09:54 -0700667 Thread::resume_cond_->Broadcast(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700668 }
Jeff Haoc5d824a2014-07-28 18:35:38 -0700669
670 if (self != nullptr) {
671 VLOG(threads) << *self << " ResumeAll complete";
672 } else {
673 VLOG(threads) << "Thread[null] ResumeAll complete";
674 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700675}
676
677void ThreadList::Resume(Thread* thread, bool for_debugger) {
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -0800678 // This assumes there was an ATRACE_BEGIN when we suspended the thread.
679 ATRACE_END();
680
Ian Rogers81d425b2012-09-27 16:03:43 -0700681 Thread* self = Thread::Current();
682 DCHECK_NE(thread, self);
Brian Carlstromba32de42014-08-27 23:43:46 -0700683 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") starting..."
684 << (for_debugger ? " (debugger)" : "");
Elliott Hughes01158d72011-09-19 19:47:10 -0700685
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700686 {
687 // To check Contains.
Ian Rogers81d425b2012-09-27 16:03:43 -0700688 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700689 // To check IsSuspended.
Ian Rogers81d425b2012-09-27 16:03:43 -0700690 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
691 DCHECK(thread->IsSuspended());
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700692 if (!Contains(thread)) {
Brian Carlstromba32de42014-08-27 23:43:46 -0700693 // We only expect threads within the thread-list to have been suspended otherwise we can't
694 // stop such threads from delete-ing themselves.
695 LOG(ERROR) << "Resume(" << reinterpret_cast<void*>(thread)
696 << ") thread not within thread list";
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700697 return;
698 }
Yu Lieac44242015-06-29 10:50:03 +0800699 thread->ModifySuspendCount(self, -1, nullptr, for_debugger);
Elliott Hughes01158d72011-09-19 19:47:10 -0700700 }
701
702 {
Brian Carlstromba32de42014-08-27 23:43:46 -0700703 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") waking others";
Ian Rogers81d425b2012-09-27 16:03:43 -0700704 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersc604d732012-10-14 16:09:54 -0700705 Thread::resume_cond_->Broadcast(self);
Elliott Hughes01158d72011-09-19 19:47:10 -0700706 }
707
Brian Carlstromba32de42014-08-27 23:43:46 -0700708 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") complete";
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700709}
Elliott Hughes01158d72011-09-19 19:47:10 -0700710
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700711static void ThreadSuspendByPeerWarning(Thread* self,
712 LogSeverity severity,
713 const char* message,
Ian Rogersc7dd2952014-10-21 23:31:19 -0700714 jobject peer) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700715 JNIEnvExt* env = self->GetJniEnv();
716 ScopedLocalRef<jstring>
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700717 scoped_name_string(env, static_cast<jstring>(env->GetObjectField(
718 peer, WellKnownClasses::java_lang_Thread_name)));
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700719 ScopedUtfChars scoped_name_chars(env, scoped_name_string.get());
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700720 if (scoped_name_chars.c_str() == nullptr) {
Ian Rogersc7dd2952014-10-21 23:31:19 -0700721 LOG(severity) << message << ": " << peer;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700722 env->ExceptionClear();
723 } else {
Ian Rogersc7dd2952014-10-21 23:31:19 -0700724 LOG(severity) << message << ": " << peer << ":" << scoped_name_chars.c_str();
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700725 }
726}
727
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700728Thread* ThreadList::SuspendThreadByPeer(jobject peer,
729 bool request_suspension,
730 bool debug_suspension,
731 bool* timed_out) {
Mathieu Chartier3a958aa2015-02-04 12:52:34 -0800732 const uint64_t start_time = NanoTime();
Mathieu Chartier99143862015-02-03 14:26:46 -0800733 useconds_t sleep_us = kThreadSuspendInitialSleepUs;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700734 *timed_out = false;
Mathieu Chartier99143862015-02-03 14:26:46 -0800735 Thread* const self = Thread::Current();
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800736 Thread* suspended_thread = nullptr;
Brian Carlstromba32de42014-08-27 23:43:46 -0700737 VLOG(threads) << "SuspendThreadByPeer starting";
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700738 while (true) {
739 Thread* thread;
740 {
Ian Rogersf3d874c2014-07-17 18:52:42 -0700741 // Note: this will transition to runnable and potentially suspend. We ensure only one thread
742 // is requesting another suspend, to avoid deadlock, by requiring this function be called
743 // holding Locks::thread_list_suspend_thread_lock_. Its important this thread suspend rather
744 // than request thread suspension, to avoid potential cycles in threads requesting each other
745 // suspend.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700746 ScopedObjectAccess soa(self);
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800747 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700748 thread = Thread::FromManagedThread(soa, peer);
Brian Carlstromba32de42014-08-27 23:43:46 -0700749 if (thread == nullptr) {
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800750 if (suspended_thread != nullptr) {
751 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
752 // If we incremented the suspend count but the thread reset its peer, we need to
753 // re-decrement it since it is shutting down and may deadlock the runtime in
754 // ThreadList::WaitForOtherNonDaemonThreadsToExit.
Yu Lieac44242015-06-29 10:50:03 +0800755 suspended_thread->ModifySuspendCount(soa.Self(), -1, nullptr, debug_suspension);
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800756 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700757 ThreadSuspendByPeerWarning(self, WARNING, "No such thread for suspend", peer);
Brian Carlstromba32de42014-08-27 23:43:46 -0700758 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700759 }
Brian Carlstromba32de42014-08-27 23:43:46 -0700760 if (!Contains(thread)) {
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800761 CHECK(suspended_thread == nullptr);
Brian Carlstromba32de42014-08-27 23:43:46 -0700762 VLOG(threads) << "SuspendThreadByPeer failed for unattached thread: "
763 << reinterpret_cast<void*>(thread);
764 return nullptr;
765 }
766 VLOG(threads) << "SuspendThreadByPeer found thread: " << *thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700767 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800768 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700769 if (request_suspension) {
Ian Rogers4ad5cd32014-11-11 23:08:07 -0800770 if (self->GetSuspendCount() > 0) {
771 // We hold the suspend count lock but another thread is trying to suspend us. Its not
772 // safe to try to suspend another thread in case we get a cycle. Start the loop again
773 // which will allow this thread to be suspended.
774 continue;
775 }
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800776 CHECK(suspended_thread == nullptr);
777 suspended_thread = thread;
Yu Lieac44242015-06-29 10:50:03 +0800778 suspended_thread->ModifySuspendCount(self, +1, nullptr, debug_suspension);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700779 request_suspension = false;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700780 } else {
781 // If the caller isn't requesting suspension, a suspension should have already occurred.
782 CHECK_GT(thread->GetSuspendCount(), 0);
783 }
784 // IsSuspended on the current thread will fail as the current thread is changed into
785 // Runnable above. As the suspend count is now raised if this is the current thread
786 // it will self suspend on transition to Runnable, making it hard to work with. It's simpler
787 // to just explicitly handle the current thread in the callers to this code.
788 CHECK_NE(thread, self) << "Attempt to suspend the current thread for the debugger";
789 // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend
790 // count, or else we've waited and it has self suspended) or is the current thread, we're
791 // done.
792 if (thread->IsSuspended()) {
Brian Carlstromba32de42014-08-27 23:43:46 -0700793 VLOG(threads) << "SuspendThreadByPeer thread suspended: " << *thread;
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -0800794 if (ATRACE_ENABLED()) {
795 std::string name;
796 thread->GetThreadName(name);
797 ATRACE_BEGIN(StringPrintf("SuspendThreadByPeer suspended %s for peer=%p", name.c_str(),
798 peer).c_str());
799 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700800 return thread;
801 }
Mathieu Chartier99143862015-02-03 14:26:46 -0800802 const uint64_t total_delay = NanoTime() - start_time;
803 if (total_delay >= MsToNs(kThreadSuspendTimeoutMs)) {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700804 ThreadSuspendByPeerWarning(self, FATAL, "Thread suspension timed out", peer);
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800805 if (suspended_thread != nullptr) {
806 CHECK_EQ(suspended_thread, thread);
Yu Lieac44242015-06-29 10:50:03 +0800807 suspended_thread->ModifySuspendCount(soa.Self(), -1, nullptr, debug_suspension);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700808 }
809 *timed_out = true;
Brian Carlstromba32de42014-08-27 23:43:46 -0700810 return nullptr;
Mathieu Chartier99143862015-02-03 14:26:46 -0800811 } else if (sleep_us == 0 &&
812 total_delay > static_cast<uint64_t>(kThreadSuspendMaxYieldUs) * 1000) {
813 // We have spun for kThreadSuspendMaxYieldUs time, switch to sleeps to prevent
814 // excessive CPU usage.
815 sleep_us = kThreadSuspendMaxYieldUs / 2;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700816 }
817 }
818 // Release locks and come out of runnable state.
819 }
Mathieu Chartier99143862015-02-03 14:26:46 -0800820 VLOG(threads) << "SuspendThreadByPeer waiting to allow thread chance to suspend";
821 ThreadSuspendSleep(sleep_us);
822 // This may stay at 0 if sleep_us == 0, but this is WAI since we want to avoid using usleep at
823 // all if possible. This shouldn't be an issue since time to suspend should always be small.
824 sleep_us = std::min(sleep_us * 2, kThreadSuspendMaxSleepUs);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700825 }
826}
827
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700828static void ThreadSuspendByThreadIdWarning(LogSeverity severity,
829 const char* message,
Ian Rogersc7dd2952014-10-21 23:31:19 -0700830 uint32_t thread_id) {
831 LOG(severity) << StringPrintf("%s: %d", message, thread_id);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700832}
833
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700834Thread* ThreadList::SuspendThreadByThreadId(uint32_t thread_id,
835 bool debug_suspension,
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700836 bool* timed_out) {
Mathieu Chartier3a958aa2015-02-04 12:52:34 -0800837 const uint64_t start_time = NanoTime();
Mathieu Chartier99143862015-02-03 14:26:46 -0800838 useconds_t sleep_us = kThreadSuspendInitialSleepUs;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700839 *timed_out = false;
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800840 Thread* suspended_thread = nullptr;
Mathieu Chartier99143862015-02-03 14:26:46 -0800841 Thread* const self = Thread::Current();
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700842 CHECK_NE(thread_id, kInvalidThreadId);
Brian Carlstromba32de42014-08-27 23:43:46 -0700843 VLOG(threads) << "SuspendThreadByThreadId starting";
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700844 while (true) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700845 {
Ian Rogersf3d874c2014-07-17 18:52:42 -0700846 // Note: this will transition to runnable and potentially suspend. We ensure only one thread
847 // is requesting another suspend, to avoid deadlock, by requiring this function be called
848 // holding Locks::thread_list_suspend_thread_lock_. Its important this thread suspend rather
849 // than request thread suspension, to avoid potential cycles in threads requesting each other
850 // suspend.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700851 ScopedObjectAccess soa(self);
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800852 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Ian Rogersf3d874c2014-07-17 18:52:42 -0700853 Thread* thread = nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700854 for (const auto& it : list_) {
855 if (it->GetThreadId() == thread_id) {
856 thread = it;
857 break;
858 }
859 }
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800860 if (thread == nullptr) {
861 CHECK(suspended_thread == nullptr) << "Suspended thread " << suspended_thread
862 << " no longer in thread list";
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700863 // There's a race in inflating a lock and the owner giving up ownership and then dying.
864 ThreadSuspendByThreadIdWarning(WARNING, "No such thread id for suspend", thread_id);
Brian Carlstromba32de42014-08-27 23:43:46 -0700865 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700866 }
Brian Carlstromba32de42014-08-27 23:43:46 -0700867 VLOG(threads) << "SuspendThreadByThreadId found thread: " << *thread;
868 DCHECK(Contains(thread));
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700869 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800870 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800871 if (suspended_thread == nullptr) {
Ian Rogers4ad5cd32014-11-11 23:08:07 -0800872 if (self->GetSuspendCount() > 0) {
873 // We hold the suspend count lock but another thread is trying to suspend us. Its not
874 // safe to try to suspend another thread in case we get a cycle. Start the loop again
875 // which will allow this thread to be suspended.
876 continue;
877 }
Yu Lieac44242015-06-29 10:50:03 +0800878 thread->ModifySuspendCount(self, +1, nullptr, debug_suspension);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800879 suspended_thread = thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700880 } else {
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800881 CHECK_EQ(suspended_thread, thread);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700882 // If the caller isn't requesting suspension, a suspension should have already occurred.
883 CHECK_GT(thread->GetSuspendCount(), 0);
884 }
885 // IsSuspended on the current thread will fail as the current thread is changed into
886 // Runnable above. As the suspend count is now raised if this is the current thread
887 // it will self suspend on transition to Runnable, making it hard to work with. It's simpler
888 // to just explicitly handle the current thread in the callers to this code.
889 CHECK_NE(thread, self) << "Attempt to suspend the current thread for the debugger";
890 // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend
891 // count, or else we've waited and it has self suspended) or is the current thread, we're
892 // done.
893 if (thread->IsSuspended()) {
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -0800894 if (ATRACE_ENABLED()) {
895 std::string name;
896 thread->GetThreadName(name);
897 ATRACE_BEGIN(StringPrintf("SuspendThreadByThreadId suspended %s id=%d",
898 name.c_str(), thread_id).c_str());
899 }
Brian Carlstromba32de42014-08-27 23:43:46 -0700900 VLOG(threads) << "SuspendThreadByThreadId thread suspended: " << *thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700901 return thread;
902 }
Mathieu Chartier99143862015-02-03 14:26:46 -0800903 const uint64_t total_delay = NanoTime() - start_time;
904 if (total_delay >= MsToNs(kThreadSuspendTimeoutMs)) {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700905 ThreadSuspendByThreadIdWarning(WARNING, "Thread suspension timed out", thread_id);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800906 if (suspended_thread != nullptr) {
Yu Lieac44242015-06-29 10:50:03 +0800907 thread->ModifySuspendCount(soa.Self(), -1, nullptr, debug_suspension);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700908 }
909 *timed_out = true;
Brian Carlstromba32de42014-08-27 23:43:46 -0700910 return nullptr;
Mathieu Chartier99143862015-02-03 14:26:46 -0800911 } else if (sleep_us == 0 &&
912 total_delay > static_cast<uint64_t>(kThreadSuspendMaxYieldUs) * 1000) {
913 // We have spun for kThreadSuspendMaxYieldUs time, switch to sleeps to prevent
914 // excessive CPU usage.
915 sleep_us = kThreadSuspendMaxYieldUs / 2;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700916 }
917 }
918 // Release locks and come out of runnable state.
919 }
Mathieu Chartier99143862015-02-03 14:26:46 -0800920 VLOG(threads) << "SuspendThreadByThreadId waiting to allow thread chance to suspend";
921 ThreadSuspendSleep(sleep_us);
922 sleep_us = std::min(sleep_us * 2, kThreadSuspendMaxSleepUs);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700923 }
924}
925
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700926Thread* ThreadList::FindThreadByThreadId(uint32_t thread_id) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700927 for (const auto& thread : list_) {
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700928 if (thread->GetThreadId() == thread_id) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700929 return thread;
930 }
931 }
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700932 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700933}
934
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700935void ThreadList::SuspendAllForDebugger() {
936 Thread* self = Thread::Current();
937 Thread* debug_thread = Dbg::GetDebugThread();
938
939 VLOG(threads) << *self << " SuspendAllForDebugger starting...";
940
Yu Lieac44242015-06-29 10:50:03 +0800941 SuspendAllInternal(self, self, debug_thread, true);
Ian Rogers66aee5c2012-08-15 17:17:47 -0700942 // Block on the mutator lock until all Runnable threads release their share of access then
943 // immediately unlock again.
944#if HAVE_TIMED_RWLOCK
945 // Timeout if we wait more than 30 seconds.
Ian Rogersc604d732012-10-14 16:09:54 -0700946 if (!Locks::mutator_lock_->ExclusiveLockWithTimeout(self, 30 * 1000, 0)) {
Sebastien Hertzbae182c2013-12-17 10:42:03 +0100947 UnsafeLogFatalForThreadSuspendAllTimeout();
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700948 } else {
Ian Rogers81d425b2012-09-27 16:03:43 -0700949 Locks::mutator_lock_->ExclusiveUnlock(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700950 }
Ian Rogers66aee5c2012-08-15 17:17:47 -0700951#else
Ian Rogers81d425b2012-09-27 16:03:43 -0700952 Locks::mutator_lock_->ExclusiveLock(self);
953 Locks::mutator_lock_->ExclusiveUnlock(self);
Ian Rogers66aee5c2012-08-15 17:17:47 -0700954#endif
Mathieu Chartier9450c6c2015-11-07 11:55:23 -0800955 // Disabled for the following race condition:
956 // Thread 1 calls SuspendAllForDebugger, gets preempted after pulsing the mutator lock.
957 // Thread 2 calls SuspendAll and SetStateUnsafe (perhaps from Dbg::Disconnected).
958 // Thread 1 fails assertion that all threads are suspended due to thread 2 being in a runnable
959 // state (from SetStateUnsafe).
960 // AssertThreadsAreSuspended(self, self, debug_thread);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700961
Sebastien Hertzed2be172014-08-19 15:33:43 +0200962 VLOG(threads) << *self << " SuspendAllForDebugger complete";
Elliott Hughes01158d72011-09-19 19:47:10 -0700963}
964
Elliott Hughes475fc232011-10-25 15:00:35 -0700965void ThreadList::SuspendSelfForDebugger() {
Sebastien Hertz1558b572015-02-25 15:05:59 +0100966 Thread* const self = Thread::Current();
967 self->SetReadyForDebugInvoke(true);
Elliott Hughes01158d72011-09-19 19:47:10 -0700968
Elliott Hughes475fc232011-10-25 15:00:35 -0700969 // The debugger thread must not suspend itself due to debugger activity!
970 Thread* debug_thread = Dbg::GetDebugThread();
Elliott Hughes475fc232011-10-25 15:00:35 -0700971 CHECK(self != debug_thread);
jeffhaoa77f0f62012-12-05 17:19:31 -0800972 CHECK_NE(self->GetState(), kRunnable);
973 Locks::mutator_lock_->AssertNotHeld(self);
Elliott Hughes475fc232011-10-25 15:00:35 -0700974
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200975 // The debugger may have detached while we were executing an invoke request. In that case, we
976 // must not suspend ourself.
977 DebugInvokeReq* pReq = self->GetInvokeReq();
978 const bool skip_thread_suspension = (pReq != nullptr && !Dbg::IsDebuggerActive());
979 if (!skip_thread_suspension) {
jeffhaoa77f0f62012-12-05 17:19:31 -0800980 // Collisions with other suspends aren't really interesting. We want
981 // to ensure that we're the only one fiddling with the suspend count
982 // though.
983 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Yu Lieac44242015-06-29 10:50:03 +0800984 self->ModifySuspendCount(self, +1, nullptr, true);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700985 CHECK_GT(self->GetSuspendCount(), 0);
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200986
987 VLOG(threads) << *self << " self-suspending (debugger)";
988 } else {
989 // We must no longer be subject to debugger suspension.
990 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
991 CHECK_EQ(self->GetDebugSuspendCount(), 0) << "Debugger detached without resuming us";
992
993 VLOG(threads) << *self << " not self-suspending because debugger detached during invoke";
jeffhaoa77f0f62012-12-05 17:19:31 -0800994 }
Elliott Hughes475fc232011-10-25 15:00:35 -0700995
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200996 // If the debugger requested an invoke, we need to send the reply and clear the request.
Sebastien Hertz1558b572015-02-25 15:05:59 +0100997 if (pReq != nullptr) {
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200998 Dbg::FinishInvokeMethod(pReq);
Sebastien Hertz1558b572015-02-25 15:05:59 +0100999 self->ClearDebugInvokeReq();
Sebastien Hertzcbc50642015-06-01 17:33:12 +02001000 pReq = nullptr; // object has been deleted, clear it for safety.
Sebastien Hertz21e729c2014-02-18 14:16:00 +01001001 }
1002
Elliott Hughes475fc232011-10-25 15:00:35 -07001003 // Tell JDWP that we've completed suspension. The JDWP thread can't
1004 // tell us to resume before we're fully asleep because we hold the
1005 // suspend count lock.
1006 Dbg::ClearWaitForEventThread();
1007
jeffhaoa77f0f62012-12-05 17:19:31 -08001008 {
1009 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001010 while (self->GetSuspendCount() != 0) {
jeffhaoa77f0f62012-12-05 17:19:31 -08001011 Thread::resume_cond_->Wait(self);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001012 if (self->GetSuspendCount() != 0) {
jeffhaoa77f0f62012-12-05 17:19:31 -08001013 // The condition was signaled but we're still suspended. This
Sebastien Hertzf272af42014-09-18 10:20:42 +02001014 // can happen when we suspend then resume all threads to
1015 // update instrumentation or compute monitor info. This can
1016 // also happen if the debugger lets go while a SIGQUIT thread
jeffhaoa77f0f62012-12-05 17:19:31 -08001017 // dump event is pending (assuming SignalCatcher was resumed for
1018 // just long enough to try to grab the thread-suspend lock).
Sebastien Hertzf272af42014-09-18 10:20:42 +02001019 VLOG(jdwp) << *self << " still suspended after undo "
1020 << "(suspend count=" << self->GetSuspendCount() << ", "
1021 << "debug suspend count=" << self->GetDebugSuspendCount() << ")";
jeffhaoa77f0f62012-12-05 17:19:31 -08001022 }
Elliott Hughes475fc232011-10-25 15:00:35 -07001023 }
Ian Rogersdd7624d2014-03-14 17:43:00 -07001024 CHECK_EQ(self->GetSuspendCount(), 0);
Elliott Hughes475fc232011-10-25 15:00:35 -07001025 }
jeffhaoa77f0f62012-12-05 17:19:31 -08001026
Sebastien Hertz1558b572015-02-25 15:05:59 +01001027 self->SetReadyForDebugInvoke(false);
Elliott Hughes1f729aa2012-03-02 13:55:41 -08001028 VLOG(threads) << *self << " self-reviving (debugger)";
Elliott Hughes475fc232011-10-25 15:00:35 -07001029}
1030
Sebastien Hertz253fa552014-10-14 17:27:15 +02001031void ThreadList::ResumeAllForDebugger() {
1032 Thread* self = Thread::Current();
1033 Thread* debug_thread = Dbg::GetDebugThread();
Sebastien Hertz253fa552014-10-14 17:27:15 +02001034
1035 VLOG(threads) << *self << " ResumeAllForDebugger starting...";
1036
1037 // Threads can't resume if we exclusively hold the mutator lock.
1038 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
1039
1040 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001041 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Sebastien Hertz253fa552014-10-14 17:27:15 +02001042 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001043 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Sebastien Hertz253fa552014-10-14 17:27:15 +02001044 // Update global suspend all state for attaching threads.
1045 DCHECK_GE(suspend_all_count_, debug_suspend_all_count_);
Sebastien Hertzf9d233d2015-01-09 14:51:41 +01001046 if (debug_suspend_all_count_ > 0) {
Sebastien Hertz253fa552014-10-14 17:27:15 +02001047 --suspend_all_count_;
1048 --debug_suspend_all_count_;
Sebastien Hertz253fa552014-10-14 17:27:15 +02001049 } else {
1050 // We've been asked to resume all threads without being asked to
Sebastien Hertzf9d233d2015-01-09 14:51:41 +01001051 // suspend them all before. That may happen if a debugger tries
1052 // to resume some suspended threads (with suspend count == 1)
1053 // at once with a VirtualMachine.Resume command. Let's print a
1054 // warning.
Sebastien Hertz253fa552014-10-14 17:27:15 +02001055 LOG(WARNING) << "Debugger attempted to resume all threads without "
1056 << "having suspended them all before.";
1057 }
Sebastien Hertzf9d233d2015-01-09 14:51:41 +01001058 // Decrement everybody's suspend count (except our own).
1059 for (const auto& thread : list_) {
1060 if (thread == self || thread == debug_thread) {
1061 continue;
1062 }
1063 if (thread->GetDebugSuspendCount() == 0) {
1064 // This thread may have been individually resumed with ThreadReference.Resume.
1065 continue;
1066 }
1067 VLOG(threads) << "requesting thread resume: " << *thread;
Yu Lieac44242015-06-29 10:50:03 +08001068 thread->ModifySuspendCount(self, -1, nullptr, true);
Sebastien Hertzf9d233d2015-01-09 14:51:41 +01001069 }
Sebastien Hertz253fa552014-10-14 17:27:15 +02001070 }
1071 }
1072
Sebastien Hertzf9d233d2015-01-09 14:51:41 +01001073 {
Sebastien Hertz253fa552014-10-14 17:27:15 +02001074 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
1075 Thread::resume_cond_->Broadcast(self);
1076 }
1077
1078 VLOG(threads) << *self << " ResumeAllForDebugger complete";
1079}
1080
Elliott Hughes234ab152011-10-26 14:02:26 -07001081void ThreadList::UndoDebuggerSuspensions() {
1082 Thread* self = Thread::Current();
1083
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001084 VLOG(threads) << *self << " UndoDebuggerSuspensions starting";
Elliott Hughes234ab152011-10-26 14:02:26 -07001085
1086 {
Ian Rogers81d425b2012-09-27 16:03:43 -07001087 MutexLock mu(self, *Locks::thread_list_lock_);
1088 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001089 // Update global suspend all state for attaching threads.
1090 suspend_all_count_ -= debug_suspend_all_count_;
1091 debug_suspend_all_count_ = 0;
1092 // Update running threads.
Mathieu Chartier02e25112013-08-14 16:14:24 -07001093 for (const auto& thread : list_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001094 if (thread == self || thread->GetDebugSuspendCount() == 0) {
Elliott Hughes234ab152011-10-26 14:02:26 -07001095 continue;
1096 }
Yu Lieac44242015-06-29 10:50:03 +08001097 thread->ModifySuspendCount(self, -thread->GetDebugSuspendCount(), nullptr, true);
Elliott Hughes234ab152011-10-26 14:02:26 -07001098 }
1099 }
1100
1101 {
Ian Rogers81d425b2012-09-27 16:03:43 -07001102 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersc604d732012-10-14 16:09:54 -07001103 Thread::resume_cond_->Broadcast(self);
Elliott Hughes234ab152011-10-26 14:02:26 -07001104 }
1105
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001106 VLOG(threads) << "UndoDebuggerSuspensions(" << *self << ") complete";
Elliott Hughes234ab152011-10-26 14:02:26 -07001107}
1108
Elliott Hughese52e49b2012-04-02 16:05:44 -07001109void ThreadList::WaitForOtherNonDaemonThreadsToExit() {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08001110 ScopedTrace trace(__PRETTY_FUNCTION__);
Ian Rogers81d425b2012-09-27 16:03:43 -07001111 Thread* self = Thread::Current();
1112 Locks::mutator_lock_->AssertNotHeld(self);
Mathieu Chartier91e56692015-03-03 13:51:04 -08001113 while (true) {
Ian Rogers120f1c72012-09-28 17:17:10 -07001114 {
1115 // No more threads can be born after we start to shutdown.
1116 MutexLock mu(self, *Locks::runtime_shutdown_lock_);
Mathieu Chartier590fee92013-09-13 13:46:47 -07001117 CHECK(Runtime::Current()->IsShuttingDownLocked());
Ian Rogers120f1c72012-09-28 17:17:10 -07001118 CHECK_EQ(Runtime::Current()->NumberOfThreadsBeingBorn(), 0U);
1119 }
Ian Rogers120f1c72012-09-28 17:17:10 -07001120 MutexLock mu(self, *Locks::thread_list_lock_);
Mathieu Chartier91e56692015-03-03 13:51:04 -08001121 // Also wait for any threads that are unregistering to finish. This is required so that no
1122 // threads access the thread list after it is deleted. TODO: This may not work for user daemon
1123 // threads since they could unregister at the wrong time.
1124 bool done = unregistering_count_ == 0;
1125 if (done) {
1126 for (const auto& thread : list_) {
1127 if (thread != self && !thread->IsDaemon()) {
1128 done = false;
1129 break;
1130 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001131 }
1132 }
Mathieu Chartier91e56692015-03-03 13:51:04 -08001133 if (done) {
1134 break;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001135 }
Mathieu Chartier91e56692015-03-03 13:51:04 -08001136 // Wait for another thread to exit before re-checking.
1137 Locks::thread_exit_cond_->Wait(self);
1138 }
Elliott Hughes038a8062011-09-18 14:12:41 -07001139}
1140
Mathieu Chartier4d87df62016-01-07 15:14:19 -08001141void ThreadList::SuspendAllDaemonThreadsForShutdown() {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08001142 ScopedTrace trace(__PRETTY_FUNCTION__);
Ian Rogers81d425b2012-09-27 16:03:43 -07001143 Thread* self = Thread::Current();
1144 MutexLock mu(self, *Locks::thread_list_lock_);
Mathieu Chartier62597d12016-01-11 10:19:06 -08001145 size_t daemons_left = 0;
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001146 { // Tell all the daemons it's time to suspend.
Ian Rogers81d425b2012-09-27 16:03:43 -07001147 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001148 for (const auto& thread : list_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001149 // This is only run after all non-daemon threads have exited, so the remainder should all be
1150 // daemons.
Ian Rogers7e762862012-10-22 15:45:08 -07001151 CHECK(thread->IsDaemon()) << *thread;
Ian Rogers81d425b2012-09-27 16:03:43 -07001152 if (thread != self) {
Yu Lieac44242015-06-29 10:50:03 +08001153 thread->ModifySuspendCount(self, +1, nullptr, false);
Mathieu Chartier62597d12016-01-11 10:19:06 -08001154 ++daemons_left;
Elliott Hughese52e49b2012-04-02 16:05:44 -07001155 }
Mathieu Chartier4d87df62016-01-07 15:14:19 -08001156 // We are shutting down the runtime, set the JNI functions of all the JNIEnvs to be
1157 // the sleep forever one.
1158 thread->GetJniEnv()->SetFunctionsToRuntimeShutdownFunctions();
Elliott Hughes038a8062011-09-18 14:12:41 -07001159 }
1160 }
Mathieu Chartier62597d12016-01-11 10:19:06 -08001161 // If we have any daemons left, wait 200ms to ensure they are not stuck in a place where they
1162 // are about to access runtime state and are not in a runnable state. Examples: Monitor code
1163 // or waking up from a condition variable. TODO: Try and see if there is a better way to wait
1164 // for daemon threads to be in a blocked state.
1165 if (daemons_left > 0) {
1166 static constexpr size_t kDaemonSleepTime = 200 * 1000;
1167 usleep(kDaemonSleepTime);
1168 }
Elliott Hughes038a8062011-09-18 14:12:41 -07001169 // Give the threads a chance to suspend, complaining if they're slow.
1170 bool have_complained = false;
Mathieu Chartierba098ba2016-01-07 09:31:33 -08001171 static constexpr size_t kTimeoutMicroseconds = 2000 * 1000;
1172 static constexpr size_t kSleepMicroseconds = 1000;
1173 for (size_t i = 0; i < kTimeoutMicroseconds / kSleepMicroseconds; ++i) {
Elliott Hughes038a8062011-09-18 14:12:41 -07001174 bool all_suspended = true;
Mathieu Chartier02e25112013-08-14 16:14:24 -07001175 for (const auto& thread : list_) {
Ian Rogers81d425b2012-09-27 16:03:43 -07001176 if (thread != self && thread->GetState() == kRunnable) {
Elliott Hughes038a8062011-09-18 14:12:41 -07001177 if (!have_complained) {
1178 LOG(WARNING) << "daemon thread not yet suspended: " << *thread;
1179 have_complained = true;
1180 }
1181 all_suspended = false;
1182 }
1183 }
1184 if (all_suspended) {
1185 return;
1186 }
Mathieu Chartierba098ba2016-01-07 09:31:33 -08001187 usleep(kSleepMicroseconds);
Elliott Hughes038a8062011-09-18 14:12:41 -07001188 }
Mathieu Chartierba098ba2016-01-07 09:31:33 -08001189 LOG(WARNING) << "timed out suspending all daemon threads";
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001190}
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001191
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001192void ThreadList::Register(Thread* self) {
1193 DCHECK_EQ(self, Thread::Current());
1194
1195 if (VLOG_IS_ON(threads)) {
1196 std::ostringstream oss;
1197 self->ShortDump(oss); // We don't hold the mutator_lock_ yet and so cannot call Dump.
Ian Rogers5a9ba012014-05-19 13:28:52 -07001198 LOG(INFO) << "ThreadList::Register() " << *self << "\n" << oss.str();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001199 }
1200
1201 // Atomically add self to the thread list and make its thread_suspend_count_ reflect ongoing
1202 // SuspendAll requests.
Ian Rogers81d425b2012-09-27 16:03:43 -07001203 MutexLock mu(self, *Locks::thread_list_lock_);
1204 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001205 CHECK_GE(suspend_all_count_, debug_suspend_all_count_);
Ian Rogers2966e132014-04-02 08:34:36 -07001206 // Modify suspend count in increments of 1 to maintain invariants in ModifySuspendCount. While
1207 // this isn't particularly efficient the suspend counts are most commonly 0 or 1.
1208 for (int delta = debug_suspend_all_count_; delta > 0; delta--) {
Yu Lieac44242015-06-29 10:50:03 +08001209 self->ModifySuspendCount(self, +1, nullptr, true);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001210 }
Ian Rogers2966e132014-04-02 08:34:36 -07001211 for (int delta = suspend_all_count_ - debug_suspend_all_count_; delta > 0; delta--) {
Yu Lieac44242015-06-29 10:50:03 +08001212 self->ModifySuspendCount(self, +1, nullptr, false);
Ian Rogers01ae5802012-09-28 16:14:01 -07001213 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001214 CHECK(!Contains(self));
1215 list_.push_back(self);
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001216 if (kUseReadBarrier) {
Hiroshi Yamauchi00370822015-08-18 14:47:25 -07001217 // Initialize according to the state of the CC collector.
1218 bool is_gc_marking =
1219 Runtime::Current()->GetHeap()->ConcurrentCopyingCollector()->IsMarking();
1220 self->SetIsGcMarking(is_gc_marking);
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001221 bool weak_ref_access_enabled =
1222 Runtime::Current()->GetHeap()->ConcurrentCopyingCollector()->IsWeakRefAccessEnabled();
1223 self->SetWeakRefAccessEnabled(weak_ref_access_enabled);
1224 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001225}
1226
1227void ThreadList::Unregister(Thread* self) {
1228 DCHECK_EQ(self, Thread::Current());
Ian Rogers68d8b422014-07-17 11:09:10 -07001229 CHECK_NE(self->GetState(), kRunnable);
1230 Locks::mutator_lock_->AssertNotHeld(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001231
1232 VLOG(threads) << "ThreadList::Unregister() " << *self;
1233
Mathieu Chartier91e56692015-03-03 13:51:04 -08001234 {
1235 MutexLock mu(self, *Locks::thread_list_lock_);
1236 ++unregistering_count_;
1237 }
1238
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001239 // Any time-consuming destruction, plus anything that can call back into managed code or
Mathieu Chartier91e56692015-03-03 13:51:04 -08001240 // suspend and so on, must happen at this point, and not in ~Thread. The self->Destroy is what
1241 // causes the threads to join. It is important to do this after incrementing unregistering_count_
1242 // since we want the runtime to wait for the daemon threads to exit before deleting the thread
1243 // list.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001244 self->Destroy();
1245
Jeff Haoe094b872014-10-14 13:12:01 -07001246 // If tracing, remember thread id and name before thread exits.
1247 Trace::StoreExitingThreadInfo(self);
1248
Ian Rogersdd7624d2014-03-14 17:43:00 -07001249 uint32_t thin_lock_id = self->GetThreadId();
Mathieu Chartier91e56692015-03-03 13:51:04 -08001250 while (true) {
Ian Rogerscfaa4552012-11-26 21:00:08 -08001251 // Remove and delete the Thread* while holding the thread_list_lock_ and
1252 // thread_suspend_count_lock_ so that the unregistering thread cannot be suspended.
Ian Rogers0878d652013-04-18 17:38:35 -07001253 // Note: deliberately not using MutexLock that could hold a stale self pointer.
Mathieu Chartier91e56692015-03-03 13:51:04 -08001254 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogersa2af5c72014-09-15 15:17:07 -07001255 if (!Contains(self)) {
Mathieu Chartier9db831a2015-02-24 17:20:30 -08001256 std::string thread_name;
1257 self->GetThreadName(thread_name);
Ian Rogersa2af5c72014-09-15 15:17:07 -07001258 std::ostringstream os;
Christopher Ferris6cff48f2014-01-26 21:36:13 -08001259 DumpNativeStack(os, GetTid(), nullptr, " native: ", nullptr);
Mathieu Chartier9db831a2015-02-24 17:20:30 -08001260 LOG(ERROR) << "Request to unregister unattached thread " << thread_name << "\n" << os.str();
Mathieu Chartier91e56692015-03-03 13:51:04 -08001261 break;
Ian Rogersa2af5c72014-09-15 15:17:07 -07001262 } else {
Mathieu Chartier91e56692015-03-03 13:51:04 -08001263 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogersa2af5c72014-09-15 15:17:07 -07001264 if (!self->IsSuspended()) {
1265 list_.remove(self);
Mathieu Chartier91e56692015-03-03 13:51:04 -08001266 break;
Ian Rogersa2af5c72014-09-15 15:17:07 -07001267 }
Ian Rogers68d8b422014-07-17 11:09:10 -07001268 }
Mathieu Chartier91e56692015-03-03 13:51:04 -08001269 // We failed to remove the thread due to a suspend request, loop and try again.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001270 }
Mathieu Chartier91e56692015-03-03 13:51:04 -08001271 delete self;
1272
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -08001273 // Release the thread ID after the thread is finished and deleted to avoid cases where we can
1274 // temporarily have multiple threads with the same thread id. When this occurs, it causes
1275 // problems in FindThreadByThreadId / SuspendThreadByThreadId.
1276 ReleaseThreadId(nullptr, thin_lock_id);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001277
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001278 // Clear the TLS data, so that the underlying native thread is recognizably detached.
1279 // (It may wish to reattach later.)
Andreas Gampe4382f1e2015-08-05 01:08:53 +00001280#ifdef __ANDROID__
1281 __get_tls()[TLS_SLOT_ART_THREAD_SELF] = nullptr;
1282#else
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001283 CHECK_PTHREAD_CALL(pthread_setspecific, (Thread::pthread_key_self_, nullptr), "detach self");
Andreas Gampe4382f1e2015-08-05 01:08:53 +00001284#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001285
1286 // Signal that a thread just detached.
Mathieu Chartier91e56692015-03-03 13:51:04 -08001287 MutexLock mu(nullptr, *Locks::thread_list_lock_);
1288 --unregistering_count_;
1289 Locks::thread_exit_cond_->Broadcast(nullptr);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001290}
1291
1292void ThreadList::ForEach(void (*callback)(Thread*, void*), void* context) {
Mathieu Chartier02e25112013-08-14 16:14:24 -07001293 for (const auto& thread : list_) {
1294 callback(thread, context);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001295 }
1296}
1297
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001298void ThreadList::VisitRoots(RootVisitor* visitor) const {
Ian Rogers81d425b2012-09-27 16:03:43 -07001299 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001300 for (const auto& thread : list_) {
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001301 thread->VisitRoots(visitor);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001302 }
Elliott Hughes038a8062011-09-18 14:12:41 -07001303}
1304
Ian Rogerscfaa4552012-11-26 21:00:08 -08001305uint32_t ThreadList::AllocThreadId(Thread* self) {
Chao-ying Fu9e369312014-05-21 11:20:52 -07001306 MutexLock mu(self, *Locks::allocated_thread_ids_lock_);
Elliott Hughes8daa0922011-09-11 13:46:25 -07001307 for (size_t i = 0; i < allocated_ids_.size(); ++i) {
1308 if (!allocated_ids_[i]) {
1309 allocated_ids_.set(i);
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001310 return i + 1; // Zero is reserved to mean "invalid".
Elliott Hughes8daa0922011-09-11 13:46:25 -07001311 }
1312 }
1313 LOG(FATAL) << "Out of internal thread ids";
1314 return 0;
1315}
1316
Ian Rogerscfaa4552012-11-26 21:00:08 -08001317void ThreadList::ReleaseThreadId(Thread* self, uint32_t id) {
Chao-ying Fu9e369312014-05-21 11:20:52 -07001318 MutexLock mu(self, *Locks::allocated_thread_ids_lock_);
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001319 --id; // Zero is reserved to mean "invalid".
Elliott Hughes8daa0922011-09-11 13:46:25 -07001320 DCHECK(allocated_ids_[id]) << id;
1321 allocated_ids_.reset(id);
1322}
1323
Mathieu Chartier4f55e222015-09-04 13:26:21 -07001324ScopedSuspendAll::ScopedSuspendAll(const char* cause, bool long_suspend) {
1325 Runtime::Current()->GetThreadList()->SuspendAll(cause, long_suspend);
1326}
1327
1328ScopedSuspendAll::~ScopedSuspendAll() {
1329 Runtime::Current()->GetThreadList()->ResumeAll();
1330}
1331
Elliott Hughes8daa0922011-09-11 13:46:25 -07001332} // namespace art