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 74 ThreadList::ThreadList(uint64_t thread_suspend_timeout_ns) 75 : suspend_all_count_(0), 76 debug_suspend_all_count_(0), 77 unregistering_count_(0), 78 suspend_all_historam_("suspend all histogram", 16, 64), 79 long_suspend_(false), 80 shut_down_(false), 81 thread_suspend_timeout_ns_(thread_suspend_timeout_ns), 82 empty_checkpoint_barrier_(new Barrier(0)) { 83 CHECK(Monitor::IsValidLockWord(LockWord::FromThinLockId(kMaxThreadId, 1, 0U))); 84 } 85 86 ThreadList::~ThreadList() { 87 CHECK(shut_down_); 88 } 89 90 void ThreadList::ShutDown() { 91 ScopedTrace trace(__PRETTY_FUNCTION__); 92 // Detach the current thread if necessary. If we failed to start, there might not be any threads. 93 // We need to detach the current thread here in case there's another thread waiting to join with 94 // us. 95 bool contains = false; 96 Thread* self = Thread::Current(); 97 { 98 MutexLock mu(self, *Locks::thread_list_lock_); 99 contains = Contains(self); 100 } 101 if (contains) { 102 Runtime::Current()->DetachCurrentThread(); 103 } 104 WaitForOtherNonDaemonThreadsToExit(); 105 // Disable GC and wait for GC to complete in case there are still daemon threads doing 106 // allocations. 107 gc::Heap* const heap = Runtime::Current()->GetHeap(); 108 heap->DisableGCForShutdown(); 109 // In case a GC is in progress, wait for it to finish. 110 heap->WaitForGcToComplete(gc::kGcCauseBackground, Thread::Current()); 111 // TODO: there's an unaddressed race here where a thread may attach during shutdown, see 112 // Thread::Init. 113 SuspendAllDaemonThreadsForShutdown(); 114 115 shut_down_ = true; 116 } 117 118 bool ThreadList::Contains(Thread* thread) { 119 return find(list_.begin(), list_.end(), thread) != list_.end(); 120 } 121 122 bool ThreadList::Contains(pid_t tid) { 123 for (const auto& thread : list_) { 124 if (thread->GetTid() == tid) { 125 return true; 126 } 127 } 128 return false; 129 } 130 131 pid_t ThreadList::GetLockOwner() { 132 return Locks::thread_list_lock_->GetExclusiveOwnerTid(); 133 } 134 135 void ThreadList::DumpNativeStacks(std::ostream& os) { 136 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_); 137 std::unique_ptr<BacktraceMap> map(BacktraceMap::Create(getpid())); 138 for (const auto& thread : list_) { 139 os << "DUMPING THREAD " << thread->GetTid() << "\n"; 140 DumpNativeStack(os, thread->GetTid(), map.get(), "\t"); 141 os << "\n"; 142 } 143 } 144 145 void ThreadList::DumpForSigQuit(std::ostream& os) { 146 { 147 ScopedObjectAccess soa(Thread::Current()); 148 // Only print if we have samples. 149 if (suspend_all_historam_.SampleSize() > 0) { 150 Histogram<uint64_t>::CumulativeData data; 151 suspend_all_historam_.CreateHistogram(&data); 152 suspend_all_historam_.PrintConfidenceIntervals(os, 0.99, data); // Dump time to suspend. 153 } 154 } 155 bool dump_native_stack = Runtime::Current()->GetDumpNativeStackOnSigQuit(); 156 Dump(os, dump_native_stack); 157 DumpUnattachedThreads(os, dump_native_stack && kDumpUnattachedThreadNativeStackForSigQuit); 158 } 159 160 static void DumpUnattachedThread(std::ostream& os, pid_t tid, bool dump_native_stack) 161 NO_THREAD_SAFETY_ANALYSIS { 162 // TODO: No thread safety analysis as DumpState with a null thread won't access fields, should 163 // refactor DumpState to avoid skipping analysis. 164 Thread::DumpState(os, nullptr, tid); 165 DumpKernelStack(os, tid, " kernel: ", false); 166 if (dump_native_stack) { 167 DumpNativeStack(os, tid, nullptr, " native: "); 168 } 169 os << std::endl; 170 } 171 172 void ThreadList::DumpUnattachedThreads(std::ostream& os, bool dump_native_stack) { 173 DIR* d = opendir("/proc/self/task"); 174 if (!d) { 175 return; 176 } 177 178 Thread* self = Thread::Current(); 179 dirent* e; 180 while ((e = readdir(d)) != nullptr) { 181 char* end; 182 pid_t tid = strtol(e->d_name, &end, 10); 183 if (!*end) { 184 bool contains; 185 { 186 MutexLock mu(self, *Locks::thread_list_lock_); 187 contains = Contains(tid); 188 } 189 if (!contains) { 190 DumpUnattachedThread(os, tid, dump_native_stack); 191 } 192 } 193 } 194 closedir(d); 195 } 196 197 // Dump checkpoint timeout in milliseconds. Larger amount on the target, since the device could be 198 // overloaded with ANR dumps. 199 static constexpr uint32_t kDumpWaitTimeout = kIsTargetBuild ? 100000 : 20000; 200 201 // A closure used by Thread::Dump. 202 class DumpCheckpoint final : public Closure { 203 public: 204 DumpCheckpoint(std::ostream* os, bool dump_native_stack) 205 : os_(os), 206 // Avoid verifying count in case a thread doesn't end up passing through the barrier. 207 // This avoids a SIGABRT that would otherwise happen in the destructor. 208 barrier_(0, /*verify_count_on_shutdown=*/false), 209 backtrace_map_(dump_native_stack ? BacktraceMap::Create(getpid()) : nullptr), 210 dump_native_stack_(dump_native_stack) { 211 if (backtrace_map_ != nullptr) { 212 backtrace_map_->SetSuffixesToIgnore(std::vector<std::string> { "oat", "odex" }); 213 } 214 } 215 216 void Run(Thread* thread) override { 217 // Note thread and self may not be equal if thread was already suspended at the point of the 218 // request. 219 Thread* self = Thread::Current(); 220 CHECK(self != nullptr); 221 std::ostringstream local_os; 222 { 223 ScopedObjectAccess soa(self); 224 thread->Dump(local_os, dump_native_stack_, backtrace_map_.get()); 225 } 226 { 227 // Use the logging lock to ensure serialization when writing to the common ostream. 228 MutexLock mu(self, *Locks::logging_lock_); 229 *os_ << local_os.str() << std::endl; 230 } 231 barrier_.Pass(self); 232 } 233 234 void WaitForThreadsToRunThroughCheckpoint(size_t threads_running_checkpoint) { 235 Thread* self = Thread::Current(); 236 ScopedThreadStateChange tsc(self, kWaitingForCheckPointsToRun); 237 bool timed_out = barrier_.Increment(self, threads_running_checkpoint, kDumpWaitTimeout); 238 if (timed_out) { 239 // Avoid a recursive abort. 240 LOG((kIsDebugBuild && (gAborting == 0)) ? ::android::base::FATAL : ::android::base::ERROR) 241 << "Unexpected time out during dump checkpoint."; 242 } 243 } 244 245 private: 246 // The common stream that will accumulate all the dumps. 247 std::ostream* const os_; 248 // The barrier to be passed through and for the requestor to wait upon. 249 Barrier barrier_; 250 // A backtrace map, so that all threads use a shared info and don't reacquire/parse separately. 251 std::unique_ptr<BacktraceMap> backtrace_map_; 252 // Whether we should dump the native stack. 253 const bool dump_native_stack_; 254 }; 255 256 void ThreadList::Dump(std::ostream& os, bool dump_native_stack) { 257 Thread* self = Thread::Current(); 258 { 259 MutexLock mu(self, *Locks::thread_list_lock_); 260 os << "DALVIK THREADS (" << list_.size() << "):\n"; 261 } 262 if (self != nullptr) { 263 DumpCheckpoint checkpoint(&os, dump_native_stack); 264 size_t threads_running_checkpoint; 265 { 266 // Use SOA to prevent deadlocks if multiple threads are calling Dump() at the same time. 267 ScopedObjectAccess soa(self); 268 threads_running_checkpoint = RunCheckpoint(&checkpoint); 269 } 270 if (threads_running_checkpoint != 0) { 271 checkpoint.WaitForThreadsToRunThroughCheckpoint(threads_running_checkpoint); 272 } 273 } else { 274 DumpUnattachedThreads(os, dump_native_stack); 275 } 276 } 277 278 void ThreadList::AssertThreadsAreSuspended(Thread* self, Thread* ignore1, Thread* ignore2) { 279 MutexLock mu(self, *Locks::thread_list_lock_); 280 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 281 for (const auto& thread : list_) { 282 if (thread != ignore1 && thread != ignore2) { 283 CHECK(thread->IsSuspended()) 284 << "\nUnsuspended thread: <<" << *thread << "\n" 285 << "self: <<" << *Thread::Current(); 286 } 287 } 288 } 289 290 #if HAVE_TIMED_RWLOCK 291 // Attempt to rectify locks so that we dump thread list with required locks before exiting. 292 NO_RETURN static void UnsafeLogFatalForThreadSuspendAllTimeout() { 293 // Increment gAborting before doing the thread list dump since we don't want any failures from 294 // AssertThreadSuspensionIsAllowable in cases where thread suspension is not allowed. 295 // See b/69044468. 296 ++gAborting; 297 Runtime* runtime = Runtime::Current(); 298 std::ostringstream ss; 299 ss << "Thread suspend timeout\n"; 300 Locks::mutator_lock_->Dump(ss); 301 ss << "\n"; 302 runtime->GetThreadList()->Dump(ss); 303 --gAborting; 304 LOG(FATAL) << ss.str(); 305 exit(0); 306 } 307 #endif 308 309 // Unlike suspending all threads where we can wait to acquire the mutator_lock_, suspending an 310 // individual thread requires polling. delay_us is the requested sleep wait. If delay_us is 0 then 311 // we use sched_yield instead of calling usleep. 312 // Although there is the possibility, here and elsewhere, that usleep could return -1 and 313 // errno = EINTR, there should be no problem if interrupted, so we do not check. 314 static void ThreadSuspendSleep(useconds_t delay_us) { 315 if (delay_us == 0) { 316 sched_yield(); 317 } else { 318 usleep(delay_us); 319 } 320 } 321 322 size_t ThreadList::RunCheckpoint(Closure* checkpoint_function, Closure* callback) { 323 Thread* self = Thread::Current(); 324 Locks::mutator_lock_->AssertNotExclusiveHeld(self); 325 Locks::thread_list_lock_->AssertNotHeld(self); 326 Locks::thread_suspend_count_lock_->AssertNotHeld(self); 327 328 std::vector<Thread*> suspended_count_modified_threads; 329 size_t count = 0; 330 { 331 // Call a checkpoint function for each thread, threads which are suspend get their checkpoint 332 // manually called. 333 MutexLock mu(self, *Locks::thread_list_lock_); 334 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 335 count = list_.size(); 336 for (const auto& thread : list_) { 337 if (thread != self) { 338 while (true) { 339 if (thread->RequestCheckpoint(checkpoint_function)) { 340 // This thread will run its checkpoint some time in the near future. 341 break; 342 } else { 343 // We are probably suspended, try to make sure that we stay suspended. 344 // The thread switched back to runnable. 345 if (thread->GetState() == kRunnable) { 346 // Spurious fail, try again. 347 continue; 348 } 349 bool updated = thread->ModifySuspendCount(self, +1, nullptr, SuspendReason::kInternal); 350 DCHECK(updated); 351 suspended_count_modified_threads.push_back(thread); 352 break; 353 } 354 } 355 } 356 } 357 // Run the callback to be called inside this critical section. 358 if (callback != nullptr) { 359 callback->Run(self); 360 } 361 } 362 363 // Run the checkpoint on ourself while we wait for threads to suspend. 364 checkpoint_function->Run(self); 365 366 // Run the checkpoint on the suspended threads. 367 for (const auto& thread : suspended_count_modified_threads) { 368 if (!thread->IsSuspended()) { 369 ScopedTrace trace([&]() { 370 std::ostringstream oss; 371 thread->ShortDump(oss); 372 return std::string("Waiting for suspension of thread ") + oss.str(); 373 }); 374 // Busy wait until the thread is suspended. 375 const uint64_t start_time = NanoTime(); 376 do { 377 ThreadSuspendSleep(kThreadSuspendInitialSleepUs); 378 } while (!thread->IsSuspended()); 379 const uint64_t total_delay = NanoTime() - start_time; 380 // Shouldn't need to wait for longer than 1000 microseconds. 381 constexpr uint64_t kLongWaitThreshold = MsToNs(1); 382 if (UNLIKELY(total_delay > kLongWaitThreshold)) { 383 LOG(WARNING) << "Long wait of " << PrettyDuration(total_delay) << " for " 384 << *thread << " suspension!"; 385 } 386 } 387 // We know for sure that the thread is suspended at this point. 388 checkpoint_function->Run(thread); 389 { 390 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 391 bool updated = thread->ModifySuspendCount(self, -1, nullptr, SuspendReason::kInternal); 392 DCHECK(updated); 393 } 394 } 395 396 { 397 // Imitate ResumeAll, threads may be waiting on Thread::resume_cond_ since we raised their 398 // suspend count. Now the suspend_count_ is lowered so we must do the broadcast. 399 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 400 Thread::resume_cond_->Broadcast(self); 401 } 402 403 return count; 404 } 405 406 void ThreadList::RunEmptyCheckpoint() { 407 Thread* self = Thread::Current(); 408 Locks::mutator_lock_->AssertNotExclusiveHeld(self); 409 Locks::thread_list_lock_->AssertNotHeld(self); 410 Locks::thread_suspend_count_lock_->AssertNotHeld(self); 411 std::vector<uint32_t> runnable_thread_ids; 412 size_t count = 0; 413 Barrier* barrier = empty_checkpoint_barrier_.get(); 414 barrier->Init(self, 0); 415 { 416 MutexLock mu(self, *Locks::thread_list_lock_); 417 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 418 for (Thread* thread : list_) { 419 if (thread != self) { 420 while (true) { 421 if (thread->RequestEmptyCheckpoint()) { 422 // This thread will run an empty checkpoint (decrement the empty checkpoint barrier) 423 // some time in the near future. 424 ++count; 425 if (kIsDebugBuild) { 426 runnable_thread_ids.push_back(thread->GetThreadId()); 427 } 428 break; 429 } 430 if (thread->GetState() != kRunnable) { 431 // It's seen suspended, we are done because it must not be in the middle of a mutator 432 // heap access. 433 break; 434 } 435 } 436 } 437 } 438 } 439 440 // Wake up the threads blocking for weak ref access so that they will respond to the empty 441 // checkpoint request. Otherwise we will hang as they are blocking in the kRunnable state. 442 Runtime::Current()->GetHeap()->GetReferenceProcessor()->BroadcastForSlowPath(self); 443 Runtime::Current()->BroadcastForNewSystemWeaks(/*broadcast_for_checkpoint=*/true); 444 { 445 ScopedThreadStateChange tsc(self, kWaitingForCheckPointsToRun); 446 uint64_t total_wait_time = 0; 447 bool first_iter = true; 448 while (true) { 449 // Wake up the runnable threads blocked on the mutexes that another thread, which is blocked 450 // on a weak ref access, holds (indirectly blocking for weak ref access through another thread 451 // and a mutex.) This needs to be done periodically because the thread may be preempted 452 // between the CheckEmptyCheckpointFromMutex call and the subsequent futex wait in 453 // Mutex::ExclusiveLock, etc. when the wakeup via WakeupToRespondToEmptyCheckpoint 454 // arrives. This could cause a *very rare* deadlock, if not repeated. Most of the cases are 455 // handled in the first iteration. 456 for (BaseMutex* mutex : Locks::expected_mutexes_on_weak_ref_access_) { 457 mutex->WakeupToRespondToEmptyCheckpoint(); 458 } 459 static constexpr uint64_t kEmptyCheckpointPeriodicTimeoutMs = 100; // 100ms 460 static constexpr uint64_t kEmptyCheckpointTotalTimeoutMs = 600 * 1000; // 10 minutes. 461 size_t barrier_count = first_iter ? count : 0; 462 first_iter = false; // Don't add to the barrier count from the second iteration on. 463 bool timed_out = barrier->Increment(self, barrier_count, kEmptyCheckpointPeriodicTimeoutMs); 464 if (!timed_out) { 465 break; // Success 466 } 467 // This is a very rare case. 468 total_wait_time += kEmptyCheckpointPeriodicTimeoutMs; 469 if (kIsDebugBuild && total_wait_time > kEmptyCheckpointTotalTimeoutMs) { 470 std::ostringstream ss; 471 ss << "Empty checkpoint timeout\n"; 472 ss << "Barrier count " << barrier->GetCount(self) << "\n"; 473 ss << "Runnable thread IDs"; 474 for (uint32_t tid : runnable_thread_ids) { 475 ss << " " << tid; 476 } 477 ss << "\n"; 478 Locks::mutator_lock_->Dump(ss); 479 ss << "\n"; 480 LOG(FATAL_WITHOUT_ABORT) << ss.str(); 481 // Some threads in 'runnable_thread_ids' are probably stuck. Try to dump their stacks. 482 // Avoid using ThreadList::Dump() initially because it is likely to get stuck as well. 483 { 484 ScopedObjectAccess soa(self); 485 MutexLock mu1(self, *Locks::thread_list_lock_); 486 for (Thread* thread : GetList()) { 487 uint32_t tid = thread->GetThreadId(); 488 bool is_in_runnable_thread_ids = 489 std::find(runnable_thread_ids.begin(), runnable_thread_ids.end(), tid) != 490 runnable_thread_ids.end(); 491 if (is_in_runnable_thread_ids && 492 thread->ReadFlag(kEmptyCheckpointRequest)) { 493 // Found a runnable thread that hasn't responded to the empty checkpoint request. 494 // Assume it's stuck and safe to dump its stack. 495 thread->Dump(LOG_STREAM(FATAL_WITHOUT_ABORT), 496 /*dump_native_stack=*/ true, 497 /*backtrace_map=*/ nullptr, 498 /*force_dump_stack=*/ true); 499 } 500 } 501 } 502 LOG(FATAL_WITHOUT_ABORT) 503 << "Dumped runnable threads that haven't responded to empty checkpoint."; 504 // Now use ThreadList::Dump() to dump more threads, noting it may get stuck. 505 Dump(LOG_STREAM(FATAL_WITHOUT_ABORT)); 506 LOG(FATAL) << "Dumped all threads."; 507 } 508 } 509 } 510 } 511 512 // A checkpoint/suspend-all hybrid to switch thread roots from 513 // from-space to to-space refs. Used to synchronize threads at a point 514 // to mark the initiation of marking while maintaining the to-space 515 // invariant. 516 size_t ThreadList::FlipThreadRoots(Closure* thread_flip_visitor, 517 Closure* flip_callback, 518 gc::collector::GarbageCollector* collector, 519 gc::GcPauseListener* pause_listener) { 520 TimingLogger::ScopedTiming split("ThreadListFlip", collector->GetTimings()); 521 Thread* self = Thread::Current(); 522 Locks::mutator_lock_->AssertNotHeld(self); 523 Locks::thread_list_lock_->AssertNotHeld(self); 524 Locks::thread_suspend_count_lock_->AssertNotHeld(self); 525 CHECK_NE(self->GetState(), kRunnable); 526 527 collector->GetHeap()->ThreadFlipBegin(self); // Sync with JNI critical calls. 528 529 // ThreadFlipBegin happens before we suspend all the threads, so it does not count towards the 530 // pause. 531 const uint64_t suspend_start_time = NanoTime(); 532 SuspendAllInternal(self, self, nullptr); 533 if (pause_listener != nullptr) { 534 pause_listener->StartPause(); 535 } 536 537 // Run the flip callback for the collector. 538 Locks::mutator_lock_->ExclusiveLock(self); 539 suspend_all_historam_.AdjustAndAddValue(NanoTime() - suspend_start_time); 540 flip_callback->Run(self); 541 Locks::mutator_lock_->ExclusiveUnlock(self); 542 collector->RegisterPause(NanoTime() - suspend_start_time); 543 if (pause_listener != nullptr) { 544 pause_listener->EndPause(); 545 } 546 547 // Resume runnable threads. 548 size_t runnable_thread_count = 0; 549 std::vector<Thread*> other_threads; 550 { 551 TimingLogger::ScopedTiming split2("ResumeRunnableThreads", collector->GetTimings()); 552 MutexLock mu(self, *Locks::thread_list_lock_); 553 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 554 --suspend_all_count_; 555 for (const auto& thread : list_) { 556 // Set the flip function for all threads because Thread::DumpState/DumpJavaStack() (invoked by 557 // a checkpoint) may cause the flip function to be run for a runnable/suspended thread before 558 // a runnable thread runs it for itself or we run it for a suspended thread below. 559 thread->SetFlipFunction(thread_flip_visitor); 560 if (thread == self) { 561 continue; 562 } 563 // Resume early the threads that were runnable but are suspended just for this thread flip or 564 // about to transition from non-runnable (eg. kNative at the SOA entry in a JNI function) to 565 // runnable (both cases waiting inside Thread::TransitionFromSuspendedToRunnable), or waiting 566 // for the thread flip to end at the JNI critical section entry (kWaitingForGcThreadFlip), 567 ThreadState state = thread->GetState(); 568 if ((state == kWaitingForGcThreadFlip || thread->IsTransitioningToRunnable()) && 569 thread->GetSuspendCount() == 1) { 570 // The thread will resume right after the broadcast. 571 bool updated = thread->ModifySuspendCount(self, -1, nullptr, SuspendReason::kInternal); 572 DCHECK(updated); 573 ++runnable_thread_count; 574 } else { 575 other_threads.push_back(thread); 576 } 577 } 578 Thread::resume_cond_->Broadcast(self); 579 } 580 581 collector->GetHeap()->ThreadFlipEnd(self); 582 583 // Run the closure on the other threads and let them resume. 584 { 585 TimingLogger::ScopedTiming split3("FlipOtherThreads", collector->GetTimings()); 586 ReaderMutexLock mu(self, *Locks::mutator_lock_); 587 for (const auto& thread : other_threads) { 588 Closure* flip_func = thread->GetFlipFunction(); 589 if (flip_func != nullptr) { 590 flip_func->Run(thread); 591 } 592 } 593 // Run it for self. 594 Closure* flip_func = self->GetFlipFunction(); 595 if (flip_func != nullptr) { 596 flip_func->Run(self); 597 } 598 } 599 600 // Resume other threads. 601 { 602 TimingLogger::ScopedTiming split4("ResumeOtherThreads", collector->GetTimings()); 603 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 604 for (const auto& thread : other_threads) { 605 bool updated = thread->ModifySuspendCount(self, -1, nullptr, SuspendReason::kInternal); 606 DCHECK(updated); 607 } 608 Thread::resume_cond_->Broadcast(self); 609 } 610 611 return runnable_thread_count + other_threads.size() + 1; // +1 for self. 612 } 613 614 void ThreadList::SuspendAll(const char* cause, bool long_suspend) { 615 Thread* self = Thread::Current(); 616 617 if (self != nullptr) { 618 VLOG(threads) << *self << " SuspendAll for " << cause << " starting..."; 619 } else { 620 VLOG(threads) << "Thread[null] SuspendAll for " << cause << " starting..."; 621 } 622 { 623 ScopedTrace trace("Suspending mutator threads"); 624 const uint64_t start_time = NanoTime(); 625 626 SuspendAllInternal(self, self); 627 // All threads are known to have suspended (but a thread may still own the mutator lock) 628 // Make sure this thread grabs exclusive access to the mutator lock and its protected data. 629 #if HAVE_TIMED_RWLOCK 630 while (true) { 631 if (Locks::mutator_lock_->ExclusiveLockWithTimeout(self, 632 NsToMs(thread_suspend_timeout_ns_), 633 0)) { 634 break; 635 } else if (!long_suspend_) { 636 // Reading long_suspend without the mutator lock is slightly racy, in some rare cases, this 637 // could result in a thread suspend timeout. 638 // Timeout if we wait more than thread_suspend_timeout_ns_ nanoseconds. 639 UnsafeLogFatalForThreadSuspendAllTimeout(); 640 } 641 } 642 #else 643 Locks::mutator_lock_->ExclusiveLock(self); 644 #endif 645 646 long_suspend_ = long_suspend; 647 648 const uint64_t end_time = NanoTime(); 649 const uint64_t suspend_time = end_time - start_time; 650 suspend_all_historam_.AdjustAndAddValue(suspend_time); 651 if (suspend_time > kLongThreadSuspendThreshold) { 652 LOG(WARNING) << "Suspending all threads took: " << PrettyDuration(suspend_time); 653 } 654 655 if (kDebugLocking) { 656 // Debug check that all threads are suspended. 657 AssertThreadsAreSuspended(self, self); 658 } 659 } 660 ATraceBegin((std::string("Mutator threads suspended for ") + cause).c_str()); 661 662 if (self != nullptr) { 663 VLOG(threads) << *self << " SuspendAll complete"; 664 } else { 665 VLOG(threads) << "Thread[null] SuspendAll complete"; 666 } 667 } 668 669 // Ensures all threads running Java suspend and that those not running Java don't start. 670 // Debugger thread might be set to kRunnable for a short period of time after the 671 // SuspendAllInternal. This is safe because it will be set back to suspended state before 672 // the SuspendAll returns. 673 void ThreadList::SuspendAllInternal(Thread* self, 674 Thread* ignore1, 675 Thread* ignore2, 676 SuspendReason reason) { 677 Locks::mutator_lock_->AssertNotExclusiveHeld(self); 678 Locks::thread_list_lock_->AssertNotHeld(self); 679 Locks::thread_suspend_count_lock_->AssertNotHeld(self); 680 if (kDebugLocking && self != nullptr) { 681 CHECK_NE(self->GetState(), kRunnable); 682 } 683 684 // First request that all threads suspend, then wait for them to suspend before 685 // returning. This suspension scheme also relies on other behaviour: 686 // 1. Threads cannot be deleted while they are suspended or have a suspend- 687 // request flag set - (see Unregister() below). 688 // 2. When threads are created, they are created in a suspended state (actually 689 // kNative) and will never begin executing Java code without first checking 690 // the suspend-request flag. 691 692 // The atomic counter for number of threads that need to pass the barrier. 693 AtomicInteger pending_threads; 694 uint32_t num_ignored = 0; 695 if (ignore1 != nullptr) { 696 ++num_ignored; 697 } 698 if (ignore2 != nullptr && ignore1 != ignore2) { 699 ++num_ignored; 700 } 701 { 702 MutexLock mu(self, *Locks::thread_list_lock_); 703 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 704 // Update global suspend all state for attaching threads. 705 ++suspend_all_count_; 706 if (reason == SuspendReason::kForDebugger) { 707 ++debug_suspend_all_count_; 708 } 709 pending_threads.store(list_.size() - num_ignored, std::memory_order_relaxed); 710 // Increment everybody's suspend count (except those that should be ignored). 711 for (const auto& thread : list_) { 712 if (thread == ignore1 || thread == ignore2) { 713 continue; 714 } 715 VLOG(threads) << "requesting thread suspend: " << *thread; 716 bool updated = thread->ModifySuspendCount(self, +1, &pending_threads, reason); 717 DCHECK(updated); 718 719 // Must install the pending_threads counter first, then check thread->IsSuspend() and clear 720 // the counter. Otherwise there's a race with Thread::TransitionFromRunnableToSuspended() 721 // that can lead a thread to miss a call to PassActiveSuspendBarriers(). 722 if (thread->IsSuspended()) { 723 // Only clear the counter for the current thread. 724 thread->ClearSuspendBarrier(&pending_threads); 725 pending_threads.fetch_sub(1, std::memory_order_seq_cst); 726 } 727 } 728 } 729 730 // Wait for the barrier to be passed by all runnable threads. This wait 731 // is done with a timeout so that we can detect problems. 732 #if ART_USE_FUTEXES 733 timespec wait_timeout; 734 InitTimeSpec(false, CLOCK_MONOTONIC, NsToMs(thread_suspend_timeout_ns_), 0, &wait_timeout); 735 #endif 736 const uint64_t start_time = NanoTime(); 737 while (true) { 738 int32_t cur_val = pending_threads.load(std::memory_order_relaxed); 739 if (LIKELY(cur_val > 0)) { 740 #if ART_USE_FUTEXES 741 if (futex(pending_threads.Address(), FUTEX_WAIT_PRIVATE, cur_val, &wait_timeout, nullptr, 0) 742 != 0) { 743 if ((errno == EAGAIN) || (errno == EINTR)) { 744 // EAGAIN and EINTR both indicate a spurious failure, try again from the beginning. 745 continue; 746 } 747 if (errno == ETIMEDOUT) { 748 const uint64_t wait_time = NanoTime() - start_time; 749 MutexLock mu(self, *Locks::thread_list_lock_); 750 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 751 std::ostringstream oss; 752 for (const auto& thread : list_) { 753 if (thread == ignore1 || thread == ignore2) { 754 continue; 755 } 756 if (!thread->IsSuspended()) { 757 oss << std::endl << "Thread not suspended: " << *thread; 758 } 759 } 760 LOG(kIsDebugBuild ? ::android::base::FATAL : ::android::base::ERROR) 761 << "Timed out waiting for threads to suspend, waited for " 762 << PrettyDuration(wait_time) 763 << oss.str(); 764 } else { 765 PLOG(FATAL) << "futex wait failed for SuspendAllInternal()"; 766 } 767 } // else re-check pending_threads in the next iteration (this may be a spurious wake-up). 768 #else 769 // Spin wait. This is likely to be slow, but on most architecture ART_USE_FUTEXES is set. 770 UNUSED(start_time); 771 #endif 772 } else { 773 CHECK_EQ(cur_val, 0); 774 break; 775 } 776 } 777 } 778 779 void ThreadList::ResumeAll() { 780 Thread* self = Thread::Current(); 781 782 if (self != nullptr) { 783 VLOG(threads) << *self << " ResumeAll starting"; 784 } else { 785 VLOG(threads) << "Thread[null] ResumeAll starting"; 786 } 787 788 ATraceEnd(); 789 790 ScopedTrace trace("Resuming mutator threads"); 791 792 if (kDebugLocking) { 793 // Debug check that all threads are suspended. 794 AssertThreadsAreSuspended(self, self); 795 } 796 797 long_suspend_ = false; 798 799 Locks::mutator_lock_->ExclusiveUnlock(self); 800 { 801 MutexLock mu(self, *Locks::thread_list_lock_); 802 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 803 // Update global suspend all state for attaching threads. 804 --suspend_all_count_; 805 // Decrement the suspend counts for all threads. 806 for (const auto& thread : list_) { 807 if (thread == self) { 808 continue; 809 } 810 bool updated = thread->ModifySuspendCount(self, -1, nullptr, SuspendReason::kInternal); 811 DCHECK(updated); 812 } 813 814 // Broadcast a notification to all suspended threads, some or all of 815 // which may choose to wake up. No need to wait for them. 816 if (self != nullptr) { 817 VLOG(threads) << *self << " ResumeAll waking others"; 818 } else { 819 VLOG(threads) << "Thread[null] ResumeAll waking others"; 820 } 821 Thread::resume_cond_->Broadcast(self); 822 } 823 824 if (self != nullptr) { 825 VLOG(threads) << *self << " ResumeAll complete"; 826 } else { 827 VLOG(threads) << "Thread[null] ResumeAll complete"; 828 } 829 } 830 831 bool ThreadList::Resume(Thread* thread, SuspendReason reason) { 832 // This assumes there was an ATraceBegin when we suspended the thread. 833 ATraceEnd(); 834 835 Thread* self = Thread::Current(); 836 DCHECK_NE(thread, self); 837 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") starting..." << reason; 838 839 { 840 // To check Contains. 841 MutexLock mu(self, *Locks::thread_list_lock_); 842 // To check IsSuspended. 843 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 844 if (UNLIKELY(!thread->IsSuspended())) { 845 LOG(ERROR) << "Resume(" << reinterpret_cast<void*>(thread) 846 << ") thread not suspended"; 847 return false; 848 } 849 if (!Contains(thread)) { 850 // We only expect threads within the thread-list to have been suspended otherwise we can't 851 // stop such threads from delete-ing themselves. 852 LOG(ERROR) << "Resume(" << reinterpret_cast<void*>(thread) 853 << ") thread not within thread list"; 854 return false; 855 } 856 if (UNLIKELY(!thread->ModifySuspendCount(self, -1, nullptr, reason))) { 857 LOG(ERROR) << "Resume(" << reinterpret_cast<void*>(thread) 858 << ") could not modify suspend count."; 859 return false; 860 } 861 } 862 863 { 864 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") waking others"; 865 MutexLock mu(self, *Locks::thread_suspend_count_lock_); 866 Thread::resume_cond_->Broadcast(self); 867 } 868 869 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") complete"; 870 return true; 871 } 872 873 static void ThreadSuspendByPeerWarning(Thread* self, 874 LogSeverity severity, 875 const char* message, 876 jobject peer) { 877 JNIEnvExt* env = self->GetJniEnv(); 878 ScopedLocalRef<jstring> 879 scoped_name_string(env, static_cast<jstring>(env->GetObjectField( 880 peer, WellKnownClasses::java_lang_Thread_name))); 881 ScopedUtfChars scoped_name_chars(env, scoped_name_string.get()); 882 if (scoped_name_chars.c_str() == nullptr) { 883 LOG(severity) << message << ": " << peer; 884 env->ExceptionClear(); 885 } else { 886 LOG(severity) << message << ": " << peer << ":" << scoped_name_chars.c_str(); 887 } 888 } 889 890 Thread* ThreadList::SuspendThreadByPeer(jobject peer, 891 bool request_suspension, 892 SuspendReason reason, 893 bool* timed_out) { 894 const uint64_t start_time = NanoTime(); 895 useconds_t sleep_us = kThreadSuspendInitialSleepUs; 896 *timed_out = false; 897 Thread* const self = Thread::Current(); 898 Thread* suspended_thread = nullptr; 899 VLOG(threads) << "SuspendThreadByPeer starting"; 900 while (true) { 901 Thread* thread; 902 { 903 // Note: this will transition to runnable and potentially suspend. We ensure only one thread 904 // is requesting another suspend, to avoid deadlock, by requiring this function be called 905 // holding Locks::thread_list_suspend_thread_lock_. Its important this thread suspend rather 906 // than request thread suspension, to avoid potential cycles in threads requesting each other 907 // suspend. 908 ScopedObjectAccess soa(self); 909 MutexLock thread_list_mu(self, *Locks::thread_list_lock_); 910 thread = Thread::FromManagedThread(soa, peer); 911 if (thread == nullptr) { 912 if (suspended_thread != nullptr) { 913 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_); 914 // If we incremented the suspend count but the thread reset its peer, we need to 915 // re-decrement it since it is shutting down and may deadlock the runtime in 916 // ThreadList::WaitForOtherNonDaemonThreadsToExit. 917 bool updated = suspended_thread->ModifySuspendCount(soa.Self(), 918 -1, 919 nullptr, 920 reason); 921 DCHECK(updated); 922 } 923 ThreadSuspendByPeerWarning(self, 924 ::android::base::WARNING, 925 "No such thread for suspend", 926 peer); 927 return nullptr; 928 } 929 if (!Contains(thread)) { 930 CHECK(suspended_thread == nullptr); 931 VLOG(threads) << "SuspendThreadByPeer failed for unattached thread: " 932 << reinterpret_cast<void*>(thread); 933 return nullptr; 934 } 935 VLOG(threads) << "SuspendThreadByPeer found thread: " << *thread; 936 { 937 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_); 938 if (request_suspension) { 939 if (self->GetSuspendCount() > 0) { 940 // We hold the suspend count lock but another thread is trying to suspend us. Its not 941 // safe to try to suspend another thread in case we get a cycle. Start the loop again 942 // which will allow this thread to be suspended. 943 continue; 944 } 945 CHECK(suspended_thread == nullptr); 946 suspended_thread = thread; 947 bool updated = suspended_thread->ModifySuspendCount(self, +1, nullptr, reason); 948 DCHECK(updated); 949 request_suspension = false; 950 } else { 951 // If the caller isn't requesting suspension, a suspension should have already occurred. 952 CHECK_GT(thread->GetSuspendCount(), 0); 953 } 954 // IsSuspended on the current thread will fail as the current thread is changed into 955 // Runnable above. As the suspend count is now raised if this is the current thread 956 // it will self suspend on transition to Runnable, making it hard to work with. It's simpler 957 // to just explicitly handle the current thread in the callers to this code. 958 CHECK_NE(thread, self) << "Attempt to suspend the current thread for the debugger"; 959 // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend 960 // count, or else we've waited and it has self suspended) or is the current thread, we're 961 // done. 962 if (thread->IsSuspended()) { 963 VLOG(threads) << "SuspendThreadByPeer thread suspended: " << *thread; 964 if (ATraceEnabled()) { 965 std::string name; 966 thread->GetThreadName(name); 967 ATraceBegin(StringPrintf("SuspendThreadByPeer suspended %s for peer=%p", name.c_str(), 968 peer).c_str()); 969 } 970 return thread; 971 } 972 const uint64_t total_delay = NanoTime() - start_time; 973 if (total_delay >= thread_suspend_timeout_ns_) { 974 ThreadSuspendByPeerWarning(self, 975 ::android::base::FATAL, 976 "Thread suspension timed out", 977 peer); 978 if (suspended_thread != nullptr) { 979 CHECK_EQ(suspended_thread, thread); 980 bool updated = suspended_thread->ModifySuspendCount(soa.Self(), 981 -1, 982 nullptr, 983 reason); 984 DCHECK(updated); 985 } 986 *timed_out = true; 987 return nullptr; 988 } else if (sleep_us == 0 && 989 total_delay > static_cast<uint64_t>(kThreadSuspendMaxYieldUs) * 1000) { 990 // We have spun for kThreadSuspendMaxYieldUs time, switch to sleeps to prevent 991 // excessive CPU usage. 992 sleep_us = kThreadSuspendMaxYieldUs / 2; 993 } 994 } 995 // Release locks and come out of runnable state. 996 } 997 VLOG(threads) << "SuspendThreadByPeer waiting to allow thread chance to suspend"; 998 ThreadSuspendSleep(sleep_us); 999 // This may stay at 0 if sleep_us == 0, but this is WAI since we want to avoid using usleep at 1000 // all if possible. This shouldn't be an issue since time to suspend should always be small. 1001 sleep_us = std::min(sleep_us * 2, kThreadSuspendMaxSleepUs); 1002 } 1003 } 1004 1005 static void ThreadSuspendByThreadIdWarning(LogSeverity severity, 1006 const char* message, 1007 uint32_t thread_id) { 1008 LOG(severity) << StringPrintf("%s: %d", message, thread_id); 1009 } 1010 1011 Thread* ThreadList::SuspendThreadByThreadId(uint32_t thread_id, 1012 SuspendReason reason, 1013 bool* timed_out) { 1014 const uint64_t start_time = NanoTime(); 1015 useconds_t sleep_us = kThreadSuspendInitialSleepUs; 1016 *timed_out = false; 1017 Thread* suspended_thread = nullptr; 1018 Thread* const self = Thread::Current(); 1019 CHECK_NE(thread_id, kInvalidThreadId); 1020 VLOG(threads) << "SuspendThreadByThreadId starting"; 1021 while (true) { 1022 { 1023 // Note: this will transition to runnable and potentially suspend. We ensure only one thread 1024 // is requesting another suspend, to avoid deadlock, by requiring this function be called 1025 // holding Locks::thread_list_suspend_thread_lock_. Its important this thread suspend rather 1026 // than request thread suspension, to avoid potential cycles in threads requesting each other 1027 // suspend. 1028 ScopedObjectAccess soa(self); 1029 MutexLock thread_list_mu(self, *Locks::thread_list_lock_); 1030 Thread* thread = nullptr; 1031 for (const auto& it : list_) { 1032 if (it->GetThreadId() == thread_id) { 1033 thread = it; 1034 break; 1035 } 1036 } 1037 if (thread == nullptr) { 1038 CHECK(suspended_thread == nullptr) << "Suspended thread " << suspended_thread 1039 << " no longer in thread list"; 1040 // There's a race in inflating a lock and the owner giving up ownership and then dying. 1041 ThreadSuspendByThreadIdWarning(::android::base::WARNING, 1042 "No such thread id for suspend", 1043 thread_id); 1044 return nullptr; 1045 } 1046 VLOG(threads) << "SuspendThreadByThreadId found thread: " << *thread; 1047 DCHECK(Contains(thread)); 1048 { 1049 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_); 1050 if (suspended_thread == nullptr) { 1051 if (self->GetSuspendCount() > 0) { 1052 // We hold the suspend count lock but another thread is trying to suspend us. Its not 1053 // safe to try to suspend another thread in case we get a cycle. Start the loop again 1054 // which will allow this thread to be suspended. 1055 continue; 1056 } 1057 bool updated = thread->ModifySuspendCount(self, +1, nullptr, reason); 1058 DCHECK(updated); 1059 suspended_thread = thread; 1060 } else { 1061 CHECK_EQ(suspended_thread, thread); 1062 // If the caller isn't requesting suspension, a suspension should have already occurred. 1063 CHECK_GT(thread->GetSuspendCount(), 0); 1064 } 1065 // IsSuspended on the current thread will fail as the current thread is changed into 1066 // Runnable above. As the suspend count is now raised if this is the current thread 1067 // it will self suspend on transition to Runnable, making it hard to work with. It's simpler 1068 // to just explicitly handle the current thread in the callers to this code. 1069 CHECK_NE(thread, self) << "Attempt to suspend the current thread for the debugger"; 1070 // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend 1071 // count, or else we've waited and it has self suspended) or is the current thread, we're 1072 // done. 1073 if (thread->IsSuspended()) { 1074 if (ATraceEnabled()) { 1075 std::string name; 1076 thread->GetThreadName(name); 1077 ATraceBegin(StringPrintf("SuspendThreadByThreadId suspended %s id=%d", 1078 name.c_str(), thread_id).c_str()); 1079 } 1080 VLOG(threads) << "SuspendThreadByThreadId thread suspended: " << *thread; 1081 return thread; 1082 } 1083 const uint64_t total_delay = NanoTime() - start_time; 1084 if (total_delay >= thread_suspend_timeout_ns_) { 1085 ThreadSuspendByThreadIdWarning(::android::base::WARNING, 1086 "Thread suspension timed out", 1087 thread_id); 1088 if (suspended_thread != nullptr) { 1089 bool updated = thread->ModifySuspendCount(soa.Self(), -1, nullptr, reason); 1090 DCHECK(updated); 1091 } 1092 *timed_out = true; 1093 return nullptr; 1094 } else if (sleep_us == 0 && 1095 total_delay > static_cast<uint64_t>(kThreadSuspendMaxYieldUs) * 1000) { 1096 // We have spun for kThreadSuspendMaxYieldUs time, switch to sleeps to prevent 1097 // excessive CPU usage. 1098 sleep_us = kThreadSuspendMaxYieldUs / 2; 1099 } 1100 } 1101 // Release locks and come out of runnable state. 1102 } 1103 VLOG(threads) << "SuspendThreadByThreadId waiting to allow thread chance to suspend"; 1104 ThreadSuspendSleep(sleep_us); 1105 sleep_us = std::min(sleep_us * 2, kThreadSuspendMaxSleepUs); 1106 } 1107 } 1108 1109 Thread* ThreadList::FindThreadByThreadId(uint32_t thread_id) { 1110 for (const auto& thread : list_) { 1111 if (thread->GetThreadId() == thread_id) { 1112 return thread; 1113 } 1114 } 1115 return nullptr; 1116 } 1117 1118 void ThreadList::SuspendAllForDebugger() { 1119 Thread* self = Thread::Current(); 1120 Thread* debug_thread = Dbg::GetDebugThread(); 1121 1122 VLOG(threads) << *self << " SuspendAllForDebugger starting..."; 1123 1124 SuspendAllInternal(self, self, debug_thread, SuspendReason::kForDebugger); 1125 // Block on the mutator lock until all Runnable threads release their share of access then 1126 // immediately unlock again. 1127 #if HAVE_TIMED_RWLOCK 1128 // Timeout if we wait more than 30 seconds. 1129 if (!Locks::mutator_lock_->ExclusiveLockWithTimeout(self, 30 * 1000, 0)) { 1130 UnsafeLogFatalForThreadSuspendAllTimeout(); 1131 } else { 1132 Locks::mutator_lock_->ExclusiveUnlock(self); 1133 } 1134 #else 1135 Locks::mutator_lock_->ExclusiveLock(self); 1136 Locks::mutator_lock_->ExclusiveUnlock(self); 1137 #endif 1138 // Disabled for the following race condition: 1139 // Thread 1 calls SuspendAllForDebugger, gets preempted after pulsing the mutator lock. 1140 // Thread 2 calls SuspendAll and SetStateUnsafe (perhaps from Dbg::Disconnected). 1141 // Thread 1 fails assertion that all threads are suspended due to thread 2 being in a runnable 1142 // state (from SetStateUnsafe). 1143 // AssertThreadsAreSuspended(self, self, debug_thread); 1144 1145 VLOG(threads) << *self << " SuspendAllForDebugger complete"; 1146 } 1147 1148 void ThreadList::SuspendSelfForDebugger() { 1149 Thread* const self = Thread::Current(); 1150 self->SetReadyForDebugInvoke(true); 1151 1152 // The debugger thread must not suspend itself due to debugger activity! 1153 Thread* debug_thread = Dbg::GetDebugThread(); 1154 CHECK(self != debug_thread); 1155 CHECK_NE(self->GetState(), kRunnable); 1156 Locks::mutator_lock_->AssertNotHeld(self); 1157 1158 // The debugger may have detached while we were executing an invoke request. In that case, we 1159 // must not suspend ourself. 1160 DebugInvokeReq* pReq = self->GetInvokeReq(); 1161 const bool skip_thread_suspension = (pReq != nullptr && !Dbg::IsDebuggerActive()); 1162 if (!skip_thread_suspension) { 1163 // Collisions with other suspends aren't really interesting. We want 1164 // to ensure that we're the only one fiddling with the suspend count 1165 // though. 1166 MutexLock mu(self, *Locks::thread_suspend_count_lock_); 1167 bool updated = self->ModifySuspendCount(self, +1, nullptr, SuspendReason::kForDebugger); 1168 DCHECK(updated); 1169 CHECK_GT(self->GetSuspendCount(), 0); 1170 1171 VLOG(threads) << *self << " self-suspending (debugger)"; 1172 } else { 1173 // We must no longer be subject to debugger suspension. 1174 MutexLock mu(self, *Locks::thread_suspend_count_lock_); 1175 CHECK_EQ(self->GetDebugSuspendCount(), 0) << "Debugger detached without resuming us"; 1176 1177 VLOG(threads) << *self << " not self-suspending because debugger detached during invoke"; 1178 } 1179 1180 // If the debugger requested an invoke, we need to send the reply and clear the request. 1181 if (pReq != nullptr) { 1182 Dbg::FinishInvokeMethod(pReq); 1183 self->ClearDebugInvokeReq(); 1184 pReq = nullptr; // object has been deleted, clear it for safety. 1185 } 1186 1187 // Tell JDWP that we've completed suspension. The JDWP thread can't 1188 // tell us to resume before we're fully asleep because we hold the 1189 // suspend count lock. 1190 Dbg::ClearWaitForEventThread(); 1191 1192 { 1193 MutexLock mu(self, *Locks::thread_suspend_count_lock_); 1194 while (self->GetSuspendCount() != 0) { 1195 Thread::resume_cond_->Wait(self); 1196 if (self->GetSuspendCount() != 0) { 1197 // The condition was signaled but we're still suspended. This 1198 // can happen when we suspend then resume all threads to 1199 // update instrumentation or compute monitor info. This can 1200 // also happen if the debugger lets go while a SIGQUIT thread 1201 // dump event is pending (assuming SignalCatcher was resumed for 1202 // just long enough to try to grab the thread-suspend lock). 1203 VLOG(jdwp) << *self << " still suspended after undo " 1204 << "(suspend count=" << self->GetSuspendCount() << ", " 1205 << "debug suspend count=" << self->GetDebugSuspendCount() << ")"; 1206 } 1207 } 1208 CHECK_EQ(self->GetSuspendCount(), 0); 1209 } 1210 1211 self->SetReadyForDebugInvoke(false); 1212 VLOG(threads) << *self << " self-reviving (debugger)"; 1213 } 1214 1215 void ThreadList::ResumeAllForDebugger() { 1216 Thread* self = Thread::Current(); 1217 Thread* debug_thread = Dbg::GetDebugThread(); 1218 1219 VLOG(threads) << *self << " ResumeAllForDebugger starting..."; 1220 1221 // Threads can't resume if we exclusively hold the mutator lock. 1222 Locks::mutator_lock_->AssertNotExclusiveHeld(self); 1223 1224 { 1225 MutexLock thread_list_mu(self, *Locks::thread_list_lock_); 1226 { 1227 MutexLock suspend_count_mu(self, *Locks::thread_suspend_count_lock_); 1228 // Update global suspend all state for attaching threads. 1229 DCHECK_GE(suspend_all_count_, debug_suspend_all_count_); 1230 if (debug_suspend_all_count_ > 0) { 1231 --suspend_all_count_; 1232 --debug_suspend_all_count_; 1233 } else { 1234 // We've been asked to resume all threads without being asked to 1235 // suspend them all before. That may happen if a debugger tries 1236 // to resume some suspended threads (with suspend count == 1) 1237 // at once with a VirtualMachine.Resume command. Let's print a 1238 // warning. 1239 LOG(WARNING) << "Debugger attempted to resume all threads without " 1240 << "having suspended them all before."; 1241 } 1242 // Decrement everybody's suspend count (except our own). 1243 for (const auto& thread : list_) { 1244 if (thread == self || thread == debug_thread) { 1245 continue; 1246 } 1247 if (thread->GetDebugSuspendCount() == 0) { 1248 // This thread may have been individually resumed with ThreadReference.Resume. 1249 continue; 1250 } 1251 VLOG(threads) << "requesting thread resume: " << *thread; 1252 bool updated = thread->ModifySuspendCount(self, -1, nullptr, SuspendReason::kForDebugger); 1253 DCHECK(updated); 1254 } 1255 } 1256 } 1257 1258 { 1259 MutexLock mu(self, *Locks::thread_suspend_count_lock_); 1260 Thread::resume_cond_->Broadcast(self); 1261 } 1262 1263 VLOG(threads) << *self << " ResumeAllForDebugger complete"; 1264 } 1265 1266 void ThreadList::UndoDebuggerSuspensions() { 1267 Thread* self = Thread::Current(); 1268 1269 VLOG(threads) << *self << " UndoDebuggerSuspensions starting"; 1270 1271 { 1272 MutexLock mu(self, *Locks::thread_list_lock_); 1273 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 1274 // Update global suspend all state for attaching threads. 1275 suspend_all_count_ -= debug_suspend_all_count_; 1276 debug_suspend_all_count_ = 0; 1277 // Update running threads. 1278 for (const auto& thread : list_) { 1279 if (thread == self || thread->GetDebugSuspendCount() == 0) { 1280 continue; 1281 } 1282 bool suspended = thread->ModifySuspendCount(self, 1283 -thread->GetDebugSuspendCount(), 1284 nullptr, 1285 SuspendReason::kForDebugger); 1286 DCHECK(suspended); 1287 } 1288 } 1289 1290 { 1291 MutexLock mu(self, *Locks::thread_suspend_count_lock_); 1292 Thread::resume_cond_->Broadcast(self); 1293 } 1294 1295 VLOG(threads) << "UndoDebuggerSuspensions(" << *self << ") complete"; 1296 } 1297 1298 void ThreadList::WaitForOtherNonDaemonThreadsToExit() { 1299 ScopedTrace trace(__PRETTY_FUNCTION__); 1300 Thread* self = Thread::Current(); 1301 Locks::mutator_lock_->AssertNotHeld(self); 1302 while (true) { 1303 { 1304 // No more threads can be born after we start to shutdown. 1305 MutexLock mu(self, *Locks::runtime_shutdown_lock_); 1306 CHECK(Runtime::Current()->IsShuttingDownLocked()); 1307 CHECK_EQ(Runtime::Current()->NumberOfThreadsBeingBorn(), 0U); 1308 } 1309 MutexLock mu(self, *Locks::thread_list_lock_); 1310 // Also wait for any threads that are unregistering to finish. This is required so that no 1311 // threads access the thread list after it is deleted. TODO: This may not work for user daemon 1312 // threads since they could unregister at the wrong time. 1313 bool done = unregistering_count_ == 0; 1314 if (done) { 1315 for (const auto& thread : list_) { 1316 if (thread != self && !thread->IsDaemon()) { 1317 done = false; 1318 break; 1319 } 1320 } 1321 } 1322 if (done) { 1323 break; 1324 } 1325 // Wait for another thread to exit before re-checking. 1326 Locks::thread_exit_cond_->Wait(self); 1327 } 1328 } 1329 1330 void ThreadList::SuspendAllDaemonThreadsForShutdown() { 1331 ScopedTrace trace(__PRETTY_FUNCTION__); 1332 Thread* self = Thread::Current(); 1333 size_t daemons_left = 0; 1334 { 1335 // Tell all the daemons it's time to suspend. 1336 MutexLock mu(self, *Locks::thread_list_lock_); 1337 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 1338 for (const auto& thread : list_) { 1339 // This is only run after all non-daemon threads have exited, so the remainder should all be 1340 // daemons. 1341 CHECK(thread->IsDaemon()) << *thread; 1342 if (thread != self) { 1343 bool updated = thread->ModifySuspendCount(self, +1, nullptr, SuspendReason::kInternal); 1344 DCHECK(updated); 1345 ++daemons_left; 1346 } 1347 // We are shutting down the runtime, set the JNI functions of all the JNIEnvs to be 1348 // the sleep forever one. 1349 thread->GetJniEnv()->SetFunctionsToRuntimeShutdownFunctions(); 1350 } 1351 } 1352 // If we have any daemons left, wait 200ms to ensure they are not stuck in a place where they 1353 // are about to access runtime state and are not in a runnable state. Examples: Monitor code 1354 // or waking up from a condition variable. TODO: Try and see if there is a better way to wait 1355 // for daemon threads to be in a blocked state. 1356 if (daemons_left > 0) { 1357 static constexpr size_t kDaemonSleepTime = 200 * 1000; 1358 usleep(kDaemonSleepTime); 1359 } 1360 // Give the threads a chance to suspend, complaining if they're slow. 1361 bool have_complained = false; 1362 static constexpr size_t kTimeoutMicroseconds = 2000 * 1000; 1363 static constexpr size_t kSleepMicroseconds = 1000; 1364 for (size_t i = 0; i < kTimeoutMicroseconds / kSleepMicroseconds; ++i) { 1365 bool all_suspended = true; 1366 { 1367 MutexLock mu(self, *Locks::thread_list_lock_); 1368 for (const auto& thread : list_) { 1369 if (thread != self && thread->GetState() == kRunnable) { 1370 if (!have_complained) { 1371 LOG(WARNING) << "daemon thread not yet suspended: " << *thread; 1372 have_complained = true; 1373 } 1374 all_suspended = false; 1375 } 1376 } 1377 } 1378 if (all_suspended) { 1379 return; 1380 } 1381 usleep(kSleepMicroseconds); 1382 } 1383 LOG(WARNING) << "timed out suspending all daemon threads"; 1384 } 1385 1386 void ThreadList::Register(Thread* self) { 1387 DCHECK_EQ(self, Thread::Current()); 1388 CHECK(!shut_down_); 1389 1390 if (VLOG_IS_ON(threads)) { 1391 std::ostringstream oss; 1392 self->ShortDump(oss); // We don't hold the mutator_lock_ yet and so cannot call Dump. 1393 LOG(INFO) << "ThreadList::Register() " << *self << "\n" << oss.str(); 1394 } 1395 1396 // Atomically add self to the thread list and make its thread_suspend_count_ reflect ongoing 1397 // SuspendAll requests. 1398 MutexLock mu(self, *Locks::thread_list_lock_); 1399 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 1400 CHECK_GE(suspend_all_count_, debug_suspend_all_count_); 1401 // Modify suspend count in increments of 1 to maintain invariants in ModifySuspendCount. While 1402 // this isn't particularly efficient the suspend counts are most commonly 0 or 1. 1403 for (int delta = debug_suspend_all_count_; delta > 0; delta--) { 1404 bool updated = self->ModifySuspendCount(self, +1, nullptr, SuspendReason::kForDebugger); 1405 DCHECK(updated); 1406 } 1407 for (int delta = suspend_all_count_ - debug_suspend_all_count_; delta > 0; delta--) { 1408 bool updated = self->ModifySuspendCount(self, +1, nullptr, SuspendReason::kInternal); 1409 DCHECK(updated); 1410 } 1411 CHECK(!Contains(self)); 1412 list_.push_back(self); 1413 if (kUseReadBarrier) { 1414 gc::collector::ConcurrentCopying* const cc = 1415 Runtime::Current()->GetHeap()->ConcurrentCopyingCollector(); 1416 // Initialize according to the state of the CC collector. 1417 self->SetIsGcMarkingAndUpdateEntrypoints(cc->IsMarking()); 1418 if (cc->IsUsingReadBarrierEntrypoints()) { 1419 self->SetReadBarrierEntrypoints(); 1420 } 1421 self->SetWeakRefAccessEnabled(cc->IsWeakRefAccessEnabled()); 1422 } 1423 self->NotifyInTheadList(); 1424 } 1425 1426 void ThreadList::Unregister(Thread* self) { 1427 DCHECK_EQ(self, Thread::Current()); 1428 CHECK_NE(self->GetState(), kRunnable); 1429 Locks::mutator_lock_->AssertNotHeld(self); 1430 1431 VLOG(threads) << "ThreadList::Unregister() " << *self; 1432 1433 { 1434 MutexLock mu(self, *Locks::thread_list_lock_); 1435 ++unregistering_count_; 1436 } 1437 1438 // Any time-consuming destruction, plus anything that can call back into managed code or 1439 // suspend and so on, must happen at this point, and not in ~Thread. The self->Destroy is what 1440 // causes the threads to join. It is important to do this after incrementing unregistering_count_ 1441 // since we want the runtime to wait for the daemon threads to exit before deleting the thread 1442 // list. 1443 self->Destroy(); 1444 1445 // If tracing, remember thread id and name before thread exits. 1446 Trace::StoreExitingThreadInfo(self); 1447 1448 uint32_t thin_lock_id = self->GetThreadId(); 1449 while (true) { 1450 // Remove and delete the Thread* while holding the thread_list_lock_ and 1451 // thread_suspend_count_lock_ so that the unregistering thread cannot be suspended. 1452 // Note: deliberately not using MutexLock that could hold a stale self pointer. 1453 { 1454 MutexLock mu(self, *Locks::thread_list_lock_); 1455 if (!Contains(self)) { 1456 std::string thread_name; 1457 self->GetThreadName(thread_name); 1458 std::ostringstream os; 1459 DumpNativeStack(os, GetTid(), nullptr, " native: ", nullptr); 1460 LOG(ERROR) << "Request to unregister unattached thread " << thread_name << "\n" << os.str(); 1461 break; 1462 } else { 1463 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 1464 if (!self->IsSuspended()) { 1465 list_.remove(self); 1466 break; 1467 } 1468 } 1469 } 1470 // In the case where we are not suspended yet, sleep to leave other threads time to execute. 1471 // This is important if there are realtime threads. b/111277984 1472 usleep(1); 1473 // We failed to remove the thread due to a suspend request, loop and try again. 1474 } 1475 delete self; 1476 1477 // Release the thread ID after the thread is finished and deleted to avoid cases where we can 1478 // temporarily have multiple threads with the same thread id. When this occurs, it causes 1479 // problems in FindThreadByThreadId / SuspendThreadByThreadId. 1480 ReleaseThreadId(nullptr, thin_lock_id); 1481 1482 // Clear the TLS data, so that the underlying native thread is recognizably detached. 1483 // (It may wish to reattach later.) 1484 #ifdef ART_TARGET_ANDROID 1485 __get_tls()[TLS_SLOT_ART_THREAD_SELF] = nullptr; 1486 #else 1487 CHECK_PTHREAD_CALL(pthread_setspecific, (Thread::pthread_key_self_, nullptr), "detach self"); 1488 #endif 1489 1490 // Signal that a thread just detached. 1491 MutexLock mu(nullptr, *Locks::thread_list_lock_); 1492 --unregistering_count_; 1493 Locks::thread_exit_cond_->Broadcast(nullptr); 1494 } 1495 1496 void ThreadList::ForEach(void (*callback)(Thread*, void*), void* context) { 1497 for (const auto& thread : list_) { 1498 callback(thread, context); 1499 } 1500 } 1501 1502 void ThreadList::VisitRootsForSuspendedThreads(RootVisitor* visitor) { 1503 Thread* const self = Thread::Current(); 1504 std::vector<Thread*> threads_to_visit; 1505 1506 // Tell threads to suspend and copy them into list. 1507 { 1508 MutexLock mu(self, *Locks::thread_list_lock_); 1509 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 1510 for (Thread* thread : list_) { 1511 bool suspended = thread->ModifySuspendCount(self, +1, nullptr, SuspendReason::kInternal); 1512 DCHECK(suspended); 1513 if (thread == self || thread->IsSuspended()) { 1514 threads_to_visit.push_back(thread); 1515 } else { 1516 bool resumed = thread->ModifySuspendCount(self, -1, nullptr, SuspendReason::kInternal); 1517 DCHECK(resumed); 1518 } 1519 } 1520 } 1521 1522 // Visit roots without holding thread_list_lock_ and thread_suspend_count_lock_ to prevent lock 1523 // order violations. 1524 for (Thread* thread : threads_to_visit) { 1525 thread->VisitRoots(visitor, kVisitRootFlagAllRoots); 1526 } 1527 1528 // Restore suspend counts. 1529 { 1530 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 1531 for (Thread* thread : threads_to_visit) { 1532 bool updated = thread->ModifySuspendCount(self, -1, nullptr, SuspendReason::kInternal); 1533 DCHECK(updated); 1534 } 1535 } 1536 } 1537 1538 void ThreadList::VisitRoots(RootVisitor* visitor, VisitRootFlags flags) const { 1539 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_); 1540 for (const auto& thread : list_) { 1541 thread->VisitRoots(visitor, flags); 1542 } 1543 } 1544 1545 uint32_t ThreadList::AllocThreadId(Thread* self) { 1546 MutexLock mu(self, *Locks::allocated_thread_ids_lock_); 1547 for (size_t i = 0; i < allocated_ids_.size(); ++i) { 1548 if (!allocated_ids_[i]) { 1549 allocated_ids_.set(i); 1550 return i + 1; // Zero is reserved to mean "invalid". 1551 } 1552 } 1553 LOG(FATAL) << "Out of internal thread ids"; 1554 UNREACHABLE(); 1555 } 1556 1557 void ThreadList::ReleaseThreadId(Thread* self, uint32_t id) { 1558 MutexLock mu(self, *Locks::allocated_thread_ids_lock_); 1559 --id; // Zero is reserved to mean "invalid". 1560 DCHECK(allocated_ids_[id]) << id; 1561 allocated_ids_.reset(id); 1562 } 1563 1564 ScopedSuspendAll::ScopedSuspendAll(const char* cause, bool long_suspend) { 1565 Runtime::Current()->GetThreadList()->SuspendAll(cause, long_suspend); 1566 } 1567 1568 ScopedSuspendAll::~ScopedSuspendAll() { 1569 Runtime::Current()->GetThreadList()->ResumeAll(); 1570 } 1571 1572 } // namespace art 1573