blob: caed36936afd15d0c92c991392d1b71ba74d9155 [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
Andreas Gampe46ee31b2016-12-14 10:11:49 -080028#include "android-base/stringprintf.h"
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"
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -080032#include "base/systrace.h"
Vladimir Marko80afd022015-05-19 18:08:00 +010033#include "base/time_utils.h"
Sameer Abu Asala8439542013-02-14 16:06:42 -080034#include "base/timing_logger.h"
Elliott Hughes475fc232011-10-25 15:00:35 -070035#include "debugger.h"
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -070036#include "gc/collector/concurrent_copying.h"
Hiroshi Yamauchi30493242016-11-03 13:06:52 -070037#include "gc/reference_processor.h"
Ian Rogersd9c4fc92013-10-01 19:45:43 -070038#include "jni_internal.h"
39#include "lock_word.h"
40#include "monitor.h"
Andreas Gampe5dd44d02016-08-02 17:20:03 -070041#include "native_stack_dump.h"
Mathieu Chartier0795f232016-09-27 18:43:30 -070042#include "scoped_thread_state_change-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080043#include "thread.h"
Jeff Haoe094b872014-10-14 13:12:01 -070044#include "trace.h"
Ian Rogersd9c4fc92013-10-01 19:45:43 -070045#include "well_known_classes.h"
Elliott Hughes475fc232011-10-25 15:00:35 -070046
Yu Lieac44242015-06-29 10:50:03 +080047#if ART_USE_FUTEXES
48#include "linux/futex.h"
49#include "sys/syscall.h"
50#ifndef SYS_futex
51#define SYS_futex __NR_futex
52#endif
53#endif // ART_USE_FUTEXES
54
Elliott Hughes8daa0922011-09-11 13:46:25 -070055namespace art {
56
Andreas Gampe46ee31b2016-12-14 10:11:49 -080057using android::base::StringPrintf;
58
Mathieu Chartier251755c2014-07-15 18:10:25 -070059static constexpr uint64_t kLongThreadSuspendThreshold = MsToNs(5);
Mathieu Chartier99143862015-02-03 14:26:46 -080060// Use 0 since we want to yield to prevent blocking for an unpredictable amount of time.
61static constexpr useconds_t kThreadSuspendInitialSleepUs = 0;
62static constexpr useconds_t kThreadSuspendMaxYieldUs = 3000;
63static constexpr useconds_t kThreadSuspendMaxSleepUs = 5000;
Mathieu Chartier251755c2014-07-15 18:10:25 -070064
Andreas Gampe8d1594d2016-03-01 14:38:37 -080065// Whether we should try to dump the native stack of unattached threads. See commit ed8b723 for
66// some history.
Andreas Gampea3e8fc32016-06-13 16:15:33 -070067// Turned off again. b/29248079
Mathieu Chartier3f386d52016-10-05 14:12:45 -070068static constexpr bool kDumpUnattachedThreadNativeStackForSigQuit = false;
Andreas Gampe8d1594d2016-03-01 14:38:37 -080069
Mathieu Chartier3fceaf52017-01-22 13:33:40 -080070ThreadList::ThreadList(uint64_t thread_suspend_timeout_ns)
Mathieu Chartierb56200b2015-10-29 10:41:51 -070071 : suspend_all_count_(0),
72 debug_suspend_all_count_(0),
73 unregistering_count_(0),
74 suspend_all_historam_("suspend all histogram", 16, 64),
Hiroshi Yamauchi30493242016-11-03 13:06:52 -070075 long_suspend_(false),
Mathieu Chartier3fceaf52017-01-22 13:33:40 -080076 thread_suspend_timeout_ns_(thread_suspend_timeout_ns),
Hiroshi Yamauchi30493242016-11-03 13:06:52 -070077 empty_checkpoint_barrier_(new Barrier(0)) {
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -080078 CHECK(Monitor::IsValidLockWord(LockWord::FromThinLockId(kMaxThreadId, 1, 0U)));
Elliott Hughes8daa0922011-09-11 13:46:25 -070079}
80
81ThreadList::~ThreadList() {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -080082 ScopedTrace trace(__PRETTY_FUNCTION__);
Elliott Hughese52e49b2012-04-02 16:05:44 -070083 // Detach the current thread if necessary. If we failed to start, there might not be any threads.
Elliott Hughes6a144332012-04-03 13:07:11 -070084 // We need to detach the current thread here in case there's another thread waiting to join with
85 // us.
Mathieu Chartierfec72f42014-10-09 12:57:58 -070086 bool contains = false;
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -080087 Thread* self = Thread::Current();
Mathieu Chartierfec72f42014-10-09 12:57:58 -070088 {
Mathieu Chartierfec72f42014-10-09 12:57:58 -070089 MutexLock mu(self, *Locks::thread_list_lock_);
90 contains = Contains(self);
91 }
92 if (contains) {
Elliott Hughes8daa0922011-09-11 13:46:25 -070093 Runtime::Current()->DetachCurrentThread();
94 }
Elliott Hughes6a144332012-04-03 13:07:11 -070095 WaitForOtherNonDaemonThreadsToExit();
Mathieu Chartier51168372015-08-12 16:40:32 -070096 // Disable GC and wait for GC to complete in case there are still daemon threads doing
97 // allocations.
98 gc::Heap* const heap = Runtime::Current()->GetHeap();
99 heap->DisableGCForShutdown();
100 // In case a GC is in progress, wait for it to finish.
101 heap->WaitForGcToComplete(gc::kGcCauseBackground, Thread::Current());
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700102 // TODO: there's an unaddressed race here where a thread may attach during shutdown, see
103 // Thread::Init.
Mathieu Chartier4d87df62016-01-07 15:14:19 -0800104 SuspendAllDaemonThreadsForShutdown();
Elliott Hughes8daa0922011-09-11 13:46:25 -0700105}
106
107bool ThreadList::Contains(Thread* thread) {
108 return find(list_.begin(), list_.end(), thread) != list_.end();
109}
110
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700111bool ThreadList::Contains(pid_t tid) {
Mathieu Chartier02e25112013-08-14 16:14:24 -0700112 for (const auto& thread : list_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700113 if (thread->GetTid() == tid) {
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700114 return true;
115 }
116 }
117 return false;
118}
119
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -0700120pid_t ThreadList::GetLockOwner() {
Ian Rogersb726dcb2012-09-05 08:57:23 -0700121 return Locks::thread_list_lock_->GetExclusiveOwnerTid();
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700122}
123
Mathieu Chartier590fee92013-09-13 13:46:47 -0700124void ThreadList::DumpNativeStacks(std::ostream& os) {
125 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
Christopher Ferris6cff48f2014-01-26 21:36:13 -0800126 std::unique_ptr<BacktraceMap> map(BacktraceMap::Create(getpid()));
Mathieu Chartier590fee92013-09-13 13:46:47 -0700127 for (const auto& thread : list_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700128 os << "DUMPING THREAD " << thread->GetTid() << "\n";
Christopher Ferris6cff48f2014-01-26 21:36:13 -0800129 DumpNativeStack(os, thread->GetTid(), map.get(), "\t");
Mathieu Chartier590fee92013-09-13 13:46:47 -0700130 os << "\n";
131 }
132}
133
Elliott Hughesc967f782012-04-16 10:23:15 -0700134void ThreadList::DumpForSigQuit(std::ostream& os) {
Mathieu Chartier70a596d2014-12-17 14:56:47 -0800135 {
136 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartier23f6e692014-12-18 18:24:39 -0800137 // Only print if we have samples.
138 if (suspend_all_historam_.SampleSize() > 0) {
139 Histogram<uint64_t>::CumulativeData data;
140 suspend_all_historam_.CreateHistogram(&data);
141 suspend_all_historam_.PrintConfidenceIntervals(os, 0.99, data); // Dump time to suspend.
142 }
Mathieu Chartier70a596d2014-12-17 14:56:47 -0800143 }
Nicolas Geoffrayd3c59652016-03-17 09:35:04 +0000144 bool dump_native_stack = Runtime::Current()->GetDumpNativeStackOnSigQuit();
145 Dump(os, dump_native_stack);
Mathieu Chartier3f386d52016-10-05 14:12:45 -0700146 DumpUnattachedThreads(os, dump_native_stack && kDumpUnattachedThreadNativeStackForSigQuit);
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700147}
148
Nicolas Geoffrayd3c59652016-03-17 09:35:04 +0000149static void DumpUnattachedThread(std::ostream& os, pid_t tid, bool dump_native_stack)
150 NO_THREAD_SAFETY_ANALYSIS {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700151 // TODO: No thread safety analysis as DumpState with a null thread won't access fields, should
Ian Rogerscfaa4552012-11-26 21:00:08 -0800152 // refactor DumpState to avoid skipping analysis.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700153 Thread::DumpState(os, nullptr, tid);
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700154 DumpKernelStack(os, tid, " kernel: ", false);
Mathieu Chartier3f386d52016-10-05 14:12:45 -0700155 if (dump_native_stack) {
Christopher Ferris6cff48f2014-01-26 21:36:13 -0800156 DumpNativeStack(os, tid, nullptr, " native: ");
Brian Carlstromed8b7232012-06-27 17:54:47 -0700157 }
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700158 os << "\n";
159}
160
Nicolas Geoffrayd3c59652016-03-17 09:35:04 +0000161void ThreadList::DumpUnattachedThreads(std::ostream& os, bool dump_native_stack) {
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700162 DIR* d = opendir("/proc/self/task");
163 if (!d) {
164 return;
165 }
166
Ian Rogers50b35e22012-10-04 10:09:15 -0700167 Thread* self = Thread::Current();
Elliott Hughes4696b5b2012-10-30 10:35:10 -0700168 dirent* e;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700169 while ((e = readdir(d)) != nullptr) {
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700170 char* end;
Elliott Hughes4696b5b2012-10-30 10:35:10 -0700171 pid_t tid = strtol(e->d_name, &end, 10);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700172 if (!*end) {
173 bool contains;
174 {
Ian Rogers50b35e22012-10-04 10:09:15 -0700175 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700176 contains = Contains(tid);
177 }
178 if (!contains) {
Nicolas Geoffrayd3c59652016-03-17 09:35:04 +0000179 DumpUnattachedThread(os, tid, dump_native_stack);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700180 }
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700181 }
182 }
183 closedir(d);
Elliott Hughesff738062012-02-03 15:00:42 -0800184}
185
Mathieu Chartier47c19592016-03-07 11:59:01 -0800186// Dump checkpoint timeout in milliseconds. Larger amount on the target, since the device could be
187// overloaded with ANR dumps.
188static constexpr uint32_t kDumpWaitTimeout = kIsTargetBuild ? 100000 : 20000;
Andreas Gampe4a3d19b2015-01-09 17:54:51 -0800189
Ian Rogers7b078e82014-09-10 14:44:24 -0700190// A closure used by Thread::Dump.
191class DumpCheckpoint FINAL : public Closure {
192 public:
Nicolas Geoffraya73280d2016-02-15 13:05:16 +0000193 DumpCheckpoint(std::ostream* os, bool dump_native_stack)
194 : os_(os),
195 barrier_(0),
196 backtrace_map_(dump_native_stack ? BacktraceMap::Create(getpid()) : nullptr),
197 dump_native_stack_(dump_native_stack) {}
Ian Rogers7b078e82014-09-10 14:44:24 -0700198
199 void Run(Thread* thread) OVERRIDE {
200 // Note thread and self may not be equal if thread was already suspended at the point of the
201 // request.
202 Thread* self = Thread::Current();
Mathieu Chartier3f386d52016-10-05 14:12:45 -0700203 CHECK(self != nullptr);
Ian Rogers7b078e82014-09-10 14:44:24 -0700204 std::ostringstream local_os;
205 {
206 ScopedObjectAccess soa(self);
Nicolas Geoffraya73280d2016-02-15 13:05:16 +0000207 thread->Dump(local_os, dump_native_stack_, backtrace_map_.get());
Ian Rogers7b078e82014-09-10 14:44:24 -0700208 }
209 local_os << "\n";
210 {
211 // Use the logging lock to ensure serialization when writing to the common ostream.
212 MutexLock mu(self, *Locks::logging_lock_);
213 *os_ << local_os.str();
214 }
Mathieu Chartier10d25082015-10-28 18:36:09 -0700215 barrier_.Pass(self);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700216 }
Ian Rogers7b078e82014-09-10 14:44:24 -0700217
218 void WaitForThreadsToRunThroughCheckpoint(size_t threads_running_checkpoint) {
219 Thread* self = Thread::Current();
220 ScopedThreadStateChange tsc(self, kWaitingForCheckPointsToRun);
Andreas Gampe1e4b0ca2015-01-14 09:06:32 -0800221 bool timed_out = barrier_.Increment(self, threads_running_checkpoint, kDumpWaitTimeout);
Ian Rogers2156ff12014-09-13 19:20:54 -0700222 if (timed_out) {
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000223 // Avoid a recursive abort.
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700224 LOG((kIsDebugBuild && (gAborting == 0)) ? ::android::base::FATAL : ::android::base::ERROR)
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000225 << "Unexpected time out during dump checkpoint.";
Ian Rogers2156ff12014-09-13 19:20:54 -0700226 }
Ian Rogers7b078e82014-09-10 14:44:24 -0700227 }
228
229 private:
230 // The common stream that will accumulate all the dumps.
231 std::ostream* const os_;
232 // The barrier to be passed through and for the requestor to wait upon.
233 Barrier barrier_;
Christopher Ferris6cff48f2014-01-26 21:36:13 -0800234 // A backtrace map, so that all threads use a shared info and don't reacquire/parse separately.
235 std::unique_ptr<BacktraceMap> backtrace_map_;
Nicolas Geoffraya73280d2016-02-15 13:05:16 +0000236 // Whether we should dump the native stack.
237 const bool dump_native_stack_;
Ian Rogers7b078e82014-09-10 14:44:24 -0700238};
239
Nicolas Geoffraya73280d2016-02-15 13:05:16 +0000240void ThreadList::Dump(std::ostream& os, bool dump_native_stack) {
Mathieu Chartier3f386d52016-10-05 14:12:45 -0700241 Thread* self = Thread::Current();
Ian Rogers7b078e82014-09-10 14:44:24 -0700242 {
Mathieu Chartier3f386d52016-10-05 14:12:45 -0700243 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogers7b078e82014-09-10 14:44:24 -0700244 os << "DALVIK THREADS (" << list_.size() << "):\n";
245 }
Mathieu Chartier3f386d52016-10-05 14:12:45 -0700246 if (self != nullptr) {
247 DumpCheckpoint checkpoint(&os, dump_native_stack);
248 size_t threads_running_checkpoint;
249 {
250 // Use SOA to prevent deadlocks if multiple threads are calling Dump() at the same time.
251 ScopedObjectAccess soa(self);
252 threads_running_checkpoint = RunCheckpoint(&checkpoint);
253 }
254 if (threads_running_checkpoint != 0) {
255 checkpoint.WaitForThreadsToRunThroughCheckpoint(threads_running_checkpoint);
256 }
257 } else {
258 DumpUnattachedThreads(os, dump_native_stack);
Lei Lidd9943d2015-02-02 14:24:44 +0800259 }
Elliott Hughes8daa0922011-09-11 13:46:25 -0700260}
261
Ian Rogers50b35e22012-10-04 10:09:15 -0700262void ThreadList::AssertThreadsAreSuspended(Thread* self, Thread* ignore1, Thread* ignore2) {
263 MutexLock mu(self, *Locks::thread_list_lock_);
264 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -0700265 for (const auto& thread : list_) {
jeffhao725a9572012-11-13 18:20:12 -0800266 if (thread != ignore1 && thread != ignore2) {
Ian Rogers01ae5802012-09-28 16:14:01 -0700267 CHECK(thread->IsSuspended())
268 << "\nUnsuspended thread: <<" << *thread << "\n"
269 << "self: <<" << *Thread::Current();
270 }
Elliott Hughes8d768a92011-09-14 16:35:25 -0700271 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700272}
273
Ian Rogers66aee5c2012-08-15 17:17:47 -0700274#if HAVE_TIMED_RWLOCK
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700275// Attempt to rectify locks so that we dump thread list with required locks before exiting.
Andreas Gampe794ad762015-02-23 08:12:24 -0800276NO_RETURN static void UnsafeLogFatalForThreadSuspendAllTimeout() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700277 Runtime* runtime = Runtime::Current();
278 std::ostringstream ss;
279 ss << "Thread suspend timeout\n";
Mathieu Chartier5869a2c2014-10-08 14:26:23 -0700280 Locks::mutator_lock_->Dump(ss);
281 ss << "\n";
Ian Rogers7b078e82014-09-10 14:44:24 -0700282 runtime->GetThreadList()->Dump(ss);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700283 LOG(FATAL) << ss.str();
Ian Rogers719d1a32014-03-06 12:13:39 -0800284 exit(0);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700285}
Ian Rogers66aee5c2012-08-15 17:17:47 -0700286#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700287
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800288// Unlike suspending all threads where we can wait to acquire the mutator_lock_, suspending an
Mathieu Chartier99143862015-02-03 14:26:46 -0800289// individual thread requires polling. delay_us is the requested sleep wait. If delay_us is 0 then
290// we use sched_yield instead of calling usleep.
291static void ThreadSuspendSleep(useconds_t delay_us) {
292 if (delay_us == 0) {
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800293 sched_yield();
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800294 } else {
Mathieu Chartier99143862015-02-03 14:26:46 -0800295 usleep(delay_us);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800296 }
297}
298
Hiroshi Yamauchifebd0cf2016-09-14 19:31:25 -0700299size_t ThreadList::RunCheckpoint(Closure* checkpoint_function, Closure* callback) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700300 Thread* self = Thread::Current();
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800301 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
302 Locks::thread_list_lock_->AssertNotHeld(self);
303 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700304
305 std::vector<Thread*> suspended_count_modified_threads;
306 size_t count = 0;
307 {
308 // Call a checkpoint function for each thread, threads which are suspend get their checkpoint
309 // manually called.
310 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700311 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier10d25082015-10-28 18:36:09 -0700312 count = list_.size();
Mathieu Chartier02e25112013-08-14 16:14:24 -0700313 for (const auto& thread : list_) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700314 if (thread != self) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700315 while (true) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700316 if (thread->RequestCheckpoint(checkpoint_function)) {
Dave Allison0aded082013-11-07 13:15:11 -0800317 // This thread will run its checkpoint some time in the near future.
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700318 break;
319 } else {
320 // We are probably suspended, try to make sure that we stay suspended.
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700321 // The thread switched back to runnable.
322 if (thread->GetState() == kRunnable) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700323 // Spurious fail, try again.
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700324 continue;
325 }
Yu Lieac44242015-06-29 10:50:03 +0800326 thread->ModifySuspendCount(self, +1, nullptr, false);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700327 suspended_count_modified_threads.push_back(thread);
328 break;
329 }
330 }
331 }
332 }
Hiroshi Yamauchifebd0cf2016-09-14 19:31:25 -0700333 // Run the callback to be called inside this critical section.
334 if (callback != nullptr) {
335 callback->Run(self);
336 }
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700337 }
338
339 // Run the checkpoint on ourself while we wait for threads to suspend.
340 checkpoint_function->Run(self);
341
342 // Run the checkpoint on the suspended threads.
Mathieu Chartier02e25112013-08-14 16:14:24 -0700343 for (const auto& thread : suspended_count_modified_threads) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700344 if (!thread->IsSuspended()) {
Mathieu Chartier99143862015-02-03 14:26:46 -0800345 if (ATRACE_ENABLED()) {
346 std::ostringstream oss;
347 thread->ShortDump(oss);
348 ATRACE_BEGIN((std::string("Waiting for suspension of thread ") + oss.str()).c_str());
349 }
350 // Busy wait until the thread is suspended.
351 const uint64_t start_time = NanoTime();
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700352 do {
Mathieu Chartier99143862015-02-03 14:26:46 -0800353 ThreadSuspendSleep(kThreadSuspendInitialSleepUs);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700354 } while (!thread->IsSuspended());
Mathieu Chartier99143862015-02-03 14:26:46 -0800355 const uint64_t total_delay = NanoTime() - start_time;
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800356 // Shouldn't need to wait for longer than 1000 microseconds.
Mathieu Chartier99143862015-02-03 14:26:46 -0800357 constexpr uint64_t kLongWaitThreshold = MsToNs(1);
358 ATRACE_END();
359 if (UNLIKELY(total_delay > kLongWaitThreshold)) {
360 LOG(WARNING) << "Long wait of " << PrettyDuration(total_delay) << " for "
361 << *thread << " suspension!";
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700362 }
363 }
364 // We know for sure that the thread is suspended at this point.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700365 checkpoint_function->Run(thread);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700366 {
367 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Yu Lieac44242015-06-29 10:50:03 +0800368 thread->ModifySuspendCount(self, -1, nullptr, false);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700369 }
370 }
371
Mathieu Chartier664bebf2012-11-12 16:54:11 -0800372 {
373 // Imitate ResumeAll, threads may be waiting on Thread::resume_cond_ since we raised their
374 // suspend count. Now the suspend_count_ is lowered so we must do the broadcast.
375 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
376 Thread::resume_cond_->Broadcast(self);
377 }
378
Lei Lidd9943d2015-02-02 14:24:44 +0800379 return count;
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700380}
381
Hiroshi Yamauchia2224042017-02-08 16:35:45 -0800382void ThreadList::RunEmptyCheckpoint() {
Hiroshi Yamauchi30493242016-11-03 13:06:52 -0700383 Thread* self = Thread::Current();
384 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
385 Locks::thread_list_lock_->AssertNotHeld(self);
386 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
Hiroshi Yamauchia2224042017-02-08 16:35:45 -0800387 std::vector<uint32_t> runnable_thread_ids;
Hiroshi Yamauchi30493242016-11-03 13:06:52 -0700388 size_t count = 0;
Hiroshi Yamauchia2224042017-02-08 16:35:45 -0800389 Barrier* barrier = empty_checkpoint_barrier_.get();
390 barrier->Init(self, 0);
Hiroshi Yamauchi30493242016-11-03 13:06:52 -0700391 {
392 MutexLock mu(self, *Locks::thread_list_lock_);
393 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
394 for (Thread* thread : list_) {
395 if (thread != self) {
396 while (true) {
397 if (thread->RequestEmptyCheckpoint()) {
398 // This thread will run an empty checkpoint (decrement the empty checkpoint barrier)
399 // some time in the near future.
400 ++count;
Hiroshi Yamauchia82769c2016-12-02 17:01:51 -0800401 if (kIsDebugBuild) {
402 runnable_thread_ids.push_back(thread->GetThreadId());
403 }
Hiroshi Yamauchi30493242016-11-03 13:06:52 -0700404 break;
405 }
406 if (thread->GetState() != kRunnable) {
407 // It's seen suspended, we are done because it must not be in the middle of a mutator
408 // heap access.
409 break;
410 }
411 }
412 }
413 }
414 }
415
416 // Wake up the threads blocking for weak ref access so that they will respond to the empty
417 // checkpoint request. Otherwise we will hang as they are blocking in the kRunnable state.
418 Runtime::Current()->GetHeap()->GetReferenceProcessor()->BroadcastForSlowPath(self);
419 Runtime::Current()->BroadcastForNewSystemWeaks(/*broadcast_for_checkpoint*/true);
Hiroshi Yamauchia2224042017-02-08 16:35:45 -0800420 {
421 ScopedThreadStateChange tsc(self, kWaitingForCheckPointsToRun);
422 uint64_t total_wait_time = 0;
423 bool first_iter = true;
424 while (true) {
425 // Wake up the runnable threads blocked on the mutexes that another thread, which is blocked
426 // on a weak ref access, holds (indirectly blocking for weak ref access through another thread
427 // and a mutex.) This needs to be done periodically because the thread may be preempted
428 // between the CheckEmptyCheckpointFromMutex call and the subsequent futex wait in
429 // Mutex::ExclusiveLock, etc. when the wakeup via WakeupToRespondToEmptyCheckpoint
430 // arrives. This could cause a *very rare* deadlock, if not repeated. Most of the cases are
431 // handled in the first iteration.
432 for (BaseMutex* mutex : Locks::expected_mutexes_on_weak_ref_access_) {
433 mutex->WakeupToRespondToEmptyCheckpoint();
434 }
435 static constexpr uint64_t kEmptyCheckpointPeriodicTimeoutMs = 100; // 100ms
436 static constexpr uint64_t kEmptyCheckpointTotalTimeoutMs = 600 * 1000; // 10 minutes.
437 size_t barrier_count = first_iter ? count : 0;
438 first_iter = false; // Don't add to the barrier count from the second iteration on.
439 bool timed_out = barrier->Increment(self, barrier_count, kEmptyCheckpointPeriodicTimeoutMs);
440 if (!timed_out) {
441 break; // Success
442 }
443 // This is a very rare case.
444 total_wait_time += kEmptyCheckpointPeriodicTimeoutMs;
445 if (kIsDebugBuild && total_wait_time > kEmptyCheckpointTotalTimeoutMs) {
446 std::ostringstream ss;
447 ss << "Empty checkpoint timeout\n";
448 ss << "Barrier count " << barrier->GetCount(self) << "\n";
449 ss << "Runnable thread IDs";
450 for (uint32_t tid : runnable_thread_ids) {
451 ss << " " << tid;
452 }
453 ss << "\n";
454 Locks::mutator_lock_->Dump(ss);
455 ss << "\n";
456 LOG(FATAL_WITHOUT_ABORT) << ss.str();
457 // Some threads in 'runnable_thread_ids' are probably stuck. Try to dump their stacks.
458 // Avoid using ThreadList::Dump() initially because it is likely to get stuck as well.
459 {
460 ScopedObjectAccess soa(self);
461 MutexLock mu1(self, *Locks::thread_list_lock_);
462 for (Thread* thread : GetList()) {
463 uint32_t tid = thread->GetThreadId();
464 bool is_in_runnable_thread_ids =
465 std::find(runnable_thread_ids.begin(), runnable_thread_ids.end(), tid) !=
466 runnable_thread_ids.end();
467 if (is_in_runnable_thread_ids &&
468 thread->ReadFlag(kEmptyCheckpointRequest)) {
469 // Found a runnable thread that hasn't responded to the empty checkpoint request.
470 // Assume it's stuck and safe to dump its stack.
471 thread->Dump(LOG_STREAM(FATAL_WITHOUT_ABORT),
472 /*dump_native_stack*/ true,
473 /*backtrace_map*/ nullptr,
474 /*force_dump_stack*/ true);
475 }
476 }
477 }
478 LOG(FATAL_WITHOUT_ABORT)
479 << "Dumped runnable threads that haven't responded to empty checkpoint.";
480 // Now use ThreadList::Dump() to dump more threads, noting it may get stuck.
481 Dump(LOG_STREAM(FATAL_WITHOUT_ABORT));
482 LOG(FATAL) << "Dumped all threads.";
483 }
484 }
485 }
Hiroshi Yamauchi30493242016-11-03 13:06:52 -0700486}
487
Dave Allison39c3bfb2014-01-28 18:33:52 -0800488// Request that a checkpoint function be run on all active (non-suspended)
489// threads. Returns the number of successful requests.
490size_t ThreadList::RunCheckpointOnRunnableThreads(Closure* checkpoint_function) {
491 Thread* self = Thread::Current();
Ian Rogers7b078e82014-09-10 14:44:24 -0700492 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
493 Locks::thread_list_lock_->AssertNotHeld(self);
494 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
495 CHECK_NE(self->GetState(), kRunnable);
Dave Allison39c3bfb2014-01-28 18:33:52 -0800496
497 size_t count = 0;
498 {
499 // Call a checkpoint function for each non-suspended thread.
500 MutexLock mu(self, *Locks::thread_list_lock_);
501 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
502 for (const auto& thread : list_) {
503 if (thread != self) {
504 if (thread->RequestCheckpoint(checkpoint_function)) {
505 // This thread will run its checkpoint some time in the near future.
506 count++;
507 }
508 }
509 }
510 }
511
512 // Return the number of threads that will run the checkpoint function.
513 return count;
514}
515
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800516// A checkpoint/suspend-all hybrid to switch thread roots from
517// from-space to to-space refs. Used to synchronize threads at a point
518// to mark the initiation of marking while maintaining the to-space
519// invariant.
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700520size_t ThreadList::FlipThreadRoots(Closure* thread_flip_visitor,
521 Closure* flip_callback,
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800522 gc::collector::GarbageCollector* collector) {
523 TimingLogger::ScopedTiming split("ThreadListFlip", collector->GetTimings());
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800524 Thread* self = Thread::Current();
525 Locks::mutator_lock_->AssertNotHeld(self);
526 Locks::thread_list_lock_->AssertNotHeld(self);
527 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
528 CHECK_NE(self->GetState(), kRunnable);
529
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700530 collector->GetHeap()->ThreadFlipBegin(self); // Sync with JNI critical calls.
531
Mathieu Chartiere9429c82017-01-27 15:22:56 -0800532 // ThreadFlipBegin happens before we suspend all the threads, so it does not count towards the
533 // pause.
534 const uint64_t suspend_start_time = NanoTime();
Mathieu Chartierb19ccb12015-07-15 10:24:16 -0700535 SuspendAllInternal(self, self, nullptr);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800536
537 // Run the flip callback for the collector.
538 Locks::mutator_lock_->ExclusiveLock(self);
Mathieu Chartiere9429c82017-01-27 15:22:56 -0800539 suspend_all_historam_.AdjustAndAddValue(NanoTime() - suspend_start_time);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800540 flip_callback->Run(self);
541 Locks::mutator_lock_->ExclusiveUnlock(self);
Mathieu Chartiere9429c82017-01-27 15:22:56 -0800542 collector->RegisterPause(NanoTime() - suspend_start_time);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800543
544 // Resume runnable threads.
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700545 size_t runnable_thread_count = 0;
Mathieu Chartierb19ccb12015-07-15 10:24:16 -0700546 std::vector<Thread*> other_threads;
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800547 {
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700548 TimingLogger::ScopedTiming split2("ResumeRunnableThreads", collector->GetTimings());
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800549 MutexLock mu(self, *Locks::thread_list_lock_);
550 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
551 --suspend_all_count_;
552 for (const auto& thread : list_) {
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700553 // Set the flip function for all threads because Thread::DumpState/DumpJavaStack() (invoked by
554 // a checkpoint) may cause the flip function to be run for a runnable/suspended thread before
555 // a runnable thread runs it for itself or we run it for a suspended thread below.
556 thread->SetFlipFunction(thread_flip_visitor);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800557 if (thread == self) {
558 continue;
559 }
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700560 // Resume early the threads that were runnable but are suspended just for this thread flip or
561 // about to transition from non-runnable (eg. kNative at the SOA entry in a JNI function) to
562 // runnable (both cases waiting inside Thread::TransitionFromSuspendedToRunnable), or waiting
563 // for the thread flip to end at the JNI critical section entry (kWaitingForGcThreadFlip),
564 ThreadState state = thread->GetState();
Hiroshi Yamauchi15af34c2016-09-26 16:56:24 -0700565 if ((state == kWaitingForGcThreadFlip || thread->IsTransitioningToRunnable()) &&
566 thread->GetSuspendCount() == 1) {
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800567 // The thread will resume right after the broadcast.
Yu Lieac44242015-06-29 10:50:03 +0800568 thread->ModifySuspendCount(self, -1, nullptr, false);
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700569 ++runnable_thread_count;
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800570 } else {
571 other_threads.push_back(thread);
572 }
573 }
574 Thread::resume_cond_->Broadcast(self);
575 }
576
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700577 collector->GetHeap()->ThreadFlipEnd(self);
578
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800579 // Run the closure on the other threads and let them resume.
580 {
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700581 TimingLogger::ScopedTiming split3("FlipOtherThreads", collector->GetTimings());
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800582 ReaderMutexLock mu(self, *Locks::mutator_lock_);
583 for (const auto& thread : other_threads) {
584 Closure* flip_func = thread->GetFlipFunction();
585 if (flip_func != nullptr) {
586 flip_func->Run(thread);
587 }
588 }
589 // Run it for self.
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700590 Closure* flip_func = self->GetFlipFunction();
591 if (flip_func != nullptr) {
592 flip_func->Run(self);
593 }
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800594 }
595
596 // Resume other threads.
597 {
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700598 TimingLogger::ScopedTiming split4("ResumeOtherThreads", collector->GetTimings());
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800599 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
600 for (const auto& thread : other_threads) {
Yu Lieac44242015-06-29 10:50:03 +0800601 thread->ModifySuspendCount(self, -1, nullptr, false);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800602 }
603 Thread::resume_cond_->Broadcast(self);
604 }
605
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700606 return runnable_thread_count + other_threads.size() + 1; // +1 for self.
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800607}
608
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700609void ThreadList::SuspendAll(const char* cause, bool long_suspend) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700610 Thread* self = Thread::Current();
611
Jeff Haoc5d824a2014-07-28 18:35:38 -0700612 if (self != nullptr) {
Mathieu Chartierbf9fc582015-03-13 17:21:25 -0700613 VLOG(threads) << *self << " SuspendAll for " << cause << " starting...";
Jeff Haoc5d824a2014-07-28 18:35:38 -0700614 } else {
Mathieu Chartierbf9fc582015-03-13 17:21:25 -0700615 VLOG(threads) << "Thread[null] SuspendAll for " << cause << " starting...";
Jeff Haoc5d824a2014-07-28 18:35:38 -0700616 }
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800617 {
618 ScopedTrace trace("Suspending mutator threads");
619 const uint64_t start_time = NanoTime();
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700620
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800621 SuspendAllInternal(self, self);
622 // All threads are known to have suspended (but a thread may still own the mutator lock)
623 // Make sure this thread grabs exclusive access to the mutator lock and its protected data.
Ian Rogers66aee5c2012-08-15 17:17:47 -0700624#if HAVE_TIMED_RWLOCK
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800625 while (true) {
Mathieu Chartier3fceaf52017-01-22 13:33:40 -0800626 if (Locks::mutator_lock_->ExclusiveLockWithTimeout(self,
627 NsToMs(thread_suspend_timeout_ns_),
628 0)) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800629 break;
630 } else if (!long_suspend_) {
631 // Reading long_suspend without the mutator lock is slightly racy, in some rare cases, this
632 // could result in a thread suspend timeout.
Mathieu Chartier3fceaf52017-01-22 13:33:40 -0800633 // Timeout if we wait more than thread_suspend_timeout_ns_ nanoseconds.
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800634 UnsafeLogFatalForThreadSuspendAllTimeout();
635 }
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700636 }
Ian Rogers66aee5c2012-08-15 17:17:47 -0700637#else
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800638 Locks::mutator_lock_->ExclusiveLock(self);
Ian Rogers66aee5c2012-08-15 17:17:47 -0700639#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700640
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800641 long_suspend_ = long_suspend;
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700642
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800643 const uint64_t end_time = NanoTime();
644 const uint64_t suspend_time = end_time - start_time;
645 suspend_all_historam_.AdjustAndAddValue(suspend_time);
646 if (suspend_time > kLongThreadSuspendThreshold) {
647 LOG(WARNING) << "Suspending all threads took: " << PrettyDuration(suspend_time);
648 }
649
650 if (kDebugLocking) {
651 // Debug check that all threads are suspended.
652 AssertThreadsAreSuspended(self, self);
653 }
Mathieu Chartier251755c2014-07-15 18:10:25 -0700654 }
Mathieu Chartierbf9fc582015-03-13 17:21:25 -0700655 ATRACE_BEGIN((std::string("Mutator threads suspended for ") + cause).c_str());
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700656
Jeff Haoc5d824a2014-07-28 18:35:38 -0700657 if (self != nullptr) {
658 VLOG(threads) << *self << " SuspendAll complete";
659 } else {
660 VLOG(threads) << "Thread[null] SuspendAll complete";
661 }
Elliott Hughes8d768a92011-09-14 16:35:25 -0700662}
663
Yu Lieac44242015-06-29 10:50:03 +0800664// Ensures all threads running Java suspend and that those not running Java don't start.
665// Debugger thread might be set to kRunnable for a short period of time after the
666// SuspendAllInternal. This is safe because it will be set back to suspended state before
667// the SuspendAll returns.
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700668void ThreadList::SuspendAllInternal(Thread* self,
669 Thread* ignore1,
670 Thread* ignore2,
Yu Lieac44242015-06-29 10:50:03 +0800671 bool debug_suspend) {
672 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
673 Locks::thread_list_lock_->AssertNotHeld(self);
674 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
675 if (kDebugLocking && self != nullptr) {
676 CHECK_NE(self->GetState(), kRunnable);
677 }
678
679 // First request that all threads suspend, then wait for them to suspend before
680 // returning. This suspension scheme also relies on other behaviour:
681 // 1. Threads cannot be deleted while they are suspended or have a suspend-
682 // request flag set - (see Unregister() below).
683 // 2. When threads are created, they are created in a suspended state (actually
684 // kNative) and will never begin executing Java code without first checking
685 // the suspend-request flag.
686
687 // The atomic counter for number of threads that need to pass the barrier.
688 AtomicInteger pending_threads;
689 uint32_t num_ignored = 0;
690 if (ignore1 != nullptr) {
691 ++num_ignored;
692 }
693 if (ignore2 != nullptr && ignore1 != ignore2) {
694 ++num_ignored;
695 }
696 {
697 MutexLock mu(self, *Locks::thread_list_lock_);
698 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
699 // Update global suspend all state for attaching threads.
700 ++suspend_all_count_;
Mathieu Chartiere9429c82017-01-27 15:22:56 -0800701 if (debug_suspend) {
Yu Lieac44242015-06-29 10:50:03 +0800702 ++debug_suspend_all_count_;
Mathieu Chartiere9429c82017-01-27 15:22:56 -0800703 }
Yu Lieac44242015-06-29 10:50:03 +0800704 pending_threads.StoreRelaxed(list_.size() - num_ignored);
705 // Increment everybody's suspend count (except those that should be ignored).
706 for (const auto& thread : list_) {
707 if (thread == ignore1 || thread == ignore2) {
708 continue;
709 }
710 VLOG(threads) << "requesting thread suspend: " << *thread;
Hiroshi Yamauchi02e7f1a2016-10-03 15:32:01 -0700711 thread->ModifySuspendCount(self, +1, &pending_threads, debug_suspend);
Yu Lieac44242015-06-29 10:50:03 +0800712
713 // Must install the pending_threads counter first, then check thread->IsSuspend() and clear
714 // the counter. Otherwise there's a race with Thread::TransitionFromRunnableToSuspended()
715 // that can lead a thread to miss a call to PassActiveSuspendBarriers().
716 if (thread->IsSuspended()) {
717 // Only clear the counter for the current thread.
718 thread->ClearSuspendBarrier(&pending_threads);
719 pending_threads.FetchAndSubSequentiallyConsistent(1);
720 }
721 }
722 }
723
724 // Wait for the barrier to be passed by all runnable threads. This wait
725 // is done with a timeout so that we can detect problems.
Mathieu Chartier19af1172015-07-14 10:05:45 -0700726#if ART_USE_FUTEXES
Yu Lieac44242015-06-29 10:50:03 +0800727 timespec wait_timeout;
Mathieu Chartier3fceaf52017-01-22 13:33:40 -0800728 InitTimeSpec(false, CLOCK_MONOTONIC, NsToMs(thread_suspend_timeout_ns_), 0, &wait_timeout);
Mathieu Chartier19af1172015-07-14 10:05:45 -0700729#endif
Mathieu Chartier32c83372017-01-11 10:09:30 -0800730 const uint64_t start_time = NanoTime();
Yu Lieac44242015-06-29 10:50:03 +0800731 while (true) {
732 int32_t cur_val = pending_threads.LoadRelaxed();
733 if (LIKELY(cur_val > 0)) {
734#if ART_USE_FUTEXES
735 if (futex(pending_threads.Address(), FUTEX_WAIT, cur_val, &wait_timeout, nullptr, 0) != 0) {
736 // EAGAIN and EINTR both indicate a spurious failure, try again from the beginning.
737 if ((errno != EAGAIN) && (errno != EINTR)) {
738 if (errno == ETIMEDOUT) {
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700739 LOG(kIsDebugBuild ? ::android::base::FATAL : ::android::base::ERROR)
Mathieu Chartier32c83372017-01-11 10:09:30 -0800740 << "Timed out waiting for threads to suspend, waited for "
741 << PrettyDuration(NanoTime() - start_time);
Yu Lieac44242015-06-29 10:50:03 +0800742 } else {
743 PLOG(FATAL) << "futex wait failed for SuspendAllInternal()";
744 }
745 }
Vladimir Markod778cd62016-07-05 17:29:55 +0100746 } // else re-check pending_threads in the next iteration (this may be a spurious wake-up).
Yu Lieac44242015-06-29 10:50:03 +0800747#else
748 // Spin wait. This is likely to be slow, but on most architecture ART_USE_FUTEXES is set.
Mathieu Chartier32c83372017-01-11 10:09:30 -0800749 UNUSED(start_time);
Yu Lieac44242015-06-29 10:50:03 +0800750#endif
751 } else {
752 CHECK_EQ(cur_val, 0);
753 break;
754 }
755 }
756}
757
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700758void ThreadList::ResumeAll() {
759 Thread* self = Thread::Current();
760
Jeff Haoc5d824a2014-07-28 18:35:38 -0700761 if (self != nullptr) {
762 VLOG(threads) << *self << " ResumeAll starting";
763 } else {
764 VLOG(threads) << "Thread[null] ResumeAll starting";
765 }
Ian Rogers01ae5802012-09-28 16:14:01 -0700766
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700767 ATRACE_END();
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800768
769 ScopedTrace trace("Resuming mutator threads");
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700770
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800771 if (kDebugLocking) {
772 // Debug check that all threads are suspended.
773 AssertThreadsAreSuspended(self, self);
774 }
Ian Rogers01ae5802012-09-28 16:14:01 -0700775
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700776 long_suspend_ = false;
777
Ian Rogers81d425b2012-09-27 16:03:43 -0700778 Locks::mutator_lock_->ExclusiveUnlock(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700779 {
Ian Rogers81d425b2012-09-27 16:03:43 -0700780 MutexLock mu(self, *Locks::thread_list_lock_);
781 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700782 // Update global suspend all state for attaching threads.
783 --suspend_all_count_;
784 // Decrement the suspend counts for all threads.
Mathieu Chartier02e25112013-08-14 16:14:24 -0700785 for (const auto& thread : list_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700786 if (thread == self) {
787 continue;
788 }
Yu Lieac44242015-06-29 10:50:03 +0800789 thread->ModifySuspendCount(self, -1, nullptr, false);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700790 }
791
792 // Broadcast a notification to all suspended threads, some or all of
793 // which may choose to wake up. No need to wait for them.
Jeff Haoc5d824a2014-07-28 18:35:38 -0700794 if (self != nullptr) {
795 VLOG(threads) << *self << " ResumeAll waking others";
796 } else {
797 VLOG(threads) << "Thread[null] ResumeAll waking others";
798 }
Ian Rogersc604d732012-10-14 16:09:54 -0700799 Thread::resume_cond_->Broadcast(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700800 }
Jeff Haoc5d824a2014-07-28 18:35:38 -0700801
802 if (self != nullptr) {
803 VLOG(threads) << *self << " ResumeAll complete";
804 } else {
805 VLOG(threads) << "Thread[null] ResumeAll complete";
806 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700807}
808
809void ThreadList::Resume(Thread* thread, bool for_debugger) {
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -0800810 // This assumes there was an ATRACE_BEGIN when we suspended the thread.
811 ATRACE_END();
812
Ian Rogers81d425b2012-09-27 16:03:43 -0700813 Thread* self = Thread::Current();
814 DCHECK_NE(thread, self);
Brian Carlstromba32de42014-08-27 23:43:46 -0700815 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") starting..."
816 << (for_debugger ? " (debugger)" : "");
Elliott Hughes01158d72011-09-19 19:47:10 -0700817
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700818 {
819 // To check Contains.
Ian Rogers81d425b2012-09-27 16:03:43 -0700820 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700821 // To check IsSuspended.
Ian Rogers81d425b2012-09-27 16:03:43 -0700822 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
823 DCHECK(thread->IsSuspended());
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700824 if (!Contains(thread)) {
Brian Carlstromba32de42014-08-27 23:43:46 -0700825 // We only expect threads within the thread-list to have been suspended otherwise we can't
826 // stop such threads from delete-ing themselves.
827 LOG(ERROR) << "Resume(" << reinterpret_cast<void*>(thread)
828 << ") thread not within thread list";
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700829 return;
830 }
Yu Lieac44242015-06-29 10:50:03 +0800831 thread->ModifySuspendCount(self, -1, nullptr, for_debugger);
Elliott Hughes01158d72011-09-19 19:47:10 -0700832 }
833
834 {
Brian Carlstromba32de42014-08-27 23:43:46 -0700835 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") waking others";
Ian Rogers81d425b2012-09-27 16:03:43 -0700836 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersc604d732012-10-14 16:09:54 -0700837 Thread::resume_cond_->Broadcast(self);
Elliott Hughes01158d72011-09-19 19:47:10 -0700838 }
839
Brian Carlstromba32de42014-08-27 23:43:46 -0700840 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") complete";
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700841}
Elliott Hughes01158d72011-09-19 19:47:10 -0700842
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700843static void ThreadSuspendByPeerWarning(Thread* self,
844 LogSeverity severity,
845 const char* message,
Ian Rogersc7dd2952014-10-21 23:31:19 -0700846 jobject peer) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700847 JNIEnvExt* env = self->GetJniEnv();
848 ScopedLocalRef<jstring>
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700849 scoped_name_string(env, static_cast<jstring>(env->GetObjectField(
850 peer, WellKnownClasses::java_lang_Thread_name)));
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700851 ScopedUtfChars scoped_name_chars(env, scoped_name_string.get());
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700852 if (scoped_name_chars.c_str() == nullptr) {
Ian Rogersc7dd2952014-10-21 23:31:19 -0700853 LOG(severity) << message << ": " << peer;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700854 env->ExceptionClear();
855 } else {
Ian Rogersc7dd2952014-10-21 23:31:19 -0700856 LOG(severity) << message << ": " << peer << ":" << scoped_name_chars.c_str();
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700857 }
858}
859
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700860Thread* ThreadList::SuspendThreadByPeer(jobject peer,
861 bool request_suspension,
862 bool debug_suspension,
863 bool* timed_out) {
Mathieu Chartier3a958aa2015-02-04 12:52:34 -0800864 const uint64_t start_time = NanoTime();
Mathieu Chartier99143862015-02-03 14:26:46 -0800865 useconds_t sleep_us = kThreadSuspendInitialSleepUs;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700866 *timed_out = false;
Mathieu Chartier99143862015-02-03 14:26:46 -0800867 Thread* const self = Thread::Current();
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800868 Thread* suspended_thread = nullptr;
Brian Carlstromba32de42014-08-27 23:43:46 -0700869 VLOG(threads) << "SuspendThreadByPeer starting";
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700870 while (true) {
871 Thread* thread;
872 {
Ian Rogersf3d874c2014-07-17 18:52:42 -0700873 // Note: this will transition to runnable and potentially suspend. We ensure only one thread
874 // is requesting another suspend, to avoid deadlock, by requiring this function be called
875 // holding Locks::thread_list_suspend_thread_lock_. Its important this thread suspend rather
876 // than request thread suspension, to avoid potential cycles in threads requesting each other
877 // suspend.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700878 ScopedObjectAccess soa(self);
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800879 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700880 thread = Thread::FromManagedThread(soa, peer);
Brian Carlstromba32de42014-08-27 23:43:46 -0700881 if (thread == nullptr) {
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800882 if (suspended_thread != nullptr) {
883 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
884 // If we incremented the suspend count but the thread reset its peer, we need to
885 // re-decrement it since it is shutting down and may deadlock the runtime in
886 // ThreadList::WaitForOtherNonDaemonThreadsToExit.
Yu Lieac44242015-06-29 10:50:03 +0800887 suspended_thread->ModifySuspendCount(soa.Self(), -1, nullptr, debug_suspension);
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800888 }
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700889 ThreadSuspendByPeerWarning(self,
890 ::android::base::WARNING,
891 "No such thread for suspend",
892 peer);
Brian Carlstromba32de42014-08-27 23:43:46 -0700893 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700894 }
Brian Carlstromba32de42014-08-27 23:43:46 -0700895 if (!Contains(thread)) {
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800896 CHECK(suspended_thread == nullptr);
Brian Carlstromba32de42014-08-27 23:43:46 -0700897 VLOG(threads) << "SuspendThreadByPeer failed for unattached thread: "
898 << reinterpret_cast<void*>(thread);
899 return nullptr;
900 }
901 VLOG(threads) << "SuspendThreadByPeer found thread: " << *thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700902 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800903 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700904 if (request_suspension) {
Ian Rogers4ad5cd32014-11-11 23:08:07 -0800905 if (self->GetSuspendCount() > 0) {
906 // We hold the suspend count lock but another thread is trying to suspend us. Its not
907 // safe to try to suspend another thread in case we get a cycle. Start the loop again
908 // which will allow this thread to be suspended.
909 continue;
910 }
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800911 CHECK(suspended_thread == nullptr);
912 suspended_thread = thread;
Yu Lieac44242015-06-29 10:50:03 +0800913 suspended_thread->ModifySuspendCount(self, +1, nullptr, debug_suspension);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700914 request_suspension = false;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700915 } else {
916 // If the caller isn't requesting suspension, a suspension should have already occurred.
917 CHECK_GT(thread->GetSuspendCount(), 0);
918 }
919 // IsSuspended on the current thread will fail as the current thread is changed into
920 // Runnable above. As the suspend count is now raised if this is the current thread
921 // it will self suspend on transition to Runnable, making it hard to work with. It's simpler
922 // to just explicitly handle the current thread in the callers to this code.
923 CHECK_NE(thread, self) << "Attempt to suspend the current thread for the debugger";
924 // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend
925 // count, or else we've waited and it has self suspended) or is the current thread, we're
926 // done.
927 if (thread->IsSuspended()) {
Brian Carlstromba32de42014-08-27 23:43:46 -0700928 VLOG(threads) << "SuspendThreadByPeer thread suspended: " << *thread;
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -0800929 if (ATRACE_ENABLED()) {
930 std::string name;
931 thread->GetThreadName(name);
932 ATRACE_BEGIN(StringPrintf("SuspendThreadByPeer suspended %s for peer=%p", name.c_str(),
933 peer).c_str());
934 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700935 return thread;
936 }
Mathieu Chartier99143862015-02-03 14:26:46 -0800937 const uint64_t total_delay = NanoTime() - start_time;
Mathieu Chartier3fceaf52017-01-22 13:33:40 -0800938 if (total_delay >= thread_suspend_timeout_ns_) {
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700939 ThreadSuspendByPeerWarning(self,
940 ::android::base::FATAL,
Andreas Gamped6e54bb2016-09-26 14:07:57 -0700941 "Thread suspension timed out",
942 peer);
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800943 if (suspended_thread != nullptr) {
944 CHECK_EQ(suspended_thread, thread);
Yu Lieac44242015-06-29 10:50:03 +0800945 suspended_thread->ModifySuspendCount(soa.Self(), -1, nullptr, debug_suspension);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700946 }
947 *timed_out = true;
Brian Carlstromba32de42014-08-27 23:43:46 -0700948 return nullptr;
Mathieu Chartier99143862015-02-03 14:26:46 -0800949 } else if (sleep_us == 0 &&
950 total_delay > static_cast<uint64_t>(kThreadSuspendMaxYieldUs) * 1000) {
951 // We have spun for kThreadSuspendMaxYieldUs time, switch to sleeps to prevent
952 // excessive CPU usage.
953 sleep_us = kThreadSuspendMaxYieldUs / 2;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700954 }
955 }
956 // Release locks and come out of runnable state.
957 }
Mathieu Chartier99143862015-02-03 14:26:46 -0800958 VLOG(threads) << "SuspendThreadByPeer waiting to allow thread chance to suspend";
959 ThreadSuspendSleep(sleep_us);
960 // This may stay at 0 if sleep_us == 0, but this is WAI since we want to avoid using usleep at
961 // all if possible. This shouldn't be an issue since time to suspend should always be small.
962 sleep_us = std::min(sleep_us * 2, kThreadSuspendMaxSleepUs);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700963 }
964}
965
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700966static void ThreadSuspendByThreadIdWarning(LogSeverity severity,
967 const char* message,
Ian Rogersc7dd2952014-10-21 23:31:19 -0700968 uint32_t thread_id) {
969 LOG(severity) << StringPrintf("%s: %d", message, thread_id);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700970}
971
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700972Thread* ThreadList::SuspendThreadByThreadId(uint32_t thread_id,
973 bool debug_suspension,
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700974 bool* timed_out) {
Mathieu Chartier3a958aa2015-02-04 12:52:34 -0800975 const uint64_t start_time = NanoTime();
Mathieu Chartier99143862015-02-03 14:26:46 -0800976 useconds_t sleep_us = kThreadSuspendInitialSleepUs;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700977 *timed_out = false;
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800978 Thread* suspended_thread = nullptr;
Mathieu Chartier99143862015-02-03 14:26:46 -0800979 Thread* const self = Thread::Current();
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700980 CHECK_NE(thread_id, kInvalidThreadId);
Brian Carlstromba32de42014-08-27 23:43:46 -0700981 VLOG(threads) << "SuspendThreadByThreadId starting";
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700982 while (true) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700983 {
Ian Rogersf3d874c2014-07-17 18:52:42 -0700984 // Note: this will transition to runnable and potentially suspend. We ensure only one thread
985 // is requesting another suspend, to avoid deadlock, by requiring this function be called
986 // holding Locks::thread_list_suspend_thread_lock_. Its important this thread suspend rather
987 // than request thread suspension, to avoid potential cycles in threads requesting each other
988 // suspend.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700989 ScopedObjectAccess soa(self);
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800990 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Ian Rogersf3d874c2014-07-17 18:52:42 -0700991 Thread* thread = nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700992 for (const auto& it : list_) {
993 if (it->GetThreadId() == thread_id) {
994 thread = it;
995 break;
996 }
997 }
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800998 if (thread == nullptr) {
999 CHECK(suspended_thread == nullptr) << "Suspended thread " << suspended_thread
1000 << " no longer in thread list";
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001001 // There's a race in inflating a lock and the owner giving up ownership and then dying.
Andreas Gampe3fec9ac2016-09-13 10:47:28 -07001002 ThreadSuspendByThreadIdWarning(::android::base::WARNING,
1003 "No such thread id for suspend",
1004 thread_id);
Brian Carlstromba32de42014-08-27 23:43:46 -07001005 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001006 }
Brian Carlstromba32de42014-08-27 23:43:46 -07001007 VLOG(threads) << "SuspendThreadByThreadId found thread: " << *thread;
1008 DCHECK(Contains(thread));
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001009 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001010 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -08001011 if (suspended_thread == nullptr) {
Ian Rogers4ad5cd32014-11-11 23:08:07 -08001012 if (self->GetSuspendCount() > 0) {
1013 // We hold the suspend count lock but another thread is trying to suspend us. Its not
1014 // safe to try to suspend another thread in case we get a cycle. Start the loop again
1015 // which will allow this thread to be suspended.
1016 continue;
1017 }
Yu Lieac44242015-06-29 10:50:03 +08001018 thread->ModifySuspendCount(self, +1, nullptr, debug_suspension);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -08001019 suspended_thread = thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001020 } else {
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -08001021 CHECK_EQ(suspended_thread, thread);
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001022 // If the caller isn't requesting suspension, a suspension should have already occurred.
1023 CHECK_GT(thread->GetSuspendCount(), 0);
1024 }
1025 // IsSuspended on the current thread will fail as the current thread is changed into
1026 // Runnable above. As the suspend count is now raised if this is the current thread
1027 // it will self suspend on transition to Runnable, making it hard to work with. It's simpler
1028 // to just explicitly handle the current thread in the callers to this code.
1029 CHECK_NE(thread, self) << "Attempt to suspend the current thread for the debugger";
1030 // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend
1031 // count, or else we've waited and it has self suspended) or is the current thread, we're
1032 // done.
1033 if (thread->IsSuspended()) {
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -08001034 if (ATRACE_ENABLED()) {
1035 std::string name;
1036 thread->GetThreadName(name);
1037 ATRACE_BEGIN(StringPrintf("SuspendThreadByThreadId suspended %s id=%d",
1038 name.c_str(), thread_id).c_str());
1039 }
Brian Carlstromba32de42014-08-27 23:43:46 -07001040 VLOG(threads) << "SuspendThreadByThreadId thread suspended: " << *thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001041 return thread;
1042 }
Mathieu Chartier99143862015-02-03 14:26:46 -08001043 const uint64_t total_delay = NanoTime() - start_time;
Mathieu Chartier3fceaf52017-01-22 13:33:40 -08001044 if (total_delay >= thread_suspend_timeout_ns_) {
Andreas Gampe3fec9ac2016-09-13 10:47:28 -07001045 ThreadSuspendByThreadIdWarning(::android::base::WARNING,
1046 "Thread suspension timed out",
1047 thread_id);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -08001048 if (suspended_thread != nullptr) {
Yu Lieac44242015-06-29 10:50:03 +08001049 thread->ModifySuspendCount(soa.Self(), -1, nullptr, debug_suspension);
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001050 }
1051 *timed_out = true;
Brian Carlstromba32de42014-08-27 23:43:46 -07001052 return nullptr;
Mathieu Chartier99143862015-02-03 14:26:46 -08001053 } else if (sleep_us == 0 &&
1054 total_delay > static_cast<uint64_t>(kThreadSuspendMaxYieldUs) * 1000) {
1055 // We have spun for kThreadSuspendMaxYieldUs time, switch to sleeps to prevent
1056 // excessive CPU usage.
1057 sleep_us = kThreadSuspendMaxYieldUs / 2;
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001058 }
1059 }
1060 // Release locks and come out of runnable state.
1061 }
Mathieu Chartier99143862015-02-03 14:26:46 -08001062 VLOG(threads) << "SuspendThreadByThreadId waiting to allow thread chance to suspend";
1063 ThreadSuspendSleep(sleep_us);
1064 sleep_us = std::min(sleep_us * 2, kThreadSuspendMaxSleepUs);
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001065 }
1066}
1067
Mathieu Chartier61b3cd42016-04-18 11:43:29 -07001068Thread* ThreadList::FindThreadByThreadId(uint32_t thread_id) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001069 for (const auto& thread : list_) {
Mathieu Chartier61b3cd42016-04-18 11:43:29 -07001070 if (thread->GetThreadId() == thread_id) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001071 return thread;
1072 }
1073 }
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001074 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001075}
1076
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001077void ThreadList::SuspendAllForDebugger() {
1078 Thread* self = Thread::Current();
1079 Thread* debug_thread = Dbg::GetDebugThread();
1080
1081 VLOG(threads) << *self << " SuspendAllForDebugger starting...";
1082
Yu Lieac44242015-06-29 10:50:03 +08001083 SuspendAllInternal(self, self, debug_thread, true);
Ian Rogers66aee5c2012-08-15 17:17:47 -07001084 // Block on the mutator lock until all Runnable threads release their share of access then
1085 // immediately unlock again.
1086#if HAVE_TIMED_RWLOCK
1087 // Timeout if we wait more than 30 seconds.
Ian Rogersc604d732012-10-14 16:09:54 -07001088 if (!Locks::mutator_lock_->ExclusiveLockWithTimeout(self, 30 * 1000, 0)) {
Sebastien Hertzbae182c2013-12-17 10:42:03 +01001089 UnsafeLogFatalForThreadSuspendAllTimeout();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001090 } else {
Ian Rogers81d425b2012-09-27 16:03:43 -07001091 Locks::mutator_lock_->ExclusiveUnlock(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001092 }
Ian Rogers66aee5c2012-08-15 17:17:47 -07001093#else
Ian Rogers81d425b2012-09-27 16:03:43 -07001094 Locks::mutator_lock_->ExclusiveLock(self);
1095 Locks::mutator_lock_->ExclusiveUnlock(self);
Ian Rogers66aee5c2012-08-15 17:17:47 -07001096#endif
Mathieu Chartier9450c6c2015-11-07 11:55:23 -08001097 // Disabled for the following race condition:
1098 // Thread 1 calls SuspendAllForDebugger, gets preempted after pulsing the mutator lock.
1099 // Thread 2 calls SuspendAll and SetStateUnsafe (perhaps from Dbg::Disconnected).
1100 // Thread 1 fails assertion that all threads are suspended due to thread 2 being in a runnable
1101 // state (from SetStateUnsafe).
1102 // AssertThreadsAreSuspended(self, self, debug_thread);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001103
Sebastien Hertzed2be172014-08-19 15:33:43 +02001104 VLOG(threads) << *self << " SuspendAllForDebugger complete";
Elliott Hughes01158d72011-09-19 19:47:10 -07001105}
1106
Elliott Hughes475fc232011-10-25 15:00:35 -07001107void ThreadList::SuspendSelfForDebugger() {
Sebastien Hertz1558b572015-02-25 15:05:59 +01001108 Thread* const self = Thread::Current();
1109 self->SetReadyForDebugInvoke(true);
Elliott Hughes01158d72011-09-19 19:47:10 -07001110
Elliott Hughes475fc232011-10-25 15:00:35 -07001111 // The debugger thread must not suspend itself due to debugger activity!
1112 Thread* debug_thread = Dbg::GetDebugThread();
Elliott Hughes475fc232011-10-25 15:00:35 -07001113 CHECK(self != debug_thread);
jeffhaoa77f0f62012-12-05 17:19:31 -08001114 CHECK_NE(self->GetState(), kRunnable);
1115 Locks::mutator_lock_->AssertNotHeld(self);
Elliott Hughes475fc232011-10-25 15:00:35 -07001116
Sebastien Hertzcbc50642015-06-01 17:33:12 +02001117 // The debugger may have detached while we were executing an invoke request. In that case, we
1118 // must not suspend ourself.
1119 DebugInvokeReq* pReq = self->GetInvokeReq();
1120 const bool skip_thread_suspension = (pReq != nullptr && !Dbg::IsDebuggerActive());
1121 if (!skip_thread_suspension) {
jeffhaoa77f0f62012-12-05 17:19:31 -08001122 // Collisions with other suspends aren't really interesting. We want
1123 // to ensure that we're the only one fiddling with the suspend count
1124 // though.
1125 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Yu Lieac44242015-06-29 10:50:03 +08001126 self->ModifySuspendCount(self, +1, nullptr, true);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001127 CHECK_GT(self->GetSuspendCount(), 0);
Sebastien Hertzcbc50642015-06-01 17:33:12 +02001128
1129 VLOG(threads) << *self << " self-suspending (debugger)";
1130 } else {
1131 // We must no longer be subject to debugger suspension.
1132 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
1133 CHECK_EQ(self->GetDebugSuspendCount(), 0) << "Debugger detached without resuming us";
1134
1135 VLOG(threads) << *self << " not self-suspending because debugger detached during invoke";
jeffhaoa77f0f62012-12-05 17:19:31 -08001136 }
Elliott Hughes475fc232011-10-25 15:00:35 -07001137
Sebastien Hertzcbc50642015-06-01 17:33:12 +02001138 // If the debugger requested an invoke, we need to send the reply and clear the request.
Sebastien Hertz1558b572015-02-25 15:05:59 +01001139 if (pReq != nullptr) {
Sebastien Hertzcbc50642015-06-01 17:33:12 +02001140 Dbg::FinishInvokeMethod(pReq);
Sebastien Hertz1558b572015-02-25 15:05:59 +01001141 self->ClearDebugInvokeReq();
Sebastien Hertzcbc50642015-06-01 17:33:12 +02001142 pReq = nullptr; // object has been deleted, clear it for safety.
Sebastien Hertz21e729c2014-02-18 14:16:00 +01001143 }
1144
Elliott Hughes475fc232011-10-25 15:00:35 -07001145 // Tell JDWP that we've completed suspension. The JDWP thread can't
1146 // tell us to resume before we're fully asleep because we hold the
1147 // suspend count lock.
1148 Dbg::ClearWaitForEventThread();
1149
jeffhaoa77f0f62012-12-05 17:19:31 -08001150 {
1151 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001152 while (self->GetSuspendCount() != 0) {
jeffhaoa77f0f62012-12-05 17:19:31 -08001153 Thread::resume_cond_->Wait(self);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001154 if (self->GetSuspendCount() != 0) {
jeffhaoa77f0f62012-12-05 17:19:31 -08001155 // The condition was signaled but we're still suspended. This
Sebastien Hertzf272af42014-09-18 10:20:42 +02001156 // can happen when we suspend then resume all threads to
1157 // update instrumentation or compute monitor info. This can
1158 // also happen if the debugger lets go while a SIGQUIT thread
jeffhaoa77f0f62012-12-05 17:19:31 -08001159 // dump event is pending (assuming SignalCatcher was resumed for
1160 // just long enough to try to grab the thread-suspend lock).
Sebastien Hertzf272af42014-09-18 10:20:42 +02001161 VLOG(jdwp) << *self << " still suspended after undo "
1162 << "(suspend count=" << self->GetSuspendCount() << ", "
1163 << "debug suspend count=" << self->GetDebugSuspendCount() << ")";
jeffhaoa77f0f62012-12-05 17:19:31 -08001164 }
Elliott Hughes475fc232011-10-25 15:00:35 -07001165 }
Ian Rogersdd7624d2014-03-14 17:43:00 -07001166 CHECK_EQ(self->GetSuspendCount(), 0);
Elliott Hughes475fc232011-10-25 15:00:35 -07001167 }
jeffhaoa77f0f62012-12-05 17:19:31 -08001168
Sebastien Hertz1558b572015-02-25 15:05:59 +01001169 self->SetReadyForDebugInvoke(false);
Elliott Hughes1f729aa2012-03-02 13:55:41 -08001170 VLOG(threads) << *self << " self-reviving (debugger)";
Elliott Hughes475fc232011-10-25 15:00:35 -07001171}
1172
Sebastien Hertz253fa552014-10-14 17:27:15 +02001173void ThreadList::ResumeAllForDebugger() {
1174 Thread* self = Thread::Current();
1175 Thread* debug_thread = Dbg::GetDebugThread();
Sebastien Hertz253fa552014-10-14 17:27:15 +02001176
1177 VLOG(threads) << *self << " ResumeAllForDebugger starting...";
1178
1179 // Threads can't resume if we exclusively hold the mutator lock.
1180 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
1181
1182 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001183 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Sebastien Hertz253fa552014-10-14 17:27:15 +02001184 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001185 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Sebastien Hertz253fa552014-10-14 17:27:15 +02001186 // Update global suspend all state for attaching threads.
1187 DCHECK_GE(suspend_all_count_, debug_suspend_all_count_);
Sebastien Hertzf9d233d2015-01-09 14:51:41 +01001188 if (debug_suspend_all_count_ > 0) {
Sebastien Hertz253fa552014-10-14 17:27:15 +02001189 --suspend_all_count_;
1190 --debug_suspend_all_count_;
Sebastien Hertz253fa552014-10-14 17:27:15 +02001191 } else {
1192 // We've been asked to resume all threads without being asked to
Sebastien Hertzf9d233d2015-01-09 14:51:41 +01001193 // suspend them all before. That may happen if a debugger tries
1194 // to resume some suspended threads (with suspend count == 1)
1195 // at once with a VirtualMachine.Resume command. Let's print a
1196 // warning.
Sebastien Hertz253fa552014-10-14 17:27:15 +02001197 LOG(WARNING) << "Debugger attempted to resume all threads without "
1198 << "having suspended them all before.";
1199 }
Sebastien Hertzf9d233d2015-01-09 14:51:41 +01001200 // Decrement everybody's suspend count (except our own).
1201 for (const auto& thread : list_) {
1202 if (thread == self || thread == debug_thread) {
1203 continue;
1204 }
1205 if (thread->GetDebugSuspendCount() == 0) {
1206 // This thread may have been individually resumed with ThreadReference.Resume.
1207 continue;
1208 }
1209 VLOG(threads) << "requesting thread resume: " << *thread;
Yu Lieac44242015-06-29 10:50:03 +08001210 thread->ModifySuspendCount(self, -1, nullptr, true);
Sebastien Hertzf9d233d2015-01-09 14:51:41 +01001211 }
Sebastien Hertz253fa552014-10-14 17:27:15 +02001212 }
1213 }
1214
Sebastien Hertzf9d233d2015-01-09 14:51:41 +01001215 {
Sebastien Hertz253fa552014-10-14 17:27:15 +02001216 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
1217 Thread::resume_cond_->Broadcast(self);
1218 }
1219
1220 VLOG(threads) << *self << " ResumeAllForDebugger complete";
1221}
1222
Elliott Hughes234ab152011-10-26 14:02:26 -07001223void ThreadList::UndoDebuggerSuspensions() {
1224 Thread* self = Thread::Current();
1225
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001226 VLOG(threads) << *self << " UndoDebuggerSuspensions starting";
Elliott Hughes234ab152011-10-26 14:02:26 -07001227
1228 {
Ian Rogers81d425b2012-09-27 16:03:43 -07001229 MutexLock mu(self, *Locks::thread_list_lock_);
1230 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001231 // Update global suspend all state for attaching threads.
1232 suspend_all_count_ -= debug_suspend_all_count_;
1233 debug_suspend_all_count_ = 0;
1234 // Update running threads.
Mathieu Chartier02e25112013-08-14 16:14:24 -07001235 for (const auto& thread : list_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001236 if (thread == self || thread->GetDebugSuspendCount() == 0) {
Elliott Hughes234ab152011-10-26 14:02:26 -07001237 continue;
1238 }
Yu Lieac44242015-06-29 10:50:03 +08001239 thread->ModifySuspendCount(self, -thread->GetDebugSuspendCount(), nullptr, true);
Elliott Hughes234ab152011-10-26 14:02:26 -07001240 }
1241 }
1242
1243 {
Ian Rogers81d425b2012-09-27 16:03:43 -07001244 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersc604d732012-10-14 16:09:54 -07001245 Thread::resume_cond_->Broadcast(self);
Elliott Hughes234ab152011-10-26 14:02:26 -07001246 }
1247
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001248 VLOG(threads) << "UndoDebuggerSuspensions(" << *self << ") complete";
Elliott Hughes234ab152011-10-26 14:02:26 -07001249}
1250
Elliott Hughese52e49b2012-04-02 16:05:44 -07001251void ThreadList::WaitForOtherNonDaemonThreadsToExit() {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08001252 ScopedTrace trace(__PRETTY_FUNCTION__);
Ian Rogers81d425b2012-09-27 16:03:43 -07001253 Thread* self = Thread::Current();
1254 Locks::mutator_lock_->AssertNotHeld(self);
Mathieu Chartier91e56692015-03-03 13:51:04 -08001255 while (true) {
Ian Rogers120f1c72012-09-28 17:17:10 -07001256 {
1257 // No more threads can be born after we start to shutdown.
1258 MutexLock mu(self, *Locks::runtime_shutdown_lock_);
Mathieu Chartier590fee92013-09-13 13:46:47 -07001259 CHECK(Runtime::Current()->IsShuttingDownLocked());
Ian Rogers120f1c72012-09-28 17:17:10 -07001260 CHECK_EQ(Runtime::Current()->NumberOfThreadsBeingBorn(), 0U);
1261 }
Ian Rogers120f1c72012-09-28 17:17:10 -07001262 MutexLock mu(self, *Locks::thread_list_lock_);
Mathieu Chartier91e56692015-03-03 13:51:04 -08001263 // Also wait for any threads that are unregistering to finish. This is required so that no
1264 // threads access the thread list after it is deleted. TODO: This may not work for user daemon
1265 // threads since they could unregister at the wrong time.
1266 bool done = unregistering_count_ == 0;
1267 if (done) {
1268 for (const auto& thread : list_) {
1269 if (thread != self && !thread->IsDaemon()) {
1270 done = false;
1271 break;
1272 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001273 }
1274 }
Mathieu Chartier91e56692015-03-03 13:51:04 -08001275 if (done) {
1276 break;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001277 }
Mathieu Chartier91e56692015-03-03 13:51:04 -08001278 // Wait for another thread to exit before re-checking.
1279 Locks::thread_exit_cond_->Wait(self);
1280 }
Elliott Hughes038a8062011-09-18 14:12:41 -07001281}
1282
Mathieu Chartier4d87df62016-01-07 15:14:19 -08001283void ThreadList::SuspendAllDaemonThreadsForShutdown() {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08001284 ScopedTrace trace(__PRETTY_FUNCTION__);
Ian Rogers81d425b2012-09-27 16:03:43 -07001285 Thread* self = Thread::Current();
Mathieu Chartier62597d12016-01-11 10:19:06 -08001286 size_t daemons_left = 0;
Nicolas Geoffrayaa45daa2016-06-20 15:58:32 +01001287 {
1288 // Tell all the daemons it's time to suspend.
1289 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogers81d425b2012-09-27 16:03:43 -07001290 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001291 for (const auto& thread : list_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001292 // This is only run after all non-daemon threads have exited, so the remainder should all be
1293 // daemons.
Ian Rogers7e762862012-10-22 15:45:08 -07001294 CHECK(thread->IsDaemon()) << *thread;
Ian Rogers81d425b2012-09-27 16:03:43 -07001295 if (thread != self) {
Yu Lieac44242015-06-29 10:50:03 +08001296 thread->ModifySuspendCount(self, +1, nullptr, false);
Mathieu Chartier62597d12016-01-11 10:19:06 -08001297 ++daemons_left;
Elliott Hughese52e49b2012-04-02 16:05:44 -07001298 }
Mathieu Chartier4d87df62016-01-07 15:14:19 -08001299 // We are shutting down the runtime, set the JNI functions of all the JNIEnvs to be
1300 // the sleep forever one.
1301 thread->GetJniEnv()->SetFunctionsToRuntimeShutdownFunctions();
Elliott Hughes038a8062011-09-18 14:12:41 -07001302 }
1303 }
Mathieu Chartier62597d12016-01-11 10:19:06 -08001304 // If we have any daemons left, wait 200ms to ensure they are not stuck in a place where they
1305 // are about to access runtime state and are not in a runnable state. Examples: Monitor code
1306 // or waking up from a condition variable. TODO: Try and see if there is a better way to wait
1307 // for daemon threads to be in a blocked state.
1308 if (daemons_left > 0) {
1309 static constexpr size_t kDaemonSleepTime = 200 * 1000;
1310 usleep(kDaemonSleepTime);
1311 }
Elliott Hughes038a8062011-09-18 14:12:41 -07001312 // Give the threads a chance to suspend, complaining if they're slow.
1313 bool have_complained = false;
Mathieu Chartierba098ba2016-01-07 09:31:33 -08001314 static constexpr size_t kTimeoutMicroseconds = 2000 * 1000;
1315 static constexpr size_t kSleepMicroseconds = 1000;
1316 for (size_t i = 0; i < kTimeoutMicroseconds / kSleepMicroseconds; ++i) {
Elliott Hughes038a8062011-09-18 14:12:41 -07001317 bool all_suspended = true;
Nicolas Geoffrayaa45daa2016-06-20 15:58:32 +01001318 {
1319 MutexLock mu(self, *Locks::thread_list_lock_);
1320 for (const auto& thread : list_) {
1321 if (thread != self && thread->GetState() == kRunnable) {
1322 if (!have_complained) {
1323 LOG(WARNING) << "daemon thread not yet suspended: " << *thread;
1324 have_complained = true;
1325 }
1326 all_suspended = false;
Elliott Hughes038a8062011-09-18 14:12:41 -07001327 }
Elliott Hughes038a8062011-09-18 14:12:41 -07001328 }
1329 }
1330 if (all_suspended) {
1331 return;
1332 }
Mathieu Chartierba098ba2016-01-07 09:31:33 -08001333 usleep(kSleepMicroseconds);
Elliott Hughes038a8062011-09-18 14:12:41 -07001334 }
Mathieu Chartierba098ba2016-01-07 09:31:33 -08001335 LOG(WARNING) << "timed out suspending all daemon threads";
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001336}
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001337
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001338void ThreadList::Register(Thread* self) {
1339 DCHECK_EQ(self, Thread::Current());
1340
1341 if (VLOG_IS_ON(threads)) {
1342 std::ostringstream oss;
1343 self->ShortDump(oss); // We don't hold the mutator_lock_ yet and so cannot call Dump.
Ian Rogers5a9ba012014-05-19 13:28:52 -07001344 LOG(INFO) << "ThreadList::Register() " << *self << "\n" << oss.str();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001345 }
1346
1347 // Atomically add self to the thread list and make its thread_suspend_count_ reflect ongoing
1348 // SuspendAll requests.
Ian Rogers81d425b2012-09-27 16:03:43 -07001349 MutexLock mu(self, *Locks::thread_list_lock_);
1350 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001351 CHECK_GE(suspend_all_count_, debug_suspend_all_count_);
Ian Rogers2966e132014-04-02 08:34:36 -07001352 // Modify suspend count in increments of 1 to maintain invariants in ModifySuspendCount. While
1353 // this isn't particularly efficient the suspend counts are most commonly 0 or 1.
1354 for (int delta = debug_suspend_all_count_; delta > 0; delta--) {
Yu Lieac44242015-06-29 10:50:03 +08001355 self->ModifySuspendCount(self, +1, nullptr, true);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001356 }
Ian Rogers2966e132014-04-02 08:34:36 -07001357 for (int delta = suspend_all_count_ - debug_suspend_all_count_; delta > 0; delta--) {
Yu Lieac44242015-06-29 10:50:03 +08001358 self->ModifySuspendCount(self, +1, nullptr, false);
Ian Rogers01ae5802012-09-28 16:14:01 -07001359 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001360 CHECK(!Contains(self));
1361 list_.push_back(self);
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001362 if (kUseReadBarrier) {
Hiroshi Yamauchi00370822015-08-18 14:47:25 -07001363 // Initialize according to the state of the CC collector.
1364 bool is_gc_marking =
1365 Runtime::Current()->GetHeap()->ConcurrentCopyingCollector()->IsMarking();
Mathieu Chartierfe814e82016-11-09 14:32:49 -08001366 self->SetIsGcMarkingAndUpdateEntrypoints(is_gc_marking);
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001367 bool weak_ref_access_enabled =
1368 Runtime::Current()->GetHeap()->ConcurrentCopyingCollector()->IsWeakRefAccessEnabled();
1369 self->SetWeakRefAccessEnabled(weak_ref_access_enabled);
1370 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001371}
1372
1373void ThreadList::Unregister(Thread* self) {
1374 DCHECK_EQ(self, Thread::Current());
Ian Rogers68d8b422014-07-17 11:09:10 -07001375 CHECK_NE(self->GetState(), kRunnable);
1376 Locks::mutator_lock_->AssertNotHeld(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001377
1378 VLOG(threads) << "ThreadList::Unregister() " << *self;
1379
Mathieu Chartier91e56692015-03-03 13:51:04 -08001380 {
1381 MutexLock mu(self, *Locks::thread_list_lock_);
1382 ++unregistering_count_;
1383 }
1384
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001385 // Any time-consuming destruction, plus anything that can call back into managed code or
Mathieu Chartier91e56692015-03-03 13:51:04 -08001386 // suspend and so on, must happen at this point, and not in ~Thread. The self->Destroy is what
1387 // causes the threads to join. It is important to do this after incrementing unregistering_count_
1388 // since we want the runtime to wait for the daemon threads to exit before deleting the thread
1389 // list.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001390 self->Destroy();
1391
Jeff Haoe094b872014-10-14 13:12:01 -07001392 // If tracing, remember thread id and name before thread exits.
1393 Trace::StoreExitingThreadInfo(self);
1394
Ian Rogersdd7624d2014-03-14 17:43:00 -07001395 uint32_t thin_lock_id = self->GetThreadId();
Mathieu Chartier91e56692015-03-03 13:51:04 -08001396 while (true) {
Ian Rogerscfaa4552012-11-26 21:00:08 -08001397 // Remove and delete the Thread* while holding the thread_list_lock_ and
1398 // thread_suspend_count_lock_ so that the unregistering thread cannot be suspended.
Ian Rogers0878d652013-04-18 17:38:35 -07001399 // Note: deliberately not using MutexLock that could hold a stale self pointer.
Mathieu Chartier91e56692015-03-03 13:51:04 -08001400 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogersa2af5c72014-09-15 15:17:07 -07001401 if (!Contains(self)) {
Mathieu Chartier9db831a2015-02-24 17:20:30 -08001402 std::string thread_name;
1403 self->GetThreadName(thread_name);
Ian Rogersa2af5c72014-09-15 15:17:07 -07001404 std::ostringstream os;
Christopher Ferris6cff48f2014-01-26 21:36:13 -08001405 DumpNativeStack(os, GetTid(), nullptr, " native: ", nullptr);
Mathieu Chartier9db831a2015-02-24 17:20:30 -08001406 LOG(ERROR) << "Request to unregister unattached thread " << thread_name << "\n" << os.str();
Mathieu Chartier91e56692015-03-03 13:51:04 -08001407 break;
Ian Rogersa2af5c72014-09-15 15:17:07 -07001408 } else {
Mathieu Chartier91e56692015-03-03 13:51:04 -08001409 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogersa2af5c72014-09-15 15:17:07 -07001410 if (!self->IsSuspended()) {
1411 list_.remove(self);
Mathieu Chartier91e56692015-03-03 13:51:04 -08001412 break;
Ian Rogersa2af5c72014-09-15 15:17:07 -07001413 }
Ian Rogers68d8b422014-07-17 11:09:10 -07001414 }
Mathieu Chartier91e56692015-03-03 13:51:04 -08001415 // We failed to remove the thread due to a suspend request, loop and try again.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001416 }
Mathieu Chartier91e56692015-03-03 13:51:04 -08001417 delete self;
1418
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -08001419 // Release the thread ID after the thread is finished and deleted to avoid cases where we can
1420 // temporarily have multiple threads with the same thread id. When this occurs, it causes
1421 // problems in FindThreadByThreadId / SuspendThreadByThreadId.
1422 ReleaseThreadId(nullptr, thin_lock_id);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001423
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001424 // Clear the TLS data, so that the underlying native thread is recognizably detached.
1425 // (It may wish to reattach later.)
Bilyan Borisovbb661c02016-04-04 16:27:32 +01001426#ifdef ART_TARGET_ANDROID
Andreas Gampe4382f1e2015-08-05 01:08:53 +00001427 __get_tls()[TLS_SLOT_ART_THREAD_SELF] = nullptr;
1428#else
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001429 CHECK_PTHREAD_CALL(pthread_setspecific, (Thread::pthread_key_self_, nullptr), "detach self");
Andreas Gampe4382f1e2015-08-05 01:08:53 +00001430#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001431
1432 // Signal that a thread just detached.
Mathieu Chartier91e56692015-03-03 13:51:04 -08001433 MutexLock mu(nullptr, *Locks::thread_list_lock_);
1434 --unregistering_count_;
1435 Locks::thread_exit_cond_->Broadcast(nullptr);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001436}
1437
1438void ThreadList::ForEach(void (*callback)(Thread*, void*), void* context) {
Mathieu Chartier02e25112013-08-14 16:14:24 -07001439 for (const auto& thread : list_) {
1440 callback(thread, context);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001441 }
1442}
1443
Mathieu Chartierf8a86b92016-06-14 17:08:47 -07001444void ThreadList::VisitRootsForSuspendedThreads(RootVisitor* visitor) {
1445 Thread* const self = Thread::Current();
1446 std::vector<Thread*> threads_to_visit;
1447
1448 // Tell threads to suspend and copy them into list.
1449 {
1450 MutexLock mu(self, *Locks::thread_list_lock_);
1451 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
1452 for (Thread* thread : list_) {
1453 thread->ModifySuspendCount(self, +1, nullptr, false);
1454 if (thread == self || thread->IsSuspended()) {
1455 threads_to_visit.push_back(thread);
1456 } else {
1457 thread->ModifySuspendCount(self, -1, nullptr, false);
1458 }
1459 }
1460 }
1461
1462 // Visit roots without holding thread_list_lock_ and thread_suspend_count_lock_ to prevent lock
1463 // order violations.
1464 for (Thread* thread : threads_to_visit) {
1465 thread->VisitRoots(visitor);
1466 }
1467
1468 // Restore suspend counts.
1469 {
1470 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
1471 for (Thread* thread : threads_to_visit) {
1472 thread->ModifySuspendCount(self, -1, nullptr, false);
1473 }
1474 }
1475}
1476
Andreas Gampe585da952016-12-02 14:52:29 -08001477void ThreadList::VisitRoots(RootVisitor* visitor, VisitRootFlags flags) const {
Ian Rogers81d425b2012-09-27 16:03:43 -07001478 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001479 for (const auto& thread : list_) {
Andreas Gampe585da952016-12-02 14:52:29 -08001480 thread->VisitRoots(visitor, flags);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001481 }
Elliott Hughes038a8062011-09-18 14:12:41 -07001482}
1483
Ian Rogerscfaa4552012-11-26 21:00:08 -08001484uint32_t ThreadList::AllocThreadId(Thread* self) {
Chao-ying Fu9e369312014-05-21 11:20:52 -07001485 MutexLock mu(self, *Locks::allocated_thread_ids_lock_);
Elliott Hughes8daa0922011-09-11 13:46:25 -07001486 for (size_t i = 0; i < allocated_ids_.size(); ++i) {
1487 if (!allocated_ids_[i]) {
1488 allocated_ids_.set(i);
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001489 return i + 1; // Zero is reserved to mean "invalid".
Elliott Hughes8daa0922011-09-11 13:46:25 -07001490 }
1491 }
1492 LOG(FATAL) << "Out of internal thread ids";
1493 return 0;
1494}
1495
Ian Rogerscfaa4552012-11-26 21:00:08 -08001496void ThreadList::ReleaseThreadId(Thread* self, uint32_t id) {
Chao-ying Fu9e369312014-05-21 11:20:52 -07001497 MutexLock mu(self, *Locks::allocated_thread_ids_lock_);
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001498 --id; // Zero is reserved to mean "invalid".
Elliott Hughes8daa0922011-09-11 13:46:25 -07001499 DCHECK(allocated_ids_[id]) << id;
1500 allocated_ids_.reset(id);
1501}
1502
Mathieu Chartier4f55e222015-09-04 13:26:21 -07001503ScopedSuspendAll::ScopedSuspendAll(const char* cause, bool long_suspend) {
1504 Runtime::Current()->GetThreadList()->SuspendAll(cause, long_suspend);
1505}
1506
1507ScopedSuspendAll::~ScopedSuspendAll() {
1508 Runtime::Current()->GetThreadList()->ResumeAll();
1509}
1510
Elliott Hughes8daa0922011-09-11 13:46:25 -07001511} // namespace art