1 //===-- ThreadGDBRemote.cpp -------------------------------------*- C++ -*-===//
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 "ThreadGDBRemote.h"
10 
11 #include "lldb/Breakpoint/Watchpoint.h"
12 #include "lldb/Target/Platform.h"
13 #include "lldb/Target/Process.h"
14 #include "lldb/Target/RegisterContext.h"
15 #include "lldb/Target/StopInfo.h"
16 #include "lldb/Target/SystemRuntime.h"
17 #include "lldb/Target/Target.h"
18 #include "lldb/Target/UnixSignals.h"
19 #include "lldb/Target/Unwind.h"
20 #include "lldb/Utility/DataExtractor.h"
21 #include "lldb/Utility/State.h"
22 #include "lldb/Utility/StreamString.h"
23 #include "lldb/Utility/StringExtractorGDBRemote.h"
24 
25 #include "ProcessGDBRemote.h"
26 #include "ProcessGDBRemoteLog.h"
27 
28 #include <memory>
29 
30 using namespace lldb;
31 using namespace lldb_private;
32 using namespace lldb_private::process_gdb_remote;
33 
34 // Thread Registers
35 
36 ThreadGDBRemote::ThreadGDBRemote(Process &process, lldb::tid_t tid)
37     : Thread(process, tid), m_thread_name(), m_dispatch_queue_name(),
38       m_thread_dispatch_qaddr(LLDB_INVALID_ADDRESS),
39       m_dispatch_queue_t(LLDB_INVALID_ADDRESS), m_queue_kind(eQueueKindUnknown),
40       m_queue_serial_number(LLDB_INVALID_QUEUE_ID),
41       m_associated_with_libdispatch_queue(eLazyBoolCalculate) {
42   Log *log(GetLogIfAnyCategoriesSet(GDBR_LOG_THREAD));
43   LLDB_LOG(log, "this = {0}, pid = {1}, tid = {2}", this, process.GetID(),
44            GetID());
45 }
46 
47 ThreadGDBRemote::~ThreadGDBRemote() {
48   ProcessSP process_sp(GetProcess());
49   Log *log(GetLogIfAnyCategoriesSet(GDBR_LOG_THREAD));
50   LLDB_LOG(log, "this = {0}, pid = {1}, tid = {2}", this,
51            process_sp ? process_sp->GetID() : LLDB_INVALID_PROCESS_ID, GetID());
52   DestroyThread();
53 }
54 
55 const char *ThreadGDBRemote::GetName() {
56   if (m_thread_name.empty())
57     return nullptr;
58   return m_thread_name.c_str();
59 }
60 
61 void ThreadGDBRemote::ClearQueueInfo() {
62   m_dispatch_queue_name.clear();
63   m_queue_kind = eQueueKindUnknown;
64   m_queue_serial_number = 0;
65   m_dispatch_queue_t = LLDB_INVALID_ADDRESS;
66   m_associated_with_libdispatch_queue = eLazyBoolCalculate;
67 }
68 
69 void ThreadGDBRemote::SetQueueInfo(std::string &&queue_name,
70                                    QueueKind queue_kind, uint64_t queue_serial,
71                                    addr_t dispatch_queue_t,
72                                    LazyBool associated_with_libdispatch_queue) {
73   m_dispatch_queue_name = queue_name;
74   m_queue_kind = queue_kind;
75   m_queue_serial_number = queue_serial;
76   m_dispatch_queue_t = dispatch_queue_t;
77   m_associated_with_libdispatch_queue = associated_with_libdispatch_queue;
78 }
79 
80 const char *ThreadGDBRemote::GetQueueName() {
81   // If our cached queue info is valid, then someone called
82   // ThreadGDBRemote::SetQueueInfo(...) with valid information that was gleaned
83   // from the stop reply packet. In this case we trust that the info is valid
84   // in m_dispatch_queue_name without refetching it
85   if (CachedQueueInfoIsValid()) {
86     if (m_dispatch_queue_name.empty())
87       return nullptr;
88     else
89       return m_dispatch_queue_name.c_str();
90   }
91   // Always re-fetch the dispatch queue name since it can change
92 
93   if (m_associated_with_libdispatch_queue == eLazyBoolNo)
94     return nullptr;
95 
96   if (m_thread_dispatch_qaddr != 0 &&
97       m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS) {
98     ProcessSP process_sp(GetProcess());
99     if (process_sp) {
100       SystemRuntime *runtime = process_sp->GetSystemRuntime();
101       if (runtime)
102         m_dispatch_queue_name =
103             runtime->GetQueueNameFromThreadQAddress(m_thread_dispatch_qaddr);
104       else
105         m_dispatch_queue_name.clear();
106 
107       if (!m_dispatch_queue_name.empty())
108         return m_dispatch_queue_name.c_str();
109     }
110   }
111   return nullptr;
112 }
113 
114 QueueKind ThreadGDBRemote::GetQueueKind() {
115   // If our cached queue info is valid, then someone called
116   // ThreadGDBRemote::SetQueueInfo(...) with valid information that was gleaned
117   // from the stop reply packet. In this case we trust that the info is valid
118   // in m_dispatch_queue_name without refetching it
119   if (CachedQueueInfoIsValid()) {
120     return m_queue_kind;
121   }
122 
123   if (m_associated_with_libdispatch_queue == eLazyBoolNo)
124     return eQueueKindUnknown;
125 
126   if (m_thread_dispatch_qaddr != 0 &&
127       m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS) {
128     ProcessSP process_sp(GetProcess());
129     if (process_sp) {
130       SystemRuntime *runtime = process_sp->GetSystemRuntime();
131       if (runtime)
132         m_queue_kind = runtime->GetQueueKind(m_thread_dispatch_qaddr);
133       return m_queue_kind;
134     }
135   }
136   return eQueueKindUnknown;
137 }
138 
139 queue_id_t ThreadGDBRemote::GetQueueID() {
140   // If our cached queue info is valid, then someone called
141   // ThreadGDBRemote::SetQueueInfo(...) with valid information that was gleaned
142   // from the stop reply packet. In this case we trust that the info is valid
143   // in m_dispatch_queue_name without refetching it
144   if (CachedQueueInfoIsValid())
145     return m_queue_serial_number;
146 
147   if (m_associated_with_libdispatch_queue == eLazyBoolNo)
148     return LLDB_INVALID_QUEUE_ID;
149 
150   if (m_thread_dispatch_qaddr != 0 &&
151       m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS) {
152     ProcessSP process_sp(GetProcess());
153     if (process_sp) {
154       SystemRuntime *runtime = process_sp->GetSystemRuntime();
155       if (runtime) {
156         return runtime->GetQueueIDFromThreadQAddress(m_thread_dispatch_qaddr);
157       }
158     }
159   }
160   return LLDB_INVALID_QUEUE_ID;
161 }
162 
163 QueueSP ThreadGDBRemote::GetQueue() {
164   queue_id_t queue_id = GetQueueID();
165   QueueSP queue;
166   if (queue_id != LLDB_INVALID_QUEUE_ID) {
167     ProcessSP process_sp(GetProcess());
168     if (process_sp) {
169       queue = process_sp->GetQueueList().FindQueueByID(queue_id);
170     }
171   }
172   return queue;
173 }
174 
175 addr_t ThreadGDBRemote::GetQueueLibdispatchQueueAddress() {
176   if (m_dispatch_queue_t == LLDB_INVALID_ADDRESS) {
177     if (m_thread_dispatch_qaddr != 0 &&
178         m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS) {
179       ProcessSP process_sp(GetProcess());
180       if (process_sp) {
181         SystemRuntime *runtime = process_sp->GetSystemRuntime();
182         if (runtime) {
183           m_dispatch_queue_t =
184               runtime->GetLibdispatchQueueAddressFromThreadQAddress(
185                   m_thread_dispatch_qaddr);
186         }
187       }
188     }
189   }
190   return m_dispatch_queue_t;
191 }
192 
193 void ThreadGDBRemote::SetQueueLibdispatchQueueAddress(
194     lldb::addr_t dispatch_queue_t) {
195   m_dispatch_queue_t = dispatch_queue_t;
196 }
197 
198 bool ThreadGDBRemote::ThreadHasQueueInformation() const {
199   return m_thread_dispatch_qaddr != 0 &&
200          m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS &&
201          m_dispatch_queue_t != LLDB_INVALID_ADDRESS &&
202          m_queue_kind != eQueueKindUnknown && m_queue_serial_number != 0;
203 }
204 
205 LazyBool ThreadGDBRemote::GetAssociatedWithLibdispatchQueue() {
206   return m_associated_with_libdispatch_queue;
207 }
208 
209 void ThreadGDBRemote::SetAssociatedWithLibdispatchQueue(
210     LazyBool associated_with_libdispatch_queue) {
211   m_associated_with_libdispatch_queue = associated_with_libdispatch_queue;
212 }
213 
214 StructuredData::ObjectSP ThreadGDBRemote::FetchThreadExtendedInfo() {
215   StructuredData::ObjectSP object_sp;
216   const lldb::user_id_t tid = GetProtocolID();
217   Log *log(GetLogIfAnyCategoriesSet(GDBR_LOG_THREAD));
218   LLDB_LOGF(log, "Fetching extended information for thread %4.4" PRIx64, tid);
219   ProcessSP process_sp(GetProcess());
220   if (process_sp) {
221     ProcessGDBRemote *gdb_process =
222         static_cast<ProcessGDBRemote *>(process_sp.get());
223     object_sp = gdb_process->GetExtendedInfoForThread(tid);
224   }
225   return object_sp;
226 }
227 
228 void ThreadGDBRemote::WillResume(StateType resume_state) {
229   int signo = GetResumeSignal();
230   const lldb::user_id_t tid = GetProtocolID();
231   Log *log(GetLogIfAnyCategoriesSet(GDBR_LOG_THREAD));
232   LLDB_LOGF(log, "Resuming thread: %4.4" PRIx64 " with state: %s.", tid,
233             StateAsCString(resume_state));
234 
235   ProcessSP process_sp(GetProcess());
236   if (process_sp) {
237     ProcessGDBRemote *gdb_process =
238         static_cast<ProcessGDBRemote *>(process_sp.get());
239     switch (resume_state) {
240     case eStateSuspended:
241     case eStateStopped:
242       // Don't append anything for threads that should stay stopped.
243       break;
244 
245     case eStateRunning:
246       if (gdb_process->GetUnixSignals()->SignalIsValid(signo))
247         gdb_process->m_continue_C_tids.push_back(std::make_pair(tid, signo));
248       else
249         gdb_process->m_continue_c_tids.push_back(tid);
250       break;
251 
252     case eStateStepping:
253       if (gdb_process->GetUnixSignals()->SignalIsValid(signo))
254         gdb_process->m_continue_S_tids.push_back(std::make_pair(tid, signo));
255       else
256         gdb_process->m_continue_s_tids.push_back(tid);
257       break;
258 
259     default:
260       break;
261     }
262   }
263 }
264 
265 void ThreadGDBRemote::RefreshStateAfterStop() {
266   // Invalidate all registers in our register context. We don't set "force" to
267   // true because the stop reply packet might have had some register values
268   // that were expedited and these will already be copied into the register
269   // context by the time this function gets called. The
270   // GDBRemoteRegisterContext class has been made smart enough to detect when
271   // it needs to invalidate which registers are valid by putting hooks in the
272   // register read and register supply functions where they check the process
273   // stop ID and do the right thing.
274   const bool force = false;
275   GetRegisterContext()->InvalidateIfNeeded(force);
276 }
277 
278 bool ThreadGDBRemote::ThreadIDIsValid(lldb::tid_t thread) {
279   return thread != 0;
280 }
281 
282 void ThreadGDBRemote::Dump(Log *log, uint32_t index) {}
283 
284 bool ThreadGDBRemote::ShouldStop(bool &step_more) { return true; }
285 lldb::RegisterContextSP ThreadGDBRemote::GetRegisterContext() {
286   if (!m_reg_context_sp)
287     m_reg_context_sp = CreateRegisterContextForFrame(nullptr);
288   return m_reg_context_sp;
289 }
290 
291 lldb::RegisterContextSP
292 ThreadGDBRemote::CreateRegisterContextForFrame(StackFrame *frame) {
293   lldb::RegisterContextSP reg_ctx_sp;
294   uint32_t concrete_frame_idx = 0;
295 
296   if (frame)
297     concrete_frame_idx = frame->GetConcreteFrameIndex();
298 
299   if (concrete_frame_idx == 0) {
300     ProcessSP process_sp(GetProcess());
301     if (process_sp) {
302       ProcessGDBRemote *gdb_process =
303           static_cast<ProcessGDBRemote *>(process_sp.get());
304       bool pSupported =
305           gdb_process->GetGDBRemote().GetpPacketSupported(GetID());
306       bool read_all_registers_at_once =
307           !pSupported || gdb_process->m_use_g_packet_for_reading;
308       bool write_all_registers_at_once = !pSupported;
309       reg_ctx_sp = std::make_shared<GDBRemoteRegisterContext>(
310           *this, concrete_frame_idx, gdb_process->m_register_info,
311           read_all_registers_at_once, write_all_registers_at_once);
312     }
313   } else {
314     Unwind *unwinder = GetUnwinder();
315     if (unwinder != nullptr)
316       reg_ctx_sp = unwinder->CreateRegisterContextForFrame(frame);
317   }
318   return reg_ctx_sp;
319 }
320 
321 bool ThreadGDBRemote::PrivateSetRegisterValue(uint32_t reg,
322                                               llvm::ArrayRef<uint8_t> data) {
323   GDBRemoteRegisterContext *gdb_reg_ctx =
324       static_cast<GDBRemoteRegisterContext *>(GetRegisterContext().get());
325   assert(gdb_reg_ctx);
326   return gdb_reg_ctx->PrivateSetRegisterValue(reg, data);
327 }
328 
329 bool ThreadGDBRemote::PrivateSetRegisterValue(uint32_t reg, uint64_t regval) {
330   GDBRemoteRegisterContext *gdb_reg_ctx =
331       static_cast<GDBRemoteRegisterContext *>(GetRegisterContext().get());
332   assert(gdb_reg_ctx);
333   return gdb_reg_ctx->PrivateSetRegisterValue(reg, regval);
334 }
335 
336 bool ThreadGDBRemote::CalculateStopInfo() {
337   ProcessSP process_sp(GetProcess());
338   if (process_sp)
339     return static_cast<ProcessGDBRemote *>(process_sp.get())
340         ->CalculateThreadStopInfo(this);
341   return false;
342 }
343