blob: acc5f17514af58d0b85db7803864ef402092c9dc [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
Elliott Hughesabbe07d2012-06-05 17:42:23 -070019#include <dirent.h>
20#include <sys/types.h>
Elliott Hughes038a8062011-09-18 14:12:41 -070021#include <unistd.h>
22
Ian Rogersc7dd2952014-10-21 23:31:19 -070023#include <sstream>
Christopher Ferrisb1b0ed22017-10-24 15:38:14 -070024#include <vector>
Ian Rogersc7dd2952014-10-21 23:31:19 -070025
Andreas Gampe46ee31b2016-12-14 10:11:49 -080026#include "android-base/stringprintf.h"
Andreas Gampe8cf9cb32017-07-19 09:28:38 -070027#include "backtrace/BacktraceMap.h"
Andreas Gampe373a9b52017-10-18 09:01:57 -070028#include "nativehelper/scoped_local_ref.h"
29#include "nativehelper/scoped_utf_chars.h"
Andreas Gampe46ee31b2016-12-14 10:11:49 -080030
Andreas Gampe39b378c2017-12-07 15:44:13 -080031#include "base/aborting.h"
Mathieu Chartier70a596d2014-12-17 14:56:47 -080032#include "base/histogram-inl.h"
Hiroshi Yamauchi967a0ad2013-09-10 16:24:21 -070033#include "base/mutex-inl.h"
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -080034#include "base/systrace.h"
Vladimir Marko80afd022015-05-19 18:08:00 +010035#include "base/time_utils.h"
Sameer Abu Asala8439542013-02-14 16:06:42 -080036#include "base/timing_logger.h"
Elliott Hughes475fc232011-10-25 15:00:35 -070037#include "debugger.h"
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -070038#include "gc/collector/concurrent_copying.h"
Andreas Gampe6e644452017-05-09 16:30:27 -070039#include "gc/gc_pause_listener.h"
Andreas Gamped4901292017-05-30 18:41:34 -070040#include "gc/heap.h"
Hiroshi Yamauchi30493242016-11-03 13:06:52 -070041#include "gc/reference_processor.h"
Andreas Gampe513061a2017-06-01 09:17:34 -070042#include "gc_root.h"
Vladimir Markoa3ad0cd2018-05-04 10:06:38 +010043#include "jni/jni_internal.h"
Ian Rogersd9c4fc92013-10-01 19:45:43 -070044#include "lock_word.h"
45#include "monitor.h"
Andreas Gampe5dd44d02016-08-02 17:20:03 -070046#include "native_stack_dump.h"
Mathieu Chartier0795f232016-09-27 18:43:30 -070047#include "scoped_thread_state_change-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080048#include "thread.h"
Jeff Haoe094b872014-10-14 13:12:01 -070049#include "trace.h"
Ian Rogersd9c4fc92013-10-01 19:45:43 -070050#include "well_known_classes.h"
Elliott Hughes475fc232011-10-25 15:00:35 -070051
Yu Lieac44242015-06-29 10:50:03 +080052#if ART_USE_FUTEXES
53#include "linux/futex.h"
54#include "sys/syscall.h"
55#ifndef SYS_futex
56#define SYS_futex __NR_futex
57#endif
58#endif // ART_USE_FUTEXES
59
Elliott Hughes8daa0922011-09-11 13:46:25 -070060namespace art {
61
Andreas Gampe46ee31b2016-12-14 10:11:49 -080062using android::base::StringPrintf;
63
Mathieu Chartier251755c2014-07-15 18:10:25 -070064static constexpr uint64_t kLongThreadSuspendThreshold = MsToNs(5);
Mathieu Chartier99143862015-02-03 14:26:46 -080065// Use 0 since we want to yield to prevent blocking for an unpredictable amount of time.
66static constexpr useconds_t kThreadSuspendInitialSleepUs = 0;
67static constexpr useconds_t kThreadSuspendMaxYieldUs = 3000;
68static constexpr useconds_t kThreadSuspendMaxSleepUs = 5000;
Mathieu Chartier251755c2014-07-15 18:10:25 -070069
Andreas Gampe8d1594d2016-03-01 14:38:37 -080070// Whether we should try to dump the native stack of unattached threads. See commit ed8b723 for
71// some history.
Christopher Ferris4531aae2017-11-02 14:01:14 -070072static constexpr bool kDumpUnattachedThreadNativeStackForSigQuit = true;
Andreas Gampe8d1594d2016-03-01 14:38:37 -080073
Mathieu Chartier3fceaf52017-01-22 13:33:40 -080074ThreadList::ThreadList(uint64_t thread_suspend_timeout_ns)
Mathieu Chartierb56200b2015-10-29 10:41:51 -070075 : suspend_all_count_(0),
Mathieu Chartierb56200b2015-10-29 10:41:51 -070076 unregistering_count_(0),
77 suspend_all_historam_("suspend all histogram", 16, 64),
Hiroshi Yamauchi30493242016-11-03 13:06:52 -070078 long_suspend_(false),
Andreas Gampec4bed162017-05-01 13:46:24 -070079 shut_down_(false),
Mathieu Chartier3fceaf52017-01-22 13:33:40 -080080 thread_suspend_timeout_ns_(thread_suspend_timeout_ns),
Hiroshi Yamauchi30493242016-11-03 13:06:52 -070081 empty_checkpoint_barrier_(new Barrier(0)) {
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -080082 CHECK(Monitor::IsValidLockWord(LockWord::FromThinLockId(kMaxThreadId, 1, 0U)));
Elliott Hughes8daa0922011-09-11 13:46:25 -070083}
84
85ThreadList::~ThreadList() {
Andreas Gampec4bed162017-05-01 13:46:24 -070086 CHECK(shut_down_);
87}
88
89void ThreadList::ShutDown() {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -080090 ScopedTrace trace(__PRETTY_FUNCTION__);
Elliott Hughese52e49b2012-04-02 16:05:44 -070091 // Detach the current thread if necessary. If we failed to start, there might not be any threads.
Elliott Hughes6a144332012-04-03 13:07:11 -070092 // We need to detach the current thread here in case there's another thread waiting to join with
93 // us.
Mathieu Chartierfec72f42014-10-09 12:57:58 -070094 bool contains = false;
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -080095 Thread* self = Thread::Current();
Mathieu Chartierfec72f42014-10-09 12:57:58 -070096 {
Mathieu Chartierfec72f42014-10-09 12:57:58 -070097 MutexLock mu(self, *Locks::thread_list_lock_);
98 contains = Contains(self);
99 }
100 if (contains) {
Elliott Hughes8daa0922011-09-11 13:46:25 -0700101 Runtime::Current()->DetachCurrentThread();
102 }
Elliott Hughes6a144332012-04-03 13:07:11 -0700103 WaitForOtherNonDaemonThreadsToExit();
Mathieu Chartier51168372015-08-12 16:40:32 -0700104 // Disable GC and wait for GC to complete in case there are still daemon threads doing
105 // allocations.
106 gc::Heap* const heap = Runtime::Current()->GetHeap();
107 heap->DisableGCForShutdown();
108 // In case a GC is in progress, wait for it to finish.
109 heap->WaitForGcToComplete(gc::kGcCauseBackground, Thread::Current());
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700110 // TODO: there's an unaddressed race here where a thread may attach during shutdown, see
111 // Thread::Init.
Mathieu Chartier4d87df62016-01-07 15:14:19 -0800112 SuspendAllDaemonThreadsForShutdown();
Andreas Gampec4bed162017-05-01 13:46:24 -0700113
114 shut_down_ = true;
Elliott Hughes8daa0922011-09-11 13:46:25 -0700115}
116
117bool ThreadList::Contains(Thread* thread) {
118 return find(list_.begin(), list_.end(), thread) != list_.end();
119}
120
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700121bool ThreadList::Contains(pid_t tid) {
Mathieu Chartier02e25112013-08-14 16:14:24 -0700122 for (const auto& thread : list_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700123 if (thread->GetTid() == tid) {
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700124 return true;
125 }
126 }
127 return false;
128}
129
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -0700130pid_t ThreadList::GetLockOwner() {
Ian Rogersb726dcb2012-09-05 08:57:23 -0700131 return Locks::thread_list_lock_->GetExclusiveOwnerTid();
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700132}
133
Mathieu Chartier590fee92013-09-13 13:46:47 -0700134void ThreadList::DumpNativeStacks(std::ostream& os) {
135 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
Christopher Ferris6cff48f2014-01-26 21:36:13 -0800136 std::unique_ptr<BacktraceMap> map(BacktraceMap::Create(getpid()));
Mathieu Chartier590fee92013-09-13 13:46:47 -0700137 for (const auto& thread : list_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700138 os << "DUMPING THREAD " << thread->GetTid() << "\n";
Christopher Ferris6cff48f2014-01-26 21:36:13 -0800139 DumpNativeStack(os, thread->GetTid(), map.get(), "\t");
Mathieu Chartier590fee92013-09-13 13:46:47 -0700140 os << "\n";
141 }
142}
143
Elliott Hughesc967f782012-04-16 10:23:15 -0700144void ThreadList::DumpForSigQuit(std::ostream& os) {
Mathieu Chartier70a596d2014-12-17 14:56:47 -0800145 {
146 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartier23f6e692014-12-18 18:24:39 -0800147 // Only print if we have samples.
148 if (suspend_all_historam_.SampleSize() > 0) {
149 Histogram<uint64_t>::CumulativeData data;
150 suspend_all_historam_.CreateHistogram(&data);
151 suspend_all_historam_.PrintConfidenceIntervals(os, 0.99, data); // Dump time to suspend.
152 }
Mathieu Chartier70a596d2014-12-17 14:56:47 -0800153 }
Nicolas Geoffray6ee49712018-03-30 14:39:05 +0000154 bool dump_native_stack = Runtime::Current()->GetDumpNativeStackOnSigQuit();
155 Dump(os, dump_native_stack);
156 DumpUnattachedThreads(os, dump_native_stack && kDumpUnattachedThreadNativeStackForSigQuit);
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700157}
158
Nicolas Geoffrayd3c59652016-03-17 09:35:04 +0000159static void DumpUnattachedThread(std::ostream& os, pid_t tid, bool dump_native_stack)
160 NO_THREAD_SAFETY_ANALYSIS {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700161 // TODO: No thread safety analysis as DumpState with a null thread won't access fields, should
Ian Rogerscfaa4552012-11-26 21:00:08 -0800162 // refactor DumpState to avoid skipping analysis.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700163 Thread::DumpState(os, nullptr, tid);
Mathieu Chartier3f386d52016-10-05 14:12:45 -0700164 if (dump_native_stack) {
Christopher Ferris6cff48f2014-01-26 21:36:13 -0800165 DumpNativeStack(os, tid, nullptr, " native: ");
Brian Carlstromed8b7232012-06-27 17:54:47 -0700166 }
Andreas Gampe5544e722017-06-05 17:01:27 -0700167 os << std::endl;
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700168}
169
Nicolas Geoffrayd3c59652016-03-17 09:35:04 +0000170void ThreadList::DumpUnattachedThreads(std::ostream& os, bool dump_native_stack) {
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700171 DIR* d = opendir("/proc/self/task");
172 if (!d) {
173 return;
174 }
175
Ian Rogers50b35e22012-10-04 10:09:15 -0700176 Thread* self = Thread::Current();
Elliott Hughes4696b5b2012-10-30 10:35:10 -0700177 dirent* e;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700178 while ((e = readdir(d)) != nullptr) {
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700179 char* end;
Elliott Hughes4696b5b2012-10-30 10:35:10 -0700180 pid_t tid = strtol(e->d_name, &end, 10);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700181 if (!*end) {
182 bool contains;
183 {
Ian Rogers50b35e22012-10-04 10:09:15 -0700184 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700185 contains = Contains(tid);
186 }
187 if (!contains) {
Nicolas Geoffrayd3c59652016-03-17 09:35:04 +0000188 DumpUnattachedThread(os, tid, dump_native_stack);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700189 }
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700190 }
191 }
192 closedir(d);
Elliott Hughesff738062012-02-03 15:00:42 -0800193}
194
Mathieu Chartier47c19592016-03-07 11:59:01 -0800195// Dump checkpoint timeout in milliseconds. Larger amount on the target, since the device could be
196// overloaded with ANR dumps.
197static constexpr uint32_t kDumpWaitTimeout = kIsTargetBuild ? 100000 : 20000;
Andreas Gampe4a3d19b2015-01-09 17:54:51 -0800198
Ian Rogers7b078e82014-09-10 14:44:24 -0700199// A closure used by Thread::Dump.
Roland Levillainbbc6e7e2018-08-24 16:58:47 +0100200class DumpCheckpoint final : public Closure {
Ian Rogers7b078e82014-09-10 14:44:24 -0700201 public:
Nicolas Geoffray6ee49712018-03-30 14:39:05 +0000202 DumpCheckpoint(std::ostream* os, bool dump_native_stack)
Nicolas Geoffraya73280d2016-02-15 13:05:16 +0000203 : os_(os),
Mathieu Chartier5a832252019-03-28 07:31:16 -0700204 // Avoid verifying count in case a thread doesn't end up passing through the barrier.
205 // This avoids a SIGABRT that would otherwise happen in the destructor.
Mathieu Chartier4f1e3282019-03-27 14:41:32 -0700206 barrier_(0, /*verify_count_on_shutdown=*/false),
Nicolas Geoffray6ee49712018-03-30 14:39:05 +0000207 backtrace_map_(dump_native_stack ? BacktraceMap::Create(getpid()) : nullptr),
208 dump_native_stack_(dump_native_stack) {
Christopher Ferrisb1b0ed22017-10-24 15:38:14 -0700209 if (backtrace_map_ != nullptr) {
210 backtrace_map_->SetSuffixesToIgnore(std::vector<std::string> { "oat", "odex" });
211 }
212 }
Ian Rogers7b078e82014-09-10 14:44:24 -0700213
Roland Levillainbbc6e7e2018-08-24 16:58:47 +0100214 void Run(Thread* thread) override {
Ian Rogers7b078e82014-09-10 14:44:24 -0700215 // Note thread and self may not be equal if thread was already suspended at the point of the
216 // request.
217 Thread* self = Thread::Current();
Mathieu Chartier3f386d52016-10-05 14:12:45 -0700218 CHECK(self != nullptr);
Ian Rogers7b078e82014-09-10 14:44:24 -0700219 std::ostringstream local_os;
220 {
221 ScopedObjectAccess soa(self);
Nicolas Geoffray6ee49712018-03-30 14:39:05 +0000222 thread->Dump(local_os, dump_native_stack_, backtrace_map_.get());
Ian Rogers7b078e82014-09-10 14:44:24 -0700223 }
Ian Rogers7b078e82014-09-10 14:44:24 -0700224 {
225 // Use the logging lock to ensure serialization when writing to the common ostream.
226 MutexLock mu(self, *Locks::logging_lock_);
Andreas Gampe5544e722017-06-05 17:01:27 -0700227 *os_ << local_os.str() << std::endl;
Ian Rogers7b078e82014-09-10 14:44:24 -0700228 }
Mathieu Chartier10d25082015-10-28 18:36:09 -0700229 barrier_.Pass(self);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700230 }
Ian Rogers7b078e82014-09-10 14:44:24 -0700231
232 void WaitForThreadsToRunThroughCheckpoint(size_t threads_running_checkpoint) {
233 Thread* self = Thread::Current();
234 ScopedThreadStateChange tsc(self, kWaitingForCheckPointsToRun);
Andreas Gampe1e4b0ca2015-01-14 09:06:32 -0800235 bool timed_out = barrier_.Increment(self, threads_running_checkpoint, kDumpWaitTimeout);
Ian Rogers2156ff12014-09-13 19:20:54 -0700236 if (timed_out) {
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000237 // Avoid a recursive abort.
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700238 LOG((kIsDebugBuild && (gAborting == 0)) ? ::android::base::FATAL : ::android::base::ERROR)
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000239 << "Unexpected time out during dump checkpoint.";
Ian Rogers2156ff12014-09-13 19:20:54 -0700240 }
Ian Rogers7b078e82014-09-10 14:44:24 -0700241 }
242
243 private:
244 // The common stream that will accumulate all the dumps.
245 std::ostream* const os_;
246 // The barrier to be passed through and for the requestor to wait upon.
247 Barrier barrier_;
Christopher Ferris6cff48f2014-01-26 21:36:13 -0800248 // A backtrace map, so that all threads use a shared info and don't reacquire/parse separately.
249 std::unique_ptr<BacktraceMap> backtrace_map_;
Nicolas Geoffray6ee49712018-03-30 14:39:05 +0000250 // Whether we should dump the native stack.
251 const bool dump_native_stack_;
Ian Rogers7b078e82014-09-10 14:44:24 -0700252};
253
Nicolas Geoffray6ee49712018-03-30 14:39:05 +0000254void ThreadList::Dump(std::ostream& os, bool dump_native_stack) {
Mathieu Chartier3f386d52016-10-05 14:12:45 -0700255 Thread* self = Thread::Current();
Ian Rogers7b078e82014-09-10 14:44:24 -0700256 {
Mathieu Chartier3f386d52016-10-05 14:12:45 -0700257 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogers7b078e82014-09-10 14:44:24 -0700258 os << "DALVIK THREADS (" << list_.size() << "):\n";
259 }
Mathieu Chartier3f386d52016-10-05 14:12:45 -0700260 if (self != nullptr) {
Nicolas Geoffray6ee49712018-03-30 14:39:05 +0000261 DumpCheckpoint checkpoint(&os, dump_native_stack);
Mathieu Chartier3f386d52016-10-05 14:12:45 -0700262 size_t threads_running_checkpoint;
263 {
264 // Use SOA to prevent deadlocks if multiple threads are calling Dump() at the same time.
265 ScopedObjectAccess soa(self);
266 threads_running_checkpoint = RunCheckpoint(&checkpoint);
267 }
268 if (threads_running_checkpoint != 0) {
269 checkpoint.WaitForThreadsToRunThroughCheckpoint(threads_running_checkpoint);
270 }
271 } else {
Nicolas Geoffray6ee49712018-03-30 14:39:05 +0000272 DumpUnattachedThreads(os, dump_native_stack);
Lei Lidd9943d2015-02-02 14:24:44 +0800273 }
Elliott Hughes8daa0922011-09-11 13:46:25 -0700274}
275
Ian Rogers50b35e22012-10-04 10:09:15 -0700276void ThreadList::AssertThreadsAreSuspended(Thread* self, Thread* ignore1, Thread* ignore2) {
277 MutexLock mu(self, *Locks::thread_list_lock_);
278 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -0700279 for (const auto& thread : list_) {
jeffhao725a9572012-11-13 18:20:12 -0800280 if (thread != ignore1 && thread != ignore2) {
Ian Rogers01ae5802012-09-28 16:14:01 -0700281 CHECK(thread->IsSuspended())
282 << "\nUnsuspended thread: <<" << *thread << "\n"
283 << "self: <<" << *Thread::Current();
284 }
Elliott Hughes8d768a92011-09-14 16:35:25 -0700285 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700286}
287
Ian Rogers66aee5c2012-08-15 17:17:47 -0700288#if HAVE_TIMED_RWLOCK
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700289// Attempt to rectify locks so that we dump thread list with required locks before exiting.
Andreas Gampe794ad762015-02-23 08:12:24 -0800290NO_RETURN static void UnsafeLogFatalForThreadSuspendAllTimeout() {
Mathieu Chartier767d0392017-11-09 14:06:43 -0800291 // Increment gAborting before doing the thread list dump since we don't want any failures from
292 // AssertThreadSuspensionIsAllowable in cases where thread suspension is not allowed.
293 // See b/69044468.
294 ++gAborting;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700295 Runtime* runtime = Runtime::Current();
296 std::ostringstream ss;
297 ss << "Thread suspend timeout\n";
Mathieu Chartier5869a2c2014-10-08 14:26:23 -0700298 Locks::mutator_lock_->Dump(ss);
299 ss << "\n";
Ian Rogers7b078e82014-09-10 14:44:24 -0700300 runtime->GetThreadList()->Dump(ss);
Mathieu Chartier767d0392017-11-09 14:06:43 -0800301 --gAborting;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700302 LOG(FATAL) << ss.str();
Ian Rogers719d1a32014-03-06 12:13:39 -0800303 exit(0);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700304}
Ian Rogers66aee5c2012-08-15 17:17:47 -0700305#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700306
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800307// Unlike suspending all threads where we can wait to acquire the mutator_lock_, suspending an
Mathieu Chartier99143862015-02-03 14:26:46 -0800308// individual thread requires polling. delay_us is the requested sleep wait. If delay_us is 0 then
309// we use sched_yield instead of calling usleep.
David Sehr446c6b22017-11-09 14:08:19 -0800310// Although there is the possibility, here and elsewhere, that usleep could return -1 and
311// errno = EINTR, there should be no problem if interrupted, so we do not check.
Mathieu Chartier99143862015-02-03 14:26:46 -0800312static void ThreadSuspendSleep(useconds_t delay_us) {
313 if (delay_us == 0) {
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800314 sched_yield();
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800315 } else {
Mathieu Chartier99143862015-02-03 14:26:46 -0800316 usleep(delay_us);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800317 }
318}
319
Hiroshi Yamauchifebd0cf2016-09-14 19:31:25 -0700320size_t ThreadList::RunCheckpoint(Closure* checkpoint_function, Closure* callback) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700321 Thread* self = Thread::Current();
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800322 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
323 Locks::thread_list_lock_->AssertNotHeld(self);
324 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700325
326 std::vector<Thread*> suspended_count_modified_threads;
327 size_t count = 0;
328 {
329 // Call a checkpoint function for each thread, threads which are suspend get their checkpoint
330 // manually called.
331 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700332 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier10d25082015-10-28 18:36:09 -0700333 count = list_.size();
Mathieu Chartier02e25112013-08-14 16:14:24 -0700334 for (const auto& thread : list_) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700335 if (thread != self) {
Vladimir Markoe41eec32019-10-18 14:41:54 +0100336 bool requested_suspend = false;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700337 while (true) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700338 if (thread->RequestCheckpoint(checkpoint_function)) {
Dave Allison0aded082013-11-07 13:15:11 -0800339 // This thread will run its checkpoint some time in the near future.
Vladimir Markoe41eec32019-10-18 14:41:54 +0100340 if (requested_suspend) {
341 // The suspend request is now unnecessary.
342 bool updated =
343 thread->ModifySuspendCount(self, -1, nullptr, SuspendReason::kInternal);
344 DCHECK(updated);
345 requested_suspend = false;
346 }
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700347 break;
348 } else {
Vladimir Markoe41eec32019-10-18 14:41:54 +0100349 // The thread is probably suspended, try to make sure that it stays suspended.
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700350 if (thread->GetState() == kRunnable) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700351 // Spurious fail, try again.
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700352 continue;
353 }
Vladimir Markoe41eec32019-10-18 14:41:54 +0100354 if (!requested_suspend) {
355 bool updated =
356 thread->ModifySuspendCount(self, +1, nullptr, SuspendReason::kInternal);
357 DCHECK(updated);
358 requested_suspend = true;
359 if (thread->IsSuspended()) {
360 break;
361 }
362 // The thread raced us to become Runnable. Try to RequestCheckpoint() again.
363 } else {
364 // The thread previously raced our suspend request to become Runnable but
365 // since it is suspended again, it must honor that suspend request now.
366 DCHECK(thread->IsSuspended());
367 break;
368 }
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700369 }
370 }
Vladimir Markoe41eec32019-10-18 14:41:54 +0100371 if (requested_suspend) {
372 suspended_count_modified_threads.push_back(thread);
373 }
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700374 }
375 }
Hiroshi Yamauchifebd0cf2016-09-14 19:31:25 -0700376 // Run the callback to be called inside this critical section.
377 if (callback != nullptr) {
378 callback->Run(self);
379 }
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700380 }
381
382 // Run the checkpoint on ourself while we wait for threads to suspend.
383 checkpoint_function->Run(self);
384
385 // Run the checkpoint on the suspended threads.
Mathieu Chartier02e25112013-08-14 16:14:24 -0700386 for (const auto& thread : suspended_count_modified_threads) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700387 // We know for sure that the thread is suspended at this point.
Vladimir Markoe41eec32019-10-18 14:41:54 +0100388 DCHECK(thread->IsSuspended());
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700389 checkpoint_function->Run(thread);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700390 {
391 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Alex Light46f93402017-06-29 11:59:50 -0700392 bool updated = thread->ModifySuspendCount(self, -1, nullptr, SuspendReason::kInternal);
Sebastien Hertz1c8f4ff2017-04-14 15:05:12 +0200393 DCHECK(updated);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700394 }
395 }
396
Mathieu Chartier664bebf2012-11-12 16:54:11 -0800397 {
398 // Imitate ResumeAll, threads may be waiting on Thread::resume_cond_ since we raised their
399 // suspend count. Now the suspend_count_ is lowered so we must do the broadcast.
400 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
401 Thread::resume_cond_->Broadcast(self);
402 }
403
Lei Lidd9943d2015-02-02 14:24:44 +0800404 return count;
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700405}
406
Hiroshi Yamauchia2224042017-02-08 16:35:45 -0800407void ThreadList::RunEmptyCheckpoint() {
Hiroshi Yamauchi30493242016-11-03 13:06:52 -0700408 Thread* self = Thread::Current();
409 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
410 Locks::thread_list_lock_->AssertNotHeld(self);
411 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
Hiroshi Yamauchia2224042017-02-08 16:35:45 -0800412 std::vector<uint32_t> runnable_thread_ids;
Hiroshi Yamauchi30493242016-11-03 13:06:52 -0700413 size_t count = 0;
Hiroshi Yamauchia2224042017-02-08 16:35:45 -0800414 Barrier* barrier = empty_checkpoint_barrier_.get();
415 barrier->Init(self, 0);
Hiroshi Yamauchi30493242016-11-03 13:06:52 -0700416 {
417 MutexLock mu(self, *Locks::thread_list_lock_);
418 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
419 for (Thread* thread : list_) {
420 if (thread != self) {
421 while (true) {
422 if (thread->RequestEmptyCheckpoint()) {
423 // This thread will run an empty checkpoint (decrement the empty checkpoint barrier)
424 // some time in the near future.
425 ++count;
Hiroshi Yamauchia82769c2016-12-02 17:01:51 -0800426 if (kIsDebugBuild) {
427 runnable_thread_ids.push_back(thread->GetThreadId());
428 }
Hiroshi Yamauchi30493242016-11-03 13:06:52 -0700429 break;
430 }
431 if (thread->GetState() != kRunnable) {
432 // It's seen suspended, we are done because it must not be in the middle of a mutator
433 // heap access.
434 break;
435 }
436 }
437 }
438 }
439 }
440
441 // Wake up the threads blocking for weak ref access so that they will respond to the empty
442 // checkpoint request. Otherwise we will hang as they are blocking in the kRunnable state.
443 Runtime::Current()->GetHeap()->GetReferenceProcessor()->BroadcastForSlowPath(self);
Andreas Gampe98ea9d92018-10-19 14:06:15 -0700444 Runtime::Current()->BroadcastForNewSystemWeaks(/*broadcast_for_checkpoint=*/true);
Hiroshi Yamauchia2224042017-02-08 16:35:45 -0800445 {
446 ScopedThreadStateChange tsc(self, kWaitingForCheckPointsToRun);
447 uint64_t total_wait_time = 0;
448 bool first_iter = true;
449 while (true) {
450 // Wake up the runnable threads blocked on the mutexes that another thread, which is blocked
451 // on a weak ref access, holds (indirectly blocking for weak ref access through another thread
452 // and a mutex.) This needs to be done periodically because the thread may be preempted
453 // between the CheckEmptyCheckpointFromMutex call and the subsequent futex wait in
454 // Mutex::ExclusiveLock, etc. when the wakeup via WakeupToRespondToEmptyCheckpoint
455 // arrives. This could cause a *very rare* deadlock, if not repeated. Most of the cases are
456 // handled in the first iteration.
457 for (BaseMutex* mutex : Locks::expected_mutexes_on_weak_ref_access_) {
458 mutex->WakeupToRespondToEmptyCheckpoint();
459 }
460 static constexpr uint64_t kEmptyCheckpointPeriodicTimeoutMs = 100; // 100ms
461 static constexpr uint64_t kEmptyCheckpointTotalTimeoutMs = 600 * 1000; // 10 minutes.
462 size_t barrier_count = first_iter ? count : 0;
463 first_iter = false; // Don't add to the barrier count from the second iteration on.
464 bool timed_out = barrier->Increment(self, barrier_count, kEmptyCheckpointPeriodicTimeoutMs);
465 if (!timed_out) {
466 break; // Success
467 }
468 // This is a very rare case.
469 total_wait_time += kEmptyCheckpointPeriodicTimeoutMs;
470 if (kIsDebugBuild && total_wait_time > kEmptyCheckpointTotalTimeoutMs) {
471 std::ostringstream ss;
472 ss << "Empty checkpoint timeout\n";
473 ss << "Barrier count " << barrier->GetCount(self) << "\n";
474 ss << "Runnable thread IDs";
475 for (uint32_t tid : runnable_thread_ids) {
476 ss << " " << tid;
477 }
478 ss << "\n";
479 Locks::mutator_lock_->Dump(ss);
480 ss << "\n";
481 LOG(FATAL_WITHOUT_ABORT) << ss.str();
482 // Some threads in 'runnable_thread_ids' are probably stuck. Try to dump their stacks.
483 // Avoid using ThreadList::Dump() initially because it is likely to get stuck as well.
484 {
485 ScopedObjectAccess soa(self);
486 MutexLock mu1(self, *Locks::thread_list_lock_);
487 for (Thread* thread : GetList()) {
488 uint32_t tid = thread->GetThreadId();
489 bool is_in_runnable_thread_ids =
490 std::find(runnable_thread_ids.begin(), runnable_thread_ids.end(), tid) !=
491 runnable_thread_ids.end();
492 if (is_in_runnable_thread_ids &&
493 thread->ReadFlag(kEmptyCheckpointRequest)) {
494 // Found a runnable thread that hasn't responded to the empty checkpoint request.
495 // Assume it's stuck and safe to dump its stack.
496 thread->Dump(LOG_STREAM(FATAL_WITHOUT_ABORT),
Andreas Gampe98ea9d92018-10-19 14:06:15 -0700497 /*dump_native_stack=*/ true,
498 /*backtrace_map=*/ nullptr,
499 /*force_dump_stack=*/ true);
Hiroshi Yamauchia2224042017-02-08 16:35:45 -0800500 }
501 }
502 }
503 LOG(FATAL_WITHOUT_ABORT)
504 << "Dumped runnable threads that haven't responded to empty checkpoint.";
505 // Now use ThreadList::Dump() to dump more threads, noting it may get stuck.
506 Dump(LOG_STREAM(FATAL_WITHOUT_ABORT));
507 LOG(FATAL) << "Dumped all threads.";
508 }
509 }
510 }
Hiroshi Yamauchi30493242016-11-03 13:06:52 -0700511}
512
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800513// A checkpoint/suspend-all hybrid to switch thread roots from
514// from-space to to-space refs. Used to synchronize threads at a point
515// to mark the initiation of marking while maintaining the to-space
516// invariant.
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700517size_t ThreadList::FlipThreadRoots(Closure* thread_flip_visitor,
518 Closure* flip_callback,
Andreas Gampe6e644452017-05-09 16:30:27 -0700519 gc::collector::GarbageCollector* collector,
520 gc::GcPauseListener* pause_listener) {
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800521 TimingLogger::ScopedTiming split("ThreadListFlip", collector->GetTimings());
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800522 Thread* self = Thread::Current();
523 Locks::mutator_lock_->AssertNotHeld(self);
524 Locks::thread_list_lock_->AssertNotHeld(self);
525 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
526 CHECK_NE(self->GetState(), kRunnable);
527
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700528 collector->GetHeap()->ThreadFlipBegin(self); // Sync with JNI critical calls.
529
Mathieu Chartiere9429c82017-01-27 15:22:56 -0800530 // ThreadFlipBegin happens before we suspend all the threads, so it does not count towards the
531 // pause.
532 const uint64_t suspend_start_time = NanoTime();
Mathieu Chartierb19ccb12015-07-15 10:24:16 -0700533 SuspendAllInternal(self, self, nullptr);
Andreas Gampe6e644452017-05-09 16:30:27 -0700534 if (pause_listener != nullptr) {
535 pause_listener->StartPause();
536 }
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800537
538 // Run the flip callback for the collector.
539 Locks::mutator_lock_->ExclusiveLock(self);
Mathieu Chartiere9429c82017-01-27 15:22:56 -0800540 suspend_all_historam_.AdjustAndAddValue(NanoTime() - suspend_start_time);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800541 flip_callback->Run(self);
542 Locks::mutator_lock_->ExclusiveUnlock(self);
Mathieu Chartiere9429c82017-01-27 15:22:56 -0800543 collector->RegisterPause(NanoTime() - suspend_start_time);
Andreas Gampe6e644452017-05-09 16:30:27 -0700544 if (pause_listener != nullptr) {
545 pause_listener->EndPause();
546 }
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800547
548 // Resume runnable threads.
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700549 size_t runnable_thread_count = 0;
Mathieu Chartierb19ccb12015-07-15 10:24:16 -0700550 std::vector<Thread*> other_threads;
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800551 {
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700552 TimingLogger::ScopedTiming split2("ResumeRunnableThreads", collector->GetTimings());
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800553 MutexLock mu(self, *Locks::thread_list_lock_);
554 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
555 --suspend_all_count_;
556 for (const auto& thread : list_) {
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700557 // Set the flip function for all threads because Thread::DumpState/DumpJavaStack() (invoked by
558 // a checkpoint) may cause the flip function to be run for a runnable/suspended thread before
559 // a runnable thread runs it for itself or we run it for a suspended thread below.
560 thread->SetFlipFunction(thread_flip_visitor);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800561 if (thread == self) {
562 continue;
563 }
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700564 // Resume early the threads that were runnable but are suspended just for this thread flip or
565 // about to transition from non-runnable (eg. kNative at the SOA entry in a JNI function) to
566 // runnable (both cases waiting inside Thread::TransitionFromSuspendedToRunnable), or waiting
567 // for the thread flip to end at the JNI critical section entry (kWaitingForGcThreadFlip),
568 ThreadState state = thread->GetState();
Hiroshi Yamauchi15af34c2016-09-26 16:56:24 -0700569 if ((state == kWaitingForGcThreadFlip || thread->IsTransitioningToRunnable()) &&
570 thread->GetSuspendCount() == 1) {
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800571 // The thread will resume right after the broadcast.
Alex Light46f93402017-06-29 11:59:50 -0700572 bool updated = thread->ModifySuspendCount(self, -1, nullptr, SuspendReason::kInternal);
Sebastien Hertz1c8f4ff2017-04-14 15:05:12 +0200573 DCHECK(updated);
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700574 ++runnable_thread_count;
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800575 } else {
576 other_threads.push_back(thread);
577 }
578 }
579 Thread::resume_cond_->Broadcast(self);
580 }
581
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700582 collector->GetHeap()->ThreadFlipEnd(self);
583
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800584 // Run the closure on the other threads and let them resume.
585 {
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700586 TimingLogger::ScopedTiming split3("FlipOtherThreads", collector->GetTimings());
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800587 ReaderMutexLock mu(self, *Locks::mutator_lock_);
588 for (const auto& thread : other_threads) {
589 Closure* flip_func = thread->GetFlipFunction();
590 if (flip_func != nullptr) {
591 flip_func->Run(thread);
592 }
593 }
594 // Run it for self.
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700595 Closure* flip_func = self->GetFlipFunction();
596 if (flip_func != nullptr) {
597 flip_func->Run(self);
598 }
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800599 }
600
601 // Resume other threads.
602 {
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700603 TimingLogger::ScopedTiming split4("ResumeOtherThreads", collector->GetTimings());
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800604 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
605 for (const auto& thread : other_threads) {
Alex Light46f93402017-06-29 11:59:50 -0700606 bool updated = thread->ModifySuspendCount(self, -1, nullptr, SuspendReason::kInternal);
Sebastien Hertz1c8f4ff2017-04-14 15:05:12 +0200607 DCHECK(updated);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800608 }
609 Thread::resume_cond_->Broadcast(self);
610 }
611
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700612 return runnable_thread_count + other_threads.size() + 1; // +1 for self.
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800613}
614
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700615void ThreadList::SuspendAll(const char* cause, bool long_suspend) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700616 Thread* self = Thread::Current();
617
Jeff Haoc5d824a2014-07-28 18:35:38 -0700618 if (self != nullptr) {
Mathieu Chartierbf9fc582015-03-13 17:21:25 -0700619 VLOG(threads) << *self << " SuspendAll for " << cause << " starting...";
Jeff Haoc5d824a2014-07-28 18:35:38 -0700620 } else {
Mathieu Chartierbf9fc582015-03-13 17:21:25 -0700621 VLOG(threads) << "Thread[null] SuspendAll for " << cause << " starting...";
Jeff Haoc5d824a2014-07-28 18:35:38 -0700622 }
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800623 {
624 ScopedTrace trace("Suspending mutator threads");
625 const uint64_t start_time = NanoTime();
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700626
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800627 SuspendAllInternal(self, self);
628 // All threads are known to have suspended (but a thread may still own the mutator lock)
629 // Make sure this thread grabs exclusive access to the mutator lock and its protected data.
Ian Rogers66aee5c2012-08-15 17:17:47 -0700630#if HAVE_TIMED_RWLOCK
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800631 while (true) {
Mathieu Chartier3fceaf52017-01-22 13:33:40 -0800632 if (Locks::mutator_lock_->ExclusiveLockWithTimeout(self,
633 NsToMs(thread_suspend_timeout_ns_),
634 0)) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800635 break;
636 } else if (!long_suspend_) {
637 // Reading long_suspend without the mutator lock is slightly racy, in some rare cases, this
638 // could result in a thread suspend timeout.
Mathieu Chartier3fceaf52017-01-22 13:33:40 -0800639 // Timeout if we wait more than thread_suspend_timeout_ns_ nanoseconds.
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800640 UnsafeLogFatalForThreadSuspendAllTimeout();
641 }
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700642 }
Ian Rogers66aee5c2012-08-15 17:17:47 -0700643#else
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800644 Locks::mutator_lock_->ExclusiveLock(self);
Ian Rogers66aee5c2012-08-15 17:17:47 -0700645#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700646
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800647 long_suspend_ = long_suspend;
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700648
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800649 const uint64_t end_time = NanoTime();
650 const uint64_t suspend_time = end_time - start_time;
651 suspend_all_historam_.AdjustAndAddValue(suspend_time);
652 if (suspend_time > kLongThreadSuspendThreshold) {
653 LOG(WARNING) << "Suspending all threads took: " << PrettyDuration(suspend_time);
654 }
655
656 if (kDebugLocking) {
657 // Debug check that all threads are suspended.
658 AssertThreadsAreSuspended(self, self);
659 }
Mathieu Chartier251755c2014-07-15 18:10:25 -0700660 }
Orion Hodson119733d2019-01-30 15:14:41 +0000661 ATraceBegin((std::string("Mutator threads suspended for ") + cause).c_str());
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700662
Jeff Haoc5d824a2014-07-28 18:35:38 -0700663 if (self != nullptr) {
664 VLOG(threads) << *self << " SuspendAll complete";
665 } else {
666 VLOG(threads) << "Thread[null] SuspendAll complete";
667 }
Elliott Hughes8d768a92011-09-14 16:35:25 -0700668}
669
Yu Lieac44242015-06-29 10:50:03 +0800670// Ensures all threads running Java suspend and that those not running Java don't start.
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700671void ThreadList::SuspendAllInternal(Thread* self,
672 Thread* ignore1,
673 Thread* ignore2,
Alex Light46f93402017-06-29 11:59:50 -0700674 SuspendReason reason) {
Yu Lieac44242015-06-29 10:50:03 +0800675 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
676 Locks::thread_list_lock_->AssertNotHeld(self);
677 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
678 if (kDebugLocking && self != nullptr) {
679 CHECK_NE(self->GetState(), kRunnable);
680 }
681
682 // First request that all threads suspend, then wait for them to suspend before
683 // returning. This suspension scheme also relies on other behaviour:
684 // 1. Threads cannot be deleted while they are suspended or have a suspend-
685 // request flag set - (see Unregister() below).
686 // 2. When threads are created, they are created in a suspended state (actually
687 // kNative) and will never begin executing Java code without first checking
688 // the suspend-request flag.
689
690 // The atomic counter for number of threads that need to pass the barrier.
691 AtomicInteger pending_threads;
692 uint32_t num_ignored = 0;
693 if (ignore1 != nullptr) {
694 ++num_ignored;
695 }
696 if (ignore2 != nullptr && ignore1 != ignore2) {
697 ++num_ignored;
698 }
699 {
700 MutexLock mu(self, *Locks::thread_list_lock_);
701 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
702 // Update global suspend all state for attaching threads.
703 ++suspend_all_count_;
Orion Hodson88591fe2018-03-06 13:35:43 +0000704 pending_threads.store(list_.size() - num_ignored, std::memory_order_relaxed);
Yu Lieac44242015-06-29 10:50:03 +0800705 // 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;
Alex Light46f93402017-06-29 11:59:50 -0700711 bool updated = thread->ModifySuspendCount(self, +1, &pending_threads, reason);
Sebastien Hertz1c8f4ff2017-04-14 15:05:12 +0200712 DCHECK(updated);
Yu Lieac44242015-06-29 10:50:03 +0800713
714 // Must install the pending_threads counter first, then check thread->IsSuspend() and clear
715 // the counter. Otherwise there's a race with Thread::TransitionFromRunnableToSuspended()
716 // that can lead a thread to miss a call to PassActiveSuspendBarriers().
717 if (thread->IsSuspended()) {
718 // Only clear the counter for the current thread.
719 thread->ClearSuspendBarrier(&pending_threads);
Orion Hodson88591fe2018-03-06 13:35:43 +0000720 pending_threads.fetch_sub(1, std::memory_order_seq_cst);
Yu Lieac44242015-06-29 10:50:03 +0800721 }
722 }
723 }
724
725 // Wait for the barrier to be passed by all runnable threads. This wait
726 // is done with a timeout so that we can detect problems.
Mathieu Chartier19af1172015-07-14 10:05:45 -0700727#if ART_USE_FUTEXES
Yu Lieac44242015-06-29 10:50:03 +0800728 timespec wait_timeout;
Mathieu Chartier3fceaf52017-01-22 13:33:40 -0800729 InitTimeSpec(false, CLOCK_MONOTONIC, NsToMs(thread_suspend_timeout_ns_), 0, &wait_timeout);
Mathieu Chartier19af1172015-07-14 10:05:45 -0700730#endif
Mathieu Chartier32c83372017-01-11 10:09:30 -0800731 const uint64_t start_time = NanoTime();
Yu Lieac44242015-06-29 10:50:03 +0800732 while (true) {
Orion Hodson88591fe2018-03-06 13:35:43 +0000733 int32_t cur_val = pending_threads.load(std::memory_order_relaxed);
Yu Lieac44242015-06-29 10:50:03 +0800734 if (LIKELY(cur_val > 0)) {
735#if ART_USE_FUTEXES
Charles Munger7530bae2018-10-29 20:03:51 -0700736 if (futex(pending_threads.Address(), FUTEX_WAIT_PRIVATE, cur_val, &wait_timeout, nullptr, 0)
737 != 0) {
Yuntao.Xiaoa1358e62018-11-26 14:28:51 +0800738 if ((errno == EAGAIN) || (errno == EINTR)) {
739 // EAGAIN and EINTR both indicate a spurious failure, try again from the beginning.
740 continue;
741 }
742 if (errno == ETIMEDOUT) {
743 const uint64_t wait_time = NanoTime() - start_time;
744 MutexLock mu(self, *Locks::thread_list_lock_);
745 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
746 std::ostringstream oss;
747 for (const auto& thread : list_) {
748 if (thread == ignore1 || thread == ignore2) {
749 continue;
750 }
751 if (!thread->IsSuspended()) {
752 oss << std::endl << "Thread not suspended: " << *thread;
753 }
Yu Lieac44242015-06-29 10:50:03 +0800754 }
Yuntao.Xiaoa1358e62018-11-26 14:28:51 +0800755 LOG(kIsDebugBuild ? ::android::base::FATAL : ::android::base::ERROR)
756 << "Timed out waiting for threads to suspend, waited for "
757 << PrettyDuration(wait_time)
758 << oss.str();
759 } else {
760 PLOG(FATAL) << "futex wait failed for SuspendAllInternal()";
Yu Lieac44242015-06-29 10:50:03 +0800761 }
Vladimir Markod778cd62016-07-05 17:29:55 +0100762 } // else re-check pending_threads in the next iteration (this may be a spurious wake-up).
Yu Lieac44242015-06-29 10:50:03 +0800763#else
764 // Spin wait. This is likely to be slow, but on most architecture ART_USE_FUTEXES is set.
Mathieu Chartier32c83372017-01-11 10:09:30 -0800765 UNUSED(start_time);
Yu Lieac44242015-06-29 10:50:03 +0800766#endif
767 } else {
768 CHECK_EQ(cur_val, 0);
769 break;
770 }
771 }
772}
773
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700774void ThreadList::ResumeAll() {
775 Thread* self = Thread::Current();
776
Jeff Haoc5d824a2014-07-28 18:35:38 -0700777 if (self != nullptr) {
778 VLOG(threads) << *self << " ResumeAll starting";
779 } else {
780 VLOG(threads) << "Thread[null] ResumeAll starting";
781 }
Ian Rogers01ae5802012-09-28 16:14:01 -0700782
Orion Hodson119733d2019-01-30 15:14:41 +0000783 ATraceEnd();
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800784
785 ScopedTrace trace("Resuming mutator threads");
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700786
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800787 if (kDebugLocking) {
788 // Debug check that all threads are suspended.
789 AssertThreadsAreSuspended(self, self);
790 }
Ian Rogers01ae5802012-09-28 16:14:01 -0700791
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700792 long_suspend_ = false;
793
Ian Rogers81d425b2012-09-27 16:03:43 -0700794 Locks::mutator_lock_->ExclusiveUnlock(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700795 {
Ian Rogers81d425b2012-09-27 16:03:43 -0700796 MutexLock mu(self, *Locks::thread_list_lock_);
797 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700798 // Update global suspend all state for attaching threads.
799 --suspend_all_count_;
800 // Decrement the suspend counts for all threads.
Mathieu Chartier02e25112013-08-14 16:14:24 -0700801 for (const auto& thread : list_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700802 if (thread == self) {
803 continue;
804 }
Alex Light46f93402017-06-29 11:59:50 -0700805 bool updated = thread->ModifySuspendCount(self, -1, nullptr, SuspendReason::kInternal);
Sebastien Hertz1c8f4ff2017-04-14 15:05:12 +0200806 DCHECK(updated);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700807 }
808
809 // Broadcast a notification to all suspended threads, some or all of
810 // which may choose to wake up. No need to wait for them.
Jeff Haoc5d824a2014-07-28 18:35:38 -0700811 if (self != nullptr) {
812 VLOG(threads) << *self << " ResumeAll waking others";
813 } else {
814 VLOG(threads) << "Thread[null] ResumeAll waking others";
815 }
Ian Rogersc604d732012-10-14 16:09:54 -0700816 Thread::resume_cond_->Broadcast(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700817 }
Jeff Haoc5d824a2014-07-28 18:35:38 -0700818
819 if (self != nullptr) {
820 VLOG(threads) << *self << " ResumeAll complete";
821 } else {
822 VLOG(threads) << "Thread[null] ResumeAll complete";
823 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700824}
825
Alex Light88fd7202017-06-30 08:31:59 -0700826bool ThreadList::Resume(Thread* thread, SuspendReason reason) {
Orion Hodson119733d2019-01-30 15:14:41 +0000827 // This assumes there was an ATraceBegin when we suspended the thread.
828 ATraceEnd();
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -0800829
Ian Rogers81d425b2012-09-27 16:03:43 -0700830 Thread* self = Thread::Current();
831 DCHECK_NE(thread, self);
Alex Light46f93402017-06-29 11:59:50 -0700832 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") starting..." << reason;
Elliott Hughes01158d72011-09-19 19:47:10 -0700833
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700834 {
835 // To check Contains.
Ian Rogers81d425b2012-09-27 16:03:43 -0700836 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700837 // To check IsSuspended.
Ian Rogers81d425b2012-09-27 16:03:43 -0700838 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Alex Light88fd7202017-06-30 08:31:59 -0700839 if (UNLIKELY(!thread->IsSuspended())) {
840 LOG(ERROR) << "Resume(" << reinterpret_cast<void*>(thread)
841 << ") thread not suspended";
842 return false;
843 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700844 if (!Contains(thread)) {
Brian Carlstromba32de42014-08-27 23:43:46 -0700845 // We only expect threads within the thread-list to have been suspended otherwise we can't
846 // stop such threads from delete-ing themselves.
847 LOG(ERROR) << "Resume(" << reinterpret_cast<void*>(thread)
848 << ") thread not within thread list";
Alex Light88fd7202017-06-30 08:31:59 -0700849 return false;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700850 }
Alex Light88fd7202017-06-30 08:31:59 -0700851 if (UNLIKELY(!thread->ModifySuspendCount(self, -1, nullptr, reason))) {
852 LOG(ERROR) << "Resume(" << reinterpret_cast<void*>(thread)
853 << ") could not modify suspend count.";
854 return false;
855 }
Elliott Hughes01158d72011-09-19 19:47:10 -0700856 }
857
858 {
Brian Carlstromba32de42014-08-27 23:43:46 -0700859 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") waking others";
Ian Rogers81d425b2012-09-27 16:03:43 -0700860 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersc604d732012-10-14 16:09:54 -0700861 Thread::resume_cond_->Broadcast(self);
Elliott Hughes01158d72011-09-19 19:47:10 -0700862 }
863
Brian Carlstromba32de42014-08-27 23:43:46 -0700864 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") complete";
Alex Light88fd7202017-06-30 08:31:59 -0700865 return true;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700866}
Elliott Hughes01158d72011-09-19 19:47:10 -0700867
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700868static void ThreadSuspendByPeerWarning(Thread* self,
869 LogSeverity severity,
870 const char* message,
Ian Rogersc7dd2952014-10-21 23:31:19 -0700871 jobject peer) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700872 JNIEnvExt* env = self->GetJniEnv();
873 ScopedLocalRef<jstring>
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700874 scoped_name_string(env, static_cast<jstring>(env->GetObjectField(
875 peer, WellKnownClasses::java_lang_Thread_name)));
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700876 ScopedUtfChars scoped_name_chars(env, scoped_name_string.get());
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700877 if (scoped_name_chars.c_str() == nullptr) {
Ian Rogersc7dd2952014-10-21 23:31:19 -0700878 LOG(severity) << message << ": " << peer;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700879 env->ExceptionClear();
880 } else {
Ian Rogersc7dd2952014-10-21 23:31:19 -0700881 LOG(severity) << message << ": " << peer << ":" << scoped_name_chars.c_str();
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700882 }
883}
884
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700885Thread* ThreadList::SuspendThreadByPeer(jobject peer,
886 bool request_suspension,
Alex Light46f93402017-06-29 11:59:50 -0700887 SuspendReason reason,
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700888 bool* timed_out) {
Mathieu Chartier3a958aa2015-02-04 12:52:34 -0800889 const uint64_t start_time = NanoTime();
Mathieu Chartier99143862015-02-03 14:26:46 -0800890 useconds_t sleep_us = kThreadSuspendInitialSleepUs;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700891 *timed_out = false;
Mathieu Chartier99143862015-02-03 14:26:46 -0800892 Thread* const self = Thread::Current();
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800893 Thread* suspended_thread = nullptr;
Brian Carlstromba32de42014-08-27 23:43:46 -0700894 VLOG(threads) << "SuspendThreadByPeer starting";
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700895 while (true) {
896 Thread* thread;
897 {
Ian Rogersf3d874c2014-07-17 18:52:42 -0700898 // Note: this will transition to runnable and potentially suspend. We ensure only one thread
899 // is requesting another suspend, to avoid deadlock, by requiring this function be called
900 // holding Locks::thread_list_suspend_thread_lock_. Its important this thread suspend rather
901 // than request thread suspension, to avoid potential cycles in threads requesting each other
902 // suspend.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700903 ScopedObjectAccess soa(self);
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800904 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700905 thread = Thread::FromManagedThread(soa, peer);
Brian Carlstromba32de42014-08-27 23:43:46 -0700906 if (thread == nullptr) {
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800907 if (suspended_thread != nullptr) {
908 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
909 // If we incremented the suspend count but the thread reset its peer, we need to
910 // re-decrement it since it is shutting down and may deadlock the runtime in
911 // ThreadList::WaitForOtherNonDaemonThreadsToExit.
Sebastien Hertz1c8f4ff2017-04-14 15:05:12 +0200912 bool updated = suspended_thread->ModifySuspendCount(soa.Self(),
913 -1,
914 nullptr,
Alex Light46f93402017-06-29 11:59:50 -0700915 reason);
Sebastien Hertz1c8f4ff2017-04-14 15:05:12 +0200916 DCHECK(updated);
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800917 }
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700918 ThreadSuspendByPeerWarning(self,
919 ::android::base::WARNING,
920 "No such thread for suspend",
921 peer);
Brian Carlstromba32de42014-08-27 23:43:46 -0700922 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700923 }
Brian Carlstromba32de42014-08-27 23:43:46 -0700924 if (!Contains(thread)) {
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800925 CHECK(suspended_thread == nullptr);
Brian Carlstromba32de42014-08-27 23:43:46 -0700926 VLOG(threads) << "SuspendThreadByPeer failed for unattached thread: "
927 << reinterpret_cast<void*>(thread);
928 return nullptr;
929 }
930 VLOG(threads) << "SuspendThreadByPeer found thread: " << *thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700931 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800932 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700933 if (request_suspension) {
Ian Rogers4ad5cd32014-11-11 23:08:07 -0800934 if (self->GetSuspendCount() > 0) {
935 // We hold the suspend count lock but another thread is trying to suspend us. Its not
936 // safe to try to suspend another thread in case we get a cycle. Start the loop again
937 // which will allow this thread to be suspended.
938 continue;
939 }
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800940 CHECK(suspended_thread == nullptr);
941 suspended_thread = thread;
Alex Light46f93402017-06-29 11:59:50 -0700942 bool updated = suspended_thread->ModifySuspendCount(self, +1, nullptr, reason);
Sebastien Hertz1c8f4ff2017-04-14 15:05:12 +0200943 DCHECK(updated);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700944 request_suspension = false;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700945 } else {
946 // If the caller isn't requesting suspension, a suspension should have already occurred.
947 CHECK_GT(thread->GetSuspendCount(), 0);
948 }
949 // IsSuspended on the current thread will fail as the current thread is changed into
950 // Runnable above. As the suspend count is now raised if this is the current thread
951 // it will self suspend on transition to Runnable, making it hard to work with. It's simpler
952 // to just explicitly handle the current thread in the callers to this code.
953 CHECK_NE(thread, self) << "Attempt to suspend the current thread for the debugger";
954 // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend
955 // count, or else we've waited and it has self suspended) or is the current thread, we're
956 // done.
957 if (thread->IsSuspended()) {
Brian Carlstromba32de42014-08-27 23:43:46 -0700958 VLOG(threads) << "SuspendThreadByPeer thread suspended: " << *thread;
Orion Hodson119733d2019-01-30 15:14:41 +0000959 if (ATraceEnabled()) {
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -0800960 std::string name;
961 thread->GetThreadName(name);
Orion Hodson119733d2019-01-30 15:14:41 +0000962 ATraceBegin(StringPrintf("SuspendThreadByPeer suspended %s for peer=%p", name.c_str(),
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -0800963 peer).c_str());
964 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700965 return thread;
966 }
Mathieu Chartier99143862015-02-03 14:26:46 -0800967 const uint64_t total_delay = NanoTime() - start_time;
Mathieu Chartier3fceaf52017-01-22 13:33:40 -0800968 if (total_delay >= thread_suspend_timeout_ns_) {
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700969 ThreadSuspendByPeerWarning(self,
970 ::android::base::FATAL,
Andreas Gamped6e54bb2016-09-26 14:07:57 -0700971 "Thread suspension timed out",
972 peer);
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800973 if (suspended_thread != nullptr) {
974 CHECK_EQ(suspended_thread, thread);
Sebastien Hertz1c8f4ff2017-04-14 15:05:12 +0200975 bool updated = suspended_thread->ModifySuspendCount(soa.Self(),
976 -1,
977 nullptr,
Alex Light46f93402017-06-29 11:59:50 -0700978 reason);
Sebastien Hertz1c8f4ff2017-04-14 15:05:12 +0200979 DCHECK(updated);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700980 }
981 *timed_out = true;
Brian Carlstromba32de42014-08-27 23:43:46 -0700982 return nullptr;
Mathieu Chartier99143862015-02-03 14:26:46 -0800983 } else if (sleep_us == 0 &&
984 total_delay > static_cast<uint64_t>(kThreadSuspendMaxYieldUs) * 1000) {
985 // We have spun for kThreadSuspendMaxYieldUs time, switch to sleeps to prevent
986 // excessive CPU usage.
987 sleep_us = kThreadSuspendMaxYieldUs / 2;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700988 }
989 }
990 // Release locks and come out of runnable state.
991 }
Mathieu Chartier99143862015-02-03 14:26:46 -0800992 VLOG(threads) << "SuspendThreadByPeer waiting to allow thread chance to suspend";
993 ThreadSuspendSleep(sleep_us);
994 // This may stay at 0 if sleep_us == 0, but this is WAI since we want to avoid using usleep at
995 // all if possible. This shouldn't be an issue since time to suspend should always be small.
996 sleep_us = std::min(sleep_us * 2, kThreadSuspendMaxSleepUs);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700997 }
998}
999
Mathieu Chartierb56200b2015-10-29 10:41:51 -07001000static void ThreadSuspendByThreadIdWarning(LogSeverity severity,
1001 const char* message,
Ian Rogersc7dd2952014-10-21 23:31:19 -07001002 uint32_t thread_id) {
1003 LOG(severity) << StringPrintf("%s: %d", message, thread_id);
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001004}
1005
Mathieu Chartierb56200b2015-10-29 10:41:51 -07001006Thread* ThreadList::SuspendThreadByThreadId(uint32_t thread_id,
Alex Light46f93402017-06-29 11:59:50 -07001007 SuspendReason reason,
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001008 bool* timed_out) {
Mathieu Chartier3a958aa2015-02-04 12:52:34 -08001009 const uint64_t start_time = NanoTime();
Mathieu Chartier99143862015-02-03 14:26:46 -08001010 useconds_t sleep_us = kThreadSuspendInitialSleepUs;
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001011 *timed_out = false;
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -08001012 Thread* suspended_thread = nullptr;
Mathieu Chartier99143862015-02-03 14:26:46 -08001013 Thread* const self = Thread::Current();
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001014 CHECK_NE(thread_id, kInvalidThreadId);
Brian Carlstromba32de42014-08-27 23:43:46 -07001015 VLOG(threads) << "SuspendThreadByThreadId starting";
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001016 while (true) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001017 {
Ian Rogersf3d874c2014-07-17 18:52:42 -07001018 // Note: this will transition to runnable and potentially suspend. We ensure only one thread
1019 // is requesting another suspend, to avoid deadlock, by requiring this function be called
1020 // holding Locks::thread_list_suspend_thread_lock_. Its important this thread suspend rather
1021 // than request thread suspension, to avoid potential cycles in threads requesting each other
1022 // suspend.
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001023 ScopedObjectAccess soa(self);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001024 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Ian Rogersf3d874c2014-07-17 18:52:42 -07001025 Thread* thread = nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001026 for (const auto& it : list_) {
1027 if (it->GetThreadId() == thread_id) {
1028 thread = it;
1029 break;
1030 }
1031 }
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -08001032 if (thread == nullptr) {
1033 CHECK(suspended_thread == nullptr) << "Suspended thread " << suspended_thread
1034 << " no longer in thread list";
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001035 // There's a race in inflating a lock and the owner giving up ownership and then dying.
Andreas Gampe3fec9ac2016-09-13 10:47:28 -07001036 ThreadSuspendByThreadIdWarning(::android::base::WARNING,
1037 "No such thread id for suspend",
1038 thread_id);
Brian Carlstromba32de42014-08-27 23:43:46 -07001039 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001040 }
Brian Carlstromba32de42014-08-27 23:43:46 -07001041 VLOG(threads) << "SuspendThreadByThreadId found thread: " << *thread;
1042 DCHECK(Contains(thread));
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001043 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001044 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -08001045 if (suspended_thread == nullptr) {
Ian Rogers4ad5cd32014-11-11 23:08:07 -08001046 if (self->GetSuspendCount() > 0) {
1047 // We hold the suspend count lock but another thread is trying to suspend us. Its not
1048 // safe to try to suspend another thread in case we get a cycle. Start the loop again
1049 // which will allow this thread to be suspended.
1050 continue;
1051 }
Alex Light46f93402017-06-29 11:59:50 -07001052 bool updated = thread->ModifySuspendCount(self, +1, nullptr, reason);
Sebastien Hertz1c8f4ff2017-04-14 15:05:12 +02001053 DCHECK(updated);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -08001054 suspended_thread = thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001055 } else {
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -08001056 CHECK_EQ(suspended_thread, thread);
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001057 // If the caller isn't requesting suspension, a suspension should have already occurred.
1058 CHECK_GT(thread->GetSuspendCount(), 0);
1059 }
1060 // IsSuspended on the current thread will fail as the current thread is changed into
1061 // Runnable above. As the suspend count is now raised if this is the current thread
1062 // it will self suspend on transition to Runnable, making it hard to work with. It's simpler
1063 // to just explicitly handle the current thread in the callers to this code.
1064 CHECK_NE(thread, self) << "Attempt to suspend the current thread for the debugger";
1065 // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend
1066 // count, or else we've waited and it has self suspended) or is the current thread, we're
1067 // done.
1068 if (thread->IsSuspended()) {
Orion Hodson119733d2019-01-30 15:14:41 +00001069 if (ATraceEnabled()) {
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -08001070 std::string name;
1071 thread->GetThreadName(name);
Orion Hodson119733d2019-01-30 15:14:41 +00001072 ATraceBegin(StringPrintf("SuspendThreadByThreadId suspended %s id=%d",
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -08001073 name.c_str(), thread_id).c_str());
1074 }
Brian Carlstromba32de42014-08-27 23:43:46 -07001075 VLOG(threads) << "SuspendThreadByThreadId thread suspended: " << *thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001076 return thread;
1077 }
Mathieu Chartier99143862015-02-03 14:26:46 -08001078 const uint64_t total_delay = NanoTime() - start_time;
Mathieu Chartier3fceaf52017-01-22 13:33:40 -08001079 if (total_delay >= thread_suspend_timeout_ns_) {
Andreas Gampe3fec9ac2016-09-13 10:47:28 -07001080 ThreadSuspendByThreadIdWarning(::android::base::WARNING,
1081 "Thread suspension timed out",
1082 thread_id);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -08001083 if (suspended_thread != nullptr) {
Alex Light46f93402017-06-29 11:59:50 -07001084 bool updated = thread->ModifySuspendCount(soa.Self(), -1, nullptr, reason);
Sebastien Hertz1c8f4ff2017-04-14 15:05:12 +02001085 DCHECK(updated);
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001086 }
1087 *timed_out = true;
Brian Carlstromba32de42014-08-27 23:43:46 -07001088 return nullptr;
Mathieu Chartier99143862015-02-03 14:26:46 -08001089 } else if (sleep_us == 0 &&
1090 total_delay > static_cast<uint64_t>(kThreadSuspendMaxYieldUs) * 1000) {
1091 // We have spun for kThreadSuspendMaxYieldUs time, switch to sleeps to prevent
1092 // excessive CPU usage.
1093 sleep_us = kThreadSuspendMaxYieldUs / 2;
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001094 }
1095 }
1096 // Release locks and come out of runnable state.
1097 }
Mathieu Chartier99143862015-02-03 14:26:46 -08001098 VLOG(threads) << "SuspendThreadByThreadId waiting to allow thread chance to suspend";
1099 ThreadSuspendSleep(sleep_us);
1100 sleep_us = std::min(sleep_us * 2, kThreadSuspendMaxSleepUs);
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001101 }
1102}
1103
Mathieu Chartier61b3cd42016-04-18 11:43:29 -07001104Thread* ThreadList::FindThreadByThreadId(uint32_t thread_id) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001105 for (const auto& thread : list_) {
Mathieu Chartier61b3cd42016-04-18 11:43:29 -07001106 if (thread->GetThreadId() == thread_id) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001107 return thread;
1108 }
1109 }
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001110 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001111}
1112
Hans Boehmdc77ca32020-01-31 16:29:35 -08001113void ThreadList::WaitForOtherNonDaemonThreadsToExit(bool check_no_birth) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08001114 ScopedTrace trace(__PRETTY_FUNCTION__);
Ian Rogers81d425b2012-09-27 16:03:43 -07001115 Thread* self = Thread::Current();
1116 Locks::mutator_lock_->AssertNotHeld(self);
Mathieu Chartier91e56692015-03-03 13:51:04 -08001117 while (true) {
Hans Boehmdc77ca32020-01-31 16:29:35 -08001118 Locks::runtime_shutdown_lock_->Lock(self);
1119 if (check_no_birth) {
Ian Rogers120f1c72012-09-28 17:17:10 -07001120 // No more threads can be born after we start to shutdown.
Mathieu Chartier590fee92013-09-13 13:46:47 -07001121 CHECK(Runtime::Current()->IsShuttingDownLocked());
Ian Rogers120f1c72012-09-28 17:17:10 -07001122 CHECK_EQ(Runtime::Current()->NumberOfThreadsBeingBorn(), 0U);
Hans Boehmdc77ca32020-01-31 16:29:35 -08001123 } else {
1124 if (Runtime::Current()->NumberOfThreadsBeingBorn() != 0U) {
1125 // Awkward. Shutdown_cond_ is private, but the only live thread may not be registered yet.
1126 // Fortunately, this is used mostly for testing, and not performance-critical.
1127 Locks::runtime_shutdown_lock_->Unlock(self);
1128 usleep(1000);
1129 continue;
1130 }
Ian Rogers120f1c72012-09-28 17:17:10 -07001131 }
Ian Rogers120f1c72012-09-28 17:17:10 -07001132 MutexLock mu(self, *Locks::thread_list_lock_);
Hans Boehmdc77ca32020-01-31 16:29:35 -08001133 Locks::runtime_shutdown_lock_->Unlock(self);
Mathieu Chartier91e56692015-03-03 13:51:04 -08001134 // Also wait for any threads that are unregistering to finish. This is required so that no
1135 // threads access the thread list after it is deleted. TODO: This may not work for user daemon
1136 // threads since they could unregister at the wrong time.
1137 bool done = unregistering_count_ == 0;
1138 if (done) {
1139 for (const auto& thread : list_) {
1140 if (thread != self && !thread->IsDaemon()) {
1141 done = false;
1142 break;
1143 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001144 }
1145 }
Mathieu Chartier91e56692015-03-03 13:51:04 -08001146 if (done) {
1147 break;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001148 }
Mathieu Chartier91e56692015-03-03 13:51:04 -08001149 // Wait for another thread to exit before re-checking.
1150 Locks::thread_exit_cond_->Wait(self);
1151 }
Elliott Hughes038a8062011-09-18 14:12:41 -07001152}
1153
Mathieu Chartier4d87df62016-01-07 15:14:19 -08001154void ThreadList::SuspendAllDaemonThreadsForShutdown() {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08001155 ScopedTrace trace(__PRETTY_FUNCTION__);
Ian Rogers81d425b2012-09-27 16:03:43 -07001156 Thread* self = Thread::Current();
Mathieu Chartier62597d12016-01-11 10:19:06 -08001157 size_t daemons_left = 0;
Nicolas Geoffrayaa45daa2016-06-20 15:58:32 +01001158 {
1159 // Tell all the daemons it's time to suspend.
1160 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogers81d425b2012-09-27 16:03:43 -07001161 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001162 for (const auto& thread : list_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001163 // This is only run after all non-daemon threads have exited, so the remainder should all be
1164 // daemons.
Ian Rogers7e762862012-10-22 15:45:08 -07001165 CHECK(thread->IsDaemon()) << *thread;
Ian Rogers81d425b2012-09-27 16:03:43 -07001166 if (thread != self) {
Alex Light46f93402017-06-29 11:59:50 -07001167 bool updated = thread->ModifySuspendCount(self, +1, nullptr, SuspendReason::kInternal);
Sebastien Hertz1c8f4ff2017-04-14 15:05:12 +02001168 DCHECK(updated);
Mathieu Chartier62597d12016-01-11 10:19:06 -08001169 ++daemons_left;
Elliott Hughese52e49b2012-04-02 16:05:44 -07001170 }
Mathieu Chartier4d87df62016-01-07 15:14:19 -08001171 // We are shutting down the runtime, set the JNI functions of all the JNIEnvs to be
1172 // the sleep forever one.
1173 thread->GetJniEnv()->SetFunctionsToRuntimeShutdownFunctions();
Elliott Hughes038a8062011-09-18 14:12:41 -07001174 }
1175 }
Hans Boehm65c18a22020-01-03 23:37:13 +00001176 if (daemons_left == 0) {
1177 // No threads left; safe to shut down.
1178 return;
Mathieu Chartier62597d12016-01-11 10:19:06 -08001179 }
Hans Boehm65c18a22020-01-03 23:37:13 +00001180 // There is not a clean way to shut down if we have daemons left. We have no mechanism for
1181 // killing them and reclaiming thread stacks. We also have no mechanism for waiting until they
1182 // have truly finished touching the memory we are about to deallocate. We do the best we can with
1183 // timeouts.
1184 //
1185 // If we have any daemons left, wait until they are (a) suspended and (b) they are not stuck
1186 // in a place where they are about to access runtime state and are not in a runnable state.
1187 // We attempt to do the latter by just waiting long enough for things to
1188 // quiesce. Examples: Monitor code or waking up from a condition variable.
1189 //
1190 // Give the threads a chance to suspend, complaining if they're slow. (a)
Elliott Hughes038a8062011-09-18 14:12:41 -07001191 bool have_complained = false;
Mathieu Chartierba098ba2016-01-07 09:31:33 -08001192 static constexpr size_t kTimeoutMicroseconds = 2000 * 1000;
1193 static constexpr size_t kSleepMicroseconds = 1000;
Hans Boehm28aaf242020-04-17 17:46:48 -07001194 bool all_suspended = false;
1195 for (size_t i = 0; !all_suspended && i < kTimeoutMicroseconds / kSleepMicroseconds; ++i) {
1196 bool found_running = false;
Nicolas Geoffrayaa45daa2016-06-20 15:58:32 +01001197 {
1198 MutexLock mu(self, *Locks::thread_list_lock_);
1199 for (const auto& thread : list_) {
1200 if (thread != self && thread->GetState() == kRunnable) {
1201 if (!have_complained) {
1202 LOG(WARNING) << "daemon thread not yet suspended: " << *thread;
1203 have_complained = true;
1204 }
Hans Boehm28aaf242020-04-17 17:46:48 -07001205 found_running = true;
Elliott Hughes038a8062011-09-18 14:12:41 -07001206 }
Elliott Hughes038a8062011-09-18 14:12:41 -07001207 }
1208 }
Hans Boehm28aaf242020-04-17 17:46:48 -07001209 if (found_running) {
1210 // Sleep briefly before checking again. Max total sleep time is kTimeoutMicroseconds.
1211 usleep(kSleepMicroseconds);
1212 } else {
1213 all_suspended = true;
1214 }
1215 }
1216 if (!all_suspended) {
1217 // We can get here if a daemon thread executed a fastnative native call, so that it
1218 // remained in runnable state, and then made a JNI call after we called
1219 // SetFunctionsToRuntimeShutdownFunctions(), causing it to permanently stay in a harmless
1220 // but runnable state. See b/147804269 .
1221 LOG(WARNING) << "timed out suspending all daemon threads";
1222 }
1223 // Assume all threads are either suspended or somehow wedged.
1224 // Wait again for all the now "suspended" threads to actually quiesce. (b)
Hans Boehm6127ace2020-04-21 20:38:14 -07001225 static constexpr size_t kDaemonSleepTime = 400'000;
Hans Boehm28aaf242020-04-17 17:46:48 -07001226 usleep(kDaemonSleepTime);
1227 std::list<Thread*> list_copy;
1228 {
1229 MutexLock mu(self, *Locks::thread_list_lock_);
1230 // Half-way through the wait, set the "runtime deleted" flag, causing any newly awoken
1231 // threads to immediately go back to sleep without touching memory. This prevents us from
1232 // touching deallocated memory, but it also prevents mutexes from getting released. Thus we
1233 // only do this once we're reasonably sure that no system mutexes are still held.
1234 for (const auto& thread : list_) {
1235 DCHECK(thread == self || !all_suspended || thread->GetState() != kRunnable);
1236 // In the !all_suspended case, the target is probably sleeping.
1237 thread->GetJniEnv()->SetRuntimeDeleted();
1238 // Possibly contended Mutex acquisitions are unsafe after this.
1239 // Releasing thread_list_lock_ is OK, since it can't block.
1240 }
1241 }
1242 // Finally wait for any threads woken before we set the "runtime deleted" flags to finish
1243 // touching memory.
1244 usleep(kDaemonSleepTime);
Hans Boehmff5ce162020-01-17 18:06:41 -08001245#if defined(__has_feature)
1246#if __has_feature(address_sanitizer) || __has_feature(hwaddress_sanitizer)
Hans Boehm28aaf242020-04-17 17:46:48 -07001247 // Sleep a bit longer with -fsanitize=address, since everything is slower.
1248 usleep(2 * kDaemonSleepTime);
Hans Boehmff5ce162020-01-17 18:06:41 -08001249#endif
1250#endif
Hans Boehm28aaf242020-04-17 17:46:48 -07001251 // At this point no threads should be touching our data structures anymore.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001252}
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001253
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001254void ThreadList::Register(Thread* self) {
1255 DCHECK_EQ(self, Thread::Current());
Andreas Gampec4bed162017-05-01 13:46:24 -07001256 CHECK(!shut_down_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001257
1258 if (VLOG_IS_ON(threads)) {
1259 std::ostringstream oss;
1260 self->ShortDump(oss); // We don't hold the mutator_lock_ yet and so cannot call Dump.
Ian Rogers5a9ba012014-05-19 13:28:52 -07001261 LOG(INFO) << "ThreadList::Register() " << *self << "\n" << oss.str();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001262 }
1263
1264 // Atomically add self to the thread list and make its thread_suspend_count_ reflect ongoing
1265 // SuspendAll requests.
Ian Rogers81d425b2012-09-27 16:03:43 -07001266 MutexLock mu(self, *Locks::thread_list_lock_);
1267 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogers2966e132014-04-02 08:34:36 -07001268 // Modify suspend count in increments of 1 to maintain invariants in ModifySuspendCount. While
1269 // this isn't particularly efficient the suspend counts are most commonly 0 or 1.
Alex Lightfc588092020-01-23 15:39:08 -08001270 for (int delta = suspend_all_count_; delta > 0; delta--) {
Alex Light46f93402017-06-29 11:59:50 -07001271 bool updated = self->ModifySuspendCount(self, +1, nullptr, SuspendReason::kInternal);
Sebastien Hertz1c8f4ff2017-04-14 15:05:12 +02001272 DCHECK(updated);
Ian Rogers01ae5802012-09-28 16:14:01 -07001273 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001274 CHECK(!Contains(self));
1275 list_.push_back(self);
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001276 if (kUseReadBarrier) {
Mathieu Chartier3768ade2017-05-02 14:04:39 -07001277 gc::collector::ConcurrentCopying* const cc =
1278 Runtime::Current()->GetHeap()->ConcurrentCopyingCollector();
Hiroshi Yamauchi00370822015-08-18 14:47:25 -07001279 // Initialize according to the state of the CC collector.
Mathieu Chartier3768ade2017-05-02 14:04:39 -07001280 self->SetIsGcMarkingAndUpdateEntrypoints(cc->IsMarking());
1281 if (cc->IsUsingReadBarrierEntrypoints()) {
1282 self->SetReadBarrierEntrypoints();
1283 }
1284 self->SetWeakRefAccessEnabled(cc->IsWeakRefAccessEnabled());
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001285 }
David Srbecky28f6cff2018-10-16 15:07:28 +01001286 self->NotifyInTheadList();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001287}
1288
1289void ThreadList::Unregister(Thread* self) {
1290 DCHECK_EQ(self, Thread::Current());
Ian Rogers68d8b422014-07-17 11:09:10 -07001291 CHECK_NE(self->GetState(), kRunnable);
1292 Locks::mutator_lock_->AssertNotHeld(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001293
1294 VLOG(threads) << "ThreadList::Unregister() " << *self;
1295
Mathieu Chartier91e56692015-03-03 13:51:04 -08001296 {
1297 MutexLock mu(self, *Locks::thread_list_lock_);
1298 ++unregistering_count_;
1299 }
1300
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001301 // Any time-consuming destruction, plus anything that can call back into managed code or
Mathieu Chartier91e56692015-03-03 13:51:04 -08001302 // suspend and so on, must happen at this point, and not in ~Thread. The self->Destroy is what
1303 // causes the threads to join. It is important to do this after incrementing unregistering_count_
1304 // since we want the runtime to wait for the daemon threads to exit before deleting the thread
1305 // list.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001306 self->Destroy();
1307
Jeff Haoe094b872014-10-14 13:12:01 -07001308 // If tracing, remember thread id and name before thread exits.
1309 Trace::StoreExitingThreadInfo(self);
1310
Ian Rogersdd7624d2014-03-14 17:43:00 -07001311 uint32_t thin_lock_id = self->GetThreadId();
Mathieu Chartier91e56692015-03-03 13:51:04 -08001312 while (true) {
Ian Rogerscfaa4552012-11-26 21:00:08 -08001313 // Remove and delete the Thread* while holding the thread_list_lock_ and
1314 // thread_suspend_count_lock_ so that the unregistering thread cannot be suspended.
Ian Rogers0878d652013-04-18 17:38:35 -07001315 // Note: deliberately not using MutexLock that could hold a stale self pointer.
Juju Sung3fef44a2019-01-07 18:18:16 +08001316 {
1317 MutexLock mu(self, *Locks::thread_list_lock_);
1318 if (!Contains(self)) {
1319 std::string thread_name;
1320 self->GetThreadName(thread_name);
1321 std::ostringstream os;
1322 DumpNativeStack(os, GetTid(), nullptr, " native: ", nullptr);
1323 LOG(ERROR) << "Request to unregister unattached thread " << thread_name << "\n" << os.str();
Mathieu Chartier91e56692015-03-03 13:51:04 -08001324 break;
Juju Sung3fef44a2019-01-07 18:18:16 +08001325 } else {
1326 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
1327 if (!self->IsSuspended()) {
1328 list_.remove(self);
1329 break;
1330 }
Ian Rogersa2af5c72014-09-15 15:17:07 -07001331 }
Ian Rogers68d8b422014-07-17 11:09:10 -07001332 }
Juju Sung3fef44a2019-01-07 18:18:16 +08001333 // In the case where we are not suspended yet, sleep to leave other threads time to execute.
1334 // This is important if there are realtime threads. b/111277984
1335 usleep(1);
Mathieu Chartier91e56692015-03-03 13:51:04 -08001336 // We failed to remove the thread due to a suspend request, loop and try again.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001337 }
Mathieu Chartier91e56692015-03-03 13:51:04 -08001338 delete self;
1339
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -08001340 // Release the thread ID after the thread is finished and deleted to avoid cases where we can
1341 // temporarily have multiple threads with the same thread id. When this occurs, it causes
1342 // problems in FindThreadByThreadId / SuspendThreadByThreadId.
1343 ReleaseThreadId(nullptr, thin_lock_id);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001344
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001345 // Clear the TLS data, so that the underlying native thread is recognizably detached.
1346 // (It may wish to reattach later.)
Andreas Gampea47a6e82019-07-24 09:46:16 -07001347#ifdef __BIONIC__
Andreas Gampe4382f1e2015-08-05 01:08:53 +00001348 __get_tls()[TLS_SLOT_ART_THREAD_SELF] = nullptr;
1349#else
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001350 CHECK_PTHREAD_CALL(pthread_setspecific, (Thread::pthread_key_self_, nullptr), "detach self");
Andreas Gampe82372002019-07-24 15:42:09 -07001351 Thread::self_tls_ = nullptr;
Andreas Gampe4382f1e2015-08-05 01:08:53 +00001352#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001353
1354 // Signal that a thread just detached.
Mathieu Chartier91e56692015-03-03 13:51:04 -08001355 MutexLock mu(nullptr, *Locks::thread_list_lock_);
1356 --unregistering_count_;
1357 Locks::thread_exit_cond_->Broadcast(nullptr);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001358}
1359
1360void ThreadList::ForEach(void (*callback)(Thread*, void*), void* context) {
Mathieu Chartier02e25112013-08-14 16:14:24 -07001361 for (const auto& thread : list_) {
1362 callback(thread, context);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001363 }
1364}
1365
Mathieu Chartierf8a86b92016-06-14 17:08:47 -07001366void ThreadList::VisitRootsForSuspendedThreads(RootVisitor* visitor) {
1367 Thread* const self = Thread::Current();
1368 std::vector<Thread*> threads_to_visit;
1369
1370 // Tell threads to suspend and copy them into list.
1371 {
1372 MutexLock mu(self, *Locks::thread_list_lock_);
1373 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
1374 for (Thread* thread : list_) {
Alex Light46f93402017-06-29 11:59:50 -07001375 bool suspended = thread->ModifySuspendCount(self, +1, nullptr, SuspendReason::kInternal);
Sebastien Hertz1c8f4ff2017-04-14 15:05:12 +02001376 DCHECK(suspended);
Mathieu Chartierf8a86b92016-06-14 17:08:47 -07001377 if (thread == self || thread->IsSuspended()) {
1378 threads_to_visit.push_back(thread);
1379 } else {
Alex Light46f93402017-06-29 11:59:50 -07001380 bool resumed = thread->ModifySuspendCount(self, -1, nullptr, SuspendReason::kInternal);
Sebastien Hertz1c8f4ff2017-04-14 15:05:12 +02001381 DCHECK(resumed);
Mathieu Chartierf8a86b92016-06-14 17:08:47 -07001382 }
1383 }
1384 }
1385
1386 // Visit roots without holding thread_list_lock_ and thread_suspend_count_lock_ to prevent lock
1387 // order violations.
1388 for (Thread* thread : threads_to_visit) {
Andreas Gampe513061a2017-06-01 09:17:34 -07001389 thread->VisitRoots(visitor, kVisitRootFlagAllRoots);
Mathieu Chartierf8a86b92016-06-14 17:08:47 -07001390 }
1391
1392 // Restore suspend counts.
1393 {
1394 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
1395 for (Thread* thread : threads_to_visit) {
Alex Light46f93402017-06-29 11:59:50 -07001396 bool updated = thread->ModifySuspendCount(self, -1, nullptr, SuspendReason::kInternal);
Sebastien Hertz1c8f4ff2017-04-14 15:05:12 +02001397 DCHECK(updated);
Mathieu Chartierf8a86b92016-06-14 17:08:47 -07001398 }
1399 }
1400}
1401
Andreas Gampe585da952016-12-02 14:52:29 -08001402void ThreadList::VisitRoots(RootVisitor* visitor, VisitRootFlags flags) const {
Ian Rogers81d425b2012-09-27 16:03:43 -07001403 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001404 for (const auto& thread : list_) {
Andreas Gampe585da952016-12-02 14:52:29 -08001405 thread->VisitRoots(visitor, flags);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001406 }
Elliott Hughes038a8062011-09-18 14:12:41 -07001407}
1408
Nicolas Geoffraye3f775b2019-12-04 14:41:52 +00001409void ThreadList::SweepInterpreterCaches(IsMarkedVisitor* visitor) const {
1410 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
1411 for (const auto& thread : list_) {
1412 thread->SweepInterpreterCache(visitor);
1413 }
1414}
1415
Alex Light55eccdf2019-10-07 13:51:13 +00001416void ThreadList::VisitReflectiveTargets(ReflectiveValueVisitor *visitor) const {
1417 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
1418 for (const auto& thread : list_) {
1419 thread->VisitReflectiveTargets(visitor);
1420 }
1421}
1422
Ian Rogerscfaa4552012-11-26 21:00:08 -08001423uint32_t ThreadList::AllocThreadId(Thread* self) {
Chao-ying Fu9e369312014-05-21 11:20:52 -07001424 MutexLock mu(self, *Locks::allocated_thread_ids_lock_);
Elliott Hughes8daa0922011-09-11 13:46:25 -07001425 for (size_t i = 0; i < allocated_ids_.size(); ++i) {
1426 if (!allocated_ids_[i]) {
1427 allocated_ids_.set(i);
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001428 return i + 1; // Zero is reserved to mean "invalid".
Elliott Hughes8daa0922011-09-11 13:46:25 -07001429 }
1430 }
1431 LOG(FATAL) << "Out of internal thread ids";
Elliott Hughesc1896c92018-11-29 11:33:18 -08001432 UNREACHABLE();
Elliott Hughes8daa0922011-09-11 13:46:25 -07001433}
1434
Ian Rogerscfaa4552012-11-26 21:00:08 -08001435void ThreadList::ReleaseThreadId(Thread* self, uint32_t id) {
Chao-ying Fu9e369312014-05-21 11:20:52 -07001436 MutexLock mu(self, *Locks::allocated_thread_ids_lock_);
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001437 --id; // Zero is reserved to mean "invalid".
Elliott Hughes8daa0922011-09-11 13:46:25 -07001438 DCHECK(allocated_ids_[id]) << id;
1439 allocated_ids_.reset(id);
1440}
1441
Mathieu Chartier4f55e222015-09-04 13:26:21 -07001442ScopedSuspendAll::ScopedSuspendAll(const char* cause, bool long_suspend) {
1443 Runtime::Current()->GetThreadList()->SuspendAll(cause, long_suspend);
1444}
1445
1446ScopedSuspendAll::~ScopedSuspendAll() {
1447 Runtime::Current()->GetThreadList()->ResumeAll();
1448}
1449
Elliott Hughes8daa0922011-09-11 13:46:25 -07001450} // namespace art