thread_list.h revision 7b078e8c04f3e1451dbdd18543c8b9692b5b067e
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#ifndef ART_RUNTIME_THREAD_LIST_H_ 18#define ART_RUNTIME_THREAD_LIST_H_ 19 20#include "base/mutex.h" 21#include "jni.h" 22#include "object_callbacks.h" 23 24#include <bitset> 25#include <list> 26 27namespace art { 28class Closure; 29class Thread; 30class TimingLogger; 31 32class ThreadList { 33 public: 34 static const uint32_t kMaxThreadId = 0xFFFF; 35 static const uint32_t kInvalidThreadId = 0; 36 static const uint32_t kMainThreadId = 1; 37 38 explicit ThreadList(); 39 ~ThreadList(); 40 41 void DumpForSigQuit(std::ostream& os) 42 LOCKS_EXCLUDED(Locks::thread_list_lock_); 43 // For thread suspend timeout dumps. 44 void Dump(std::ostream& os) 45 LOCKS_EXCLUDED(Locks::thread_list_lock_, 46 Locks::thread_suspend_count_lock_); 47 pid_t GetLockOwner(); // For SignalCatcher. 48 49 // Thread suspension support. 50 void ResumeAll() 51 UNLOCK_FUNCTION(Locks::mutator_lock_) 52 LOCKS_EXCLUDED(Locks::thread_list_lock_, 53 Locks::thread_suspend_count_lock_); 54 void Resume(Thread* thread, bool for_debugger = false) 55 LOCKS_EXCLUDED(Locks::thread_suspend_count_lock_); 56 57 // Suspends all threads and gets exclusive access to the mutator_lock_. 58 void SuspendAll() 59 EXCLUSIVE_LOCK_FUNCTION(Locks::mutator_lock_) 60 LOCKS_EXCLUDED(Locks::thread_list_lock_, 61 Locks::thread_suspend_count_lock_); 62 63 64 // Suspend a thread using a peer, typically used by the debugger. Returns the thread on success, 65 // else NULL. The peer is used to identify the thread to avoid races with the thread terminating. 66 // If the thread should be suspended then value of request_suspension should be true otherwise 67 // the routine will wait for a previous suspend request. If the suspension times out then *timeout 68 // is set to true. 69 Thread* SuspendThreadByPeer(jobject peer, bool request_suspension, bool debug_suspension, 70 bool* timed_out) 71 EXCLUSIVE_LOCKS_REQUIRED(Locks::thread_list_suspend_thread_lock_) 72 LOCKS_EXCLUDED(Locks::mutator_lock_, 73 Locks::thread_list_lock_, 74 Locks::thread_suspend_count_lock_); 75 76 // Suspend a thread using its thread id, typically used by lock/monitor inflation. Returns the 77 // thread on success else NULL. The thread id is used to identify the thread to avoid races with 78 // the thread terminating. Note that as thread ids are recycled this may not suspend the expected 79 // thread, that may be terminating. If the suspension times out then *timeout is set to true. 80 Thread* SuspendThreadByThreadId(uint32_t thread_id, bool debug_suspension, bool* timed_out) 81 EXCLUSIVE_LOCKS_REQUIRED(Locks::thread_list_suspend_thread_lock_) 82 LOCKS_EXCLUDED(Locks::mutator_lock_, 83 Locks::thread_list_lock_, 84 Locks::thread_suspend_count_lock_); 85 86 // Find an already suspended thread (or self) by its id. 87 Thread* FindThreadByThreadId(uint32_t thin_lock_id); 88 89 // Run a checkpoint on threads, running threads are not suspended but run the checkpoint inside 90 // of the suspend check. Returns how many checkpoints we should expect to run. 91 size_t RunCheckpoint(Closure* checkpoint_function) 92 LOCKS_EXCLUDED(Locks::thread_list_lock_, 93 Locks::thread_suspend_count_lock_); 94 95 size_t RunCheckpointOnRunnableThreads(Closure* checkpoint_function) 96 LOCKS_EXCLUDED(Locks::thread_list_lock_, 97 Locks::thread_suspend_count_lock_); 98 99 // Suspends all threads 100 void SuspendAllForDebugger() 101 LOCKS_EXCLUDED(Locks::mutator_lock_, 102 Locks::thread_list_lock_, 103 Locks::thread_suspend_count_lock_); 104 105 void SuspendSelfForDebugger() 106 LOCKS_EXCLUDED(Locks::thread_suspend_count_lock_); 107 108 void UndoDebuggerSuspensions() 109 LOCKS_EXCLUDED(Locks::thread_list_lock_, 110 Locks::thread_suspend_count_lock_); 111 112 // Iterates over all the threads. 113 void ForEach(void (*callback)(Thread*, void*), void* context) 114 EXCLUSIVE_LOCKS_REQUIRED(Locks::thread_list_lock_); 115 116 // Add/remove current thread from list. 117 void Register(Thread* self) 118 EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_) 119 LOCKS_EXCLUDED(Locks::mutator_lock_, Locks::thread_list_lock_); 120 void Unregister(Thread* self) LOCKS_EXCLUDED(Locks::mutator_lock_, Locks::thread_list_lock_); 121 122 void VisitRoots(RootCallback* callback, void* arg) const 123 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 124 125 void VerifyRoots(VerifyRootCallback* callback, void* arg) const 126 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 127 128 // Return a copy of the thread list. 129 std::list<Thread*> GetList() EXCLUSIVE_LOCKS_REQUIRED(Locks::thread_list_lock_) { 130 return list_; 131 } 132 133 void DumpNativeStacks(std::ostream& os) 134 LOCKS_EXCLUDED(Locks::thread_list_lock_); 135 136 private: 137 uint32_t AllocThreadId(Thread* self); 138 void ReleaseThreadId(Thread* self, uint32_t id) LOCKS_EXCLUDED(Locks::allocated_thread_ids_lock_); 139 140 bool Contains(Thread* thread) EXCLUSIVE_LOCKS_REQUIRED(Locks::thread_list_lock_); 141 bool Contains(pid_t tid) EXCLUSIVE_LOCKS_REQUIRED(Locks::thread_list_lock_); 142 143 void DumpUnattachedThreads(std::ostream& os) 144 LOCKS_EXCLUDED(Locks::thread_list_lock_); 145 146 void SuspendAllDaemonThreads() 147 LOCKS_EXCLUDED(Locks::thread_list_lock_, 148 Locks::thread_suspend_count_lock_); 149 void WaitForOtherNonDaemonThreadsToExit() 150 LOCKS_EXCLUDED(Locks::thread_list_lock_, 151 Locks::thread_suspend_count_lock_); 152 153 void AssertThreadsAreSuspended(Thread* self, Thread* ignore1, Thread* ignore2 = NULL) 154 LOCKS_EXCLUDED(Locks::thread_list_lock_, 155 Locks::thread_suspend_count_lock_); 156 157 std::bitset<kMaxThreadId> allocated_ids_ GUARDED_BY(Locks::allocated_thread_ids_lock_); 158 159 // The actual list of all threads. 160 std::list<Thread*> list_ GUARDED_BY(Locks::thread_list_lock_); 161 162 // Ongoing suspend all requests, used to ensure threads added to list_ respect SuspendAll. 163 int suspend_all_count_ GUARDED_BY(Locks::thread_suspend_count_lock_); 164 int debug_suspend_all_count_ GUARDED_BY(Locks::thread_suspend_count_lock_); 165 166 // Signaled when threads terminate. Used to determine when all non-daemons have terminated. 167 ConditionVariable thread_exit_cond_ GUARDED_BY(Locks::thread_list_lock_); 168 169 friend class Thread; 170 171 DISALLOW_COPY_AND_ASSIGN(ThreadList); 172}; 173 174} // namespace art 175 176#endif // ART_RUNTIME_THREAD_LIST_H_ 177