thread_list.cc revision dcfd6cad9670ca3ae460a4af0bbe7d88cae21a3c
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#define ATRACE_TAG ATRACE_TAG_DALVIK 20 21#include <cutils/trace.h> 22#include <dirent.h> 23#include <ScopedLocalRef.h> 24#include <ScopedUtfChars.h> 25#include <sys/types.h> 26#include <unistd.h> 27 28#include "base/mutex.h" 29#include "base/mutex-inl.h" 30#include "base/timing_logger.h" 31#include "debugger.h" 32#include "jni_internal.h" 33#include "lock_word.h" 34#include "monitor.h" 35#include "scoped_thread_state_change.h" 36#include "thread.h" 37#include "utils.h" 38#include "well_known_classes.h" 39 40namespace art { 41 42static constexpr uint64_t kLongThreadSuspendThreshold = MsToNs(5); 43 44ThreadList::ThreadList() 45 : suspend_all_count_(0), debug_suspend_all_count_(0), 46 thread_exit_cond_("thread exit condition variable", *Locks::thread_list_lock_) { 47 CHECK(Monitor::IsValidLockWord(LockWord::FromThinLockId(kMaxThreadId, 1))); 48} 49 50ThreadList::~ThreadList() { 51 // Detach the current thread if necessary. If we failed to start, there might not be any threads. 52 // We need to detach the current thread here in case there's another thread waiting to join with 53 // us. 54 if (Contains(Thread::Current())) { 55 Runtime::Current()->DetachCurrentThread(); 56 } 57 58 WaitForOtherNonDaemonThreadsToExit(); 59 // TODO: there's an unaddressed race here where a thread may attach during shutdown, see 60 // Thread::Init. 61 SuspendAllDaemonThreads(); 62} 63 64bool ThreadList::Contains(Thread* thread) { 65 return find(list_.begin(), list_.end(), thread) != list_.end(); 66} 67 68bool ThreadList::Contains(pid_t tid) { 69 for (const auto& thread : list_) { 70 if (thread->GetTid() == tid) { 71 return true; 72 } 73 } 74 return false; 75} 76 77pid_t ThreadList::GetLockOwner() { 78 return Locks::thread_list_lock_->GetExclusiveOwnerTid(); 79} 80 81void ThreadList::DumpNativeStacks(std::ostream& os) { 82 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_); 83 for (const auto& thread : list_) { 84 os << "DUMPING THREAD " << thread->GetTid() << "\n"; 85 DumpNativeStack(os, thread->GetTid(), "\t"); 86 os << "\n"; 87 } 88} 89 90void ThreadList::DumpForSigQuit(std::ostream& os) { 91 { 92 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_); 93 DumpLocked(os); 94 } 95 DumpUnattachedThreads(os); 96} 97 98static void DumpUnattachedThread(std::ostream& os, pid_t tid) NO_THREAD_SAFETY_ANALYSIS { 99 // TODO: No thread safety analysis as DumpState with a NULL thread won't access fields, should 100 // refactor DumpState to avoid skipping analysis. 101 Thread::DumpState(os, NULL, tid); 102 DumpKernelStack(os, tid, " kernel: ", false); 103 // TODO: Reenable this when the native code in system_server can handle it. 104 // Currently "adb shell kill -3 `pid system_server`" will cause it to exit. 105 if (false) { 106 DumpNativeStack(os, tid, " native: "); 107 } 108 os << "\n"; 109} 110 111void ThreadList::DumpUnattachedThreads(std::ostream& os) { 112 DIR* d = opendir("/proc/self/task"); 113 if (!d) { 114 return; 115 } 116 117 Thread* self = Thread::Current(); 118 dirent* e; 119 while ((e = readdir(d)) != NULL) { 120 char* end; 121 pid_t tid = strtol(e->d_name, &end, 10); 122 if (!*end) { 123 bool contains; 124 { 125 MutexLock mu(self, *Locks::thread_list_lock_); 126 contains = Contains(tid); 127 } 128 if (!contains) { 129 DumpUnattachedThread(os, tid); 130 } 131 } 132 } 133 closedir(d); 134} 135 136void ThreadList::DumpLocked(std::ostream& os) { 137 os << "DALVIK THREADS (" << list_.size() << "):\n"; 138 for (const auto& thread : list_) { 139 thread->Dump(os); 140 os << "\n"; 141 } 142} 143 144void ThreadList::AssertThreadsAreSuspended(Thread* self, Thread* ignore1, Thread* ignore2) { 145 MutexLock mu(self, *Locks::thread_list_lock_); 146 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 147 for (const auto& thread : list_) { 148 if (thread != ignore1 && thread != ignore2) { 149 CHECK(thread->IsSuspended()) 150 << "\nUnsuspended thread: <<" << *thread << "\n" 151 << "self: <<" << *Thread::Current(); 152 } 153 } 154} 155 156#if HAVE_TIMED_RWLOCK 157// Attempt to rectify locks so that we dump thread list with required locks before exiting. 158static void UnsafeLogFatalForThreadSuspendAllTimeout() NO_THREAD_SAFETY_ANALYSIS __attribute__((noreturn)); 159static void UnsafeLogFatalForThreadSuspendAllTimeout() { 160 Runtime* runtime = Runtime::Current(); 161 std::ostringstream ss; 162 ss << "Thread suspend timeout\n"; 163 runtime->GetThreadList()->DumpLocked(ss); 164 LOG(FATAL) << ss.str(); 165 exit(0); 166} 167#endif 168 169// Unlike suspending all threads where we can wait to acquire the mutator_lock_, suspending an 170// individual thread requires polling. delay_us is the requested sleep and total_delay_us 171// accumulates the total time spent sleeping for timeouts. The first sleep is just a yield, 172// subsequently sleeps increase delay_us from 1ms to 500ms by doubling. 173static void ThreadSuspendSleep(Thread* self, useconds_t* delay_us, useconds_t* total_delay_us) { 174 useconds_t new_delay_us = (*delay_us) * 2; 175 CHECK_GE(new_delay_us, *delay_us); 176 if (new_delay_us < 500000) { // Don't allow sleeping to be more than 0.5s. 177 *delay_us = new_delay_us; 178 } 179 if (*delay_us == 0) { 180 sched_yield(); 181 // Default to 1 milliseconds (note that this gets multiplied by 2 before the first sleep). 182 *delay_us = 500; 183 } else { 184 usleep(*delay_us); 185 *total_delay_us += *delay_us; 186 } 187} 188 189size_t ThreadList::RunCheckpoint(Closure* checkpoint_function) { 190 Thread* self = Thread::Current(); 191 Locks::mutator_lock_->AssertNotExclusiveHeld(self); 192 Locks::thread_list_lock_->AssertNotHeld(self); 193 Locks::thread_suspend_count_lock_->AssertNotHeld(self); 194 if (kDebugLocking) { 195 CHECK_NE(self->GetState(), kRunnable); 196 } 197 198 std::vector<Thread*> suspended_count_modified_threads; 199 size_t count = 0; 200 { 201 // Call a checkpoint function for each thread, threads which are suspend get their checkpoint 202 // manually called. 203 MutexLock mu(self, *Locks::thread_list_lock_); 204 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 205 for (const auto& thread : list_) { 206 if (thread != self) { 207 while (true) { 208 if (thread->RequestCheckpoint(checkpoint_function)) { 209 // This thread will run its checkpoint some time in the near future. 210 count++; 211 break; 212 } else { 213 // We are probably suspended, try to make sure that we stay suspended. 214 // The thread switched back to runnable. 215 if (thread->GetState() == kRunnable) { 216 // Spurious fail, try again. 217 continue; 218 } 219 thread->ModifySuspendCount(self, +1, false); 220 suspended_count_modified_threads.push_back(thread); 221 break; 222 } 223 } 224 } 225 } 226 } 227 228 // Run the checkpoint on ourself while we wait for threads to suspend. 229 checkpoint_function->Run(self); 230 231 // Run the checkpoint on the suspended threads. 232 for (const auto& thread : suspended_count_modified_threads) { 233 if (!thread->IsSuspended()) { 234 // Wait until the thread is suspended. 235 useconds_t total_delay_us = 0; 236 do { 237 useconds_t delay_us = 100; 238 ThreadSuspendSleep(self, &delay_us, &total_delay_us); 239 } while (!thread->IsSuspended()); 240 // Shouldn't need to wait for longer than 1000 microseconds. 241 constexpr useconds_t kLongWaitThresholdUS = 1000; 242 if (UNLIKELY(total_delay_us > kLongWaitThresholdUS)) { 243 LOG(WARNING) << "Waited " << total_delay_us << " us for thread suspend!"; 244 } 245 } 246 // We know for sure that the thread is suspended at this point. 247 checkpoint_function->Run(thread); 248 { 249 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 250 thread->ModifySuspendCount(self, -1, false); 251 } 252 } 253 254 { 255 // Imitate ResumeAll, threads may be waiting on Thread::resume_cond_ since we raised their 256 // suspend count. Now the suspend_count_ is lowered so we must do the broadcast. 257 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 258 Thread::resume_cond_->Broadcast(self); 259 } 260 261 // Add one for self. 262 return count + suspended_count_modified_threads.size() + 1; 263} 264 265// Request that a checkpoint function be run on all active (non-suspended) 266// threads. Returns the number of successful requests. 267size_t ThreadList::RunCheckpointOnRunnableThreads(Closure* checkpoint_function) { 268 Thread* self = Thread::Current(); 269 if (kIsDebugBuild) { 270 Locks::mutator_lock_->AssertNotExclusiveHeld(self); 271 Locks::thread_list_lock_->AssertNotHeld(self); 272 Locks::thread_suspend_count_lock_->AssertNotHeld(self); 273 CHECK_NE(self->GetState(), kRunnable); 274 } 275 276 size_t count = 0; 277 { 278 // Call a checkpoint function for each non-suspended thread. 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 != self) { 283 if (thread->RequestCheckpoint(checkpoint_function)) { 284 // This thread will run its checkpoint some time in the near future. 285 count++; 286 } 287 } 288 } 289 } 290 291 // Return the number of threads that will run the checkpoint function. 292 return count; 293} 294 295void ThreadList::SuspendAll() { 296 Thread* self = Thread::Current(); 297 298 if (self != nullptr) { 299 VLOG(threads) << *self << " SuspendAll starting..."; 300 } else { 301 VLOG(threads) << "Thread[null] SuspendAll starting..."; 302 } 303 ATRACE_BEGIN("Suspending mutator threads"); 304 uint64_t start_time = NanoTime(); 305 306 Locks::mutator_lock_->AssertNotHeld(self); 307 Locks::thread_list_lock_->AssertNotHeld(self); 308 Locks::thread_suspend_count_lock_->AssertNotHeld(self); 309 if (kDebugLocking && self != nullptr) { 310 CHECK_NE(self->GetState(), kRunnable); 311 } 312 { 313 MutexLock mu(self, *Locks::thread_list_lock_); 314 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 315 // Update global suspend all state for attaching threads. 316 ++suspend_all_count_; 317 // Increment everybody's suspend count (except our own). 318 for (const auto& thread : list_) { 319 if (thread == self) { 320 continue; 321 } 322 VLOG(threads) << "requesting thread suspend: " << *thread; 323 thread->ModifySuspendCount(self, +1, false); 324 } 325 } 326 327 // Block on the mutator lock until all Runnable threads release their share of access. 328#if HAVE_TIMED_RWLOCK 329 // Timeout if we wait more than 30 seconds. 330 if (!Locks::mutator_lock_->ExclusiveLockWithTimeout(self, 30 * 1000, 0)) { 331 UnsafeLogFatalForThreadSuspendAllTimeout(); 332 } 333#else 334 Locks::mutator_lock_->ExclusiveLock(self); 335#endif 336 337 uint64_t end_time = NanoTime(); 338 if (end_time - start_time > kLongThreadSuspendThreshold) { 339 LOG(WARNING) << "Suspending all threads took: " << PrettyDuration(end_time - start_time); 340 } 341 342 if (kDebugLocking) { 343 // Debug check that all threads are suspended. 344 AssertThreadsAreSuspended(self, self); 345 } 346 347 ATRACE_END(); 348 ATRACE_BEGIN("Mutator threads suspended"); 349 350 if (self != nullptr) { 351 VLOG(threads) << *self << " SuspendAll complete"; 352 } else { 353 VLOG(threads) << "Thread[null] SuspendAll complete"; 354 } 355} 356 357void ThreadList::ResumeAll() { 358 Thread* self = Thread::Current(); 359 360 if (self != nullptr) { 361 VLOG(threads) << *self << " ResumeAll starting"; 362 } else { 363 VLOG(threads) << "Thread[null] ResumeAll starting"; 364 } 365 366 ATRACE_END(); 367 ATRACE_BEGIN("Resuming mutator threads"); 368 369 if (kDebugLocking) { 370 // Debug check that all threads are suspended. 371 AssertThreadsAreSuspended(self, self); 372 } 373 374 Locks::mutator_lock_->ExclusiveUnlock(self); 375 { 376 MutexLock mu(self, *Locks::thread_list_lock_); 377 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 378 // Update global suspend all state for attaching threads. 379 --suspend_all_count_; 380 // Decrement the suspend counts for all threads. 381 for (const auto& thread : list_) { 382 if (thread == self) { 383 continue; 384 } 385 thread->ModifySuspendCount(self, -1, false); 386 } 387 388 // Broadcast a notification to all suspended threads, some or all of 389 // which may choose to wake up. No need to wait for them. 390 if (self != nullptr) { 391 VLOG(threads) << *self << " ResumeAll waking others"; 392 } else { 393 VLOG(threads) << "Thread[null] ResumeAll waking others"; 394 } 395 Thread::resume_cond_->Broadcast(self); 396 } 397 ATRACE_END(); 398 399 if (self != nullptr) { 400 VLOG(threads) << *self << " ResumeAll complete"; 401 } else { 402 VLOG(threads) << "Thread[null] ResumeAll complete"; 403 } 404} 405 406void ThreadList::Resume(Thread* thread, bool for_debugger) { 407 Thread* self = Thread::Current(); 408 DCHECK_NE(thread, self); 409 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") starting..." 410 << (for_debugger ? " (debugger)" : ""); 411 412 { 413 // To check Contains. 414 MutexLock mu(self, *Locks::thread_list_lock_); 415 // To check IsSuspended. 416 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 417 DCHECK(thread->IsSuspended()); 418 if (!Contains(thread)) { 419 // We only expect threads within the thread-list to have been suspended otherwise we can't 420 // stop such threads from delete-ing themselves. 421 LOG(ERROR) << "Resume(" << reinterpret_cast<void*>(thread) 422 << ") thread not within thread list"; 423 return; 424 } 425 thread->ModifySuspendCount(self, -1, for_debugger); 426 } 427 428 { 429 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") waking others"; 430 MutexLock mu(self, *Locks::thread_suspend_count_lock_); 431 Thread::resume_cond_->Broadcast(self); 432 } 433 434 VLOG(threads) << "Resume(" << reinterpret_cast<void*>(thread) << ") complete"; 435} 436 437static void ThreadSuspendByPeerWarning(Thread* self, int level, const char* message, jobject peer) { 438 JNIEnvExt* env = self->GetJniEnv(); 439 ScopedLocalRef<jstring> 440 scoped_name_string(env, (jstring)env->GetObjectField(peer, 441 WellKnownClasses::java_lang_Thread_name)); 442 ScopedUtfChars scoped_name_chars(env, scoped_name_string.get()); 443 if (scoped_name_chars.c_str() == NULL) { 444 LOG(level) << message << ": " << peer; 445 env->ExceptionClear(); 446 } else { 447 LOG(level) << message << ": " << peer << ":" << scoped_name_chars.c_str(); 448 } 449} 450 451Thread* ThreadList::SuspendThreadByPeer(jobject peer, bool request_suspension, 452 bool debug_suspension, bool* timed_out) { 453 static const useconds_t kTimeoutUs = 30 * 1000000; // 30s. 454 useconds_t total_delay_us = 0; 455 useconds_t delay_us = 0; 456 bool did_suspend_request = false; 457 *timed_out = false; 458 Thread* self = Thread::Current(); 459 VLOG(threads) << "SuspendThreadByPeer starting"; 460 while (true) { 461 Thread* thread; 462 { 463 // Note: this will transition to runnable and potentially suspend. We ensure only one thread 464 // is requesting another suspend, to avoid deadlock, by requiring this function be called 465 // holding Locks::thread_list_suspend_thread_lock_. Its important this thread suspend rather 466 // than request thread suspension, to avoid potential cycles in threads requesting each other 467 // suspend. 468 ScopedObjectAccess soa(self); 469 MutexLock mu(self, *Locks::thread_list_lock_); 470 thread = Thread::FromManagedThread(soa, peer); 471 if (thread == nullptr) { 472 ThreadSuspendByPeerWarning(self, WARNING, "No such thread for suspend", peer); 473 return nullptr; 474 } 475 if (!Contains(thread)) { 476 VLOG(threads) << "SuspendThreadByPeer failed for unattached thread: " 477 << reinterpret_cast<void*>(thread); 478 return nullptr; 479 } 480 VLOG(threads) << "SuspendThreadByPeer found thread: " << *thread; 481 { 482 MutexLock mu(self, *Locks::thread_suspend_count_lock_); 483 if (request_suspension) { 484 thread->ModifySuspendCount(self, +1, debug_suspension); 485 request_suspension = false; 486 did_suspend_request = true; 487 } else { 488 // If the caller isn't requesting suspension, a suspension should have already occurred. 489 CHECK_GT(thread->GetSuspendCount(), 0); 490 } 491 // IsSuspended on the current thread will fail as the current thread is changed into 492 // Runnable above. As the suspend count is now raised if this is the current thread 493 // it will self suspend on transition to Runnable, making it hard to work with. It's simpler 494 // to just explicitly handle the current thread in the callers to this code. 495 CHECK_NE(thread, self) << "Attempt to suspend the current thread for the debugger"; 496 // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend 497 // count, or else we've waited and it has self suspended) or is the current thread, we're 498 // done. 499 if (thread->IsSuspended()) { 500 VLOG(threads) << "SuspendThreadByPeer thread suspended: " << *thread; 501 return thread; 502 } 503 if (total_delay_us >= kTimeoutUs) { 504 ThreadSuspendByPeerWarning(self, FATAL, "Thread suspension timed out", peer); 505 if (did_suspend_request) { 506 thread->ModifySuspendCount(soa.Self(), -1, debug_suspension); 507 } 508 *timed_out = true; 509 return nullptr; 510 } 511 } 512 // Release locks and come out of runnable state. 513 } 514 VLOG(threads) << "SuspendThreadByPeer sleeping to allow thread chance to suspend"; 515 ThreadSuspendSleep(self, &delay_us, &total_delay_us); 516 } 517} 518 519static void ThreadSuspendByThreadIdWarning(int level, const char* message, uint32_t thread_id) { 520 LOG(level) << StringPrintf("%s: %d", message, thread_id); 521} 522 523Thread* ThreadList::SuspendThreadByThreadId(uint32_t thread_id, bool debug_suspension, 524 bool* timed_out) { 525 static const useconds_t kTimeoutUs = 30 * 1000000; // 30s. 526 useconds_t total_delay_us = 0; 527 useconds_t delay_us = 0; 528 *timed_out = false; 529 Thread* suspended_thread = nullptr; 530 Thread* self = Thread::Current(); 531 CHECK_NE(thread_id, kInvalidThreadId); 532 VLOG(threads) << "SuspendThreadByThreadId starting"; 533 while (true) { 534 { 535 // Note: this will transition to runnable and potentially suspend. We ensure only one thread 536 // is requesting another suspend, to avoid deadlock, by requiring this function be called 537 // holding Locks::thread_list_suspend_thread_lock_. Its important this thread suspend rather 538 // than request thread suspension, to avoid potential cycles in threads requesting each other 539 // suspend. 540 ScopedObjectAccess soa(self); 541 MutexLock mu(self, *Locks::thread_list_lock_); 542 Thread* thread = nullptr; 543 for (const auto& it : list_) { 544 if (it->GetThreadId() == thread_id) { 545 thread = it; 546 break; 547 } 548 } 549 if (thread == nullptr) { 550 CHECK(suspended_thread == nullptr) << "Suspended thread " << suspended_thread 551 << " no longer in thread list"; 552 // There's a race in inflating a lock and the owner giving up ownership and then dying. 553 ThreadSuspendByThreadIdWarning(WARNING, "No such thread id for suspend", thread_id); 554 return nullptr; 555 } 556 VLOG(threads) << "SuspendThreadByThreadId found thread: " << *thread; 557 DCHECK(Contains(thread)); 558 { 559 MutexLock mu(self, *Locks::thread_suspend_count_lock_); 560 if (suspended_thread == nullptr) { 561 thread->ModifySuspendCount(self, +1, debug_suspension); 562 suspended_thread = thread; 563 } else { 564 CHECK_EQ(suspended_thread, thread); 565 // If the caller isn't requesting suspension, a suspension should have already occurred. 566 CHECK_GT(thread->GetSuspendCount(), 0); 567 } 568 // IsSuspended on the current thread will fail as the current thread is changed into 569 // Runnable above. As the suspend count is now raised if this is the current thread 570 // it will self suspend on transition to Runnable, making it hard to work with. It's simpler 571 // to just explicitly handle the current thread in the callers to this code. 572 CHECK_NE(thread, self) << "Attempt to suspend the current thread for the debugger"; 573 // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend 574 // count, or else we've waited and it has self suspended) or is the current thread, we're 575 // done. 576 if (thread->IsSuspended()) { 577 VLOG(threads) << "SuspendThreadByThreadId thread suspended: " << *thread; 578 return thread; 579 } 580 if (total_delay_us >= kTimeoutUs) { 581 ThreadSuspendByThreadIdWarning(WARNING, "Thread suspension timed out", thread_id); 582 if (suspended_thread != nullptr) { 583 thread->ModifySuspendCount(soa.Self(), -1, debug_suspension); 584 } 585 *timed_out = true; 586 return nullptr; 587 } 588 } 589 // Release locks and come out of runnable state. 590 } 591 VLOG(threads) << "SuspendThreadByThreadId sleeping to allow thread chance to suspend"; 592 ThreadSuspendSleep(self, &delay_us, &total_delay_us); 593 } 594} 595 596Thread* ThreadList::FindThreadByThreadId(uint32_t thin_lock_id) { 597 Thread* self = Thread::Current(); 598 MutexLock mu(self, *Locks::thread_list_lock_); 599 for (const auto& thread : list_) { 600 if (thread->GetThreadId() == thin_lock_id) { 601 CHECK(thread == self || thread->IsSuspended()); 602 return thread; 603 } 604 } 605 return NULL; 606} 607 608void ThreadList::SuspendAllForDebugger() { 609 Thread* self = Thread::Current(); 610 Thread* debug_thread = Dbg::GetDebugThread(); 611 612 VLOG(threads) << *self << " SuspendAllForDebugger starting..."; 613 614 { 615 MutexLock mu(self, *Locks::thread_list_lock_); 616 { 617 MutexLock mu(self, *Locks::thread_suspend_count_lock_); 618 // Update global suspend all state for attaching threads. 619 ++suspend_all_count_; 620 ++debug_suspend_all_count_; 621 // Increment everybody's suspend count (except our own). 622 for (const auto& thread : list_) { 623 if (thread == self || thread == debug_thread) { 624 continue; 625 } 626 VLOG(threads) << "requesting thread suspend: " << *thread; 627 thread->ModifySuspendCount(self, +1, true); 628 } 629 } 630 } 631 632 // Block on the mutator lock until all Runnable threads release their share of access then 633 // immediately unlock again. 634#if HAVE_TIMED_RWLOCK 635 // Timeout if we wait more than 30 seconds. 636 if (!Locks::mutator_lock_->ExclusiveLockWithTimeout(self, 30 * 1000, 0)) { 637 UnsafeLogFatalForThreadSuspendAllTimeout(); 638 } else { 639 Locks::mutator_lock_->ExclusiveUnlock(self); 640 } 641#else 642 Locks::mutator_lock_->ExclusiveLock(self); 643 Locks::mutator_lock_->ExclusiveUnlock(self); 644#endif 645 AssertThreadsAreSuspended(self, self, debug_thread); 646 647 VLOG(threads) << *self << " SuspendAllForDebugger complete"; 648} 649 650void ThreadList::SuspendSelfForDebugger() { 651 Thread* self = Thread::Current(); 652 653 // The debugger thread must not suspend itself due to debugger activity! 654 Thread* debug_thread = Dbg::GetDebugThread(); 655 CHECK(debug_thread != NULL); 656 CHECK(self != debug_thread); 657 CHECK_NE(self->GetState(), kRunnable); 658 Locks::mutator_lock_->AssertNotHeld(self); 659 660 { 661 // Collisions with other suspends aren't really interesting. We want 662 // to ensure that we're the only one fiddling with the suspend count 663 // though. 664 MutexLock mu(self, *Locks::thread_suspend_count_lock_); 665 self->ModifySuspendCount(self, +1, true); 666 CHECK_GT(self->GetSuspendCount(), 0); 667 } 668 669 VLOG(threads) << *self << " self-suspending (debugger)"; 670 671 // Tell JDWP we've completed invocation and are ready to suspend. 672 DebugInvokeReq* pReq = self->GetInvokeReq(); 673 DCHECK(pReq != NULL); 674 if (pReq->invoke_needed) { 675 // Clear this before signaling. 676 pReq->Clear(); 677 678 VLOG(jdwp) << "invoke complete, signaling"; 679 MutexLock mu(self, pReq->lock); 680 pReq->cond.Signal(self); 681 } 682 683 // Tell JDWP that we've completed suspension. The JDWP thread can't 684 // tell us to resume before we're fully asleep because we hold the 685 // suspend count lock. 686 Dbg::ClearWaitForEventThread(); 687 688 { 689 MutexLock mu(self, *Locks::thread_suspend_count_lock_); 690 while (self->GetSuspendCount() != 0) { 691 Thread::resume_cond_->Wait(self); 692 if (self->GetSuspendCount() != 0) { 693 // The condition was signaled but we're still suspended. This 694 // can happen when we suspend then resume all threads to 695 // update instrumentation or compute monitor info. This can 696 // also happen if the debugger lets go while a SIGQUIT thread 697 // dump event is pending (assuming SignalCatcher was resumed for 698 // just long enough to try to grab the thread-suspend lock). 699 VLOG(jdwp) << *self << " still suspended after undo " 700 << "(suspend count=" << self->GetSuspendCount() << ", " 701 << "debug suspend count=" << self->GetDebugSuspendCount() << ")"; 702 } 703 } 704 CHECK_EQ(self->GetSuspendCount(), 0); 705 } 706 707 VLOG(threads) << *self << " self-reviving (debugger)"; 708} 709 710void ThreadList::UndoDebuggerSuspensions() { 711 Thread* self = Thread::Current(); 712 713 VLOG(threads) << *self << " UndoDebuggerSuspensions starting"; 714 715 { 716 MutexLock mu(self, *Locks::thread_list_lock_); 717 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 718 // Update global suspend all state for attaching threads. 719 suspend_all_count_ -= debug_suspend_all_count_; 720 debug_suspend_all_count_ = 0; 721 // Update running threads. 722 for (const auto& thread : list_) { 723 if (thread == self || thread->GetDebugSuspendCount() == 0) { 724 continue; 725 } 726 thread->ModifySuspendCount(self, -thread->GetDebugSuspendCount(), true); 727 } 728 } 729 730 { 731 MutexLock mu(self, *Locks::thread_suspend_count_lock_); 732 Thread::resume_cond_->Broadcast(self); 733 } 734 735 VLOG(threads) << "UndoDebuggerSuspensions(" << *self << ") complete"; 736} 737 738void ThreadList::WaitForOtherNonDaemonThreadsToExit() { 739 Thread* self = Thread::Current(); 740 Locks::mutator_lock_->AssertNotHeld(self); 741 bool all_threads_are_daemons; 742 do { 743 { 744 // No more threads can be born after we start to shutdown. 745 MutexLock mu(self, *Locks::runtime_shutdown_lock_); 746 CHECK(Runtime::Current()->IsShuttingDownLocked()); 747 CHECK_EQ(Runtime::Current()->NumberOfThreadsBeingBorn(), 0U); 748 } 749 all_threads_are_daemons = true; 750 MutexLock mu(self, *Locks::thread_list_lock_); 751 for (const auto& thread : list_) { 752 if (thread != self && !thread->IsDaemon()) { 753 all_threads_are_daemons = false; 754 break; 755 } 756 } 757 if (!all_threads_are_daemons) { 758 // Wait for another thread to exit before re-checking. 759 thread_exit_cond_.Wait(self); 760 } 761 } while (!all_threads_are_daemons); 762} 763 764void ThreadList::SuspendAllDaemonThreads() { 765 Thread* self = Thread::Current(); 766 MutexLock mu(self, *Locks::thread_list_lock_); 767 { // Tell all the daemons it's time to suspend. 768 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 769 for (const auto& thread : list_) { 770 // This is only run after all non-daemon threads have exited, so the remainder should all be 771 // daemons. 772 CHECK(thread->IsDaemon()) << *thread; 773 if (thread != self) { 774 thread->ModifySuspendCount(self, +1, false); 775 } 776 } 777 } 778 // Give the threads a chance to suspend, complaining if they're slow. 779 bool have_complained = false; 780 for (int i = 0; i < 10; ++i) { 781 usleep(200 * 1000); 782 bool all_suspended = true; 783 for (const auto& thread : list_) { 784 if (thread != self && thread->GetState() == kRunnable) { 785 if (!have_complained) { 786 LOG(WARNING) << "daemon thread not yet suspended: " << *thread; 787 have_complained = true; 788 } 789 all_suspended = false; 790 } 791 } 792 if (all_suspended) { 793 return; 794 } 795 } 796 LOG(ERROR) << "suspend all daemons failed"; 797} 798void ThreadList::Register(Thread* self) { 799 DCHECK_EQ(self, Thread::Current()); 800 801 if (VLOG_IS_ON(threads)) { 802 std::ostringstream oss; 803 self->ShortDump(oss); // We don't hold the mutator_lock_ yet and so cannot call Dump. 804 LOG(INFO) << "ThreadList::Register() " << *self << "\n" << oss.str(); 805 } 806 807 // Atomically add self to the thread list and make its thread_suspend_count_ reflect ongoing 808 // SuspendAll requests. 809 MutexLock mu(self, *Locks::thread_list_lock_); 810 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 811 CHECK_GE(suspend_all_count_, debug_suspend_all_count_); 812 // Modify suspend count in increments of 1 to maintain invariants in ModifySuspendCount. While 813 // this isn't particularly efficient the suspend counts are most commonly 0 or 1. 814 for (int delta = debug_suspend_all_count_; delta > 0; delta--) { 815 self->ModifySuspendCount(self, +1, true); 816 } 817 for (int delta = suspend_all_count_ - debug_suspend_all_count_; delta > 0; delta--) { 818 self->ModifySuspendCount(self, +1, false); 819 } 820 CHECK(!Contains(self)); 821 list_.push_back(self); 822} 823 824void ThreadList::Unregister(Thread* self) { 825 DCHECK_EQ(self, Thread::Current()); 826 827 VLOG(threads) << "ThreadList::Unregister() " << *self; 828 829 // Any time-consuming destruction, plus anything that can call back into managed code or 830 // suspend and so on, must happen at this point, and not in ~Thread. 831 self->Destroy(); 832 833 uint32_t thin_lock_id = self->GetThreadId(); 834 while (self != nullptr) { 835 // Remove and delete the Thread* while holding the thread_list_lock_ and 836 // thread_suspend_count_lock_ so that the unregistering thread cannot be suspended. 837 // Note: deliberately not using MutexLock that could hold a stale self pointer. 838 Locks::thread_list_lock_->ExclusiveLock(self); 839 if (!Contains(self)) { 840 std::ostringstream os; 841 DumpNativeStack(os, GetTid(), " native: ", nullptr); 842 LOG(ERROR) << "Request to unregister unattached thread\n" << os.str(); 843 self = nullptr; 844 } else { 845 // Note: we don't take the thread_suspend_count_lock_ here as to be suspending a thread other 846 // than yourself you need to hold the thread_list_lock_ (see Thread::ModifySuspendCount). 847 if (!self->IsSuspended()) { 848 list_.remove(self); 849 delete self; 850 self = nullptr; 851 } 852 } 853 Locks::thread_list_lock_->ExclusiveUnlock(self); 854 } 855 // Release the thread ID after the thread is finished and deleted to avoid cases where we can 856 // temporarily have multiple threads with the same thread id. When this occurs, it causes 857 // problems in FindThreadByThreadId / SuspendThreadByThreadId. 858 ReleaseThreadId(nullptr, thin_lock_id); 859 860 // Clear the TLS data, so that the underlying native thread is recognizably detached. 861 // (It may wish to reattach later.) 862 CHECK_PTHREAD_CALL(pthread_setspecific, (Thread::pthread_key_self_, NULL), "detach self"); 863 864 // Signal that a thread just detached. 865 MutexLock mu(NULL, *Locks::thread_list_lock_); 866 thread_exit_cond_.Signal(NULL); 867} 868 869void ThreadList::ForEach(void (*callback)(Thread*, void*), void* context) { 870 for (const auto& thread : list_) { 871 callback(thread, context); 872 } 873} 874 875void ThreadList::VisitRoots(RootCallback* callback, void* arg) const { 876 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_); 877 for (const auto& thread : list_) { 878 thread->VisitRoots(callback, arg); 879 } 880} 881 882class VerifyRootWrapperArg { 883 public: 884 VerifyRootWrapperArg(VerifyRootCallback* callback, void* arg) : callback_(callback), arg_(arg) { 885 } 886 VerifyRootCallback* const callback_; 887 void* const arg_; 888}; 889 890static void VerifyRootWrapperCallback(mirror::Object** root, void* arg, uint32_t /*thread_id*/, 891 RootType root_type) { 892 VerifyRootWrapperArg* wrapperArg = reinterpret_cast<VerifyRootWrapperArg*>(arg); 893 wrapperArg->callback_(*root, wrapperArg->arg_, 0, NULL, root_type); 894} 895 896void ThreadList::VerifyRoots(VerifyRootCallback* callback, void* arg) const { 897 VerifyRootWrapperArg wrapper(callback, arg); 898 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_); 899 for (const auto& thread : list_) { 900 thread->VisitRoots(VerifyRootWrapperCallback, &wrapper); 901 } 902} 903 904uint32_t ThreadList::AllocThreadId(Thread* self) { 905 MutexLock mu(self, *Locks::allocated_thread_ids_lock_); 906 for (size_t i = 0; i < allocated_ids_.size(); ++i) { 907 if (!allocated_ids_[i]) { 908 allocated_ids_.set(i); 909 return i + 1; // Zero is reserved to mean "invalid". 910 } 911 } 912 LOG(FATAL) << "Out of internal thread ids"; 913 return 0; 914} 915 916void ThreadList::ReleaseThreadId(Thread* self, uint32_t id) { 917 MutexLock mu(self, *Locks::allocated_thread_ids_lock_); 918 --id; // Zero is reserved to mean "invalid". 919 DCHECK(allocated_ids_[id]) << id; 920 allocated_ids_.reset(id); 921} 922 923} // namespace art 924