thread_list.cc revision 82558acbca3eae5b7e47748bcfb8070855266676
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 DCHECK(self != nullptr); 298 299 VLOG(threads) << *self << " SuspendAll starting..."; 300 ATRACE_BEGIN("Suspending mutator threads"); 301 uint64_t start_time = NanoTime(); 302 303 Locks::mutator_lock_->AssertNotHeld(self); 304 Locks::thread_list_lock_->AssertNotHeld(self); 305 Locks::thread_suspend_count_lock_->AssertNotHeld(self); 306 if (kDebugLocking) { 307 CHECK_NE(self->GetState(), kRunnable); 308 } 309 { 310 MutexLock mu(self, *Locks::thread_list_lock_); 311 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 312 // Update global suspend all state for attaching threads. 313 ++suspend_all_count_; 314 // Increment everybody's suspend count (except our own). 315 for (const auto& thread : list_) { 316 if (thread == self) { 317 continue; 318 } 319 VLOG(threads) << "requesting thread suspend: " << *thread; 320 thread->ModifySuspendCount(self, +1, false); 321 } 322 } 323 324 // Block on the mutator lock until all Runnable threads release their share of access. 325#if HAVE_TIMED_RWLOCK 326 // Timeout if we wait more than 30 seconds. 327 if (!Locks::mutator_lock_->ExclusiveLockWithTimeout(self, 30 * 1000, 0)) { 328 UnsafeLogFatalForThreadSuspendAllTimeout(); 329 } 330#else 331 Locks::mutator_lock_->ExclusiveLock(self); 332#endif 333 334 uint64_t end_time = NanoTime(); 335 if (end_time - start_time > kLongThreadSuspendThreshold) { 336 LOG(WARNING) << "Suspending all threads took: " << PrettyDuration(end_time - start_time); 337 } 338 339 if (kDebugLocking) { 340 // Debug check that all threads are suspended. 341 AssertThreadsAreSuspended(self, self); 342 } 343 344 ATRACE_END(); 345 ATRACE_BEGIN("Mutator threads suspended"); 346 347 VLOG(threads) << *self << " SuspendAll complete"; 348} 349 350void ThreadList::ResumeAll() { 351 Thread* self = Thread::Current(); 352 DCHECK(self != nullptr); 353 354 VLOG(threads) << *self << " ResumeAll starting"; 355 356 ATRACE_END(); 357 ATRACE_BEGIN("Resuming mutator threads"); 358 359 if (kDebugLocking) { 360 // Debug check that all threads are suspended. 361 AssertThreadsAreSuspended(self, self); 362 } 363 364 Locks::mutator_lock_->ExclusiveUnlock(self); 365 { 366 MutexLock mu(self, *Locks::thread_list_lock_); 367 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 368 // Update global suspend all state for attaching threads. 369 --suspend_all_count_; 370 // Decrement the suspend counts for all threads. 371 for (const auto& thread : list_) { 372 if (thread == self) { 373 continue; 374 } 375 thread->ModifySuspendCount(self, -1, false); 376 } 377 378 // Broadcast a notification to all suspended threads, some or all of 379 // which may choose to wake up. No need to wait for them. 380 VLOG(threads) << *self << " ResumeAll waking others"; 381 Thread::resume_cond_->Broadcast(self); 382 } 383 ATRACE_END(); 384 VLOG(threads) << *self << " ResumeAll complete"; 385} 386 387void ThreadList::Resume(Thread* thread, bool for_debugger) { 388 Thread* self = Thread::Current(); 389 DCHECK_NE(thread, self); 390 VLOG(threads) << "Resume(" << *thread << ") starting..." << (for_debugger ? " (debugger)" : ""); 391 392 { 393 // To check Contains. 394 MutexLock mu(self, *Locks::thread_list_lock_); 395 // To check IsSuspended. 396 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 397 DCHECK(thread->IsSuspended()); 398 if (!Contains(thread)) { 399 return; 400 } 401 thread->ModifySuspendCount(self, -1, for_debugger); 402 } 403 404 { 405 VLOG(threads) << "Resume(" << *thread << ") waking others"; 406 MutexLock mu(self, *Locks::thread_suspend_count_lock_); 407 Thread::resume_cond_->Broadcast(self); 408 } 409 410 VLOG(threads) << "Resume(" << *thread << ") complete"; 411} 412 413static void ThreadSuspendByPeerWarning(Thread* self, int level, const char* message, jobject peer) { 414 JNIEnvExt* env = self->GetJniEnv(); 415 ScopedLocalRef<jstring> 416 scoped_name_string(env, (jstring)env->GetObjectField(peer, 417 WellKnownClasses::java_lang_Thread_name)); 418 ScopedUtfChars scoped_name_chars(env, scoped_name_string.get()); 419 if (scoped_name_chars.c_str() == NULL) { 420 LOG(level) << message << ": " << peer; 421 env->ExceptionClear(); 422 } else { 423 LOG(level) << message << ": " << peer << ":" << scoped_name_chars.c_str(); 424 } 425} 426 427Thread* ThreadList::SuspendThreadByPeer(jobject peer, bool request_suspension, 428 bool debug_suspension, bool* timed_out) { 429 static const useconds_t kTimeoutUs = 30 * 1000000; // 30s. 430 useconds_t total_delay_us = 0; 431 useconds_t delay_us = 0; 432 bool did_suspend_request = false; 433 *timed_out = false; 434 Thread* self = Thread::Current(); 435 while (true) { 436 Thread* thread; 437 { 438 // Note: this will transition to runnable and potentially suspend. We ensure only one thread 439 // is requesting another suspend, to avoid deadlock, by requiring this function be called 440 // holding Locks::thread_list_suspend_thread_lock_. Its important this thread suspend rather 441 // than request thread suspension, to avoid potential cycles in threads requesting each other 442 // suspend. 443 ScopedObjectAccess soa(self); 444 MutexLock mu(self, *Locks::thread_list_lock_); 445 thread = Thread::FromManagedThread(soa, peer); 446 if (thread == NULL) { 447 ThreadSuspendByPeerWarning(self, WARNING, "No such thread for suspend", peer); 448 return NULL; 449 } 450 { 451 MutexLock mu(self, *Locks::thread_suspend_count_lock_); 452 if (request_suspension) { 453 thread->ModifySuspendCount(self, +1, debug_suspension); 454 request_suspension = false; 455 did_suspend_request = true; 456 } else { 457 // If the caller isn't requesting suspension, a suspension should have already occurred. 458 CHECK_GT(thread->GetSuspendCount(), 0); 459 } 460 // IsSuspended on the current thread will fail as the current thread is changed into 461 // Runnable above. As the suspend count is now raised if this is the current thread 462 // it will self suspend on transition to Runnable, making it hard to work with. It's simpler 463 // to just explicitly handle the current thread in the callers to this code. 464 CHECK_NE(thread, self) << "Attempt to suspend the current thread for the debugger"; 465 // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend 466 // count, or else we've waited and it has self suspended) or is the current thread, we're 467 // done. 468 if (thread->IsSuspended()) { 469 return thread; 470 } 471 if (total_delay_us >= kTimeoutUs) { 472 ThreadSuspendByPeerWarning(self, FATAL, "Thread suspension timed out", peer); 473 if (did_suspend_request) { 474 thread->ModifySuspendCount(soa.Self(), -1, debug_suspension); 475 } 476 *timed_out = true; 477 return NULL; 478 } 479 } 480 // Release locks and come out of runnable state. 481 } 482 ThreadSuspendSleep(self, &delay_us, &total_delay_us); 483 } 484} 485 486static void ThreadSuspendByThreadIdWarning(int level, const char* message, uint32_t thread_id) { 487 LOG(level) << StringPrintf("%s: %d", message, thread_id); 488} 489 490Thread* ThreadList::SuspendThreadByThreadId(uint32_t thread_id, bool debug_suspension, 491 bool* timed_out) { 492 static const useconds_t kTimeoutUs = 30 * 1000000; // 30s. 493 useconds_t total_delay_us = 0; 494 useconds_t delay_us = 0; 495 *timed_out = false; 496 Thread* suspended_thread = nullptr; 497 Thread* self = Thread::Current(); 498 CHECK_NE(thread_id, kInvalidThreadId); 499 while (true) { 500 { 501 // Note: this will transition to runnable and potentially suspend. We ensure only one thread 502 // is requesting another suspend, to avoid deadlock, by requiring this function be called 503 // holding Locks::thread_list_suspend_thread_lock_. Its important this thread suspend rather 504 // than request thread suspension, to avoid potential cycles in threads requesting each other 505 // suspend. 506 ScopedObjectAccess soa(self); 507 MutexLock mu(self, *Locks::thread_list_lock_); 508 Thread* thread = nullptr; 509 for (const auto& it : list_) { 510 if (it->GetThreadId() == thread_id) { 511 thread = it; 512 break; 513 } 514 } 515 if (thread == nullptr) { 516 CHECK(suspended_thread == nullptr) << "Suspended thread " << suspended_thread 517 << " no longer in thread list"; 518 // There's a race in inflating a lock and the owner giving up ownership and then dying. 519 ThreadSuspendByThreadIdWarning(WARNING, "No such thread id for suspend", thread_id); 520 return NULL; 521 } 522 { 523 MutexLock mu(self, *Locks::thread_suspend_count_lock_); 524 if (suspended_thread == nullptr) { 525 thread->ModifySuspendCount(self, +1, debug_suspension); 526 suspended_thread = thread; 527 } else { 528 CHECK_EQ(suspended_thread, thread); 529 // If the caller isn't requesting suspension, a suspension should have already occurred. 530 CHECK_GT(thread->GetSuspendCount(), 0); 531 } 532 // IsSuspended on the current thread will fail as the current thread is changed into 533 // Runnable above. As the suspend count is now raised if this is the current thread 534 // it will self suspend on transition to Runnable, making it hard to work with. It's simpler 535 // to just explicitly handle the current thread in the callers to this code. 536 CHECK_NE(thread, self) << "Attempt to suspend the current thread for the debugger"; 537 // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend 538 // count, or else we've waited and it has self suspended) or is the current thread, we're 539 // done. 540 if (thread->IsSuspended()) { 541 return thread; 542 } 543 if (total_delay_us >= kTimeoutUs) { 544 ThreadSuspendByThreadIdWarning(WARNING, "Thread suspension timed out", thread_id); 545 if (suspended_thread != nullptr) { 546 thread->ModifySuspendCount(soa.Self(), -1, debug_suspension); 547 } 548 *timed_out = true; 549 return NULL; 550 } 551 } 552 // Release locks and come out of runnable state. 553 } 554 ThreadSuspendSleep(self, &delay_us, &total_delay_us); 555 } 556} 557 558Thread* ThreadList::FindThreadByThreadId(uint32_t thin_lock_id) { 559 Thread* self = Thread::Current(); 560 MutexLock mu(self, *Locks::thread_list_lock_); 561 for (const auto& thread : list_) { 562 if (thread->GetThreadId() == thin_lock_id) { 563 CHECK(thread == self || thread->IsSuspended()); 564 return thread; 565 } 566 } 567 return NULL; 568} 569 570void ThreadList::SuspendAllForDebugger() { 571 Thread* self = Thread::Current(); 572 Thread* debug_thread = Dbg::GetDebugThread(); 573 574 VLOG(threads) << *self << " SuspendAllForDebugger starting..."; 575 576 { 577 MutexLock mu(self, *Locks::thread_list_lock_); 578 { 579 MutexLock mu(self, *Locks::thread_suspend_count_lock_); 580 // Update global suspend all state for attaching threads. 581 ++suspend_all_count_; 582 ++debug_suspend_all_count_; 583 // Increment everybody's suspend count (except our own). 584 for (const auto& thread : list_) { 585 if (thread == self || thread == debug_thread) { 586 continue; 587 } 588 VLOG(threads) << "requesting thread suspend: " << *thread; 589 thread->ModifySuspendCount(self, +1, true); 590 } 591 } 592 } 593 594 // Block on the mutator lock until all Runnable threads release their share of access then 595 // immediately unlock again. 596#if HAVE_TIMED_RWLOCK 597 // Timeout if we wait more than 30 seconds. 598 if (!Locks::mutator_lock_->ExclusiveLockWithTimeout(self, 30 * 1000, 0)) { 599 UnsafeLogFatalForThreadSuspendAllTimeout(); 600 } else { 601 Locks::mutator_lock_->ExclusiveUnlock(self); 602 } 603#else 604 Locks::mutator_lock_->ExclusiveLock(self); 605 Locks::mutator_lock_->ExclusiveUnlock(self); 606#endif 607 AssertThreadsAreSuspended(self, self, debug_thread); 608 609 VLOG(threads) << *self << " SuspendAll complete"; 610} 611 612void ThreadList::SuspendSelfForDebugger() { 613 Thread* self = Thread::Current(); 614 615 // The debugger thread must not suspend itself due to debugger activity! 616 Thread* debug_thread = Dbg::GetDebugThread(); 617 CHECK(debug_thread != NULL); 618 CHECK(self != debug_thread); 619 CHECK_NE(self->GetState(), kRunnable); 620 Locks::mutator_lock_->AssertNotHeld(self); 621 622 { 623 // Collisions with other suspends aren't really interesting. We want 624 // to ensure that we're the only one fiddling with the suspend count 625 // though. 626 MutexLock mu(self, *Locks::thread_suspend_count_lock_); 627 self->ModifySuspendCount(self, +1, true); 628 CHECK_GT(self->GetSuspendCount(), 0); 629 } 630 631 VLOG(threads) << *self << " self-suspending (debugger)"; 632 633 // Tell JDWP we've completed invocation and are ready to suspend. 634 DebugInvokeReq* pReq = self->GetInvokeReq(); 635 DCHECK(pReq != NULL); 636 if (pReq->invoke_needed) { 637 // Clear this before signaling. 638 pReq->Clear(); 639 640 VLOG(jdwp) << "invoke complete, signaling"; 641 MutexLock mu(self, pReq->lock); 642 pReq->cond.Signal(self); 643 } 644 645 // Tell JDWP that we've completed suspension. The JDWP thread can't 646 // tell us to resume before we're fully asleep because we hold the 647 // suspend count lock. 648 Dbg::ClearWaitForEventThread(); 649 650 { 651 MutexLock mu(self, *Locks::thread_suspend_count_lock_); 652 while (self->GetSuspendCount() != 0) { 653 Thread::resume_cond_->Wait(self); 654 if (self->GetSuspendCount() != 0) { 655 // The condition was signaled but we're still suspended. This 656 // can happen if the debugger lets go while a SIGQUIT thread 657 // dump event is pending (assuming SignalCatcher was resumed for 658 // just long enough to try to grab the thread-suspend lock). 659 LOG(WARNING) << *self << " still suspended after undo " 660 << "(suspend count=" << self->GetSuspendCount() << ")"; 661 } 662 } 663 CHECK_EQ(self->GetSuspendCount(), 0); 664 } 665 666 VLOG(threads) << *self << " self-reviving (debugger)"; 667} 668 669void ThreadList::UndoDebuggerSuspensions() { 670 Thread* self = Thread::Current(); 671 672 VLOG(threads) << *self << " UndoDebuggerSuspensions starting"; 673 674 { 675 MutexLock mu(self, *Locks::thread_list_lock_); 676 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 677 // Update global suspend all state for attaching threads. 678 suspend_all_count_ -= debug_suspend_all_count_; 679 debug_suspend_all_count_ = 0; 680 // Update running threads. 681 for (const auto& thread : list_) { 682 if (thread == self || thread->GetDebugSuspendCount() == 0) { 683 continue; 684 } 685 thread->ModifySuspendCount(self, -thread->GetDebugSuspendCount(), true); 686 } 687 } 688 689 { 690 MutexLock mu(self, *Locks::thread_suspend_count_lock_); 691 Thread::resume_cond_->Broadcast(self); 692 } 693 694 VLOG(threads) << "UndoDebuggerSuspensions(" << *self << ") complete"; 695} 696 697void ThreadList::WaitForOtherNonDaemonThreadsToExit() { 698 Thread* self = Thread::Current(); 699 Locks::mutator_lock_->AssertNotHeld(self); 700 bool all_threads_are_daemons; 701 do { 702 { 703 // No more threads can be born after we start to shutdown. 704 MutexLock mu(self, *Locks::runtime_shutdown_lock_); 705 CHECK(Runtime::Current()->IsShuttingDownLocked()); 706 CHECK_EQ(Runtime::Current()->NumberOfThreadsBeingBorn(), 0U); 707 } 708 all_threads_are_daemons = true; 709 MutexLock mu(self, *Locks::thread_list_lock_); 710 for (const auto& thread : list_) { 711 if (thread != self && !thread->IsDaemon()) { 712 all_threads_are_daemons = false; 713 break; 714 } 715 } 716 if (!all_threads_are_daemons) { 717 // Wait for another thread to exit before re-checking. 718 thread_exit_cond_.Wait(self); 719 } 720 } while (!all_threads_are_daemons); 721} 722 723void ThreadList::SuspendAllDaemonThreads() { 724 Thread* self = Thread::Current(); 725 MutexLock mu(self, *Locks::thread_list_lock_); 726 { // Tell all the daemons it's time to suspend. 727 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 728 for (const auto& thread : list_) { 729 // This is only run after all non-daemon threads have exited, so the remainder should all be 730 // daemons. 731 CHECK(thread->IsDaemon()) << *thread; 732 if (thread != self) { 733 thread->ModifySuspendCount(self, +1, false); 734 } 735 } 736 } 737 // Give the threads a chance to suspend, complaining if they're slow. 738 bool have_complained = false; 739 for (int i = 0; i < 10; ++i) { 740 usleep(200 * 1000); 741 bool all_suspended = true; 742 for (const auto& thread : list_) { 743 if (thread != self && thread->GetState() == kRunnable) { 744 if (!have_complained) { 745 LOG(WARNING) << "daemon thread not yet suspended: " << *thread; 746 have_complained = true; 747 } 748 all_suspended = false; 749 } 750 } 751 if (all_suspended) { 752 return; 753 } 754 } 755 LOG(ERROR) << "suspend all daemons failed"; 756} 757void ThreadList::Register(Thread* self) { 758 DCHECK_EQ(self, Thread::Current()); 759 760 if (VLOG_IS_ON(threads)) { 761 std::ostringstream oss; 762 self->ShortDump(oss); // We don't hold the mutator_lock_ yet and so cannot call Dump. 763 LOG(INFO) << "ThreadList::Register() " << *self << "\n" << oss.str(); 764 } 765 766 // Atomically add self to the thread list and make its thread_suspend_count_ reflect ongoing 767 // SuspendAll requests. 768 MutexLock mu(self, *Locks::thread_list_lock_); 769 MutexLock mu2(self, *Locks::thread_suspend_count_lock_); 770 CHECK_GE(suspend_all_count_, debug_suspend_all_count_); 771 // Modify suspend count in increments of 1 to maintain invariants in ModifySuspendCount. While 772 // this isn't particularly efficient the suspend counts are most commonly 0 or 1. 773 for (int delta = debug_suspend_all_count_; delta > 0; delta--) { 774 self->ModifySuspendCount(self, +1, true); 775 } 776 for (int delta = suspend_all_count_ - debug_suspend_all_count_; delta > 0; delta--) { 777 self->ModifySuspendCount(self, +1, false); 778 } 779 CHECK(!Contains(self)); 780 list_.push_back(self); 781} 782 783void ThreadList::Unregister(Thread* self) { 784 DCHECK_EQ(self, Thread::Current()); 785 786 VLOG(threads) << "ThreadList::Unregister() " << *self; 787 788 // Any time-consuming destruction, plus anything that can call back into managed code or 789 // suspend and so on, must happen at this point, and not in ~Thread. 790 self->Destroy(); 791 792 uint32_t thin_lock_id = self->GetThreadId(); 793 while (self != nullptr) { 794 // Remove and delete the Thread* while holding the thread_list_lock_ and 795 // thread_suspend_count_lock_ so that the unregistering thread cannot be suspended. 796 // Note: deliberately not using MutexLock that could hold a stale self pointer. 797 Locks::thread_list_lock_->ExclusiveLock(self); 798 CHECK(Contains(self)); 799 // Note: we don't take the thread_suspend_count_lock_ here as to be suspending a thread other 800 // than yourself you need to hold the thread_list_lock_ (see Thread::ModifySuspendCount). 801 if (!self->IsSuspended()) { 802 list_.remove(self); 803 delete self; 804 self = nullptr; 805 } 806 Locks::thread_list_lock_->ExclusiveUnlock(self); 807 } 808 // Release the thread ID after the thread is finished and deleted to avoid cases where we can 809 // temporarily have multiple threads with the same thread id. When this occurs, it causes 810 // problems in FindThreadByThreadId / SuspendThreadByThreadId. 811 ReleaseThreadId(nullptr, thin_lock_id); 812 813 // Clear the TLS data, so that the underlying native thread is recognizably detached. 814 // (It may wish to reattach later.) 815 CHECK_PTHREAD_CALL(pthread_setspecific, (Thread::pthread_key_self_, NULL), "detach self"); 816 817 // Signal that a thread just detached. 818 MutexLock mu(NULL, *Locks::thread_list_lock_); 819 thread_exit_cond_.Signal(NULL); 820} 821 822void ThreadList::ForEach(void (*callback)(Thread*, void*), void* context) { 823 for (const auto& thread : list_) { 824 callback(thread, context); 825 } 826} 827 828void ThreadList::VisitRoots(RootCallback* callback, void* arg) const { 829 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_); 830 for (const auto& thread : list_) { 831 thread->VisitRoots(callback, arg); 832 } 833} 834 835class VerifyRootWrapperArg { 836 public: 837 VerifyRootWrapperArg(VerifyRootCallback* callback, void* arg) : callback_(callback), arg_(arg) { 838 } 839 VerifyRootCallback* const callback_; 840 void* const arg_; 841}; 842 843static void VerifyRootWrapperCallback(mirror::Object** root, void* arg, uint32_t /*thread_id*/, 844 RootType root_type) { 845 VerifyRootWrapperArg* wrapperArg = reinterpret_cast<VerifyRootWrapperArg*>(arg); 846 wrapperArg->callback_(*root, wrapperArg->arg_, 0, NULL, root_type); 847} 848 849void ThreadList::VerifyRoots(VerifyRootCallback* callback, void* arg) const { 850 VerifyRootWrapperArg wrapper(callback, arg); 851 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_); 852 for (const auto& thread : list_) { 853 thread->VisitRoots(VerifyRootWrapperCallback, &wrapper); 854 } 855} 856 857uint32_t ThreadList::AllocThreadId(Thread* self) { 858 MutexLock mu(self, *Locks::allocated_thread_ids_lock_); 859 for (size_t i = 0; i < allocated_ids_.size(); ++i) { 860 if (!allocated_ids_[i]) { 861 allocated_ids_.set(i); 862 return i + 1; // Zero is reserved to mean "invalid". 863 } 864 } 865 LOG(FATAL) << "Out of internal thread ids"; 866 return 0; 867} 868 869void ThreadList::ReleaseThreadId(Thread* self, uint32_t id) { 870 MutexLock mu(self, *Locks::allocated_thread_ids_lock_); 871 --id; // Zero is reserved to mean "invalid". 872 DCHECK(allocated_ids_[id]) << id; 873 allocated_ids_.reset(id); 874} 875 876} // namespace art 877