1 //===-- InstrumentationRuntimeMainThreadChecker.cpp -----------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "InstrumentationRuntimeMainThreadChecker.h" 10 11 #include "Plugins/Process/Utility/HistoryThread.h" 12 #include "lldb/Breakpoint/StoppointCallbackContext.h" 13 #include "lldb/Core/Module.h" 14 #include "lldb/Core/PluginManager.h" 15 #include "lldb/Symbol/Symbol.h" 16 #include "lldb/Symbol/SymbolContext.h" 17 #include "lldb/Symbol/Variable.h" 18 #include "lldb/Symbol/VariableList.h" 19 #include "lldb/Target/InstrumentationRuntimeStopInfo.h" 20 #include "lldb/Target/RegisterContext.h" 21 #include "lldb/Target/SectionLoadList.h" 22 #include "lldb/Target/StopInfo.h" 23 #include "lldb/Target/Target.h" 24 #include "lldb/Target/Thread.h" 25 #include "lldb/Utility/RegularExpression.h" 26 27 #include <memory> 28 29 using namespace lldb; 30 using namespace lldb_private; 31 32 LLDB_PLUGIN_DEFINE(InstrumentationRuntimeMainThreadChecker) 33 34 InstrumentationRuntimeMainThreadChecker:: 35 ~InstrumentationRuntimeMainThreadChecker() { 36 Deactivate(); 37 } 38 39 lldb::InstrumentationRuntimeSP 40 InstrumentationRuntimeMainThreadChecker::CreateInstance( 41 const lldb::ProcessSP &process_sp) { 42 return InstrumentationRuntimeSP( 43 new InstrumentationRuntimeMainThreadChecker(process_sp)); 44 } 45 46 void InstrumentationRuntimeMainThreadChecker::Initialize() { 47 PluginManager::RegisterPlugin( 48 GetPluginNameStatic(), 49 "MainThreadChecker instrumentation runtime plugin.", CreateInstance, 50 GetTypeStatic); 51 } 52 53 void InstrumentationRuntimeMainThreadChecker::Terminate() { 54 PluginManager::UnregisterPlugin(CreateInstance); 55 } 56 57 lldb::InstrumentationRuntimeType 58 InstrumentationRuntimeMainThreadChecker::GetTypeStatic() { 59 return eInstrumentationRuntimeTypeMainThreadChecker; 60 } 61 62 const RegularExpression & 63 InstrumentationRuntimeMainThreadChecker::GetPatternForRuntimeLibrary() { 64 static RegularExpression regex(llvm::StringRef("libMainThreadChecker.dylib")); 65 return regex; 66 } 67 68 bool InstrumentationRuntimeMainThreadChecker::CheckIfRuntimeIsValid( 69 const lldb::ModuleSP module_sp) { 70 static ConstString test_sym("__main_thread_checker_on_report"); 71 const Symbol *symbol = 72 module_sp->FindFirstSymbolWithNameAndType(test_sym, lldb::eSymbolTypeAny); 73 return symbol != nullptr; 74 } 75 76 StructuredData::ObjectSP 77 InstrumentationRuntimeMainThreadChecker::RetrieveReportData( 78 ExecutionContextRef exe_ctx_ref) { 79 ProcessSP process_sp = GetProcessSP(); 80 if (!process_sp) 81 return StructuredData::ObjectSP(); 82 83 ThreadSP thread_sp = exe_ctx_ref.GetThreadSP(); 84 StackFrameSP frame_sp = 85 thread_sp->GetSelectedFrame(DoNoSelectMostRelevantFrame); 86 ModuleSP runtime_module_sp = GetRuntimeModuleSP(); 87 Target &target = process_sp->GetTarget(); 88 89 if (!frame_sp) 90 return StructuredData::ObjectSP(); 91 92 RegisterContextSP regctx_sp = frame_sp->GetRegisterContext(); 93 if (!regctx_sp) 94 return StructuredData::ObjectSP(); 95 96 const RegisterInfo *reginfo = regctx_sp->GetRegisterInfoByName("arg1"); 97 if (!reginfo) 98 return StructuredData::ObjectSP(); 99 100 uint64_t apiname_ptr = regctx_sp->ReadRegisterAsUnsigned(reginfo, 0); 101 if (!apiname_ptr) 102 return StructuredData::ObjectSP(); 103 104 std::string apiName; 105 Status read_error; 106 target.ReadCStringFromMemory(apiname_ptr, apiName, read_error); 107 if (read_error.Fail()) 108 return StructuredData::ObjectSP(); 109 110 std::string className; 111 std::string selector; 112 if (apiName.substr(0, 2) == "-[") { 113 size_t spacePos = apiName.find(' '); 114 if (spacePos != std::string::npos) { 115 className = apiName.substr(2, spacePos - 2); 116 selector = apiName.substr(spacePos + 1, apiName.length() - spacePos - 2); 117 } 118 } 119 120 // Gather the PCs of the user frames in the backtrace. 121 StructuredData::Array *trace = new StructuredData::Array(); 122 auto trace_sp = StructuredData::ObjectSP(trace); 123 StackFrameSP responsible_frame; 124 for (unsigned I = 0; I < thread_sp->GetStackFrameCount(); ++I) { 125 StackFrameSP frame = thread_sp->GetStackFrameAtIndex(I); 126 Address addr = frame->GetFrameCodeAddressForSymbolication(); 127 if (addr.GetModule() == runtime_module_sp) // Skip PCs from the runtime. 128 continue; 129 130 // The first non-runtime frame is responsible for the bug. 131 if (!responsible_frame) 132 responsible_frame = frame; 133 134 lldb::addr_t PC = addr.GetLoadAddress(&target); 135 trace->AddIntegerItem(PC); 136 } 137 138 auto *d = new StructuredData::Dictionary(); 139 auto dict_sp = StructuredData::ObjectSP(d); 140 d->AddStringItem("instrumentation_class", "MainThreadChecker"); 141 d->AddStringItem("api_name", apiName); 142 d->AddStringItem("class_name", className); 143 d->AddStringItem("selector", selector); 144 d->AddStringItem("description", 145 apiName + " must be used from main thread only"); 146 d->AddIntegerItem("tid", thread_sp->GetIndexID()); 147 d->AddItem("trace", trace_sp); 148 return dict_sp; 149 } 150 151 bool InstrumentationRuntimeMainThreadChecker::NotifyBreakpointHit( 152 void *baton, StoppointCallbackContext *context, user_id_t break_id, 153 user_id_t break_loc_id) { 154 assert(baton && "null baton"); 155 if (!baton) 156 return false; ///< false => resume execution. 157 158 InstrumentationRuntimeMainThreadChecker *const instance = 159 static_cast<InstrumentationRuntimeMainThreadChecker *>(baton); 160 161 ProcessSP process_sp = instance->GetProcessSP(); 162 ThreadSP thread_sp = context->exe_ctx_ref.GetThreadSP(); 163 if (!process_sp || !thread_sp || 164 process_sp != context->exe_ctx_ref.GetProcessSP()) 165 return false; 166 167 if (process_sp->GetModIDRef().IsLastResumeForUserExpression()) 168 return false; 169 170 StructuredData::ObjectSP report = 171 instance->RetrieveReportData(context->exe_ctx_ref); 172 173 if (report) { 174 std::string description = std::string(report->GetAsDictionary() 175 ->GetValueForKey("description") 176 ->GetAsString() 177 ->GetValue()); 178 thread_sp->SetStopInfo( 179 InstrumentationRuntimeStopInfo::CreateStopReasonWithInstrumentationData( 180 *thread_sp, description, report)); 181 return true; 182 } 183 184 return false; 185 } 186 187 void InstrumentationRuntimeMainThreadChecker::Activate() { 188 if (IsActive()) 189 return; 190 191 ProcessSP process_sp = GetProcessSP(); 192 if (!process_sp) 193 return; 194 195 ModuleSP runtime_module_sp = GetRuntimeModuleSP(); 196 197 ConstString symbol_name("__main_thread_checker_on_report"); 198 const Symbol *symbol = runtime_module_sp->FindFirstSymbolWithNameAndType( 199 symbol_name, eSymbolTypeCode); 200 201 if (symbol == nullptr) 202 return; 203 204 if (!symbol->ValueIsAddress() || !symbol->GetAddressRef().IsValid()) 205 return; 206 207 Target &target = process_sp->GetTarget(); 208 addr_t symbol_address = symbol->GetAddressRef().GetOpcodeLoadAddress(&target); 209 210 if (symbol_address == LLDB_INVALID_ADDRESS) 211 return; 212 213 Breakpoint *breakpoint = 214 process_sp->GetTarget() 215 .CreateBreakpoint(symbol_address, /*internal=*/true, 216 /*hardware=*/false) 217 .get(); 218 const bool sync = false; 219 breakpoint->SetCallback( 220 InstrumentationRuntimeMainThreadChecker::NotifyBreakpointHit, this, sync); 221 breakpoint->SetBreakpointKind("main-thread-checker-report"); 222 SetBreakpointID(breakpoint->GetID()); 223 224 SetActive(true); 225 } 226 227 void InstrumentationRuntimeMainThreadChecker::Deactivate() { 228 SetActive(false); 229 230 auto BID = GetBreakpointID(); 231 if (BID == LLDB_INVALID_BREAK_ID) 232 return; 233 234 if (ProcessSP process_sp = GetProcessSP()) { 235 process_sp->GetTarget().RemoveBreakpointByID(BID); 236 SetBreakpointID(LLDB_INVALID_BREAK_ID); 237 } 238 } 239 240 lldb::ThreadCollectionSP 241 InstrumentationRuntimeMainThreadChecker::GetBacktracesFromExtendedStopInfo( 242 StructuredData::ObjectSP info) { 243 ThreadCollectionSP threads; 244 threads = std::make_shared<ThreadCollection>(); 245 246 ProcessSP process_sp = GetProcessSP(); 247 248 if (info->GetObjectForDotSeparatedPath("instrumentation_class") 249 ->GetStringValue() != "MainThreadChecker") 250 return threads; 251 252 std::vector<lldb::addr_t> PCs; 253 auto trace = info->GetObjectForDotSeparatedPath("trace")->GetAsArray(); 254 trace->ForEach([&PCs](StructuredData::Object *PC) -> bool { 255 PCs.push_back(PC->GetUnsignedIntegerValue()); 256 return true; 257 }); 258 259 if (PCs.empty()) 260 return threads; 261 262 StructuredData::ObjectSP thread_id_obj = 263 info->GetObjectForDotSeparatedPath("tid"); 264 tid_t tid = thread_id_obj ? thread_id_obj->GetUnsignedIntegerValue() : 0; 265 266 // We gather symbolication addresses above, so no need for HistoryThread to 267 // try to infer the call addresses. 268 bool pcs_are_call_addresses = true; 269 ThreadSP new_thread_sp = std::make_shared<HistoryThread>( 270 *process_sp, tid, PCs, pcs_are_call_addresses); 271 272 // Save this in the Process' ExtendedThreadList so a strong pointer retains 273 // the object 274 process_sp->GetExtendedThreadList().AddThread(new_thread_sp); 275 threads->AddThread(new_thread_sp); 276 277 return threads; 278 } 279