blob: ab1f198646a9bbc4f5a2c8a93e38aa021e30bb35 [file] [log] [blame]
Elliott Hughes8daa0922011-09-11 13:46:25 -07001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "thread_list.h"
18
Christopher Ferris6cff48f2014-01-26 21:36:13 -080019#include <backtrace/BacktraceMap.h>
Elliott Hughesabbe07d2012-06-05 17:42:23 -070020#include <dirent.h>
Ian Rogersd9c4fc92013-10-01 19:45:43 -070021#include <ScopedLocalRef.h>
22#include <ScopedUtfChars.h>
Elliott Hughesabbe07d2012-06-05 17:42:23 -070023#include <sys/types.h>
Elliott Hughes038a8062011-09-18 14:12:41 -070024#include <unistd.h>
25
Ian Rogersc7dd2952014-10-21 23:31:19 -070026#include <sstream>
27
Mathieu Chartier70a596d2014-12-17 14:56:47 -080028#include "base/histogram-inl.h"
Hiroshi Yamauchi967a0ad2013-09-10 16:24:21 -070029#include "base/mutex-inl.h"
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -080030#include "base/systrace.h"
Vladimir Marko80afd022015-05-19 18:08:00 +010031#include "base/time_utils.h"
Sameer Abu Asala8439542013-02-14 16:06:42 -080032#include "base/timing_logger.h"
Elliott Hughes475fc232011-10-25 15:00:35 -070033#include "debugger.h"
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -070034#include "gc/collector/concurrent_copying.h"
Ian Rogersd9c4fc92013-10-01 19:45:43 -070035#include "jni_internal.h"
36#include "lock_word.h"
37#include "monitor.h"
Andreas Gampe5dd44d02016-08-02 17:20:03 -070038#include "native_stack_dump.h"
Ian Rogersd9c4fc92013-10-01 19:45:43 -070039#include "scoped_thread_state_change.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080040#include "thread.h"
Jeff Haoe094b872014-10-14 13:12:01 -070041#include "trace.h"
Ian Rogersd9c4fc92013-10-01 19:45:43 -070042#include "well_known_classes.h"
Elliott Hughes475fc232011-10-25 15:00:35 -070043
Yu Lieac44242015-06-29 10:50:03 +080044#if ART_USE_FUTEXES
45#include "linux/futex.h"
46#include "sys/syscall.h"
47#ifndef SYS_futex
48#define SYS_futex __NR_futex
49#endif
50#endif // ART_USE_FUTEXES
51
Elliott Hughes8daa0922011-09-11 13:46:25 -070052namespace art {
53
Mathieu Chartier251755c2014-07-15 18:10:25 -070054static constexpr uint64_t kLongThreadSuspendThreshold = MsToNs(5);
Mathieu Chartier99143862015-02-03 14:26:46 -080055static constexpr uint64_t kThreadSuspendTimeoutMs = 30 * 1000; // 30s.
56// Use 0 since we want to yield to prevent blocking for an unpredictable amount of time.
57static constexpr useconds_t kThreadSuspendInitialSleepUs = 0;
58static constexpr useconds_t kThreadSuspendMaxYieldUs = 3000;
59static constexpr useconds_t kThreadSuspendMaxSleepUs = 5000;
Mathieu Chartier251755c2014-07-15 18:10:25 -070060
Andreas Gampe8d1594d2016-03-01 14:38:37 -080061// Whether we should try to dump the native stack of unattached threads. See commit ed8b723 for
62// some history.
Andreas Gampea3e8fc32016-06-13 16:15:33 -070063// Turned off again. b/29248079
64static constexpr bool kDumpUnattachedThreadNativeStack = false;
Andreas Gampe8d1594d2016-03-01 14:38:37 -080065
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -080066ThreadList::ThreadList()
Mathieu Chartierb56200b2015-10-29 10:41:51 -070067 : suspend_all_count_(0),
68 debug_suspend_all_count_(0),
69 unregistering_count_(0),
70 suspend_all_historam_("suspend all histogram", 16, 64),
71 long_suspend_(false) {
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -080072 CHECK(Monitor::IsValidLockWord(LockWord::FromThinLockId(kMaxThreadId, 1, 0U)));
Elliott Hughes8daa0922011-09-11 13:46:25 -070073}
74
75ThreadList::~ThreadList() {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -080076 ScopedTrace trace(__PRETTY_FUNCTION__);
Elliott Hughese52e49b2012-04-02 16:05:44 -070077 // Detach the current thread if necessary. If we failed to start, there might not be any threads.
Elliott Hughes6a144332012-04-03 13:07:11 -070078 // We need to detach the current thread here in case there's another thread waiting to join with
79 // us.
Mathieu Chartierfec72f42014-10-09 12:57:58 -070080 bool contains = false;
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -080081 Thread* self = Thread::Current();
Mathieu Chartierfec72f42014-10-09 12:57:58 -070082 {
Mathieu Chartierfec72f42014-10-09 12:57:58 -070083 MutexLock mu(self, *Locks::thread_list_lock_);
84 contains = Contains(self);
85 }
86 if (contains) {
Elliott Hughes8daa0922011-09-11 13:46:25 -070087 Runtime::Current()->DetachCurrentThread();
88 }
Elliott Hughes6a144332012-04-03 13:07:11 -070089 WaitForOtherNonDaemonThreadsToExit();
Mathieu Chartier51168372015-08-12 16:40:32 -070090 // Disable GC and wait for GC to complete in case there are still daemon threads doing
91 // allocations.
92 gc::Heap* const heap = Runtime::Current()->GetHeap();
93 heap->DisableGCForShutdown();
94 // In case a GC is in progress, wait for it to finish.
95 heap->WaitForGcToComplete(gc::kGcCauseBackground, Thread::Current());
Ian Rogers00f7d0e2012-07-19 15:28:27 -070096 // TODO: there's an unaddressed race here where a thread may attach during shutdown, see
97 // Thread::Init.
Mathieu Chartier4d87df62016-01-07 15:14:19 -080098 SuspendAllDaemonThreadsForShutdown();
Elliott Hughes8daa0922011-09-11 13:46:25 -070099}
100
101bool ThreadList::Contains(Thread* thread) {
102 return find(list_.begin(), list_.end(), thread) != list_.end();
103}
104
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700105bool ThreadList::Contains(pid_t tid) {
Mathieu Chartier02e25112013-08-14 16:14:24 -0700106 for (const auto& thread : list_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700107 if (thread->GetTid() == tid) {
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700108 return true;
109 }
110 }
111 return false;
112}
113
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -0700114pid_t ThreadList::GetLockOwner() {
Ian Rogersb726dcb2012-09-05 08:57:23 -0700115 return Locks::thread_list_lock_->GetExclusiveOwnerTid();
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700116}
117
Mathieu Chartier590fee92013-09-13 13:46:47 -0700118void ThreadList::DumpNativeStacks(std::ostream& os) {
119 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
Christopher Ferris6cff48f2014-01-26 21:36:13 -0800120 std::unique_ptr<BacktraceMap> map(BacktraceMap::Create(getpid()));
Mathieu Chartier590fee92013-09-13 13:46:47 -0700121 for (const auto& thread : list_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700122 os << "DUMPING THREAD " << thread->GetTid() << "\n";
Christopher Ferris6cff48f2014-01-26 21:36:13 -0800123 DumpNativeStack(os, thread->GetTid(), map.get(), "\t");
Mathieu Chartier590fee92013-09-13 13:46:47 -0700124 os << "\n";
125 }
126}
127
Elliott Hughesc967f782012-04-16 10:23:15 -0700128void ThreadList::DumpForSigQuit(std::ostream& os) {
Mathieu Chartier70a596d2014-12-17 14:56:47 -0800129 {
130 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartier23f6e692014-12-18 18:24:39 -0800131 // Only print if we have samples.
132 if (suspend_all_historam_.SampleSize() > 0) {
133 Histogram<uint64_t>::CumulativeData data;
134 suspend_all_historam_.CreateHistogram(&data);
135 suspend_all_historam_.PrintConfidenceIntervals(os, 0.99, data); // Dump time to suspend.
136 }
Mathieu Chartier70a596d2014-12-17 14:56:47 -0800137 }
Nicolas Geoffrayd3c59652016-03-17 09:35:04 +0000138 bool dump_native_stack = Runtime::Current()->GetDumpNativeStackOnSigQuit();
139 Dump(os, dump_native_stack);
140 DumpUnattachedThreads(os, dump_native_stack);
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700141}
142
Nicolas Geoffrayd3c59652016-03-17 09:35:04 +0000143static void DumpUnattachedThread(std::ostream& os, pid_t tid, bool dump_native_stack)
144 NO_THREAD_SAFETY_ANALYSIS {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700145 // TODO: No thread safety analysis as DumpState with a null thread won't access fields, should
Ian Rogerscfaa4552012-11-26 21:00:08 -0800146 // refactor DumpState to avoid skipping analysis.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700147 Thread::DumpState(os, nullptr, tid);
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700148 DumpKernelStack(os, tid, " kernel: ", false);
Nicolas Geoffrayd3c59652016-03-17 09:35:04 +0000149 if (dump_native_stack && kDumpUnattachedThreadNativeStack) {
Christopher Ferris6cff48f2014-01-26 21:36:13 -0800150 DumpNativeStack(os, tid, nullptr, " native: ");
Brian Carlstromed8b7232012-06-27 17:54:47 -0700151 }
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700152 os << "\n";
153}
154
Nicolas Geoffrayd3c59652016-03-17 09:35:04 +0000155void ThreadList::DumpUnattachedThreads(std::ostream& os, bool dump_native_stack) {
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700156 DIR* d = opendir("/proc/self/task");
157 if (!d) {
158 return;
159 }
160
Ian Rogers50b35e22012-10-04 10:09:15 -0700161 Thread* self = Thread::Current();
Elliott Hughes4696b5b2012-10-30 10:35:10 -0700162 dirent* e;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700163 while ((e = readdir(d)) != nullptr) {
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700164 char* end;
Elliott Hughes4696b5b2012-10-30 10:35:10 -0700165 pid_t tid = strtol(e->d_name, &end, 10);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700166 if (!*end) {
167 bool contains;
168 {
Ian Rogers50b35e22012-10-04 10:09:15 -0700169 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700170 contains = Contains(tid);
171 }
172 if (!contains) {
Nicolas Geoffrayd3c59652016-03-17 09:35:04 +0000173 DumpUnattachedThread(os, tid, dump_native_stack);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700174 }
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700175 }
176 }
177 closedir(d);
Elliott Hughesff738062012-02-03 15:00:42 -0800178}
179
Mathieu Chartier47c19592016-03-07 11:59:01 -0800180// Dump checkpoint timeout in milliseconds. Larger amount on the target, since the device could be
181// overloaded with ANR dumps.
182static constexpr uint32_t kDumpWaitTimeout = kIsTargetBuild ? 100000 : 20000;
Andreas Gampe4a3d19b2015-01-09 17:54:51 -0800183
Ian Rogers7b078e82014-09-10 14:44:24 -0700184// A closure used by Thread::Dump.
185class DumpCheckpoint FINAL : public Closure {
186 public:
Nicolas Geoffraya73280d2016-02-15 13:05:16 +0000187 DumpCheckpoint(std::ostream* os, bool dump_native_stack)
188 : os_(os),
189 barrier_(0),
190 backtrace_map_(dump_native_stack ? BacktraceMap::Create(getpid()) : nullptr),
191 dump_native_stack_(dump_native_stack) {}
Ian Rogers7b078e82014-09-10 14:44:24 -0700192
193 void Run(Thread* thread) OVERRIDE {
194 // Note thread and self may not be equal if thread was already suspended at the point of the
195 // request.
196 Thread* self = Thread::Current();
197 std::ostringstream local_os;
198 {
199 ScopedObjectAccess soa(self);
Nicolas Geoffraya73280d2016-02-15 13:05:16 +0000200 thread->Dump(local_os, dump_native_stack_, backtrace_map_.get());
Ian Rogers7b078e82014-09-10 14:44:24 -0700201 }
202 local_os << "\n";
203 {
204 // Use the logging lock to ensure serialization when writing to the common ostream.
205 MutexLock mu(self, *Locks::logging_lock_);
206 *os_ << local_os.str();
207 }
Mathieu Chartier10d25082015-10-28 18:36:09 -0700208 barrier_.Pass(self);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700209 }
Ian Rogers7b078e82014-09-10 14:44:24 -0700210
211 void WaitForThreadsToRunThroughCheckpoint(size_t threads_running_checkpoint) {
212 Thread* self = Thread::Current();
213 ScopedThreadStateChange tsc(self, kWaitingForCheckPointsToRun);
Andreas Gampe1e4b0ca2015-01-14 09:06:32 -0800214 bool timed_out = barrier_.Increment(self, threads_running_checkpoint, kDumpWaitTimeout);
Ian Rogers2156ff12014-09-13 19:20:54 -0700215 if (timed_out) {
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000216 // Avoid a recursive abort.
217 LOG((kIsDebugBuild && (gAborting == 0)) ? FATAL : ERROR)
218 << "Unexpected time out during dump checkpoint.";
Ian Rogers2156ff12014-09-13 19:20:54 -0700219 }
Ian Rogers7b078e82014-09-10 14:44:24 -0700220 }
221
222 private:
223 // The common stream that will accumulate all the dumps.
224 std::ostream* const os_;
225 // The barrier to be passed through and for the requestor to wait upon.
226 Barrier barrier_;
Christopher Ferris6cff48f2014-01-26 21:36:13 -0800227 // A backtrace map, so that all threads use a shared info and don't reacquire/parse separately.
228 std::unique_ptr<BacktraceMap> backtrace_map_;
Nicolas Geoffraya73280d2016-02-15 13:05:16 +0000229 // Whether we should dump the native stack.
230 const bool dump_native_stack_;
Ian Rogers7b078e82014-09-10 14:44:24 -0700231};
232
Nicolas Geoffraya73280d2016-02-15 13:05:16 +0000233void ThreadList::Dump(std::ostream& os, bool dump_native_stack) {
Ian Rogers7b078e82014-09-10 14:44:24 -0700234 {
235 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
236 os << "DALVIK THREADS (" << list_.size() << "):\n";
237 }
Nicolas Geoffraya73280d2016-02-15 13:05:16 +0000238 DumpCheckpoint checkpoint(&os, dump_native_stack);
Mathieu Chartiere99f5322016-06-10 17:04:20 -0700239 size_t threads_running_checkpoint;
240 {
241 // Use SOA to prevent deadlocks if multiple threads are calling Dump() at the same time.
242 ScopedObjectAccess soa(Thread::Current());
243 threads_running_checkpoint = RunCheckpoint(&checkpoint);
244 }
Lei Lidd9943d2015-02-02 14:24:44 +0800245 if (threads_running_checkpoint != 0) {
246 checkpoint.WaitForThreadsToRunThroughCheckpoint(threads_running_checkpoint);
247 }
Elliott Hughes8daa0922011-09-11 13:46:25 -0700248}
249
Ian Rogers50b35e22012-10-04 10:09:15 -0700250void ThreadList::AssertThreadsAreSuspended(Thread* self, Thread* ignore1, Thread* ignore2) {
251 MutexLock mu(self, *Locks::thread_list_lock_);
252 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -0700253 for (const auto& thread : list_) {
jeffhao725a9572012-11-13 18:20:12 -0800254 if (thread != ignore1 && thread != ignore2) {
Ian Rogers01ae5802012-09-28 16:14:01 -0700255 CHECK(thread->IsSuspended())
256 << "\nUnsuspended thread: <<" << *thread << "\n"
257 << "self: <<" << *Thread::Current();
258 }
Elliott Hughes8d768a92011-09-14 16:35:25 -0700259 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700260}
261
Ian Rogers66aee5c2012-08-15 17:17:47 -0700262#if HAVE_TIMED_RWLOCK
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700263// Attempt to rectify locks so that we dump thread list with required locks before exiting.
Andreas Gampe794ad762015-02-23 08:12:24 -0800264NO_RETURN static void UnsafeLogFatalForThreadSuspendAllTimeout() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700265 Runtime* runtime = Runtime::Current();
266 std::ostringstream ss;
267 ss << "Thread suspend timeout\n";
Mathieu Chartier5869a2c2014-10-08 14:26:23 -0700268 Locks::mutator_lock_->Dump(ss);
269 ss << "\n";
Ian Rogers7b078e82014-09-10 14:44:24 -0700270 runtime->GetThreadList()->Dump(ss);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700271 LOG(FATAL) << ss.str();
Ian Rogers719d1a32014-03-06 12:13:39 -0800272 exit(0);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700273}
Ian Rogers66aee5c2012-08-15 17:17:47 -0700274#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700275
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800276// Unlike suspending all threads where we can wait to acquire the mutator_lock_, suspending an
Mathieu Chartier99143862015-02-03 14:26:46 -0800277// individual thread requires polling. delay_us is the requested sleep wait. If delay_us is 0 then
278// we use sched_yield instead of calling usleep.
279static void ThreadSuspendSleep(useconds_t delay_us) {
280 if (delay_us == 0) {
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800281 sched_yield();
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800282 } else {
Mathieu Chartier99143862015-02-03 14:26:46 -0800283 usleep(delay_us);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800284 }
285}
286
Mathieu Chartier0e4627e2012-10-23 16:13:36 -0700287size_t ThreadList::RunCheckpoint(Closure* checkpoint_function) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700288 Thread* self = Thread::Current();
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800289 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
290 Locks::thread_list_lock_->AssertNotHeld(self);
291 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700292
293 std::vector<Thread*> suspended_count_modified_threads;
294 size_t count = 0;
295 {
296 // Call a checkpoint function for each thread, threads which are suspend get their checkpoint
297 // manually called.
298 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700299 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier10d25082015-10-28 18:36:09 -0700300 count = list_.size();
Mathieu Chartier02e25112013-08-14 16:14:24 -0700301 for (const auto& thread : list_) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700302 if (thread != self) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700303 while (true) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700304 if (thread->RequestCheckpoint(checkpoint_function)) {
Dave Allison0aded082013-11-07 13:15:11 -0800305 // This thread will run its checkpoint some time in the near future.
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700306 break;
307 } else {
308 // We are probably suspended, try to make sure that we stay suspended.
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700309 // The thread switched back to runnable.
310 if (thread->GetState() == kRunnable) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700311 // Spurious fail, try again.
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700312 continue;
313 }
Yu Lieac44242015-06-29 10:50:03 +0800314 thread->ModifySuspendCount(self, +1, nullptr, false);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700315 suspended_count_modified_threads.push_back(thread);
316 break;
317 }
318 }
319 }
320 }
321 }
322
323 // Run the checkpoint on ourself while we wait for threads to suspend.
324 checkpoint_function->Run(self);
325
326 // Run the checkpoint on the suspended threads.
Mathieu Chartier02e25112013-08-14 16:14:24 -0700327 for (const auto& thread : suspended_count_modified_threads) {
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700328 if (!thread->IsSuspended()) {
Mathieu Chartier99143862015-02-03 14:26:46 -0800329 if (ATRACE_ENABLED()) {
330 std::ostringstream oss;
331 thread->ShortDump(oss);
332 ATRACE_BEGIN((std::string("Waiting for suspension of thread ") + oss.str()).c_str());
333 }
334 // Busy wait until the thread is suspended.
335 const uint64_t start_time = NanoTime();
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700336 do {
Mathieu Chartier99143862015-02-03 14:26:46 -0800337 ThreadSuspendSleep(kThreadSuspendInitialSleepUs);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700338 } while (!thread->IsSuspended());
Mathieu Chartier99143862015-02-03 14:26:46 -0800339 const uint64_t total_delay = NanoTime() - start_time;
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800340 // Shouldn't need to wait for longer than 1000 microseconds.
Mathieu Chartier99143862015-02-03 14:26:46 -0800341 constexpr uint64_t kLongWaitThreshold = MsToNs(1);
342 ATRACE_END();
343 if (UNLIKELY(total_delay > kLongWaitThreshold)) {
344 LOG(WARNING) << "Long wait of " << PrettyDuration(total_delay) << " for "
345 << *thread << " suspension!";
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700346 }
347 }
348 // We know for sure that the thread is suspended at this point.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700349 checkpoint_function->Run(thread);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700350 {
351 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Yu Lieac44242015-06-29 10:50:03 +0800352 thread->ModifySuspendCount(self, -1, nullptr, false);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700353 }
354 }
355
Mathieu Chartier664bebf2012-11-12 16:54:11 -0800356 {
357 // Imitate ResumeAll, threads may be waiting on Thread::resume_cond_ since we raised their
358 // suspend count. Now the suspend_count_ is lowered so we must do the broadcast.
359 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
360 Thread::resume_cond_->Broadcast(self);
361 }
362
Lei Lidd9943d2015-02-02 14:24:44 +0800363 return count;
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700364}
365
Dave Allison39c3bfb2014-01-28 18:33:52 -0800366// Request that a checkpoint function be run on all active (non-suspended)
367// threads. Returns the number of successful requests.
368size_t ThreadList::RunCheckpointOnRunnableThreads(Closure* checkpoint_function) {
369 Thread* self = Thread::Current();
Ian Rogers7b078e82014-09-10 14:44:24 -0700370 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
371 Locks::thread_list_lock_->AssertNotHeld(self);
372 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
373 CHECK_NE(self->GetState(), kRunnable);
Dave Allison39c3bfb2014-01-28 18:33:52 -0800374
375 size_t count = 0;
376 {
377 // Call a checkpoint function for each non-suspended thread.
378 MutexLock mu(self, *Locks::thread_list_lock_);
379 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
380 for (const auto& thread : list_) {
381 if (thread != self) {
382 if (thread->RequestCheckpoint(checkpoint_function)) {
383 // This thread will run its checkpoint some time in the near future.
384 count++;
385 }
386 }
387 }
388 }
389
390 // Return the number of threads that will run the checkpoint function.
391 return count;
392}
393
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800394// A checkpoint/suspend-all hybrid to switch thread roots from
395// from-space to to-space refs. Used to synchronize threads at a point
396// to mark the initiation of marking while maintaining the to-space
397// invariant.
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700398size_t ThreadList::FlipThreadRoots(Closure* thread_flip_visitor,
399 Closure* flip_callback,
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800400 gc::collector::GarbageCollector* collector) {
401 TimingLogger::ScopedTiming split("ThreadListFlip", collector->GetTimings());
402 const uint64_t start_time = NanoTime();
403 Thread* self = Thread::Current();
404 Locks::mutator_lock_->AssertNotHeld(self);
405 Locks::thread_list_lock_->AssertNotHeld(self);
406 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
407 CHECK_NE(self->GetState(), kRunnable);
408
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700409 collector->GetHeap()->ThreadFlipBegin(self); // Sync with JNI critical calls.
410
Mathieu Chartierb19ccb12015-07-15 10:24:16 -0700411 SuspendAllInternal(self, self, nullptr);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800412
413 // Run the flip callback for the collector.
414 Locks::mutator_lock_->ExclusiveLock(self);
415 flip_callback->Run(self);
416 Locks::mutator_lock_->ExclusiveUnlock(self);
417 collector->RegisterPause(NanoTime() - start_time);
418
419 // Resume runnable threads.
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700420 size_t runnable_thread_count = 0;
Mathieu Chartierb19ccb12015-07-15 10:24:16 -0700421 std::vector<Thread*> other_threads;
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800422 {
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700423 TimingLogger::ScopedTiming split2("ResumeRunnableThreads", collector->GetTimings());
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800424 MutexLock mu(self, *Locks::thread_list_lock_);
425 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
426 --suspend_all_count_;
427 for (const auto& thread : list_) {
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700428 // Set the flip function for all threads because Thread::DumpState/DumpJavaStack() (invoked by
429 // a checkpoint) may cause the flip function to be run for a runnable/suspended thread before
430 // a runnable thread runs it for itself or we run it for a suspended thread below.
431 thread->SetFlipFunction(thread_flip_visitor);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800432 if (thread == self) {
433 continue;
434 }
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700435 // Resume early the threads that were runnable but are suspended just for this thread flip or
436 // about to transition from non-runnable (eg. kNative at the SOA entry in a JNI function) to
437 // runnable (both cases waiting inside Thread::TransitionFromSuspendedToRunnable), or waiting
438 // for the thread flip to end at the JNI critical section entry (kWaitingForGcThreadFlip),
439 ThreadState state = thread->GetState();
440 if (state == kWaitingForGcThreadFlip ||
441 thread->IsTransitioningToRunnable()) {
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800442 // The thread will resume right after the broadcast.
Yu Lieac44242015-06-29 10:50:03 +0800443 thread->ModifySuspendCount(self, -1, nullptr, false);
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700444 ++runnable_thread_count;
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800445 } else {
446 other_threads.push_back(thread);
447 }
448 }
449 Thread::resume_cond_->Broadcast(self);
450 }
451
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700452 collector->GetHeap()->ThreadFlipEnd(self);
453
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800454 // Run the closure on the other threads and let them resume.
455 {
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700456 TimingLogger::ScopedTiming split3("FlipOtherThreads", collector->GetTimings());
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800457 ReaderMutexLock mu(self, *Locks::mutator_lock_);
458 for (const auto& thread : other_threads) {
459 Closure* flip_func = thread->GetFlipFunction();
460 if (flip_func != nullptr) {
461 flip_func->Run(thread);
462 }
463 }
464 // Run it for self.
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700465 Closure* flip_func = self->GetFlipFunction();
466 if (flip_func != nullptr) {
467 flip_func->Run(self);
468 }
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800469 }
470
471 // Resume other threads.
472 {
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700473 TimingLogger::ScopedTiming split4("ResumeOtherThreads", collector->GetTimings());
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800474 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
475 for (const auto& thread : other_threads) {
Yu Lieac44242015-06-29 10:50:03 +0800476 thread->ModifySuspendCount(self, -1, nullptr, false);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800477 }
478 Thread::resume_cond_->Broadcast(self);
479 }
480
Hiroshi Yamauchiee235822016-08-19 17:03:27 -0700481 return runnable_thread_count + other_threads.size() + 1; // +1 for self.
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800482}
483
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700484void ThreadList::SuspendAll(const char* cause, bool long_suspend) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700485 Thread* self = Thread::Current();
486
Jeff Haoc5d824a2014-07-28 18:35:38 -0700487 if (self != nullptr) {
Mathieu Chartierbf9fc582015-03-13 17:21:25 -0700488 VLOG(threads) << *self << " SuspendAll for " << cause << " starting...";
Jeff Haoc5d824a2014-07-28 18:35:38 -0700489 } else {
Mathieu Chartierbf9fc582015-03-13 17:21:25 -0700490 VLOG(threads) << "Thread[null] SuspendAll for " << cause << " starting...";
Jeff Haoc5d824a2014-07-28 18:35:38 -0700491 }
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800492 {
493 ScopedTrace trace("Suspending mutator threads");
494 const uint64_t start_time = NanoTime();
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700495
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800496 SuspendAllInternal(self, self);
497 // All threads are known to have suspended (but a thread may still own the mutator lock)
498 // Make sure this thread grabs exclusive access to the mutator lock and its protected data.
Ian Rogers66aee5c2012-08-15 17:17:47 -0700499#if HAVE_TIMED_RWLOCK
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800500 while (true) {
501 if (Locks::mutator_lock_->ExclusiveLockWithTimeout(self, kThreadSuspendTimeoutMs, 0)) {
502 break;
503 } else if (!long_suspend_) {
504 // Reading long_suspend without the mutator lock is slightly racy, in some rare cases, this
505 // could result in a thread suspend timeout.
506 // Timeout if we wait more than kThreadSuspendTimeoutMs seconds.
507 UnsafeLogFatalForThreadSuspendAllTimeout();
508 }
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700509 }
Ian Rogers66aee5c2012-08-15 17:17:47 -0700510#else
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800511 Locks::mutator_lock_->ExclusiveLock(self);
Ian Rogers66aee5c2012-08-15 17:17:47 -0700512#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700513
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800514 long_suspend_ = long_suspend;
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700515
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800516 const uint64_t end_time = NanoTime();
517 const uint64_t suspend_time = end_time - start_time;
518 suspend_all_historam_.AdjustAndAddValue(suspend_time);
519 if (suspend_time > kLongThreadSuspendThreshold) {
520 LOG(WARNING) << "Suspending all threads took: " << PrettyDuration(suspend_time);
521 }
522
523 if (kDebugLocking) {
524 // Debug check that all threads are suspended.
525 AssertThreadsAreSuspended(self, self);
526 }
Mathieu Chartier251755c2014-07-15 18:10:25 -0700527 }
Mathieu Chartierbf9fc582015-03-13 17:21:25 -0700528 ATRACE_BEGIN((std::string("Mutator threads suspended for ") + cause).c_str());
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700529
Jeff Haoc5d824a2014-07-28 18:35:38 -0700530 if (self != nullptr) {
531 VLOG(threads) << *self << " SuspendAll complete";
532 } else {
533 VLOG(threads) << "Thread[null] SuspendAll complete";
534 }
Elliott Hughes8d768a92011-09-14 16:35:25 -0700535}
536
Yu Lieac44242015-06-29 10:50:03 +0800537// Ensures all threads running Java suspend and that those not running Java don't start.
538// Debugger thread might be set to kRunnable for a short period of time after the
539// SuspendAllInternal. This is safe because it will be set back to suspended state before
540// the SuspendAll returns.
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700541void ThreadList::SuspendAllInternal(Thread* self,
542 Thread* ignore1,
543 Thread* ignore2,
Yu Lieac44242015-06-29 10:50:03 +0800544 bool debug_suspend) {
545 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
546 Locks::thread_list_lock_->AssertNotHeld(self);
547 Locks::thread_suspend_count_lock_->AssertNotHeld(self);
548 if (kDebugLocking && self != nullptr) {
549 CHECK_NE(self->GetState(), kRunnable);
550 }
551
552 // First request that all threads suspend, then wait for them to suspend before
553 // returning. This suspension scheme also relies on other behaviour:
554 // 1. Threads cannot be deleted while they are suspended or have a suspend-
555 // request flag set - (see Unregister() below).
556 // 2. When threads are created, they are created in a suspended state (actually
557 // kNative) and will never begin executing Java code without first checking
558 // the suspend-request flag.
559
560 // The atomic counter for number of threads that need to pass the barrier.
561 AtomicInteger pending_threads;
562 uint32_t num_ignored = 0;
563 if (ignore1 != nullptr) {
564 ++num_ignored;
565 }
566 if (ignore2 != nullptr && ignore1 != ignore2) {
567 ++num_ignored;
568 }
569 {
570 MutexLock mu(self, *Locks::thread_list_lock_);
571 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
572 // Update global suspend all state for attaching threads.
573 ++suspend_all_count_;
574 if (debug_suspend)
575 ++debug_suspend_all_count_;
576 pending_threads.StoreRelaxed(list_.size() - num_ignored);
577 // Increment everybody's suspend count (except those that should be ignored).
578 for (const auto& thread : list_) {
579 if (thread == ignore1 || thread == ignore2) {
580 continue;
581 }
582 VLOG(threads) << "requesting thread suspend: " << *thread;
583 while (true) {
584 if (LIKELY(thread->ModifySuspendCount(self, +1, &pending_threads, debug_suspend))) {
585 break;
586 } else {
587 // Failure means the list of active_suspend_barriers is full, we should release the
588 // thread_suspend_count_lock_ (to avoid deadlock) and wait till the target thread has
589 // executed Thread::PassActiveSuspendBarriers(). Note that we could not simply wait for
590 // the thread to change to a suspended state, because it might need to run checkpoint
591 // function before the state change, which also needs thread_suspend_count_lock_.
592
593 // This is very unlikely to happen since more than kMaxSuspendBarriers threads need to
594 // execute SuspendAllInternal() simultaneously, and target thread stays in kRunnable
595 // in the mean time.
596 Locks::thread_suspend_count_lock_->ExclusiveUnlock(self);
597 NanoSleep(100000);
598 Locks::thread_suspend_count_lock_->ExclusiveLock(self);
599 }
600 }
601
602 // Must install the pending_threads counter first, then check thread->IsSuspend() and clear
603 // the counter. Otherwise there's a race with Thread::TransitionFromRunnableToSuspended()
604 // that can lead a thread to miss a call to PassActiveSuspendBarriers().
605 if (thread->IsSuspended()) {
606 // Only clear the counter for the current thread.
607 thread->ClearSuspendBarrier(&pending_threads);
608 pending_threads.FetchAndSubSequentiallyConsistent(1);
609 }
610 }
611 }
612
613 // Wait for the barrier to be passed by all runnable threads. This wait
614 // is done with a timeout so that we can detect problems.
Mathieu Chartier19af1172015-07-14 10:05:45 -0700615#if ART_USE_FUTEXES
Yu Lieac44242015-06-29 10:50:03 +0800616 timespec wait_timeout;
617 InitTimeSpec(true, CLOCK_MONOTONIC, 10000, 0, &wait_timeout);
Mathieu Chartier19af1172015-07-14 10:05:45 -0700618#endif
Yu Lieac44242015-06-29 10:50:03 +0800619 while (true) {
620 int32_t cur_val = pending_threads.LoadRelaxed();
621 if (LIKELY(cur_val > 0)) {
622#if ART_USE_FUTEXES
623 if (futex(pending_threads.Address(), FUTEX_WAIT, cur_val, &wait_timeout, nullptr, 0) != 0) {
624 // EAGAIN and EINTR both indicate a spurious failure, try again from the beginning.
625 if ((errno != EAGAIN) && (errno != EINTR)) {
626 if (errno == ETIMEDOUT) {
627 LOG(kIsDebugBuild ? FATAL : ERROR) << "Unexpected time out during suspend all.";
628 } else {
629 PLOG(FATAL) << "futex wait failed for SuspendAllInternal()";
630 }
631 }
Vladimir Markod778cd62016-07-05 17:29:55 +0100632 } // else re-check pending_threads in the next iteration (this may be a spurious wake-up).
Yu Lieac44242015-06-29 10:50:03 +0800633#else
634 // Spin wait. This is likely to be slow, but on most architecture ART_USE_FUTEXES is set.
635#endif
636 } else {
637 CHECK_EQ(cur_val, 0);
638 break;
639 }
640 }
641}
642
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700643void ThreadList::ResumeAll() {
644 Thread* self = Thread::Current();
645
Jeff Haoc5d824a2014-07-28 18:35:38 -0700646 if (self != nullptr) {
647 VLOG(threads) << *self << " ResumeAll starting";
648 } else {
649 VLOG(threads) << "Thread[null] ResumeAll starting";
650 }
Ian Rogers01ae5802012-09-28 16:14:01 -0700651
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700652 ATRACE_END();
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800653
654 ScopedTrace trace("Resuming mutator threads");
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700655
Mathieu Chartier6dda8982014-03-06 11:11:48 -0800656 if (kDebugLocking) {
657 // Debug check that all threads are suspended.
658 AssertThreadsAreSuspended(self, self);
659 }
Ian Rogers01ae5802012-09-28 16:14:01 -0700660
Mathieu Chartierbf44d422015-06-02 11:42:18 -0700661 long_suspend_ = false;
662
Ian Rogers81d425b2012-09-27 16:03:43 -0700663 Locks::mutator_lock_->ExclusiveUnlock(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700664 {
Ian Rogers81d425b2012-09-27 16:03:43 -0700665 MutexLock mu(self, *Locks::thread_list_lock_);
666 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700667 // Update global suspend all state for attaching threads.
668 --suspend_all_count_;
669 // Decrement the suspend counts for all threads.
Mathieu Chartier02e25112013-08-14 16:14:24 -0700670 for (const auto& thread : list_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700671 if (thread == self) {
672 continue;
673 }
Yu Lieac44242015-06-29 10:50:03 +0800674 thread->ModifySuspendCount(self, -1, nullptr, false);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700675 }
676
677 // Broadcast a notification to all suspended threads, some or all of
678 // which may choose to wake up. No need to wait for them.
Jeff Haoc5d824a2014-07-28 18:35:38 -0700679 if (self != nullptr) {
680 VLOG(threads) << *self << " ResumeAll waking others";
681 } else {
682 VLOG(threads) << "Thread[null] ResumeAll waking others";
683 }
Ian Rogersc604d732012-10-14 16:09:54 -0700684 Thread::resume_cond_->Broadcast(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700685 }
Jeff Haoc5d824a2014-07-28 18:35:38 -0700686
687 if (self != nullptr) {
688 VLOG(threads) << *self << " ResumeAll complete";
689 } else {
690 VLOG(threads) << "Thread[null] ResumeAll complete";
691 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700692}
693
694void ThreadList::Resume(Thread* thread, bool for_debugger) {
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -0800695 // This assumes there was an ATRACE_BEGIN when we suspended the thread.
696 ATRACE_END();
697
Ian Rogers81d425b2012-09-27 16:03:43 -0700698 Thread* self = Thread::Current();
699 DCHECK_NE(thread, self);
Brian Carlstromba32de42014-08-27 23:43:46 -0700700 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") starting..."
701 << (for_debugger ? " (debugger)" : "");
Elliott Hughes01158d72011-09-19 19:47:10 -0700702
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700703 {
704 // To check Contains.
Ian Rogers81d425b2012-09-27 16:03:43 -0700705 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700706 // To check IsSuspended.
Ian Rogers81d425b2012-09-27 16:03:43 -0700707 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
708 DCHECK(thread->IsSuspended());
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700709 if (!Contains(thread)) {
Brian Carlstromba32de42014-08-27 23:43:46 -0700710 // We only expect threads within the thread-list to have been suspended otherwise we can't
711 // stop such threads from delete-ing themselves.
712 LOG(ERROR) << "Resume(" << reinterpret_cast<void*>(thread)
713 << ") thread not within thread list";
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700714 return;
715 }
Yu Lieac44242015-06-29 10:50:03 +0800716 thread->ModifySuspendCount(self, -1, nullptr, for_debugger);
Elliott Hughes01158d72011-09-19 19:47:10 -0700717 }
718
719 {
Brian Carlstromba32de42014-08-27 23:43:46 -0700720 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") waking others";
Ian Rogers81d425b2012-09-27 16:03:43 -0700721 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersc604d732012-10-14 16:09:54 -0700722 Thread::resume_cond_->Broadcast(self);
Elliott Hughes01158d72011-09-19 19:47:10 -0700723 }
724
Brian Carlstromba32de42014-08-27 23:43:46 -0700725 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") complete";
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700726}
Elliott Hughes01158d72011-09-19 19:47:10 -0700727
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700728static void ThreadSuspendByPeerWarning(Thread* self,
729 LogSeverity severity,
730 const char* message,
Ian Rogersc7dd2952014-10-21 23:31:19 -0700731 jobject peer) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700732 JNIEnvExt* env = self->GetJniEnv();
733 ScopedLocalRef<jstring>
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700734 scoped_name_string(env, static_cast<jstring>(env->GetObjectField(
735 peer, WellKnownClasses::java_lang_Thread_name)));
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700736 ScopedUtfChars scoped_name_chars(env, scoped_name_string.get());
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700737 if (scoped_name_chars.c_str() == nullptr) {
Ian Rogersc7dd2952014-10-21 23:31:19 -0700738 LOG(severity) << message << ": " << peer;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700739 env->ExceptionClear();
740 } else {
Ian Rogersc7dd2952014-10-21 23:31:19 -0700741 LOG(severity) << message << ": " << peer << ":" << scoped_name_chars.c_str();
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700742 }
743}
744
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700745Thread* ThreadList::SuspendThreadByPeer(jobject peer,
746 bool request_suspension,
747 bool debug_suspension,
748 bool* timed_out) {
Mathieu Chartier3a958aa2015-02-04 12:52:34 -0800749 const uint64_t start_time = NanoTime();
Mathieu Chartier99143862015-02-03 14:26:46 -0800750 useconds_t sleep_us = kThreadSuspendInitialSleepUs;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700751 *timed_out = false;
Mathieu Chartier99143862015-02-03 14:26:46 -0800752 Thread* const self = Thread::Current();
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800753 Thread* suspended_thread = nullptr;
Brian Carlstromba32de42014-08-27 23:43:46 -0700754 VLOG(threads) << "SuspendThreadByPeer starting";
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700755 while (true) {
756 Thread* thread;
757 {
Ian Rogersf3d874c2014-07-17 18:52:42 -0700758 // Note: this will transition to runnable and potentially suspend. We ensure only one thread
759 // is requesting another suspend, to avoid deadlock, by requiring this function be called
760 // holding Locks::thread_list_suspend_thread_lock_. Its important this thread suspend rather
761 // than request thread suspension, to avoid potential cycles in threads requesting each other
762 // suspend.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700763 ScopedObjectAccess soa(self);
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800764 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700765 thread = Thread::FromManagedThread(soa, peer);
Brian Carlstromba32de42014-08-27 23:43:46 -0700766 if (thread == nullptr) {
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800767 if (suspended_thread != nullptr) {
768 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
769 // If we incremented the suspend count but the thread reset its peer, we need to
770 // re-decrement it since it is shutting down and may deadlock the runtime in
771 // ThreadList::WaitForOtherNonDaemonThreadsToExit.
Yu Lieac44242015-06-29 10:50:03 +0800772 suspended_thread->ModifySuspendCount(soa.Self(), -1, nullptr, debug_suspension);
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800773 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700774 ThreadSuspendByPeerWarning(self, WARNING, "No such thread for suspend", peer);
Brian Carlstromba32de42014-08-27 23:43:46 -0700775 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700776 }
Brian Carlstromba32de42014-08-27 23:43:46 -0700777 if (!Contains(thread)) {
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800778 CHECK(suspended_thread == nullptr);
Brian Carlstromba32de42014-08-27 23:43:46 -0700779 VLOG(threads) << "SuspendThreadByPeer failed for unattached thread: "
780 << reinterpret_cast<void*>(thread);
781 return nullptr;
782 }
783 VLOG(threads) << "SuspendThreadByPeer found thread: " << *thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700784 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800785 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700786 if (request_suspension) {
Ian Rogers4ad5cd32014-11-11 23:08:07 -0800787 if (self->GetSuspendCount() > 0) {
788 // We hold the suspend count lock but another thread is trying to suspend us. Its not
789 // safe to try to suspend another thread in case we get a cycle. Start the loop again
790 // which will allow this thread to be suspended.
791 continue;
792 }
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800793 CHECK(suspended_thread == nullptr);
794 suspended_thread = thread;
Yu Lieac44242015-06-29 10:50:03 +0800795 suspended_thread->ModifySuspendCount(self, +1, nullptr, debug_suspension);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700796 request_suspension = false;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700797 } else {
798 // If the caller isn't requesting suspension, a suspension should have already occurred.
799 CHECK_GT(thread->GetSuspendCount(), 0);
800 }
801 // IsSuspended on the current thread will fail as the current thread is changed into
802 // Runnable above. As the suspend count is now raised if this is the current thread
803 // it will self suspend on transition to Runnable, making it hard to work with. It's simpler
804 // to just explicitly handle the current thread in the callers to this code.
805 CHECK_NE(thread, self) << "Attempt to suspend the current thread for the debugger";
806 // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend
807 // count, or else we've waited and it has self suspended) or is the current thread, we're
808 // done.
809 if (thread->IsSuspended()) {
Brian Carlstromba32de42014-08-27 23:43:46 -0700810 VLOG(threads) << "SuspendThreadByPeer thread suspended: " << *thread;
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -0800811 if (ATRACE_ENABLED()) {
812 std::string name;
813 thread->GetThreadName(name);
814 ATRACE_BEGIN(StringPrintf("SuspendThreadByPeer suspended %s for peer=%p", name.c_str(),
815 peer).c_str());
816 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700817 return thread;
818 }
Mathieu Chartier99143862015-02-03 14:26:46 -0800819 const uint64_t total_delay = NanoTime() - start_time;
820 if (total_delay >= MsToNs(kThreadSuspendTimeoutMs)) {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700821 ThreadSuspendByPeerWarning(self, FATAL, "Thread suspension timed out", peer);
Mathieu Chartier82a800d2014-12-15 15:59:49 -0800822 if (suspended_thread != nullptr) {
823 CHECK_EQ(suspended_thread, thread);
Yu Lieac44242015-06-29 10:50:03 +0800824 suspended_thread->ModifySuspendCount(soa.Self(), -1, nullptr, debug_suspension);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700825 }
826 *timed_out = true;
Brian Carlstromba32de42014-08-27 23:43:46 -0700827 return nullptr;
Mathieu Chartier99143862015-02-03 14:26:46 -0800828 } else if (sleep_us == 0 &&
829 total_delay > static_cast<uint64_t>(kThreadSuspendMaxYieldUs) * 1000) {
830 // We have spun for kThreadSuspendMaxYieldUs time, switch to sleeps to prevent
831 // excessive CPU usage.
832 sleep_us = kThreadSuspendMaxYieldUs / 2;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700833 }
834 }
835 // Release locks and come out of runnable state.
836 }
Mathieu Chartier99143862015-02-03 14:26:46 -0800837 VLOG(threads) << "SuspendThreadByPeer waiting to allow thread chance to suspend";
838 ThreadSuspendSleep(sleep_us);
839 // This may stay at 0 if sleep_us == 0, but this is WAI since we want to avoid using usleep at
840 // all if possible. This shouldn't be an issue since time to suspend should always be small.
841 sleep_us = std::min(sleep_us * 2, kThreadSuspendMaxSleepUs);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700842 }
843}
844
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700845static void ThreadSuspendByThreadIdWarning(LogSeverity severity,
846 const char* message,
Ian Rogersc7dd2952014-10-21 23:31:19 -0700847 uint32_t thread_id) {
848 LOG(severity) << StringPrintf("%s: %d", message, thread_id);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700849}
850
Mathieu Chartierb56200b2015-10-29 10:41:51 -0700851Thread* ThreadList::SuspendThreadByThreadId(uint32_t thread_id,
852 bool debug_suspension,
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700853 bool* timed_out) {
Mathieu Chartier3a958aa2015-02-04 12:52:34 -0800854 const uint64_t start_time = NanoTime();
Mathieu Chartier99143862015-02-03 14:26:46 -0800855 useconds_t sleep_us = kThreadSuspendInitialSleepUs;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700856 *timed_out = false;
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800857 Thread* suspended_thread = nullptr;
Mathieu Chartier99143862015-02-03 14:26:46 -0800858 Thread* const self = Thread::Current();
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700859 CHECK_NE(thread_id, kInvalidThreadId);
Brian Carlstromba32de42014-08-27 23:43:46 -0700860 VLOG(threads) << "SuspendThreadByThreadId starting";
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700861 while (true) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700862 {
Ian Rogersf3d874c2014-07-17 18:52:42 -0700863 // Note: this will transition to runnable and potentially suspend. We ensure only one thread
864 // is requesting another suspend, to avoid deadlock, by requiring this function be called
865 // holding Locks::thread_list_suspend_thread_lock_. Its important this thread suspend rather
866 // than request thread suspension, to avoid potential cycles in threads requesting each other
867 // suspend.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700868 ScopedObjectAccess soa(self);
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800869 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Ian Rogersf3d874c2014-07-17 18:52:42 -0700870 Thread* thread = nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700871 for (const auto& it : list_) {
872 if (it->GetThreadId() == thread_id) {
873 thread = it;
874 break;
875 }
876 }
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800877 if (thread == nullptr) {
878 CHECK(suspended_thread == nullptr) << "Suspended thread " << suspended_thread
879 << " no longer in thread list";
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700880 // There's a race in inflating a lock and the owner giving up ownership and then dying.
881 ThreadSuspendByThreadIdWarning(WARNING, "No such thread id for suspend", thread_id);
Brian Carlstromba32de42014-08-27 23:43:46 -0700882 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700883 }
Brian Carlstromba32de42014-08-27 23:43:46 -0700884 VLOG(threads) << "SuspendThreadByThreadId found thread: " << *thread;
885 DCHECK(Contains(thread));
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700886 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800887 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800888 if (suspended_thread == nullptr) {
Ian Rogers4ad5cd32014-11-11 23:08:07 -0800889 if (self->GetSuspendCount() > 0) {
890 // We hold the suspend count lock but another thread is trying to suspend us. Its not
891 // safe to try to suspend another thread in case we get a cycle. Start the loop again
892 // which will allow this thread to be suspended.
893 continue;
894 }
Yu Lieac44242015-06-29 10:50:03 +0800895 thread->ModifySuspendCount(self, +1, nullptr, debug_suspension);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800896 suspended_thread = thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700897 } else {
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800898 CHECK_EQ(suspended_thread, thread);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700899 // If the caller isn't requesting suspension, a suspension should have already occurred.
900 CHECK_GT(thread->GetSuspendCount(), 0);
901 }
902 // IsSuspended on the current thread will fail as the current thread is changed into
903 // Runnable above. As the suspend count is now raised if this is the current thread
904 // it will self suspend on transition to Runnable, making it hard to work with. It's simpler
905 // to just explicitly handle the current thread in the callers to this code.
906 CHECK_NE(thread, self) << "Attempt to suspend the current thread for the debugger";
907 // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend
908 // count, or else we've waited and it has self suspended) or is the current thread, we're
909 // done.
910 if (thread->IsSuspended()) {
Mathieu Chartierf0dc8b52014-12-17 10:13:30 -0800911 if (ATRACE_ENABLED()) {
912 std::string name;
913 thread->GetThreadName(name);
914 ATRACE_BEGIN(StringPrintf("SuspendThreadByThreadId suspended %s id=%d",
915 name.c_str(), thread_id).c_str());
916 }
Brian Carlstromba32de42014-08-27 23:43:46 -0700917 VLOG(threads) << "SuspendThreadByThreadId thread suspended: " << *thread;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700918 return thread;
919 }
Mathieu Chartier99143862015-02-03 14:26:46 -0800920 const uint64_t total_delay = NanoTime() - start_time;
921 if (total_delay >= MsToNs(kThreadSuspendTimeoutMs)) {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700922 ThreadSuspendByThreadIdWarning(WARNING, "Thread suspension timed out", thread_id);
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -0800923 if (suspended_thread != nullptr) {
Yu Lieac44242015-06-29 10:50:03 +0800924 thread->ModifySuspendCount(soa.Self(), -1, nullptr, debug_suspension);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700925 }
926 *timed_out = true;
Brian Carlstromba32de42014-08-27 23:43:46 -0700927 return nullptr;
Mathieu Chartier99143862015-02-03 14:26:46 -0800928 } else if (sleep_us == 0 &&
929 total_delay > static_cast<uint64_t>(kThreadSuspendMaxYieldUs) * 1000) {
930 // We have spun for kThreadSuspendMaxYieldUs time, switch to sleeps to prevent
931 // excessive CPU usage.
932 sleep_us = kThreadSuspendMaxYieldUs / 2;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700933 }
934 }
935 // Release locks and come out of runnable state.
936 }
Mathieu Chartier99143862015-02-03 14:26:46 -0800937 VLOG(threads) << "SuspendThreadByThreadId waiting to allow thread chance to suspend";
938 ThreadSuspendSleep(sleep_us);
939 sleep_us = std::min(sleep_us * 2, kThreadSuspendMaxSleepUs);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700940 }
941}
942
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700943Thread* ThreadList::FindThreadByThreadId(uint32_t thread_id) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700944 for (const auto& thread : list_) {
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700945 if (thread->GetThreadId() == thread_id) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700946 return thread;
947 }
948 }
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700949 return nullptr;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700950}
951
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700952void ThreadList::SuspendAllForDebugger() {
953 Thread* self = Thread::Current();
954 Thread* debug_thread = Dbg::GetDebugThread();
955
956 VLOG(threads) << *self << " SuspendAllForDebugger starting...";
957
Yu Lieac44242015-06-29 10:50:03 +0800958 SuspendAllInternal(self, self, debug_thread, true);
Ian Rogers66aee5c2012-08-15 17:17:47 -0700959 // Block on the mutator lock until all Runnable threads release their share of access then
960 // immediately unlock again.
961#if HAVE_TIMED_RWLOCK
962 // Timeout if we wait more than 30 seconds.
Ian Rogersc604d732012-10-14 16:09:54 -0700963 if (!Locks::mutator_lock_->ExclusiveLockWithTimeout(self, 30 * 1000, 0)) {
Sebastien Hertzbae182c2013-12-17 10:42:03 +0100964 UnsafeLogFatalForThreadSuspendAllTimeout();
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700965 } else {
Ian Rogers81d425b2012-09-27 16:03:43 -0700966 Locks::mutator_lock_->ExclusiveUnlock(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700967 }
Ian Rogers66aee5c2012-08-15 17:17:47 -0700968#else
Ian Rogers81d425b2012-09-27 16:03:43 -0700969 Locks::mutator_lock_->ExclusiveLock(self);
970 Locks::mutator_lock_->ExclusiveUnlock(self);
Ian Rogers66aee5c2012-08-15 17:17:47 -0700971#endif
Mathieu Chartier9450c6c2015-11-07 11:55:23 -0800972 // Disabled for the following race condition:
973 // Thread 1 calls SuspendAllForDebugger, gets preempted after pulsing the mutator lock.
974 // Thread 2 calls SuspendAll and SetStateUnsafe (perhaps from Dbg::Disconnected).
975 // Thread 1 fails assertion that all threads are suspended due to thread 2 being in a runnable
976 // state (from SetStateUnsafe).
977 // AssertThreadsAreSuspended(self, self, debug_thread);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700978
Sebastien Hertzed2be172014-08-19 15:33:43 +0200979 VLOG(threads) << *self << " SuspendAllForDebugger complete";
Elliott Hughes01158d72011-09-19 19:47:10 -0700980}
981
Elliott Hughes475fc232011-10-25 15:00:35 -0700982void ThreadList::SuspendSelfForDebugger() {
Sebastien Hertz1558b572015-02-25 15:05:59 +0100983 Thread* const self = Thread::Current();
984 self->SetReadyForDebugInvoke(true);
Elliott Hughes01158d72011-09-19 19:47:10 -0700985
Elliott Hughes475fc232011-10-25 15:00:35 -0700986 // The debugger thread must not suspend itself due to debugger activity!
987 Thread* debug_thread = Dbg::GetDebugThread();
Elliott Hughes475fc232011-10-25 15:00:35 -0700988 CHECK(self != debug_thread);
jeffhaoa77f0f62012-12-05 17:19:31 -0800989 CHECK_NE(self->GetState(), kRunnable);
990 Locks::mutator_lock_->AssertNotHeld(self);
Elliott Hughes475fc232011-10-25 15:00:35 -0700991
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200992 // The debugger may have detached while we were executing an invoke request. In that case, we
993 // must not suspend ourself.
994 DebugInvokeReq* pReq = self->GetInvokeReq();
995 const bool skip_thread_suspension = (pReq != nullptr && !Dbg::IsDebuggerActive());
996 if (!skip_thread_suspension) {
jeffhaoa77f0f62012-12-05 17:19:31 -0800997 // Collisions with other suspends aren't really interesting. We want
998 // to ensure that we're the only one fiddling with the suspend count
999 // though.
1000 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Yu Lieac44242015-06-29 10:50:03 +08001001 self->ModifySuspendCount(self, +1, nullptr, true);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001002 CHECK_GT(self->GetSuspendCount(), 0);
Sebastien Hertzcbc50642015-06-01 17:33:12 +02001003
1004 VLOG(threads) << *self << " self-suspending (debugger)";
1005 } else {
1006 // We must no longer be subject to debugger suspension.
1007 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
1008 CHECK_EQ(self->GetDebugSuspendCount(), 0) << "Debugger detached without resuming us";
1009
1010 VLOG(threads) << *self << " not self-suspending because debugger detached during invoke";
jeffhaoa77f0f62012-12-05 17:19:31 -08001011 }
Elliott Hughes475fc232011-10-25 15:00:35 -07001012
Sebastien Hertzcbc50642015-06-01 17:33:12 +02001013 // If the debugger requested an invoke, we need to send the reply and clear the request.
Sebastien Hertz1558b572015-02-25 15:05:59 +01001014 if (pReq != nullptr) {
Sebastien Hertzcbc50642015-06-01 17:33:12 +02001015 Dbg::FinishInvokeMethod(pReq);
Sebastien Hertz1558b572015-02-25 15:05:59 +01001016 self->ClearDebugInvokeReq();
Sebastien Hertzcbc50642015-06-01 17:33:12 +02001017 pReq = nullptr; // object has been deleted, clear it for safety.
Sebastien Hertz21e729c2014-02-18 14:16:00 +01001018 }
1019
Elliott Hughes475fc232011-10-25 15:00:35 -07001020 // Tell JDWP that we've completed suspension. The JDWP thread can't
1021 // tell us to resume before we're fully asleep because we hold the
1022 // suspend count lock.
1023 Dbg::ClearWaitForEventThread();
1024
jeffhaoa77f0f62012-12-05 17:19:31 -08001025 {
1026 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001027 while (self->GetSuspendCount() != 0) {
jeffhaoa77f0f62012-12-05 17:19:31 -08001028 Thread::resume_cond_->Wait(self);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001029 if (self->GetSuspendCount() != 0) {
jeffhaoa77f0f62012-12-05 17:19:31 -08001030 // The condition was signaled but we're still suspended. This
Sebastien Hertzf272af42014-09-18 10:20:42 +02001031 // can happen when we suspend then resume all threads to
1032 // update instrumentation or compute monitor info. This can
1033 // also happen if the debugger lets go while a SIGQUIT thread
jeffhaoa77f0f62012-12-05 17:19:31 -08001034 // dump event is pending (assuming SignalCatcher was resumed for
1035 // just long enough to try to grab the thread-suspend lock).
Sebastien Hertzf272af42014-09-18 10:20:42 +02001036 VLOG(jdwp) << *self << " still suspended after undo "
1037 << "(suspend count=" << self->GetSuspendCount() << ", "
1038 << "debug suspend count=" << self->GetDebugSuspendCount() << ")";
jeffhaoa77f0f62012-12-05 17:19:31 -08001039 }
Elliott Hughes475fc232011-10-25 15:00:35 -07001040 }
Ian Rogersdd7624d2014-03-14 17:43:00 -07001041 CHECK_EQ(self->GetSuspendCount(), 0);
Elliott Hughes475fc232011-10-25 15:00:35 -07001042 }
jeffhaoa77f0f62012-12-05 17:19:31 -08001043
Sebastien Hertz1558b572015-02-25 15:05:59 +01001044 self->SetReadyForDebugInvoke(false);
Elliott Hughes1f729aa2012-03-02 13:55:41 -08001045 VLOG(threads) << *self << " self-reviving (debugger)";
Elliott Hughes475fc232011-10-25 15:00:35 -07001046}
1047
Sebastien Hertz253fa552014-10-14 17:27:15 +02001048void ThreadList::ResumeAllForDebugger() {
1049 Thread* self = Thread::Current();
1050 Thread* debug_thread = Dbg::GetDebugThread();
Sebastien Hertz253fa552014-10-14 17:27:15 +02001051
1052 VLOG(threads) << *self << " ResumeAllForDebugger starting...";
1053
1054 // Threads can't resume if we exclusively hold the mutator lock.
1055 Locks::mutator_lock_->AssertNotExclusiveHeld(self);
1056
1057 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001058 MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
Sebastien Hertz253fa552014-10-14 17:27:15 +02001059 {
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001060 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
Sebastien Hertz253fa552014-10-14 17:27:15 +02001061 // Update global suspend all state for attaching threads.
1062 DCHECK_GE(suspend_all_count_, debug_suspend_all_count_);
Sebastien Hertzf9d233d2015-01-09 14:51:41 +01001063 if (debug_suspend_all_count_ > 0) {
Sebastien Hertz253fa552014-10-14 17:27:15 +02001064 --suspend_all_count_;
1065 --debug_suspend_all_count_;
Sebastien Hertz253fa552014-10-14 17:27:15 +02001066 } else {
1067 // We've been asked to resume all threads without being asked to
Sebastien Hertzf9d233d2015-01-09 14:51:41 +01001068 // suspend them all before. That may happen if a debugger tries
1069 // to resume some suspended threads (with suspend count == 1)
1070 // at once with a VirtualMachine.Resume command. Let's print a
1071 // warning.
Sebastien Hertz253fa552014-10-14 17:27:15 +02001072 LOG(WARNING) << "Debugger attempted to resume all threads without "
1073 << "having suspended them all before.";
1074 }
Sebastien Hertzf9d233d2015-01-09 14:51:41 +01001075 // Decrement everybody's suspend count (except our own).
1076 for (const auto& thread : list_) {
1077 if (thread == self || thread == debug_thread) {
1078 continue;
1079 }
1080 if (thread->GetDebugSuspendCount() == 0) {
1081 // This thread may have been individually resumed with ThreadReference.Resume.
1082 continue;
1083 }
1084 VLOG(threads) << "requesting thread resume: " << *thread;
Yu Lieac44242015-06-29 10:50:03 +08001085 thread->ModifySuspendCount(self, -1, nullptr, true);
Sebastien Hertzf9d233d2015-01-09 14:51:41 +01001086 }
Sebastien Hertz253fa552014-10-14 17:27:15 +02001087 }
1088 }
1089
Sebastien Hertzf9d233d2015-01-09 14:51:41 +01001090 {
Sebastien Hertz253fa552014-10-14 17:27:15 +02001091 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
1092 Thread::resume_cond_->Broadcast(self);
1093 }
1094
1095 VLOG(threads) << *self << " ResumeAllForDebugger complete";
1096}
1097
Elliott Hughes234ab152011-10-26 14:02:26 -07001098void ThreadList::UndoDebuggerSuspensions() {
1099 Thread* self = Thread::Current();
1100
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001101 VLOG(threads) << *self << " UndoDebuggerSuspensions starting";
Elliott Hughes234ab152011-10-26 14:02:26 -07001102
1103 {
Ian Rogers81d425b2012-09-27 16:03:43 -07001104 MutexLock mu(self, *Locks::thread_list_lock_);
1105 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001106 // Update global suspend all state for attaching threads.
1107 suspend_all_count_ -= debug_suspend_all_count_;
1108 debug_suspend_all_count_ = 0;
1109 // Update running threads.
Mathieu Chartier02e25112013-08-14 16:14:24 -07001110 for (const auto& thread : list_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001111 if (thread == self || thread->GetDebugSuspendCount() == 0) {
Elliott Hughes234ab152011-10-26 14:02:26 -07001112 continue;
1113 }
Yu Lieac44242015-06-29 10:50:03 +08001114 thread->ModifySuspendCount(self, -thread->GetDebugSuspendCount(), nullptr, true);
Elliott Hughes234ab152011-10-26 14:02:26 -07001115 }
1116 }
1117
1118 {
Ian Rogers81d425b2012-09-27 16:03:43 -07001119 MutexLock mu(self, *Locks::thread_suspend_count_lock_);
Ian Rogersc604d732012-10-14 16:09:54 -07001120 Thread::resume_cond_->Broadcast(self);
Elliott Hughes234ab152011-10-26 14:02:26 -07001121 }
1122
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001123 VLOG(threads) << "UndoDebuggerSuspensions(" << *self << ") complete";
Elliott Hughes234ab152011-10-26 14:02:26 -07001124}
1125
Elliott Hughese52e49b2012-04-02 16:05:44 -07001126void ThreadList::WaitForOtherNonDaemonThreadsToExit() {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08001127 ScopedTrace trace(__PRETTY_FUNCTION__);
Ian Rogers81d425b2012-09-27 16:03:43 -07001128 Thread* self = Thread::Current();
1129 Locks::mutator_lock_->AssertNotHeld(self);
Mathieu Chartier91e56692015-03-03 13:51:04 -08001130 while (true) {
Ian Rogers120f1c72012-09-28 17:17:10 -07001131 {
1132 // No more threads can be born after we start to shutdown.
1133 MutexLock mu(self, *Locks::runtime_shutdown_lock_);
Mathieu Chartier590fee92013-09-13 13:46:47 -07001134 CHECK(Runtime::Current()->IsShuttingDownLocked());
Ian Rogers120f1c72012-09-28 17:17:10 -07001135 CHECK_EQ(Runtime::Current()->NumberOfThreadsBeingBorn(), 0U);
1136 }
Ian Rogers120f1c72012-09-28 17:17:10 -07001137 MutexLock mu(self, *Locks::thread_list_lock_);
Mathieu Chartier91e56692015-03-03 13:51:04 -08001138 // Also wait for any threads that are unregistering to finish. This is required so that no
1139 // threads access the thread list after it is deleted. TODO: This may not work for user daemon
1140 // threads since they could unregister at the wrong time.
1141 bool done = unregistering_count_ == 0;
1142 if (done) {
1143 for (const auto& thread : list_) {
1144 if (thread != self && !thread->IsDaemon()) {
1145 done = false;
1146 break;
1147 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001148 }
1149 }
Mathieu Chartier91e56692015-03-03 13:51:04 -08001150 if (done) {
1151 break;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001152 }
Mathieu Chartier91e56692015-03-03 13:51:04 -08001153 // Wait for another thread to exit before re-checking.
1154 Locks::thread_exit_cond_->Wait(self);
1155 }
Elliott Hughes038a8062011-09-18 14:12:41 -07001156}
1157
Mathieu Chartier4d87df62016-01-07 15:14:19 -08001158void ThreadList::SuspendAllDaemonThreadsForShutdown() {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08001159 ScopedTrace trace(__PRETTY_FUNCTION__);
Ian Rogers81d425b2012-09-27 16:03:43 -07001160 Thread* self = Thread::Current();
Mathieu Chartier62597d12016-01-11 10:19:06 -08001161 size_t daemons_left = 0;
Nicolas Geoffrayaa45daa2016-06-20 15:58:32 +01001162 {
1163 // Tell all the daemons it's time to suspend.
1164 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogers81d425b2012-09-27 16:03:43 -07001165 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001166 for (const auto& thread : list_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001167 // This is only run after all non-daemon threads have exited, so the remainder should all be
1168 // daemons.
Ian Rogers7e762862012-10-22 15:45:08 -07001169 CHECK(thread->IsDaemon()) << *thread;
Ian Rogers81d425b2012-09-27 16:03:43 -07001170 if (thread != self) {
Yu Lieac44242015-06-29 10:50:03 +08001171 thread->ModifySuspendCount(self, +1, nullptr, false);
Mathieu Chartier62597d12016-01-11 10:19:06 -08001172 ++daemons_left;
Elliott Hughese52e49b2012-04-02 16:05:44 -07001173 }
Mathieu Chartier4d87df62016-01-07 15:14:19 -08001174 // We are shutting down the runtime, set the JNI functions of all the JNIEnvs to be
1175 // the sleep forever one.
1176 thread->GetJniEnv()->SetFunctionsToRuntimeShutdownFunctions();
Elliott Hughes038a8062011-09-18 14:12:41 -07001177 }
1178 }
Mathieu Chartier62597d12016-01-11 10:19:06 -08001179 // If we have any daemons left, wait 200ms to ensure they are not stuck in a place where they
1180 // are about to access runtime state and are not in a runnable state. Examples: Monitor code
1181 // or waking up from a condition variable. TODO: Try and see if there is a better way to wait
1182 // for daemon threads to be in a blocked state.
1183 if (daemons_left > 0) {
1184 static constexpr size_t kDaemonSleepTime = 200 * 1000;
1185 usleep(kDaemonSleepTime);
1186 }
Elliott Hughes038a8062011-09-18 14:12:41 -07001187 // Give the threads a chance to suspend, complaining if they're slow.
1188 bool have_complained = false;
Mathieu Chartierba098ba2016-01-07 09:31:33 -08001189 static constexpr size_t kTimeoutMicroseconds = 2000 * 1000;
1190 static constexpr size_t kSleepMicroseconds = 1000;
1191 for (size_t i = 0; i < kTimeoutMicroseconds / kSleepMicroseconds; ++i) {
Elliott Hughes038a8062011-09-18 14:12:41 -07001192 bool all_suspended = true;
Nicolas Geoffrayaa45daa2016-06-20 15:58:32 +01001193 {
1194 MutexLock mu(self, *Locks::thread_list_lock_);
1195 for (const auto& thread : list_) {
1196 if (thread != self && thread->GetState() == kRunnable) {
1197 if (!have_complained) {
1198 LOG(WARNING) << "daemon thread not yet suspended: " << *thread;
1199 have_complained = true;
1200 }
1201 all_suspended = false;
Elliott Hughes038a8062011-09-18 14:12:41 -07001202 }
Elliott Hughes038a8062011-09-18 14:12:41 -07001203 }
1204 }
1205 if (all_suspended) {
1206 return;
1207 }
Mathieu Chartierba098ba2016-01-07 09:31:33 -08001208 usleep(kSleepMicroseconds);
Elliott Hughes038a8062011-09-18 14:12:41 -07001209 }
Mathieu Chartierba098ba2016-01-07 09:31:33 -08001210 LOG(WARNING) << "timed out suspending all daemon threads";
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001211}
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001212
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001213void ThreadList::Register(Thread* self) {
1214 DCHECK_EQ(self, Thread::Current());
1215
1216 if (VLOG_IS_ON(threads)) {
1217 std::ostringstream oss;
1218 self->ShortDump(oss); // We don't hold the mutator_lock_ yet and so cannot call Dump.
Ian Rogers5a9ba012014-05-19 13:28:52 -07001219 LOG(INFO) << "ThreadList::Register() " << *self << "\n" << oss.str();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001220 }
1221
1222 // Atomically add self to the thread list and make its thread_suspend_count_ reflect ongoing
1223 // SuspendAll requests.
Ian Rogers81d425b2012-09-27 16:03:43 -07001224 MutexLock mu(self, *Locks::thread_list_lock_);
1225 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001226 CHECK_GE(suspend_all_count_, debug_suspend_all_count_);
Ian Rogers2966e132014-04-02 08:34:36 -07001227 // Modify suspend count in increments of 1 to maintain invariants in ModifySuspendCount. While
1228 // this isn't particularly efficient the suspend counts are most commonly 0 or 1.
1229 for (int delta = debug_suspend_all_count_; delta > 0; delta--) {
Yu Lieac44242015-06-29 10:50:03 +08001230 self->ModifySuspendCount(self, +1, nullptr, true);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001231 }
Ian Rogers2966e132014-04-02 08:34:36 -07001232 for (int delta = suspend_all_count_ - debug_suspend_all_count_; delta > 0; delta--) {
Yu Lieac44242015-06-29 10:50:03 +08001233 self->ModifySuspendCount(self, +1, nullptr, false);
Ian Rogers01ae5802012-09-28 16:14:01 -07001234 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001235 CHECK(!Contains(self));
1236 list_.push_back(self);
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001237 if (kUseReadBarrier) {
Hiroshi Yamauchi00370822015-08-18 14:47:25 -07001238 // Initialize according to the state of the CC collector.
1239 bool is_gc_marking =
1240 Runtime::Current()->GetHeap()->ConcurrentCopyingCollector()->IsMarking();
1241 self->SetIsGcMarking(is_gc_marking);
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001242 bool weak_ref_access_enabled =
1243 Runtime::Current()->GetHeap()->ConcurrentCopyingCollector()->IsWeakRefAccessEnabled();
1244 self->SetWeakRefAccessEnabled(weak_ref_access_enabled);
1245 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001246}
1247
1248void ThreadList::Unregister(Thread* self) {
1249 DCHECK_EQ(self, Thread::Current());
Ian Rogers68d8b422014-07-17 11:09:10 -07001250 CHECK_NE(self->GetState(), kRunnable);
1251 Locks::mutator_lock_->AssertNotHeld(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001252
1253 VLOG(threads) << "ThreadList::Unregister() " << *self;
1254
Mathieu Chartier91e56692015-03-03 13:51:04 -08001255 {
1256 MutexLock mu(self, *Locks::thread_list_lock_);
1257 ++unregistering_count_;
1258 }
1259
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001260 // Any time-consuming destruction, plus anything that can call back into managed code or
Mathieu Chartier91e56692015-03-03 13:51:04 -08001261 // suspend and so on, must happen at this point, and not in ~Thread. The self->Destroy is what
1262 // causes the threads to join. It is important to do this after incrementing unregistering_count_
1263 // since we want the runtime to wait for the daemon threads to exit before deleting the thread
1264 // list.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001265 self->Destroy();
1266
Jeff Haoe094b872014-10-14 13:12:01 -07001267 // If tracing, remember thread id and name before thread exits.
1268 Trace::StoreExitingThreadInfo(self);
1269
Ian Rogersdd7624d2014-03-14 17:43:00 -07001270 uint32_t thin_lock_id = self->GetThreadId();
Mathieu Chartier91e56692015-03-03 13:51:04 -08001271 while (true) {
Ian Rogerscfaa4552012-11-26 21:00:08 -08001272 // Remove and delete the Thread* while holding the thread_list_lock_ and
1273 // thread_suspend_count_lock_ so that the unregistering thread cannot be suspended.
Ian Rogers0878d652013-04-18 17:38:35 -07001274 // Note: deliberately not using MutexLock that could hold a stale self pointer.
Mathieu Chartier91e56692015-03-03 13:51:04 -08001275 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogersa2af5c72014-09-15 15:17:07 -07001276 if (!Contains(self)) {
Mathieu Chartier9db831a2015-02-24 17:20:30 -08001277 std::string thread_name;
1278 self->GetThreadName(thread_name);
Ian Rogersa2af5c72014-09-15 15:17:07 -07001279 std::ostringstream os;
Christopher Ferris6cff48f2014-01-26 21:36:13 -08001280 DumpNativeStack(os, GetTid(), nullptr, " native: ", nullptr);
Mathieu Chartier9db831a2015-02-24 17:20:30 -08001281 LOG(ERROR) << "Request to unregister unattached thread " << thread_name << "\n" << os.str();
Mathieu Chartier91e56692015-03-03 13:51:04 -08001282 break;
Ian Rogersa2af5c72014-09-15 15:17:07 -07001283 } else {
Mathieu Chartier91e56692015-03-03 13:51:04 -08001284 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
Ian Rogersa2af5c72014-09-15 15:17:07 -07001285 if (!self->IsSuspended()) {
1286 list_.remove(self);
Mathieu Chartier91e56692015-03-03 13:51:04 -08001287 break;
Ian Rogersa2af5c72014-09-15 15:17:07 -07001288 }
Ian Rogers68d8b422014-07-17 11:09:10 -07001289 }
Mathieu Chartier91e56692015-03-03 13:51:04 -08001290 // We failed to remove the thread due to a suspend request, loop and try again.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001291 }
Mathieu Chartier91e56692015-03-03 13:51:04 -08001292 delete self;
1293
Mathieu Chartier5f51d4b2013-12-03 14:24:05 -08001294 // Release the thread ID after the thread is finished and deleted to avoid cases where we can
1295 // temporarily have multiple threads with the same thread id. When this occurs, it causes
1296 // problems in FindThreadByThreadId / SuspendThreadByThreadId.
1297 ReleaseThreadId(nullptr, thin_lock_id);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001298
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001299 // Clear the TLS data, so that the underlying native thread is recognizably detached.
1300 // (It may wish to reattach later.)
Bilyan Borisovbb661c02016-04-04 16:27:32 +01001301#ifdef ART_TARGET_ANDROID
Andreas Gampe4382f1e2015-08-05 01:08:53 +00001302 __get_tls()[TLS_SLOT_ART_THREAD_SELF] = nullptr;
1303#else
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001304 CHECK_PTHREAD_CALL(pthread_setspecific, (Thread::pthread_key_self_, nullptr), "detach self");
Andreas Gampe4382f1e2015-08-05 01:08:53 +00001305#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001306
1307 // Signal that a thread just detached.
Mathieu Chartier91e56692015-03-03 13:51:04 -08001308 MutexLock mu(nullptr, *Locks::thread_list_lock_);
1309 --unregistering_count_;
1310 Locks::thread_exit_cond_->Broadcast(nullptr);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001311}
1312
1313void ThreadList::ForEach(void (*callback)(Thread*, void*), void* context) {
Mathieu Chartier02e25112013-08-14 16:14:24 -07001314 for (const auto& thread : list_) {
1315 callback(thread, context);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001316 }
1317}
1318
Mathieu Chartierf8a86b92016-06-14 17:08:47 -07001319void ThreadList::VisitRootsForSuspendedThreads(RootVisitor* visitor) {
1320 Thread* const self = Thread::Current();
1321 std::vector<Thread*> threads_to_visit;
1322
1323 // Tell threads to suspend and copy them into list.
1324 {
1325 MutexLock mu(self, *Locks::thread_list_lock_);
1326 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
1327 for (Thread* thread : list_) {
1328 thread->ModifySuspendCount(self, +1, nullptr, false);
1329 if (thread == self || thread->IsSuspended()) {
1330 threads_to_visit.push_back(thread);
1331 } else {
1332 thread->ModifySuspendCount(self, -1, nullptr, false);
1333 }
1334 }
1335 }
1336
1337 // Visit roots without holding thread_list_lock_ and thread_suspend_count_lock_ to prevent lock
1338 // order violations.
1339 for (Thread* thread : threads_to_visit) {
1340 thread->VisitRoots(visitor);
1341 }
1342
1343 // Restore suspend counts.
1344 {
1345 MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
1346 for (Thread* thread : threads_to_visit) {
1347 thread->ModifySuspendCount(self, -1, nullptr, false);
1348 }
1349 }
1350}
1351
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001352void ThreadList::VisitRoots(RootVisitor* visitor) const {
Ian Rogers81d425b2012-09-27 16:03:43 -07001353 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001354 for (const auto& thread : list_) {
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001355 thread->VisitRoots(visitor);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001356 }
Elliott Hughes038a8062011-09-18 14:12:41 -07001357}
1358
Ian Rogerscfaa4552012-11-26 21:00:08 -08001359uint32_t ThreadList::AllocThreadId(Thread* self) {
Chao-ying Fu9e369312014-05-21 11:20:52 -07001360 MutexLock mu(self, *Locks::allocated_thread_ids_lock_);
Elliott Hughes8daa0922011-09-11 13:46:25 -07001361 for (size_t i = 0; i < allocated_ids_.size(); ++i) {
1362 if (!allocated_ids_[i]) {
1363 allocated_ids_.set(i);
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001364 return i + 1; // Zero is reserved to mean "invalid".
Elliott Hughes8daa0922011-09-11 13:46:25 -07001365 }
1366 }
1367 LOG(FATAL) << "Out of internal thread ids";
1368 return 0;
1369}
1370
Ian Rogerscfaa4552012-11-26 21:00:08 -08001371void ThreadList::ReleaseThreadId(Thread* self, uint32_t id) {
Chao-ying Fu9e369312014-05-21 11:20:52 -07001372 MutexLock mu(self, *Locks::allocated_thread_ids_lock_);
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001373 --id; // Zero is reserved to mean "invalid".
Elliott Hughes8daa0922011-09-11 13:46:25 -07001374 DCHECK(allocated_ids_[id]) << id;
1375 allocated_ids_.reset(id);
1376}
1377
Mathieu Chartier4f55e222015-09-04 13:26:21 -07001378ScopedSuspendAll::ScopedSuspendAll(const char* cause, bool long_suspend) {
1379 Runtime::Current()->GetThreadList()->SuspendAll(cause, long_suspend);
1380}
1381
1382ScopedSuspendAll::~ScopedSuspendAll() {
1383 Runtime::Current()->GetThreadList()->ResumeAll();
1384}
1385
Elliott Hughes8daa0922011-09-11 13:46:25 -07001386} // namespace art