1//===-- ProcessGDBRemote.h --------------------------------------*- 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#ifndef LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_PROCESSGDBREMOTE_H
10#define LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_PROCESSGDBREMOTE_H
11
12#include <atomic>
13#include <map>
14#include <mutex>
15#include <optional>
16#include <string>
17#include <vector>
18
19#include "lldb/Core/LoadedModuleInfoList.h"
20#include "lldb/Core/ModuleSpec.h"
21#include "lldb/Core/ThreadSafeValue.h"
22#include "lldb/Host/HostThread.h"
23#include "lldb/Target/DynamicRegisterInfo.h"
24#include "lldb/Target/Process.h"
25#include "lldb/Target/Thread.h"
26#include "lldb/Utility/ArchSpec.h"
27#include "lldb/Utility/Broadcaster.h"
28#include "lldb/Utility/ConstString.h"
29#include "lldb/Utility/GDBRemote.h"
30#include "lldb/Utility/Status.h"
31#include "lldb/Utility/StreamString.h"
32#include "lldb/Utility/StringExtractor.h"
33#include "lldb/Utility/StringList.h"
34#include "lldb/Utility/StructuredData.h"
35#include "lldb/lldb-private-forward.h"
36
37#include "GDBRemoteCommunicationClient.h"
38#include "GDBRemoteRegisterContext.h"
39
40#include "llvm/ADT/DenseMap.h"
41#include "llvm/ADT/StringMap.h"
42
43namespace lldb_private {
44namespace process_gdb_remote {
45
46class ThreadGDBRemote;
47
48class ProcessGDBRemote : public Process,
49 private GDBRemoteClientBase::ContinueDelegate {
50public:
51 ~ProcessGDBRemote() override;
52
53 static lldb::ProcessSP CreateInstance(lldb::TargetSP target_sp,
54 lldb::ListenerSP listener_sp,
55 const FileSpec *crash_file_path,
56 bool can_connect);
57
58 static void Initialize();
59
60 static void DebuggerInitialize(Debugger &debugger);
61
62 static void Terminate();
63
64 static llvm::StringRef GetPluginNameStatic() { return "gdb-remote"; }
65
66 static llvm::StringRef GetPluginDescriptionStatic();
67
68 static std::chrono::seconds GetPacketTimeout();
69
70 ArchSpec GetSystemArchitecture() override;
71
72 // Check if a given Process
73 bool CanDebug(lldb::TargetSP target_sp,
74 bool plugin_specified_by_name) override;
75
76 CommandObject *GetPluginCommandObject() override;
77
78 void DumpPluginHistory(Stream &s) override;
79
80 // Creating a new process, or attaching to an existing one
81 Status DoWillLaunch(Module *module) override;
82
83 Status DoLaunch(Module *exe_module, ProcessLaunchInfo &launch_info) override;
84
85 void DidLaunch() override;
86
87 Status DoWillAttachToProcessWithID(lldb::pid_t pid) override;
88
89 Status DoWillAttachToProcessWithName(const char *process_name,
90 bool wait_for_launch) override;
91
92 Status DoConnectRemote(llvm::StringRef remote_url) override;
93
94 Status WillLaunchOrAttach();
95
96 Status DoAttachToProcessWithID(lldb::pid_t pid,
97 const ProcessAttachInfo &attach_info) override;
98
99 Status
100 DoAttachToProcessWithName(const char *process_name,
101 const ProcessAttachInfo &attach_info) override;
102
103 void DidAttach(ArchSpec &process_arch) override;
104
105 // PluginInterface protocol
106 llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
107
108 // Process Control
109 Status WillResume() override;
110
111 bool SupportsReverseDirection() override;
112
113 Status DoResume(lldb::RunDirection direction) override;
114
115 Status DoHalt(bool &caused_stop) override;
116
117 Status DoDetach(bool keep_stopped) override;
118
119 bool DetachRequiresHalt() override { return true; }
120
121 Status DoSignal(int signal) override;
122
123 Status DoDestroy() override;
124
125 void RefreshStateAfterStop() override;
126
127 void SetUnixSignals(const lldb::UnixSignalsSP &signals_sp);
128
129 // Process Queries
130 bool IsAlive() override;
131
132 lldb::addr_t GetImageInfoAddress() override;
133
134 void WillPublicStop() override;
135
136 // Process Memory
137 size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
138 Status &error) override;
139
140 Status
141 WriteObjectFile(std::vector<ObjectFile::LoadableData> entries) override;
142
143 size_t DoWriteMemory(lldb::addr_t addr, const void *buf, size_t size,
144 Status &error) override;
145
146 lldb::addr_t DoAllocateMemory(size_t size, uint32_t permissions,
147 Status &error) override;
148
149 Status DoDeallocateMemory(lldb::addr_t ptr) override;
150
151 // Process STDIO
152 size_t PutSTDIN(const char *buf, size_t buf_size, Status &error) override;
153
154 // Process Breakpoints
155 Status EnableBreakpointSite(BreakpointSite *bp_site) override;
156
157 Status DisableBreakpointSite(BreakpointSite *bp_site) override;
158
159 // Process Watchpoints
160 Status EnableWatchpoint(lldb::WatchpointSP wp_sp,
161 bool notify = true) override;
162
163 Status DisableWatchpoint(lldb::WatchpointSP wp_sp,
164 bool notify = true) override;
165
166 std::optional<uint32_t> GetWatchpointSlotCount() override;
167
168 llvm::Expected<TraceSupportedResponse> TraceSupported() override;
169
170 llvm::Error TraceStop(const TraceStopRequest &request) override;
171
172 llvm::Error TraceStart(const llvm::json::Value &request) override;
173
174 llvm::Expected<std::string> TraceGetState(llvm::StringRef type) override;
175
176 llvm::Expected<std::vector<uint8_t>>
177 TraceGetBinaryData(const TraceGetBinaryDataRequest &request) override;
178
179 std::optional<bool> DoGetWatchpointReportedAfter() override;
180
181 bool StartNoticingNewThreads() override;
182
183 bool StopNoticingNewThreads() override;
184
185 GDBRemoteCommunicationClient &GetGDBRemote() { return m_gdb_comm; }
186
187 Status SendEventData(const char *data) override;
188
189 // Override DidExit so we can disconnect from the remote GDB server
190 void DidExit() override;
191
192 void SetUserSpecifiedMaxMemoryTransferSize(uint64_t user_specified_max);
193
194 bool GetModuleSpec(const FileSpec &module_file_spec, const ArchSpec &arch,
195 ModuleSpec &module_spec) override;
196
197 void PrefetchModuleSpecs(llvm::ArrayRef<FileSpec> module_file_specs,
198 const llvm::Triple &triple) override;
199
200 llvm::VersionTuple GetHostOSVersion() override;
201 llvm::VersionTuple GetHostMacCatalystVersion() override;
202
203 llvm::Error LoadModules() override;
204
205 llvm::Expected<LoadedModuleInfoList> GetLoadedModuleList() override;
206
207 Status GetFileLoadAddress(const FileSpec &file, bool &is_loaded,
208 lldb::addr_t &load_addr) override;
209
210 void ModulesDidLoad(ModuleList &module_list) override;
211
212 StructuredData::ObjectSP
213 GetLoadedDynamicLibrariesInfos(lldb::addr_t image_list_address,
214 lldb::addr_t image_count) override;
215
216 Status
217 ConfigureStructuredData(llvm::StringRef type_name,
218 const StructuredData::ObjectSP &config_sp) override;
219
220 StructuredData::ObjectSP GetLoadedDynamicLibrariesInfos() override;
221
222 StructuredData::ObjectSP GetLoadedDynamicLibrariesInfos(
223 const std::vector<lldb::addr_t> &load_addresses) override;
224
225 StructuredData::ObjectSP
226 GetLoadedDynamicLibrariesInfos_sender(StructuredData::ObjectSP args);
227
228 StructuredData::ObjectSP GetSharedCacheInfo() override;
229
230 StructuredData::ObjectSP GetDynamicLoaderProcessState() override;
231
232 std::string HarmonizeThreadIdsForProfileData(
233 StringExtractorGDBRemote &inputStringExtractor);
234
235 void DidFork(lldb::pid_t child_pid, lldb::tid_t child_tid) override;
236 void DidVFork(lldb::pid_t child_pid, lldb::tid_t child_tid) override;
237 void DidVForkDone() override;
238 void DidExec() override;
239
240 llvm::Expected<bool> SaveCore(llvm::StringRef outfile) override;
241
242protected:
243 friend class ThreadGDBRemote;
244 friend class GDBRemoteCommunicationClient;
245 friend class GDBRemoteRegisterContext;
246
247 ProcessGDBRemote(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp);
248
249 bool SupportsMemoryTagging() override;
250
251 /// Broadcaster event bits definitions.
252 enum {
253 eBroadcastBitAsyncContinue = (1 << 0),
254 eBroadcastBitAsyncThreadShouldExit = (1 << 1),
255 eBroadcastBitAsyncThreadDidExit = (1 << 2)
256 };
257
258 GDBRemoteCommunicationClient m_gdb_comm;
259 std::atomic<lldb::pid_t> m_debugserver_pid;
260
261 std::optional<StringExtractorGDBRemote> m_last_stop_packet;
262 std::recursive_mutex m_last_stop_packet_mutex;
263
264 GDBRemoteDynamicRegisterInfoSP m_register_info_sp;
265 Broadcaster m_async_broadcaster;
266 lldb::ListenerSP m_async_listener_sp;
267 HostThread m_async_thread;
268 std::recursive_mutex m_async_thread_state_mutex;
269 typedef std::vector<lldb::tid_t> tid_collection;
270 typedef std::vector<std::pair<lldb::tid_t, int>> tid_sig_collection;
271 typedef std::map<lldb::addr_t, lldb::addr_t> MMapMap;
272 typedef std::map<uint32_t, std::string> ExpeditedRegisterMap;
273 tid_collection m_thread_ids; // Thread IDs for all threads. This list gets
274 // updated after stopping
275 std::vector<lldb::addr_t> m_thread_pcs; // PC values for all the threads.
276 StructuredData::ObjectSP m_jstopinfo_sp; // Stop info only for any threads
277 // that have valid stop infos
278 StructuredData::ObjectSP m_jthreadsinfo_sp; // Full stop info, expedited
279 // registers and memory for all
280 // threads if "jThreadsInfo"
281 // packet is supported
282 tid_collection m_continue_c_tids; // 'c' for continue
283 tid_sig_collection m_continue_C_tids; // 'C' for continue with signal
284 tid_collection m_continue_s_tids; // 's' for step
285 tid_sig_collection m_continue_S_tids; // 'S' for step with signal
286 uint64_t m_max_memory_size; // The maximum number of bytes to read/write when
287 // reading and writing memory
288 uint64_t m_remote_stub_max_memory_size; // The maximum memory size the remote
289 // gdb stub can handle
290 MMapMap m_addr_to_mmap_size;
291 lldb::BreakpointSP m_thread_create_bp_sp;
292 bool m_waiting_for_attach;
293 lldb::CommandObjectSP m_command_sp;
294 int64_t m_breakpoint_pc_offset;
295 lldb::tid_t m_initial_tid; // The initial thread ID, given by stub on attach
296 bool m_use_g_packet_for_reading;
297
298 bool m_allow_flash_writes;
299 using FlashRangeVector = lldb_private::RangeVector<lldb::addr_t, size_t>;
300 using FlashRange = FlashRangeVector::Entry;
301 FlashRangeVector m_erased_flash_ranges;
302
303 // Number of vfork() operations being handled.
304 uint32_t m_vfork_in_progress_count;
305
306 // Accessors
307 bool IsRunning(lldb::StateType state) {
308 return state == lldb::eStateRunning || IsStepping(state);
309 }
310
311 bool IsStepping(lldb::StateType state) {
312 return state == lldb::eStateStepping;
313 }
314
315 bool CanResume(lldb::StateType state) { return state == lldb::eStateStopped; }
316
317 bool HasExited(lldb::StateType state) { return state == lldb::eStateExited; }
318
319 void Clear();
320
321 bool DoUpdateThreadList(ThreadList &old_thread_list,
322 ThreadList &new_thread_list) override;
323
324 Status EstablishConnectionIfNeeded(const ProcessInfo &process_info);
325
326 Status LaunchAndConnectToDebugserver(const ProcessInfo &process_info);
327
328 void KillDebugserverProcess();
329
330 void BuildDynamicRegisterInfo(bool force);
331
332 void SetLastStopPacket(const StringExtractorGDBRemote &response);
333
334 bool ParsePythonTargetDefinition(const FileSpec &target_definition_fspec);
335
336 DataExtractor GetAuxvData() override;
337
338 StructuredData::ObjectSP GetExtendedInfoForThread(lldb::tid_t tid);
339
340 void GetMaxMemorySize();
341
342 bool CalculateThreadStopInfo(ThreadGDBRemote *thread);
343
344 size_t UpdateThreadPCsFromStopReplyThreadsValue(llvm::StringRef value);
345
346 size_t UpdateThreadIDsFromStopReplyThreadsValue(llvm::StringRef value);
347
348 bool StartAsyncThread();
349
350 void StopAsyncThread();
351
352 lldb::thread_result_t AsyncThread();
353
354 static void
355 MonitorDebugserverProcess(std::weak_ptr<ProcessGDBRemote> process_wp,
356 lldb::pid_t pid, int signo, int exit_status);
357
358 lldb::StateType SetThreadStopInfo(StringExtractor &stop_packet);
359
360 bool
361 GetThreadStopInfoFromJSON(ThreadGDBRemote *thread,
362 const StructuredData::ObjectSP &thread_infos_sp);
363
364 lldb::ThreadSP SetThreadStopInfo(StructuredData::Dictionary *thread_dict);
365
366 lldb::ThreadSP
367 SetThreadStopInfo(lldb::tid_t tid,
368 ExpeditedRegisterMap &expedited_register_map, uint8_t signo,
369 const std::string &thread_name, const std::string &reason,
370 const std::string &description, uint32_t exc_type,
371 const std::vector<lldb::addr_t> &exc_data,
372 lldb::addr_t thread_dispatch_qaddr, bool queue_vars_valid,
373 lldb_private::LazyBool associated_with_libdispatch_queue,
374 lldb::addr_t dispatch_queue_t, std::string &queue_name,
375 lldb::QueueKind queue_kind, uint64_t queue_serial);
376
377 void ClearThreadIDList();
378
379 bool UpdateThreadIDList();
380
381 void DidLaunchOrAttach(ArchSpec &process_arch);
382 void LoadStubBinaries();
383 void MaybeLoadExecutableModule();
384
385 Status ConnectToDebugserver(llvm::StringRef host_port);
386
387 const char *GetDispatchQueueNameForThread(lldb::addr_t thread_dispatch_qaddr,
388 std::string &dispatch_queue_name);
389
390 DynamicLoader *GetDynamicLoader() override;
391
392 bool GetGDBServerRegisterInfoXMLAndProcess(
393 ArchSpec &arch_to_use, std::string xml_filename,
394 std::vector<DynamicRegisterInfo::Register> &registers);
395
396 // Convert DynamicRegisterInfo::Registers into RegisterInfos and add
397 // to the dynamic register list.
398 void AddRemoteRegisters(std::vector<DynamicRegisterInfo::Register> &registers,
399 const ArchSpec &arch_to_use);
400 // Query remote GDBServer for register information
401 bool GetGDBServerRegisterInfo(ArchSpec &arch);
402
403 lldb::ModuleSP LoadModuleAtAddress(const FileSpec &file,
404 lldb::addr_t link_map,
405 lldb::addr_t base_addr,
406 bool value_is_offset);
407
408 Status UpdateAutomaticSignalFiltering() override;
409
410 Status FlashErase(lldb::addr_t addr, size_t size);
411
412 Status FlashDone();
413
414 bool HasErased(FlashRange range);
415
416 llvm::Expected<std::vector<uint8_t>>
417 DoReadMemoryTags(lldb::addr_t addr, size_t len, int32_t type) override;
418
419 Status DoWriteMemoryTags(lldb::addr_t addr, size_t len, int32_t type,
420 const std::vector<uint8_t> &tags) override;
421
422 Status DoGetMemoryRegionInfo(lldb::addr_t load_addr,
423 MemoryRegionInfo &region_info) override;
424
425private:
426 // For ProcessGDBRemote only
427 std::string m_partial_profile_data;
428 std::map<uint64_t, uint32_t> m_thread_id_to_used_usec_map;
429 uint64_t m_last_signals_version = 0;
430
431 static bool NewThreadNotifyBreakpointHit(void *baton,
432 StoppointCallbackContext *context,
433 lldb::user_id_t break_id,
434 lldb::user_id_t break_loc_id);
435
436 /// Remove the breakpoints associated with thread creation from the Target.
437 void RemoveNewThreadBreakpoints();
438
439 // ContinueDelegate interface
440 void HandleAsyncStdout(llvm::StringRef out) override;
441 void HandleAsyncMisc(llvm::StringRef data) override;
442 void HandleStopReply() override;
443 void HandleAsyncStructuredDataPacket(llvm::StringRef data) override;
444
445 lldb::ThreadSP
446 HandleThreadAsyncInterrupt(uint8_t signo,
447 const std::string &description) override;
448
449 void SetThreadPc(const lldb::ThreadSP &thread_sp, uint64_t index);
450 using ModuleCacheKey = std::pair<std::string, std::string>;
451 // KeyInfo for the cached module spec DenseMap.
452 // The invariant is that all real keys will have the file and architecture
453 // set.
454 // The empty key has an empty file and an empty arch.
455 // The tombstone key has an invalid arch and an empty file.
456 // The comparison and hash functions take the file name and architecture
457 // triple into account.
458 struct ModuleCacheInfo {
459 static ModuleCacheKey getEmptyKey() { return ModuleCacheKey(); }
460
461 static ModuleCacheKey getTombstoneKey() { return ModuleCacheKey("", "T"); }
462
463 static unsigned getHashValue(const ModuleCacheKey &key) {
464 return llvm::hash_combine(args: key.first, args: key.second);
465 }
466
467 static bool isEqual(const ModuleCacheKey &LHS, const ModuleCacheKey &RHS) {
468 return LHS == RHS;
469 }
470 };
471
472 llvm::DenseMap<ModuleCacheKey, ModuleSpec, ModuleCacheInfo>
473 m_cached_module_specs;
474
475 ProcessGDBRemote(const ProcessGDBRemote &) = delete;
476 const ProcessGDBRemote &operator=(const ProcessGDBRemote &) = delete;
477
478 // fork helpers
479 void DidForkSwitchSoftwareBreakpoints(bool enable);
480 void DidForkSwitchHardwareTraps(bool enable);
481
482 void ParseExpeditedRegisters(ExpeditedRegisterMap &expedited_register_map,
483 lldb::ThreadSP thread_sp);
484
485 // Lists of register fields generated from the remote's target XML.
486 // Pointers to these RegisterFlags will be set in the register info passed
487 // back to the upper levels of lldb. Doing so is safe because this class will
488 // live at least as long as the debug session. We therefore do not store the
489 // data directly in the map because the map may reallocate it's storage as new
490 // entries are added. Which would invalidate any pointers set in the register
491 // info up to that point.
492 llvm::StringMap<std::unique_ptr<RegisterFlags>> m_registers_flags_types;
493
494 // Enum types are referenced by register fields. This does not store the data
495 // directly because the map may reallocate. Pointers to these are contained
496 // within instances of RegisterFlags.
497 llvm::StringMap<std::unique_ptr<FieldEnum>> m_registers_enum_types;
498};
499
500} // namespace process_gdb_remote
501} // namespace lldb_private
502
503#endif // LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_PROCESSGDBREMOTE_H
504

source code of lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h