1 /*
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 
19 #include <dirent.h>
20 #include <sys/types.h>
21 #include <unistd.h>
22 
23 #include <sstream>
24 #include <vector>
25 
26 #include "android-base/stringprintf.h"
27 #include "backtrace/BacktraceMap.h"
28 #include "nativehelper/scoped_local_ref.h"
29 #include "nativehelper/scoped_utf_chars.h"
30 
31 #include "base/aborting.h"
32 #include "base/histogram-inl.h"
33 #include "base/mutex-inl.h"
34 #include "base/systrace.h"
35 #include "base/time_utils.h"
36 #include "base/timing_logger.h"
37 #include "debugger.h"
38 #include "gc/collector/concurrent_copying.h"
39 #include "gc/gc_pause_listener.h"
40 #include "gc/heap.h"
41 #include "gc/reference_processor.h"
42 #include "gc_root.h"
43 #include "jni/jni_internal.h"
44 #include "lock_word.h"
45 #include "monitor.h"
46 #include "native_stack_dump.h"
47 #include "scoped_thread_state_change-inl.h"
48 #include "thread.h"
49 #include "trace.h"
50 #include "well_known_classes.h"
51 
52 #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 
60 namespace art {
61 
62 using android::base::StringPrintf;
63 
64 static constexpr uint64_t kLongThreadSuspendThreshold = MsToNs(5);
65 // Use 0 since we want to yield to prevent blocking for an unpredictable amount of time.
66 static constexpr useconds_t kThreadSuspendInitialSleepUs = 0;
67 static constexpr useconds_t kThreadSuspendMaxYieldUs = 3000;
68 static constexpr useconds_t kThreadSuspendMaxSleepUs = 5000;
69 
70 // Whether we should try to dump the native stack of unattached threads. See commit ed8b723 for
71 // some history.
72 static constexpr bool kDumpUnattachedThreadNativeStackForSigQuit = true;
73 
ThreadList(uint64_t thread_suspend_timeout_ns)74 ThreadList::ThreadList(uint64_t thread_suspend_timeout_ns)
75     : suspend_all_count_(0),
76       unregistering_count_(0),
77       suspend_all_historam_("suspend all histogram", 16, 64),
78       long_suspend_(false),
79       shut_down_(false),
80       thread_suspend_timeout_ns_(thread_suspend_timeout_ns),
81       empty_checkpoint_barrier_(new Barrier(0)) {
82   CHECK(Monitor::IsValidLockWord(LockWord::FromThinLockId(kMaxThreadId, 1, 0U)));
83 }
84 
~ThreadList()85 ThreadList::~ThreadList() {
86   CHECK(shut_down_);
87 }
88 
ShutDown()89 void ThreadList::ShutDown() {
90   ScopedTrace trace(__PRETTY_FUNCTION__);
91   // Detach the current thread if necessary. If we failed to start, there might not be any threads.
92   // We need to detach the current thread here in case there's another thread waiting to join with
93   // us.
94   bool contains = false;
95   Thread* self = Thread::Current();
96   {
97     MutexLock mu(self, *Locks::thread_list_lock_);
98     contains = Contains(self);
99   }
100   if (contains) {
101     Runtime::Current()->DetachCurrentThread();
102   }
103   WaitForOtherNonDaemonThreadsToExit();
104   // 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());
110   // TODO: there's an unaddressed race here where a thread may attach during shutdown, see
111   //       Thread::Init.
112   SuspendAllDaemonThreadsForShutdown();
113 
114   shut_down_ = true;
115 }
116 
Contains(Thread * thread)117 bool ThreadList::Contains(Thread* thread) {
118   return find(list_.begin(), list_.end(), thread) != list_.end();
119 }
120 
Contains(pid_t tid)121 bool ThreadList::Contains(pid_t tid) {
122   for (const auto& thread : list_) {
123     if (thread->GetTid() == tid) {
124       return true;
125     }
126   }
127   return false;
128 }
129 
GetLockOwner()130 pid_t ThreadList::GetLockOwner() {
131   return Locks::thread_list_lock_->GetExclusiveOwnerTid();
132 }
133 
DumpNativeStacks(std::ostream & os)134 void ThreadList::DumpNativeStacks(std::ostream& os) {
135   MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
136   std::unique_ptr<BacktraceMap> map(BacktraceMap::Create(getpid()));
137   for (const auto& thread : list_) {
138     os << "DUMPING THREAD " << thread->GetTid() << "\n";
139     DumpNativeStack(os, thread->GetTid(), map.get(), "\t");
140     os << "\n";
141   }
142 }
143 
DumpForSigQuit(std::ostream & os)144 void ThreadList::DumpForSigQuit(std::ostream& os) {
145   {
146     ScopedObjectAccess soa(Thread::Current());
147     // 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     }
153   }
154   bool dump_native_stack = Runtime::Current()->GetDumpNativeStackOnSigQuit();
155   Dump(os, dump_native_stack);
156   DumpUnattachedThreads(os, dump_native_stack && kDumpUnattachedThreadNativeStackForSigQuit);
157 }
158 
DumpUnattachedThread(std::ostream & os,pid_t tid,bool dump_native_stack)159 static void DumpUnattachedThread(std::ostream& os, pid_t tid, bool dump_native_stack)
160     NO_THREAD_SAFETY_ANALYSIS {
161   // TODO: No thread safety analysis as DumpState with a null thread won't access fields, should
162   // refactor DumpState to avoid skipping analysis.
163   Thread::DumpState(os, nullptr, tid);
164   if (dump_native_stack) {
165     DumpNativeStack(os, tid, nullptr, "  native: ");
166   }
167   os << std::endl;
168 }
169 
DumpUnattachedThreads(std::ostream & os,bool dump_native_stack)170 void ThreadList::DumpUnattachedThreads(std::ostream& os, bool dump_native_stack) {
171   DIR* d = opendir("/proc/self/task");
172   if (!d) {
173     return;
174   }
175 
176   Thread* self = Thread::Current();
177   dirent* e;
178   while ((e = readdir(d)) != nullptr) {
179     char* end;
180     pid_t tid = strtol(e->d_name, &end, 10);
181     if (!*end) {
182       bool contains;
183       {
184         MutexLock mu(self, *Locks::thread_list_lock_);
185         contains = Contains(tid);
186       }
187       if (!contains) {
188         DumpUnattachedThread(os, tid, dump_native_stack);
189       }
190     }
191   }
192   closedir(d);
193 }
194 
195 // Dump checkpoint timeout in milliseconds. Larger amount on the target, since the device could be
196 // overloaded with ANR dumps.
197 static constexpr uint32_t kDumpWaitTimeout = kIsTargetBuild ? 100000 : 20000;
198 
199 // A closure used by Thread::Dump.
200 class DumpCheckpoint final : public Closure {
201  public:
DumpCheckpoint(std::ostream * os,bool dump_native_stack)202   DumpCheckpoint(std::ostream* os, bool dump_native_stack)
203       : os_(os),
204         // 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.
206         barrier_(0, /*verify_count_on_shutdown=*/false),
207         backtrace_map_(dump_native_stack ? BacktraceMap::Create(getpid()) : nullptr),
208         dump_native_stack_(dump_native_stack) {
209     if (backtrace_map_ != nullptr) {
210       backtrace_map_->SetSuffixesToIgnore(std::vector<std::string> { "oat", "odex" });
211     }
212   }
213 
Run(Thread * thread)214   void Run(Thread* thread) override {
215     // 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();
218     CHECK(self != nullptr);
219     std::ostringstream local_os;
220     {
221       ScopedObjectAccess soa(self);
222       thread->Dump(local_os, dump_native_stack_, backtrace_map_.get());
223     }
224     {
225       // Use the logging lock to ensure serialization when writing to the common ostream.
226       MutexLock mu(self, *Locks::logging_lock_);
227       *os_ << local_os.str() << std::endl;
228     }
229     barrier_.Pass(self);
230   }
231 
WaitForThreadsToRunThroughCheckpoint(size_t threads_running_checkpoint)232   void WaitForThreadsToRunThroughCheckpoint(size_t threads_running_checkpoint) {
233     Thread* self = Thread::Current();
234     ScopedThreadStateChange tsc(self, kWaitingForCheckPointsToRun);
235     bool timed_out = barrier_.Increment(self, threads_running_checkpoint, kDumpWaitTimeout);
236     if (timed_out) {
237       // Avoid a recursive abort.
238       LOG((kIsDebugBuild && (gAborting == 0)) ? ::android::base::FATAL : ::android::base::ERROR)
239           << "Unexpected time out during dump checkpoint.";
240     }
241   }
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_;
248   // A backtrace map, so that all threads use a shared info and don't reacquire/parse separately.
249   std::unique_ptr<BacktraceMap> backtrace_map_;
250   // Whether we should dump the native stack.
251   const bool dump_native_stack_;
252 };
253 
Dump(std::ostream & os,bool dump_native_stack)254 void ThreadList::Dump(std::ostream& os, bool dump_native_stack) {
255   Thread* self = Thread::Current();
256   {
257     MutexLock mu(self, *Locks::thread_list_lock_);
258     os << "DALVIK THREADS (" << list_.size() << "):\n";
259   }
260   if (self != nullptr) {
261     DumpCheckpoint checkpoint(&os, dump_native_stack);
262     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 {
272     DumpUnattachedThreads(os, dump_native_stack);
273   }
274 }
275 
AssertThreadsAreSuspended(Thread * self,Thread * ignore1,Thread * ignore2)276 void 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_);
279   for (const auto& thread : list_) {
280     if (thread != ignore1 && thread != ignore2) {
281       CHECK(thread->IsSuspended())
282             << "\nUnsuspended thread: <<" << *thread << "\n"
283             << "self: <<" << *Thread::Current();
284     }
285   }
286 }
287 
288 #if HAVE_TIMED_RWLOCK
289 // Attempt to rectify locks so that we dump thread list with required locks before exiting.
UnsafeLogFatalForThreadSuspendAllTimeout()290 NO_RETURN static void UnsafeLogFatalForThreadSuspendAllTimeout() {
291   // 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;
295   Runtime* runtime = Runtime::Current();
296   std::ostringstream ss;
297   ss << "Thread suspend timeout\n";
298   Locks::mutator_lock_->Dump(ss);
299   ss << "\n";
300   runtime->GetThreadList()->Dump(ss);
301   --gAborting;
302   LOG(FATAL) << ss.str();
303   exit(0);
304 }
305 #endif
306 
307 // Unlike suspending all threads where we can wait to acquire the mutator_lock_, suspending an
308 // 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.
310 // 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.
ThreadSuspendSleep(useconds_t delay_us)312 static void ThreadSuspendSleep(useconds_t delay_us) {
313   if (delay_us == 0) {
314     sched_yield();
315   } else {
316     usleep(delay_us);
317   }
318 }
319 
RunCheckpoint(Closure * checkpoint_function,Closure * callback)320 size_t ThreadList::RunCheckpoint(Closure* checkpoint_function, Closure* callback) {
321   Thread* self = Thread::Current();
322   Locks::mutator_lock_->AssertNotExclusiveHeld(self);
323   Locks::thread_list_lock_->AssertNotHeld(self);
324   Locks::thread_suspend_count_lock_->AssertNotHeld(self);
325 
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_);
332     MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
333     count = list_.size();
334     for (const auto& thread : list_) {
335       if (thread != self) {
336         bool requested_suspend = false;
337         while (true) {
338           if (thread->RequestCheckpoint(checkpoint_function)) {
339             // This thread will run its checkpoint some time in the near future.
340             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             }
347             break;
348           } else {
349             // The thread is probably suspended, try to make sure that it stays suspended.
350             if (thread->GetState() == kRunnable) {
351               // Spurious fail, try again.
352               continue;
353             }
354             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             }
369           }
370         }
371         if (requested_suspend) {
372           suspended_count_modified_threads.push_back(thread);
373         }
374       }
375     }
376     // Run the callback to be called inside this critical section.
377     if (callback != nullptr) {
378       callback->Run(self);
379     }
380   }
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.
386   for (const auto& thread : suspended_count_modified_threads) {
387     // We know for sure that the thread is suspended at this point.
388     DCHECK(thread->IsSuspended());
389     checkpoint_function->Run(thread);
390     {
391       MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
392       bool updated = thread->ModifySuspendCount(self, -1, nullptr, SuspendReason::kInternal);
393       DCHECK(updated);
394     }
395   }
396 
397   {
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 
404   return count;
405 }
406 
RunEmptyCheckpoint()407 void ThreadList::RunEmptyCheckpoint() {
408   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);
412   std::vector<uint32_t> runnable_thread_ids;
413   size_t count = 0;
414   Barrier* barrier = empty_checkpoint_barrier_.get();
415   barrier->Init(self, 0);
416   {
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;
426             if (kIsDebugBuild) {
427               runnable_thread_ids.push_back(thread->GetThreadId());
428             }
429             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);
444   Runtime::Current()->BroadcastForNewSystemWeaks(/*broadcast_for_checkpoint=*/true);
445   {
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),
497                            /*dump_native_stack=*/ true,
498                            /*backtrace_map=*/ nullptr,
499                            /*force_dump_stack=*/ true);
500             }
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   }
511 }
512 
513 // 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.
FlipThreadRoots(Closure * thread_flip_visitor,Closure * flip_callback,gc::collector::GarbageCollector * collector,gc::GcPauseListener * pause_listener)517 size_t ThreadList::FlipThreadRoots(Closure* thread_flip_visitor,
518                                    Closure* flip_callback,
519                                    gc::collector::GarbageCollector* collector,
520                                    gc::GcPauseListener* pause_listener) {
521   TimingLogger::ScopedTiming split("ThreadListFlip", collector->GetTimings());
522   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 
528   collector->GetHeap()->ThreadFlipBegin(self);  // Sync with JNI critical calls.
529 
530   // 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();
533   SuspendAllInternal(self, self, nullptr);
534   if (pause_listener != nullptr) {
535     pause_listener->StartPause();
536   }
537 
538   // Run the flip callback for the collector.
539   Locks::mutator_lock_->ExclusiveLock(self);
540   suspend_all_historam_.AdjustAndAddValue(NanoTime() - suspend_start_time);
541   flip_callback->Run(self);
542   Locks::mutator_lock_->ExclusiveUnlock(self);
543   collector->RegisterPause(NanoTime() - suspend_start_time);
544   if (pause_listener != nullptr) {
545     pause_listener->EndPause();
546   }
547 
548   // Resume runnable threads.
549   size_t runnable_thread_count = 0;
550   std::vector<Thread*> other_threads;
551   {
552     TimingLogger::ScopedTiming split2("ResumeRunnableThreads", collector->GetTimings());
553     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_) {
557       // 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);
561       if (thread == self) {
562         continue;
563       }
564       // 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();
569       if ((state == kWaitingForGcThreadFlip || thread->IsTransitioningToRunnable()) &&
570           thread->GetSuspendCount() == 1) {
571         // The thread will resume right after the broadcast.
572         bool updated = thread->ModifySuspendCount(self, -1, nullptr, SuspendReason::kInternal);
573         DCHECK(updated);
574         ++runnable_thread_count;
575       } else {
576         other_threads.push_back(thread);
577       }
578     }
579     Thread::resume_cond_->Broadcast(self);
580   }
581 
582   collector->GetHeap()->ThreadFlipEnd(self);
583 
584   // Run the closure on the other threads and let them resume.
585   {
586     TimingLogger::ScopedTiming split3("FlipOtherThreads", collector->GetTimings());
587     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.
595     Closure* flip_func = self->GetFlipFunction();
596     if (flip_func != nullptr) {
597       flip_func->Run(self);
598     }
599   }
600 
601   // Resume other threads.
602   {
603     TimingLogger::ScopedTiming split4("ResumeOtherThreads", collector->GetTimings());
604     MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
605     for (const auto& thread : other_threads) {
606       bool updated = thread->ModifySuspendCount(self, -1, nullptr, SuspendReason::kInternal);
607       DCHECK(updated);
608     }
609     Thread::resume_cond_->Broadcast(self);
610   }
611 
612   return runnable_thread_count + other_threads.size() + 1;  // +1 for self.
613 }
614 
SuspendAll(const char * cause,bool long_suspend)615 void ThreadList::SuspendAll(const char* cause, bool long_suspend) {
616   Thread* self = Thread::Current();
617 
618   if (self != nullptr) {
619     VLOG(threads) << *self << " SuspendAll for " << cause << " starting...";
620   } else {
621     VLOG(threads) << "Thread[null] SuspendAll for " << cause << " starting...";
622   }
623   {
624     ScopedTrace trace("Suspending mutator threads");
625     const uint64_t start_time = NanoTime();
626 
627     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.
630 #if HAVE_TIMED_RWLOCK
631     while (true) {
632       if (Locks::mutator_lock_->ExclusiveLockWithTimeout(self,
633                                                          NsToMs(thread_suspend_timeout_ns_),
634                                                          0)) {
635         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.
639         // Timeout if we wait more than thread_suspend_timeout_ns_ nanoseconds.
640         UnsafeLogFatalForThreadSuspendAllTimeout();
641       }
642     }
643 #else
644     Locks::mutator_lock_->ExclusiveLock(self);
645 #endif
646 
647     long_suspend_ = long_suspend;
648 
649     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     }
660   }
661   ATraceBegin((std::string("Mutator threads suspended for ") + cause).c_str());
662 
663   if (self != nullptr) {
664     VLOG(threads) << *self << " SuspendAll complete";
665   } else {
666     VLOG(threads) << "Thread[null] SuspendAll complete";
667   }
668 }
669 
670 // Ensures all threads running Java suspend and that those not running Java don't start.
SuspendAllInternal(Thread * self,Thread * ignore1,Thread * ignore2,SuspendReason reason)671 void ThreadList::SuspendAllInternal(Thread* self,
672                                     Thread* ignore1,
673                                     Thread* ignore2,
674                                     SuspendReason reason) {
675   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_;
704     pending_threads.store(list_.size() - num_ignored, std::memory_order_relaxed);
705     // Increment everybody's suspend count (except those that should be ignored).
706     for (const auto& thread : list_) {
707       if (thread == ignore1 || thread == ignore2) {
708         continue;
709       }
710       VLOG(threads) << "requesting thread suspend: " << *thread;
711       bool updated = thread->ModifySuspendCount(self, +1, &pending_threads, reason);
712       DCHECK(updated);
713 
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);
720         pending_threads.fetch_sub(1, std::memory_order_seq_cst);
721       }
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.
727 #if ART_USE_FUTEXES
728   timespec wait_timeout;
729   InitTimeSpec(false, CLOCK_MONOTONIC, NsToMs(thread_suspend_timeout_ns_), 0, &wait_timeout);
730 #endif
731   const uint64_t start_time = NanoTime();
732   while (true) {
733     int32_t cur_val = pending_threads.load(std::memory_order_relaxed);
734     if (LIKELY(cur_val > 0)) {
735 #if ART_USE_FUTEXES
736       if (futex(pending_threads.Address(), FUTEX_WAIT_PRIVATE, cur_val, &wait_timeout, nullptr, 0)
737           != 0) {
738         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             }
754           }
755           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()";
761         }
762       }  // else re-check pending_threads in the next iteration (this may be a spurious wake-up).
763 #else
764       // Spin wait. This is likely to be slow, but on most architecture ART_USE_FUTEXES is set.
765       UNUSED(start_time);
766 #endif
767     } else {
768       CHECK_EQ(cur_val, 0);
769       break;
770     }
771   }
772 }
773 
ResumeAll()774 void ThreadList::ResumeAll() {
775   Thread* self = Thread::Current();
776 
777   if (self != nullptr) {
778     VLOG(threads) << *self << " ResumeAll starting";
779   } else {
780     VLOG(threads) << "Thread[null] ResumeAll starting";
781   }
782 
783   ATraceEnd();
784 
785   ScopedTrace trace("Resuming mutator threads");
786 
787   if (kDebugLocking) {
788     // Debug check that all threads are suspended.
789     AssertThreadsAreSuspended(self, self);
790   }
791 
792   long_suspend_ = false;
793 
794   Locks::mutator_lock_->ExclusiveUnlock(self);
795   {
796     MutexLock mu(self, *Locks::thread_list_lock_);
797     MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
798     // Update global suspend all state for attaching threads.
799     --suspend_all_count_;
800     // Decrement the suspend counts for all threads.
801     for (const auto& thread : list_) {
802       if (thread == self) {
803         continue;
804       }
805       bool updated = thread->ModifySuspendCount(self, -1, nullptr, SuspendReason::kInternal);
806       DCHECK(updated);
807     }
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.
811     if (self != nullptr) {
812       VLOG(threads) << *self << " ResumeAll waking others";
813     } else {
814       VLOG(threads) << "Thread[null] ResumeAll waking others";
815     }
816     Thread::resume_cond_->Broadcast(self);
817   }
818 
819   if (self != nullptr) {
820     VLOG(threads) << *self << " ResumeAll complete";
821   } else {
822     VLOG(threads) << "Thread[null] ResumeAll complete";
823   }
824 }
825 
Resume(Thread * thread,SuspendReason reason)826 bool ThreadList::Resume(Thread* thread, SuspendReason reason) {
827   // This assumes there was an ATraceBegin when we suspended the thread.
828   ATraceEnd();
829 
830   Thread* self = Thread::Current();
831   DCHECK_NE(thread, self);
832   VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") starting..." << reason;
833 
834   {
835     // To check Contains.
836     MutexLock mu(self, *Locks::thread_list_lock_);
837     // To check IsSuspended.
838     MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
839     if (UNLIKELY(!thread->IsSuspended())) {
840       LOG(ERROR) << "Resume(" << reinterpret_cast<void*>(thread)
841           << ") thread not suspended";
842       return false;
843     }
844     if (!Contains(thread)) {
845       // 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";
849       return false;
850     }
851     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     }
856   }
857 
858   {
859     VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") waking others";
860     MutexLock mu(self, *Locks::thread_suspend_count_lock_);
861     Thread::resume_cond_->Broadcast(self);
862   }
863 
864   VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") complete";
865   return true;
866 }
867 
ThreadSuspendByPeerWarning(Thread * self,LogSeverity severity,const char * message,jobject peer)868 static void ThreadSuspendByPeerWarning(Thread* self,
869                                        LogSeverity severity,
870                                        const char* message,
871                                        jobject peer) {
872   JNIEnvExt* env = self->GetJniEnv();
873   ScopedLocalRef<jstring>
874       scoped_name_string(env, static_cast<jstring>(env->GetObjectField(
875           peer, WellKnownClasses::java_lang_Thread_name)));
876   ScopedUtfChars scoped_name_chars(env, scoped_name_string.get());
877   if (scoped_name_chars.c_str() == nullptr) {
878       LOG(severity) << message << ": " << peer;
879       env->ExceptionClear();
880   } else {
881       LOG(severity) << message << ": " << peer << ":" << scoped_name_chars.c_str();
882   }
883 }
884 
SuspendThreadByPeer(jobject peer,bool request_suspension,SuspendReason reason,bool * timed_out)885 Thread* ThreadList::SuspendThreadByPeer(jobject peer,
886                                         bool request_suspension,
887                                         SuspendReason reason,
888                                         bool* timed_out) {
889   const uint64_t start_time = NanoTime();
890   useconds_t sleep_us = kThreadSuspendInitialSleepUs;
891   *timed_out = false;
892   Thread* const self = Thread::Current();
893   Thread* suspended_thread = nullptr;
894   VLOG(threads) << "SuspendThreadByPeer starting";
895   while (true) {
896     Thread* thread;
897     {
898       // 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.
903       ScopedObjectAccess soa(self);
904       MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
905       thread = Thread::FromManagedThread(soa, peer);
906       if (thread == nullptr) {
907         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.
912           bool updated = suspended_thread->ModifySuspendCount(soa.Self(),
913                                                               -1,
914                                                               nullptr,
915                                                               reason);
916           DCHECK(updated);
917         }
918         ThreadSuspendByPeerWarning(self,
919                                    ::android::base::WARNING,
920                                     "No such thread for suspend",
921                                     peer);
922         return nullptr;
923       }
924       if (!Contains(thread)) {
925         CHECK(suspended_thread == nullptr);
926         VLOG(threads) << "SuspendThreadByPeer failed for unattached thread: "
927             << reinterpret_cast<void*>(thread);
928         return nullptr;
929       }
930       VLOG(threads) << "SuspendThreadByPeer found thread: " << *thread;
931       {
932         MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
933         if (request_suspension) {
934           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           }
940           CHECK(suspended_thread == nullptr);
941           suspended_thread = thread;
942           bool updated = suspended_thread->ModifySuspendCount(self, +1, nullptr, reason);
943           DCHECK(updated);
944           request_suspension = false;
945         } 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()) {
958           VLOG(threads) << "SuspendThreadByPeer thread suspended: " << *thread;
959           if (ATraceEnabled()) {
960             std::string name;
961             thread->GetThreadName(name);
962             ATraceBegin(StringPrintf("SuspendThreadByPeer suspended %s for peer=%p", name.c_str(),
963                                       peer).c_str());
964           }
965           return thread;
966         }
967         const uint64_t total_delay = NanoTime() - start_time;
968         if (total_delay >= thread_suspend_timeout_ns_) {
969           ThreadSuspendByPeerWarning(self,
970                                      ::android::base::FATAL,
971                                      "Thread suspension timed out",
972                                      peer);
973           if (suspended_thread != nullptr) {
974             CHECK_EQ(suspended_thread, thread);
975             bool updated = suspended_thread->ModifySuspendCount(soa.Self(),
976                                                                 -1,
977                                                                 nullptr,
978                                                                 reason);
979             DCHECK(updated);
980           }
981           *timed_out = true;
982           return nullptr;
983         } 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;
988         }
989       }
990       // Release locks and come out of runnable state.
991     }
992     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);
997   }
998 }
999 
ThreadSuspendByThreadIdWarning(LogSeverity severity,const char * message,uint32_t thread_id)1000 static void ThreadSuspendByThreadIdWarning(LogSeverity severity,
1001                                            const char* message,
1002                                            uint32_t thread_id) {
1003   LOG(severity) << StringPrintf("%s: %d", message, thread_id);
1004 }
1005 
SuspendThreadByThreadId(uint32_t thread_id,SuspendReason reason,bool * timed_out)1006 Thread* ThreadList::SuspendThreadByThreadId(uint32_t thread_id,
1007                                             SuspendReason reason,
1008                                             bool* timed_out) {
1009   const uint64_t start_time = NanoTime();
1010   useconds_t sleep_us = kThreadSuspendInitialSleepUs;
1011   *timed_out = false;
1012   Thread* suspended_thread = nullptr;
1013   Thread* const self = Thread::Current();
1014   CHECK_NE(thread_id, kInvalidThreadId);
1015   VLOG(threads) << "SuspendThreadByThreadId starting";
1016   while (true) {
1017     {
1018       // 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.
1023       ScopedObjectAccess soa(self);
1024       MutexLock thread_list_mu(self, *Locks::thread_list_lock_);
1025       Thread* thread = nullptr;
1026       for (const auto& it : list_) {
1027         if (it->GetThreadId() == thread_id) {
1028           thread = it;
1029           break;
1030         }
1031       }
1032       if (thread == nullptr) {
1033         CHECK(suspended_thread == nullptr) << "Suspended thread " << suspended_thread
1034             << " no longer in thread list";
1035         // There's a race in inflating a lock and the owner giving up ownership and then dying.
1036         ThreadSuspendByThreadIdWarning(::android::base::WARNING,
1037                                        "No such thread id for suspend",
1038                                        thread_id);
1039         return nullptr;
1040       }
1041       VLOG(threads) << "SuspendThreadByThreadId found thread: " << *thread;
1042       DCHECK(Contains(thread));
1043       {
1044         MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_);
1045         if (suspended_thread == nullptr) {
1046           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           }
1052           bool updated = thread->ModifySuspendCount(self, +1, nullptr, reason);
1053           DCHECK(updated);
1054           suspended_thread = thread;
1055         } else {
1056           CHECK_EQ(suspended_thread, thread);
1057           // 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()) {
1069           if (ATraceEnabled()) {
1070             std::string name;
1071             thread->GetThreadName(name);
1072             ATraceBegin(StringPrintf("SuspendThreadByThreadId suspended %s id=%d",
1073                                       name.c_str(), thread_id).c_str());
1074           }
1075           VLOG(threads) << "SuspendThreadByThreadId thread suspended: " << *thread;
1076           return thread;
1077         }
1078         const uint64_t total_delay = NanoTime() - start_time;
1079         if (total_delay >= thread_suspend_timeout_ns_) {
1080           ThreadSuspendByThreadIdWarning(::android::base::WARNING,
1081                                          "Thread suspension timed out",
1082                                          thread_id);
1083           if (suspended_thread != nullptr) {
1084             bool updated = thread->ModifySuspendCount(soa.Self(), -1, nullptr, reason);
1085             DCHECK(updated);
1086           }
1087           *timed_out = true;
1088           return nullptr;
1089         } 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;
1094         }
1095       }
1096       // Release locks and come out of runnable state.
1097     }
1098     VLOG(threads) << "SuspendThreadByThreadId waiting to allow thread chance to suspend";
1099     ThreadSuspendSleep(sleep_us);
1100     sleep_us = std::min(sleep_us * 2, kThreadSuspendMaxSleepUs);
1101   }
1102 }
1103 
FindThreadByThreadId(uint32_t thread_id)1104 Thread* ThreadList::FindThreadByThreadId(uint32_t thread_id) {
1105   for (const auto& thread : list_) {
1106     if (thread->GetThreadId() == thread_id) {
1107       return thread;
1108     }
1109   }
1110   return nullptr;
1111 }
1112 
WaitForOtherNonDaemonThreadsToExit(bool check_no_birth)1113 void ThreadList::WaitForOtherNonDaemonThreadsToExit(bool check_no_birth) {
1114   ScopedTrace trace(__PRETTY_FUNCTION__);
1115   Thread* self = Thread::Current();
1116   Locks::mutator_lock_->AssertNotHeld(self);
1117   while (true) {
1118     Locks::runtime_shutdown_lock_->Lock(self);
1119     if (check_no_birth) {
1120       // No more threads can be born after we start to shutdown.
1121       CHECK(Runtime::Current()->IsShuttingDownLocked());
1122       CHECK_EQ(Runtime::Current()->NumberOfThreadsBeingBorn(), 0U);
1123     } 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       }
1131     }
1132     MutexLock mu(self, *Locks::thread_list_lock_);
1133     Locks::runtime_shutdown_lock_->Unlock(self);
1134     // 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         }
1144       }
1145     }
1146     if (done) {
1147       break;
1148     }
1149     // Wait for another thread to exit before re-checking.
1150     Locks::thread_exit_cond_->Wait(self);
1151   }
1152 }
1153 
SuspendAllDaemonThreadsForShutdown()1154 void ThreadList::SuspendAllDaemonThreadsForShutdown() {
1155   ScopedTrace trace(__PRETTY_FUNCTION__);
1156   Thread* self = Thread::Current();
1157   size_t daemons_left = 0;
1158   {
1159     // Tell all the daemons it's time to suspend.
1160     MutexLock mu(self, *Locks::thread_list_lock_);
1161     MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
1162     for (const auto& thread : list_) {
1163       // This is only run after all non-daemon threads have exited, so the remainder should all be
1164       // daemons.
1165       CHECK(thread->IsDaemon()) << *thread;
1166       if (thread != self) {
1167         bool updated = thread->ModifySuspendCount(self, +1, nullptr, SuspendReason::kInternal);
1168         DCHECK(updated);
1169         ++daemons_left;
1170       }
1171       // 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();
1174     }
1175   }
1176   if (daemons_left == 0) {
1177     // No threads left; safe to shut down.
1178     return;
1179   }
1180   // 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)
1191   bool have_complained = false;
1192   static constexpr size_t kTimeoutMicroseconds = 2000 * 1000;
1193   static constexpr size_t kSleepMicroseconds = 1000;
1194   bool all_suspended = false;
1195   for (size_t i = 0; !all_suspended && i < kTimeoutMicroseconds / kSleepMicroseconds; ++i) {
1196     bool found_running = false;
1197     {
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           }
1205           found_running = true;
1206         }
1207       }
1208     }
1209     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)
1225   static constexpr size_t kDaemonSleepTime = 200 * 1000;
1226   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);
1245 #if defined(__has_feature)
1246 #if __has_feature(address_sanitizer) || __has_feature(hwaddress_sanitizer)
1247   // Sleep a bit longer with -fsanitize=address, since everything is slower.
1248   usleep(2 * kDaemonSleepTime);
1249 #endif
1250 #endif
1251   // At this point no threads should be touching our data structures anymore.
1252 }
1253 
Register(Thread * self)1254 void ThreadList::Register(Thread* self) {
1255   DCHECK_EQ(self, Thread::Current());
1256   CHECK(!shut_down_);
1257 
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.
1261     LOG(INFO) << "ThreadList::Register() " << *self  << "\n" << oss.str();
1262   }
1263 
1264   // Atomically add self to the thread list and make its thread_suspend_count_ reflect ongoing
1265   // SuspendAll requests.
1266   MutexLock mu(self, *Locks::thread_list_lock_);
1267   MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
1268   // 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.
1270   for (int delta = suspend_all_count_; delta > 0; delta--) {
1271     bool updated = self->ModifySuspendCount(self, +1, nullptr, SuspendReason::kInternal);
1272     DCHECK(updated);
1273   }
1274   CHECK(!Contains(self));
1275   list_.push_back(self);
1276   if (kUseReadBarrier) {
1277     gc::collector::ConcurrentCopying* const cc =
1278         Runtime::Current()->GetHeap()->ConcurrentCopyingCollector();
1279     // Initialize according to the state of the CC collector.
1280     self->SetIsGcMarkingAndUpdateEntrypoints(cc->IsMarking());
1281     if (cc->IsUsingReadBarrierEntrypoints()) {
1282       self->SetReadBarrierEntrypoints();
1283     }
1284     self->SetWeakRefAccessEnabled(cc->IsWeakRefAccessEnabled());
1285   }
1286   self->NotifyInTheadList();
1287 }
1288 
Unregister(Thread * self)1289 void ThreadList::Unregister(Thread* self) {
1290   DCHECK_EQ(self, Thread::Current());
1291   CHECK_NE(self->GetState(), kRunnable);
1292   Locks::mutator_lock_->AssertNotHeld(self);
1293 
1294   VLOG(threads) << "ThreadList::Unregister() " << *self;
1295 
1296   {
1297     MutexLock mu(self, *Locks::thread_list_lock_);
1298     ++unregistering_count_;
1299   }
1300 
1301   // Any time-consuming destruction, plus anything that can call back into managed code or
1302   // 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.
1306   self->Destroy();
1307 
1308   // If tracing, remember thread id and name before thread exits.
1309   Trace::StoreExitingThreadInfo(self);
1310 
1311   uint32_t thin_lock_id = self->GetThreadId();
1312   while (true) {
1313     // 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.
1315     // Note: deliberately not using MutexLock that could hold a stale self pointer.
1316     {
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();
1324         break;
1325       } else {
1326         MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
1327         if (!self->IsSuspended()) {
1328           list_.remove(self);
1329           break;
1330         }
1331       }
1332     }
1333     // 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);
1336     // We failed to remove the thread due to a suspend request, loop and try again.
1337   }
1338   delete self;
1339 
1340   // 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);
1344 
1345   // Clear the TLS data, so that the underlying native thread is recognizably detached.
1346   // (It may wish to reattach later.)
1347 #ifdef __BIONIC__
1348   __get_tls()[TLS_SLOT_ART_THREAD_SELF] = nullptr;
1349 #else
1350   CHECK_PTHREAD_CALL(pthread_setspecific, (Thread::pthread_key_self_, nullptr), "detach self");
1351   Thread::self_tls_ = nullptr;
1352 #endif
1353 
1354   // Signal that a thread just detached.
1355   MutexLock mu(nullptr, *Locks::thread_list_lock_);
1356   --unregistering_count_;
1357   Locks::thread_exit_cond_->Broadcast(nullptr);
1358 }
1359 
ForEach(void (* callback)(Thread *,void *),void * context)1360 void ThreadList::ForEach(void (*callback)(Thread*, void*), void* context) {
1361   for (const auto& thread : list_) {
1362     callback(thread, context);
1363   }
1364 }
1365 
VisitRootsForSuspendedThreads(RootVisitor * visitor)1366 void 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_) {
1375       bool suspended = thread->ModifySuspendCount(self, +1, nullptr, SuspendReason::kInternal);
1376       DCHECK(suspended);
1377       if (thread == self || thread->IsSuspended()) {
1378         threads_to_visit.push_back(thread);
1379       } else {
1380         bool resumed = thread->ModifySuspendCount(self, -1, nullptr, SuspendReason::kInternal);
1381         DCHECK(resumed);
1382       }
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) {
1389     thread->VisitRoots(visitor, kVisitRootFlagAllRoots);
1390   }
1391 
1392   // Restore suspend counts.
1393   {
1394     MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
1395     for (Thread* thread : threads_to_visit) {
1396       bool updated = thread->ModifySuspendCount(self, -1, nullptr, SuspendReason::kInternal);
1397       DCHECK(updated);
1398     }
1399   }
1400 }
1401 
VisitRoots(RootVisitor * visitor,VisitRootFlags flags) const1402 void ThreadList::VisitRoots(RootVisitor* visitor, VisitRootFlags flags) const {
1403   MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
1404   for (const auto& thread : list_) {
1405     thread->VisitRoots(visitor, flags);
1406   }
1407 }
1408 
SweepInterpreterCaches(IsMarkedVisitor * visitor) const1409 void 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 
VisitReflectiveTargets(ReflectiveValueVisitor * visitor) const1416 void 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 
AllocThreadId(Thread * self)1423 uint32_t ThreadList::AllocThreadId(Thread* self) {
1424   MutexLock mu(self, *Locks::allocated_thread_ids_lock_);
1425   for (size_t i = 0; i < allocated_ids_.size(); ++i) {
1426     if (!allocated_ids_[i]) {
1427       allocated_ids_.set(i);
1428       return i + 1;  // Zero is reserved to mean "invalid".
1429     }
1430   }
1431   LOG(FATAL) << "Out of internal thread ids";
1432   UNREACHABLE();
1433 }
1434 
ReleaseThreadId(Thread * self,uint32_t id)1435 void ThreadList::ReleaseThreadId(Thread* self, uint32_t id) {
1436   MutexLock mu(self, *Locks::allocated_thread_ids_lock_);
1437   --id;  // Zero is reserved to mean "invalid".
1438   DCHECK(allocated_ids_[id]) << id;
1439   allocated_ids_.reset(id);
1440 }
1441 
ScopedSuspendAll(const char * cause,bool long_suspend)1442 ScopedSuspendAll::ScopedSuspendAll(const char* cause, bool long_suspend) {
1443   Runtime::Current()->GetThreadList()->SuspendAll(cause, long_suspend);
1444 }
1445 
~ScopedSuspendAll()1446 ScopedSuspendAll::~ScopedSuspendAll() {
1447   Runtime::Current()->GetThreadList()->ResumeAll();
1448 }
1449 
1450 }  // namespace art
1451