1 //===-- ProcessGDBRemote.h --------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #ifndef liblldb_ProcessGDBRemote_h_
11 #define liblldb_ProcessGDBRemote_h_
12 
13 // C Includes
14 // C++ Includes
15 #include <atomic>
16 #include <map>
17 #include <mutex>
18 #include <string>
19 #include <vector>
20 
21 // Other libraries and framework includes
22 // Project includes
23 #include "lldb/Core/ArchSpec.h"
24 #include "lldb/Core/Broadcaster.h"
25 #include "lldb/Core/ConstString.h"
26 #include "lldb/Core/Error.h"
27 #include "lldb/Core/LoadedModuleInfoList.h"
28 #include "lldb/Core/ModuleSpec.h"
29 #include "lldb/Core/StreamString.h"
30 #include "lldb/Core/StringList.h"
31 #include "lldb/Core/StructuredData.h"
32 #include "lldb/Core/ThreadSafeValue.h"
33 #include "lldb/Host/HostThread.h"
34 #include "lldb/Target/Process.h"
35 #include "lldb/Target/Thread.h"
36 #include "lldb/Utility/StringExtractor.h"
37 #include "lldb/lldb-private-forward.h"
38 
39 #include "GDBRemoteCommunicationClient.h"
40 #include "GDBRemoteRegisterContext.h"
41 
42 #include "llvm/ADT/DenseMap.h"
43 
44 namespace lldb_private {
45 namespace process_gdb_remote {
46 
47 class ThreadGDBRemote;
48 
49 class ProcessGDBRemote : public Process,
50                          private GDBRemoteClientBase::ContinueDelegate {
51 public:
52   ProcessGDBRemote(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp);
53 
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 
60   static void Initialize();
61 
62   static void DebuggerInitialize(Debugger &debugger);
63 
64   static void Terminate();
65 
66   static ConstString GetPluginNameStatic();
67 
68   static const char *GetPluginDescriptionStatic();
69 
70   //------------------------------------------------------------------
71   // Check if a given Process
72   //------------------------------------------------------------------
73   bool CanDebug(lldb::TargetSP target_sp,
74                 bool plugin_specified_by_name) override;
75 
76   CommandObject *GetPluginCommandObject() override;
77 
78   //------------------------------------------------------------------
79   // Creating a new process, or attaching to an existing one
80   //------------------------------------------------------------------
81   Error WillLaunch(Module *module) override;
82 
83   Error DoLaunch(Module *exe_module, ProcessLaunchInfo &launch_info) override;
84 
85   void DidLaunch() override;
86 
87   Error WillAttachToProcessWithID(lldb::pid_t pid) override;
88 
89   Error WillAttachToProcessWithName(const char *process_name,
90                                     bool wait_for_launch) override;
91 
92   Error DoConnectRemote(Stream *strm, llvm::StringRef remote_url) override;
93 
94   Error WillLaunchOrAttach();
95 
96   Error DoAttachToProcessWithID(lldb::pid_t pid,
97                                 const ProcessAttachInfo &attach_info) override;
98 
99   Error
100   DoAttachToProcessWithName(const char *process_name,
101                             const ProcessAttachInfo &attach_info) override;
102 
103   void DidAttach(ArchSpec &process_arch) override;
104 
105   //------------------------------------------------------------------
106   // PluginInterface protocol
107   //------------------------------------------------------------------
108   ConstString GetPluginName() override;
109 
110   uint32_t GetPluginVersion() override;
111 
112   //------------------------------------------------------------------
113   // Process Control
114   //------------------------------------------------------------------
115   Error WillResume() override;
116 
117   Error DoResume() override;
118 
119   Error DoHalt(bool &caused_stop) override;
120 
121   Error DoDetach(bool keep_stopped) override;
122 
123   bool DetachRequiresHalt() override { return true; }
124 
125   Error DoSignal(int signal) override;
126 
127   Error DoDestroy() override;
128 
129   void RefreshStateAfterStop() override;
130 
131   void SetUnixSignals(const lldb::UnixSignalsSP &signals_sp);
132 
133   //------------------------------------------------------------------
134   // Process Queries
135   //------------------------------------------------------------------
136   bool IsAlive() override;
137 
138   lldb::addr_t GetImageInfoAddress() override;
139 
140   void WillPublicStop() override;
141 
142   //------------------------------------------------------------------
143   // Process Memory
144   //------------------------------------------------------------------
145   size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
146                       Error &error) override;
147 
148   size_t DoWriteMemory(lldb::addr_t addr, const void *buf, size_t size,
149                        Error &error) override;
150 
151   lldb::addr_t DoAllocateMemory(size_t size, uint32_t permissions,
152                                 Error &error) override;
153 
154   Error GetMemoryRegionInfo(lldb::addr_t load_addr,
155                             MemoryRegionInfo &region_info) override;
156 
157   Error DoDeallocateMemory(lldb::addr_t ptr) override;
158 
159   //------------------------------------------------------------------
160   // Process STDIO
161   //------------------------------------------------------------------
162   size_t PutSTDIN(const char *buf, size_t buf_size, Error &error) override;
163 
164   //----------------------------------------------------------------------
165   // Process Breakpoints
166   //----------------------------------------------------------------------
167   Error EnableBreakpointSite(BreakpointSite *bp_site) override;
168 
169   Error DisableBreakpointSite(BreakpointSite *bp_site) override;
170 
171   //----------------------------------------------------------------------
172   // Process Watchpoints
173   //----------------------------------------------------------------------
174   Error EnableWatchpoint(Watchpoint *wp, bool notify = true) override;
175 
176   Error DisableWatchpoint(Watchpoint *wp, bool notify = true) override;
177 
178   Error GetWatchpointSupportInfo(uint32_t &num) override;
179 
180   Error GetWatchpointSupportInfo(uint32_t &num, bool &after) override;
181 
182   bool StartNoticingNewThreads() override;
183 
184   bool StopNoticingNewThreads() override;
185 
186   GDBRemoteCommunicationClient &GetGDBRemote() { return m_gdb_comm; }
187 
188   Error SendEventData(const char *data) override;
189 
190   //----------------------------------------------------------------------
191   // Override DidExit so we can disconnect from the remote GDB server
192   //----------------------------------------------------------------------
193   void DidExit() override;
194 
195   void SetUserSpecifiedMaxMemoryTransferSize(uint64_t user_specified_max);
196 
197   bool GetModuleSpec(const FileSpec &module_file_spec, const ArchSpec &arch,
198                      ModuleSpec &module_spec) override;
199 
200   void PrefetchModuleSpecs(llvm::ArrayRef<FileSpec> module_file_specs,
201                            const llvm::Triple &triple) override;
202 
203   bool GetHostOSVersion(uint32_t &major, uint32_t &minor,
204                         uint32_t &update) override;
205 
206   size_t LoadModules(LoadedModuleInfoList &module_list) override;
207 
208   size_t LoadModules() override;
209 
210   Error GetFileLoadAddress(const FileSpec &file, bool &is_loaded,
211                            lldb::addr_t &load_addr) override;
212 
213   void ModulesDidLoad(ModuleList &module_list) override;
214 
215   StructuredData::ObjectSP
216   GetLoadedDynamicLibrariesInfos(lldb::addr_t image_list_address,
217                                  lldb::addr_t image_count) override;
218 
219   Error
220   ConfigureStructuredData(const ConstString &type_name,
221                           const StructuredData::ObjectSP &config_sp) override;
222 
223   StructuredData::ObjectSP GetLoadedDynamicLibrariesInfos() override;
224 
225   StructuredData::ObjectSP GetLoadedDynamicLibrariesInfos(
226       const std::vector<lldb::addr_t> &load_addresses) override;
227 
228   StructuredData::ObjectSP
229   GetLoadedDynamicLibrariesInfos_sender(StructuredData::ObjectSP args);
230 
231   StructuredData::ObjectSP GetSharedCacheInfo() override;
232 
233   std::string HarmonizeThreadIdsForProfileData(
234       StringExtractorGDBRemote &inputStringExtractor);
235 
236 protected:
237   friend class ThreadGDBRemote;
238   friend class GDBRemoteCommunicationClient;
239   friend class GDBRemoteRegisterContext;
240 
241   //------------------------------------------------------------------
242   /// Broadcaster event bits definitions.
243   //------------------------------------------------------------------
244   enum {
245     eBroadcastBitAsyncContinue = (1 << 0),
246     eBroadcastBitAsyncThreadShouldExit = (1 << 1),
247     eBroadcastBitAsyncThreadDidExit = (1 << 2)
248   };
249 
250   Flags m_flags; // Process specific flags (see eFlags enums)
251   GDBRemoteCommunicationClient m_gdb_comm;
252   std::atomic<lldb::pid_t> m_debugserver_pid;
253   std::vector<StringExtractorGDBRemote> m_stop_packet_stack; // The stop packet
254                                                              // stack replaces
255                                                              // the last stop
256                                                              // packet variable
257   std::recursive_mutex m_last_stop_packet_mutex;
258   GDBRemoteDynamicRegisterInfo m_register_info;
259   Broadcaster m_async_broadcaster;
260   lldb::ListenerSP m_async_listener_sp;
261   HostThread m_async_thread;
262   std::recursive_mutex m_async_thread_state_mutex;
263   typedef std::vector<lldb::tid_t> tid_collection;
264   typedef std::vector<std::pair<lldb::tid_t, int>> tid_sig_collection;
265   typedef std::map<lldb::addr_t, lldb::addr_t> MMapMap;
266   typedef std::map<uint32_t, std::string> ExpeditedRegisterMap;
267   tid_collection m_thread_ids; // Thread IDs for all threads. This list gets
268                                // updated after stopping
269   std::vector<lldb::addr_t> m_thread_pcs;     // PC values for all the threads.
270   StructuredData::ObjectSP m_jstopinfo_sp;    // Stop info only for any threads
271                                               // that have valid stop infos
272   StructuredData::ObjectSP m_jthreadsinfo_sp; // Full stop info, expedited
273                                               // registers and memory for all
274                                               // threads if "jThreadsInfo"
275                                               // packet is supported
276   tid_collection m_continue_c_tids;           // 'c' for continue
277   tid_sig_collection m_continue_C_tids;       // 'C' for continue with signal
278   tid_collection m_continue_s_tids;           // 's' for step
279   tid_sig_collection m_continue_S_tids;       // 'S' for step with signal
280   uint64_t m_max_memory_size; // The maximum number of bytes to read/write when
281                               // reading and writing memory
282   uint64_t m_remote_stub_max_memory_size; // The maximum memory size the remote
283                                           // gdb stub can handle
284   MMapMap m_addr_to_mmap_size;
285   lldb::BreakpointSP m_thread_create_bp_sp;
286   bool m_waiting_for_attach;
287   bool m_destroy_tried_resuming;
288   lldb::CommandObjectSP m_command_sp;
289   int64_t m_breakpoint_pc_offset;
290   lldb::tid_t m_initial_tid; // The initial thread ID, given by stub on attach
291 
292   //----------------------------------------------------------------------
293   // Accessors
294   //----------------------------------------------------------------------
295   bool IsRunning(lldb::StateType state) {
296     return state == lldb::eStateRunning || IsStepping(state);
297   }
298 
299   bool IsStepping(lldb::StateType state) {
300     return state == lldb::eStateStepping;
301   }
302 
303   bool CanResume(lldb::StateType state) { return state == lldb::eStateStopped; }
304 
305   bool HasExited(lldb::StateType state) { return state == lldb::eStateExited; }
306 
307   bool ProcessIDIsValid() const;
308 
309   void Clear();
310 
311   Flags &GetFlags() { return m_flags; }
312 
313   const Flags &GetFlags() const { return m_flags; }
314 
315   bool UpdateThreadList(ThreadList &old_thread_list,
316                         ThreadList &new_thread_list) override;
317 
318   Error EstablishConnectionIfNeeded(const ProcessInfo &process_info);
319 
320   Error LaunchAndConnectToDebugserver(const ProcessInfo &process_info);
321 
322   void KillDebugserverProcess();
323 
324   void BuildDynamicRegisterInfo(bool force);
325 
326   void SetLastStopPacket(const StringExtractorGDBRemote &response);
327 
328   bool ParsePythonTargetDefinition(const FileSpec &target_definition_fspec);
329 
330   const lldb::DataBufferSP GetAuxvData() override;
331 
332   StructuredData::ObjectSP GetExtendedInfoForThread(lldb::tid_t tid);
333 
334   void GetMaxMemorySize();
335 
336   bool CalculateThreadStopInfo(ThreadGDBRemote *thread);
337 
338   size_t UpdateThreadPCsFromStopReplyThreadsValue(std::string &value);
339 
340   size_t UpdateThreadIDsFromStopReplyThreadsValue(std::string &value);
341 
342   bool HandleNotifyPacket(StringExtractorGDBRemote &packet);
343 
344   bool StartAsyncThread();
345 
346   void StopAsyncThread();
347 
348   static lldb::thread_result_t AsyncThread(void *arg);
349 
350   static bool
351   MonitorDebugserverProcess(std::weak_ptr<ProcessGDBRemote> process_wp,
352                             lldb::pid_t pid, bool exited, int signo,
353                             int exit_status);
354 
355   lldb::StateType SetThreadStopInfo(StringExtractor &stop_packet);
356 
357   bool
358   GetThreadStopInfoFromJSON(ThreadGDBRemote *thread,
359                             const StructuredData::ObjectSP &thread_infos_sp);
360 
361   lldb::ThreadSP SetThreadStopInfo(StructuredData::Dictionary *thread_dict);
362 
363   lldb::ThreadSP
364   SetThreadStopInfo(lldb::tid_t tid,
365                     ExpeditedRegisterMap &expedited_register_map, uint8_t signo,
366                     const std::string &thread_name, const std::string &reason,
367                     const std::string &description, uint32_t exc_type,
368                     const std::vector<lldb::addr_t> &exc_data,
369                     lldb::addr_t thread_dispatch_qaddr, bool queue_vars_valid,
370                     lldb_private::LazyBool associated_with_libdispatch_queue,
371                     lldb::addr_t dispatch_queue_t, std::string &queue_name,
372                     lldb::QueueKind queue_kind, uint64_t queue_serial);
373 
374   void HandleStopReplySequence();
375 
376   void ClearThreadIDList();
377 
378   bool UpdateThreadIDList();
379 
380   void DidLaunchOrAttach(ArchSpec &process_arch);
381 
382   Error ConnectToDebugserver(llvm::StringRef host_port);
383 
384   const char *GetDispatchQueueNameForThread(lldb::addr_t thread_dispatch_qaddr,
385                                             std::string &dispatch_queue_name);
386 
387   DynamicLoader *GetDynamicLoader() override;
388 
389   // Query remote GDBServer for register information
390   bool GetGDBServerRegisterInfo(ArchSpec &arch);
391 
392   // Query remote GDBServer for a detailed loaded library list
393   Error GetLoadedModuleList(LoadedModuleInfoList &);
394 
395   lldb::ModuleSP LoadModuleAtAddress(const FileSpec &file,
396                                      lldb::addr_t link_map,
397                                      lldb::addr_t base_addr,
398                                      bool value_is_offset);
399 
400 private:
401   //------------------------------------------------------------------
402   // For ProcessGDBRemote only
403   //------------------------------------------------------------------
404   std::string m_partial_profile_data;
405   std::map<uint64_t, uint32_t> m_thread_id_to_used_usec_map;
406 
407   static bool NewThreadNotifyBreakpointHit(void *baton,
408                                            StoppointCallbackContext *context,
409                                            lldb::user_id_t break_id,
410                                            lldb::user_id_t break_loc_id);
411 
412   //------------------------------------------------------------------
413   // ContinueDelegate interface
414   //------------------------------------------------------------------
415   void HandleAsyncStdout(llvm::StringRef out) override;
416   void HandleAsyncMisc(llvm::StringRef data) override;
417   void HandleStopReply() override;
418   void HandleAsyncStructuredDataPacket(llvm::StringRef data) override;
419 
420   using ModuleCacheKey = std::pair<std::string, std::string>;
421   // KeyInfo for the cached module spec DenseMap.
422   // The invariant is that all real keys will have the file and architecture
423   // set.
424   // The empty key has an empty file and an empty arch.
425   // The tombstone key has an invalid arch and an empty file.
426   // The comparison and hash functions take the file name and architecture
427   // triple into account.
428   struct ModuleCacheInfo {
429     static ModuleCacheKey getEmptyKey() { return ModuleCacheKey(); }
430 
431     static ModuleCacheKey getTombstoneKey() { return ModuleCacheKey("", "T"); }
432 
433     static unsigned getHashValue(const ModuleCacheKey &key) {
434       return llvm::hash_combine(key.first, key.second);
435     }
436 
437     static bool isEqual(const ModuleCacheKey &LHS, const ModuleCacheKey &RHS) {
438       return LHS == RHS;
439     }
440   };
441 
442   llvm::DenseMap<ModuleCacheKey, ModuleSpec, ModuleCacheInfo>
443       m_cached_module_specs;
444 
445   DISALLOW_COPY_AND_ASSIGN(ProcessGDBRemote);
446 };
447 
448 } // namespace process_gdb_remote
449 } // namespace lldb_private
450 
451 #endif // liblldb_ProcessGDBRemote_h_
452