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