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

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