1 //===-- NativeProcessLinux.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_NativeProcessLinux_H_
11 #define liblldb_NativeProcessLinux_H_
12 
13 // C Includes
14 #include <semaphore.h>
15 #include <signal.h>
16 
17 // C++ Includes
18 #include <unordered_set>
19 
20 // Other libraries and framework includes
21 #include "lldb/Core/ArchSpec.h"
22 #include "lldb/lldb-types.h"
23 #include "lldb/Host/Debug.h"
24 #include "lldb/Host/HostThread.h"
25 #include "lldb/Host/Mutex.h"
26 #include "lldb/Target/MemoryRegionInfo.h"
27 
28 #include "lldb/Host/common/NativeProcessProtocol.h"
29 
30 namespace lldb_private {
31     class Error;
32     class Module;
33     class Scalar;
34 
35 namespace process_linux {
36     class ThreadStateCoordinator;
37 
38     /// @class NativeProcessLinux
39     /// @brief Manages communication with the inferior (debugee) process.
40     ///
41     /// Upon construction, this class prepares and launches an inferior process for
42     /// debugging.
43     ///
44     /// Changes in the inferior process state are broadcasted.
45     class NativeProcessLinux: public NativeProcessProtocol
46     {
47     public:
48 
49         static Error
50         LaunchProcess (
51             Module *exe_module,
52             ProcessLaunchInfo &launch_info,
53             NativeProcessProtocol::NativeDelegate &native_delegate,
54             NativeProcessProtocolSP &native_process_sp);
55 
56         static Error
57         AttachToProcess (
58             lldb::pid_t pid,
59             NativeProcessProtocol::NativeDelegate &native_delegate,
60             NativeProcessProtocolSP &native_process_sp);
61 
62         // ---------------------------------------------------------------------
63         // NativeProcessProtocol Interface
64         // ---------------------------------------------------------------------
65         Error
66         Resume (const ResumeActionList &resume_actions) override;
67 
68         Error
69         Halt () override;
70 
71         Error
72         Detach () override;
73 
74         Error
75         Signal (int signo) override;
76 
77         Error
78         Interrupt () override;
79 
80         Error
81         Kill () override;
82 
83         Error
84         GetMemoryRegionInfo (lldb::addr_t load_addr, MemoryRegionInfo &range_info) override;
85 
86         Error
87         ReadMemory (lldb::addr_t addr, void *buf, lldb::addr_t size, lldb::addr_t &bytes_read) override;
88 
89         Error
90         WriteMemory (lldb::addr_t addr, const void *buf, lldb::addr_t size, lldb::addr_t &bytes_written) override;
91 
92         Error
93         AllocateMemory (lldb::addr_t size, uint32_t permissions, lldb::addr_t &addr) override;
94 
95         Error
96         DeallocateMemory (lldb::addr_t addr) override;
97 
98         lldb::addr_t
99         GetSharedLibraryInfoAddress () override;
100 
101         size_t
102         UpdateThreads () override;
103 
104         bool
105         GetArchitecture (ArchSpec &arch) const override;
106 
107         Error
108         SetBreakpoint (lldb::addr_t addr, uint32_t size, bool hardware) override;
109 
110         void
111         DoStopIDBumped (uint32_t newBumpId) override;
112 
113         void
114         Terminate () override;
115 
116         // ---------------------------------------------------------------------
117         // Interface used by NativeRegisterContext-derived classes.
118         // ---------------------------------------------------------------------
119 
120         /// Reads the contents from the register identified by the given (architecture
121         /// dependent) offset.
122         ///
123         /// This method is provided for use by RegisterContextLinux derivatives.
124         Error
125         ReadRegisterValue(lldb::tid_t tid, unsigned offset, const char *reg_name,
126                           unsigned size, RegisterValue &value);
127 
128         /// Writes the given value to the register identified by the given
129         /// (architecture dependent) offset.
130         ///
131         /// This method is provided for use by RegisterContextLinux derivatives.
132         Error
133         WriteRegisterValue(lldb::tid_t tid, unsigned offset, const char *reg_name,
134                            const RegisterValue &value);
135 
136         /// Reads all general purpose registers into the specified buffer.
137         Error
138         ReadGPR(lldb::tid_t tid, void *buf, size_t buf_size);
139 
140         /// Reads generic floating point registers into the specified buffer.
141         Error
142         ReadFPR(lldb::tid_t tid, void *buf, size_t buf_size);
143 
144         /// Reads the specified register set into the specified buffer.
145         /// For instance, the extended floating-point register set.
146         Error
147         ReadRegisterSet(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset);
148 
149         /// Writes all general purpose registers into the specified buffer.
150         Error
151         WriteGPR(lldb::tid_t tid, void *buf, size_t buf_size);
152 
153         /// Writes generic floating point registers into the specified buffer.
154         Error
155         WriteFPR(lldb::tid_t tid, void *buf, size_t buf_size);
156 
157         /// Writes the specified register set into the specified buffer.
158         /// For instance, the extended floating-point register set.
159         Error
160         WriteRegisterSet(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset);
161 
162         Error
163         GetLoadedModuleFileSpec(const char* module_path, FileSpec& file_spec) override;
164 
165     protected:
166         // ---------------------------------------------------------------------
167         // NativeProcessProtocol protected interface
168         // ---------------------------------------------------------------------
169         Error
170         GetSoftwareBreakpointTrapOpcode (size_t trap_opcode_size_hint, size_t &actual_opcode_size, const uint8_t *&trap_opcode_bytes) override;
171 
172     private:
173 
174         ArchSpec m_arch;
175 
176         HostThread m_operation_thread;
177         HostThread m_monitor_thread;
178 
179         // current operation which must be executed on the priviliged thread
180         void *m_operation;
181         Mutex m_operation_mutex;
182 
183         // semaphores notified when Operation is ready to be processed and when
184         // the operation is complete.
185         sem_t m_operation_pending;
186         sem_t m_operation_done;
187 
188         LazyBool m_supports_mem_region;
189         std::vector<MemoryRegionInfo> m_mem_region_cache;
190         Mutex m_mem_region_cache_mutex;
191 
192         std::unique_ptr<ThreadStateCoordinator> m_coordinator_up;
193         HostThread m_coordinator_thread;
194 
195         struct OperationArgs
196         {
197             OperationArgs(NativeProcessLinux *monitor);
198 
199             ~OperationArgs();
200 
201             NativeProcessLinux *m_monitor;      // The monitor performing the attach.
202             sem_t m_semaphore;              // Posted to once operation complete.
203             Error m_error;    // Set if process operation failed.
204         };
205 
206         /// @class LauchArgs
207         ///
208         /// @brief Simple structure to pass data to the thread responsible for
209         /// launching a child process.
210         struct LaunchArgs : OperationArgs
211         {
212             LaunchArgs(NativeProcessLinux *monitor,
213                     Module *module,
214                     char const **argv,
215                     char const **envp,
216                     const std::string &stdin_path,
217                     const std::string &stdout_path,
218                     const std::string &stderr_path,
219                     const char *working_dir,
220                     const ProcessLaunchInfo &launch_info);
221 
222             ~LaunchArgs();
223 
224             Module *m_module;                 // The executable image to launch.
225             char const **m_argv;              // Process arguments.
226             char const **m_envp;              // Process environment.
227             const std::string &m_stdin_path;  // Redirect stdin if not empty.
228             const std::string &m_stdout_path; // Redirect stdout if not empty.
229             const std::string &m_stderr_path; // Redirect stderr if not empty.
230             const char *m_working_dir;        // Working directory or NULL.
231             const ProcessLaunchInfo &m_launch_info;
232         };
233 
234         struct AttachArgs : OperationArgs
235         {
236             AttachArgs(NativeProcessLinux *monitor,
237                        lldb::pid_t pid);
238 
239             ~AttachArgs();
240 
241             lldb::pid_t m_pid;              // pid of the process to be attached.
242         };
243 
244         // ---------------------------------------------------------------------
245         // Private Instance Methods
246         // ---------------------------------------------------------------------
247         NativeProcessLinux ();
248 
249         /// Launches an inferior process ready for debugging.  Forms the
250         /// implementation of Process::DoLaunch.
251         void
252         LaunchInferior (
253             Module *module,
254             char const *argv[],
255             char const *envp[],
256             const std::string &stdin_path,
257             const std::string &stdout_path,
258             const std::string &stderr_path,
259             const char *working_dir,
260             const ProcessLaunchInfo &launch_info,
261             Error &error);
262 
263         /// Attaches to an existing process.  Forms the
264         /// implementation of Process::DoAttach
265         void
266         AttachToInferior (lldb::pid_t pid, Error &error);
267 
268         void
269         StartLaunchOpThread(LaunchArgs *args, Error &error);
270 
271         static void *
272         LaunchOpThread(void *arg);
273 
274         static bool
275         Launch(LaunchArgs *args);
276 
277         void
278         StartAttachOpThread(AttachArgs *args, Error &error);
279 
280         static void *
281         AttachOpThread(void *args);
282 
283         static bool
284         Attach(AttachArgs *args);
285 
286         static Error
287         SetDefaultPtraceOpts(const lldb::pid_t);
288 
289         static void
290         ServeOperation(OperationArgs *args);
291 
292         static bool
293         DupDescriptor(const char *path, int fd, int flags);
294 
295         static bool
296         MonitorCallback(void *callback_baton,
297                 lldb::pid_t pid, bool exited, int signal, int status);
298 
299         void
300         MonitorSIGTRAP(const siginfo_t *info, lldb::pid_t pid);
301 
302         void
303         MonitorTrace(lldb::pid_t pid, NativeThreadProtocolSP thread_sp);
304 
305         void
306         MonitorBreakpoint(lldb::pid_t pid, NativeThreadProtocolSP thread_sp);
307 
308         void
309         MonitorWatchpoint(lldb::pid_t pid, NativeThreadProtocolSP thread_sp, uint32_t wp_index);
310 
311         void
312         MonitorSignal(const siginfo_t *info, lldb::pid_t pid, bool exited);
313 
314 #if 0
315         static ::ProcessMessage::CrashReason
316         GetCrashReasonForSIGSEGV(const siginfo_t *info);
317 
318         static ::ProcessMessage::CrashReason
319         GetCrashReasonForSIGILL(const siginfo_t *info);
320 
321         static ::ProcessMessage::CrashReason
322         GetCrashReasonForSIGFPE(const siginfo_t *info);
323 
324         static ::ProcessMessage::CrashReason
325         GetCrashReasonForSIGBUS(const siginfo_t *info);
326 #endif
327 
328         void
329         DoOperation(void *op);
330 
331         /// Stops the child monitor thread.
332         void
333         StopMonitorThread();
334 
335         /// Stops the operation thread used to attach/launch a process.
336         void
337         StopOpThread();
338 
339         Error
340         StartCoordinatorThread ();
341 
342         static void*
343         CoordinatorThread (void *arg);
344 
345         void
346         StopCoordinatorThread ();
347 
348         /// Stops monitoring the child process thread.
349         void
350         StopMonitor();
351 
352         bool
353         HasThreadNoLock (lldb::tid_t thread_id);
354 
355         NativeThreadProtocolSP
356         MaybeGetThreadNoLock (lldb::tid_t thread_id);
357 
358         bool
359         StopTrackingThread (lldb::tid_t thread_id);
360 
361         NativeThreadProtocolSP
362         AddThread (lldb::tid_t thread_id);
363 
364         NativeThreadProtocolSP
365         GetOrCreateThread (lldb::tid_t thread_id, bool &created);
366 
367         Error
368         GetSoftwareBreakpointSize (NativeRegisterContextSP context_sp, uint32_t &actual_opcode_size);
369 
370         Error
371         FixupBreakpointPCAsNeeded (NativeThreadProtocolSP &thread_sp);
372 
373         /// Writes a siginfo_t structure corresponding to the given thread ID to the
374         /// memory region pointed to by @p siginfo.
375         Error
376         GetSignalInfo(lldb::tid_t tid, void *siginfo);
377 
378         /// Writes the raw event message code (vis-a-vis PTRACE_GETEVENTMSG)
379         /// corresponding to the given thread ID to the memory pointed to by @p
380         /// message.
381         Error
382         GetEventMessage(lldb::tid_t tid, unsigned long *message);
383 
384         /// Resumes the given thread.  If @p signo is anything but
385         /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the thread.
386         Error
387         Resume(lldb::tid_t tid, uint32_t signo);
388 
389         /// Single steps the given thread.  If @p signo is anything but
390         /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the thread.
391         Error
392         SingleStep(lldb::tid_t tid, uint32_t signo);
393 
394         // ThreadStateCoordinator helper methods.
395         void
396         NotifyThreadCreateStopped (lldb::tid_t tid);
397 
398         void
399         NotifyThreadCreateRunning (lldb::tid_t tid);
400 
401         void
402         NotifyThreadDeath (lldb::tid_t tid);
403 
404         void
405         NotifyThreadStop (lldb::tid_t tid);
406 
407         void
408         CallAfterRunningThreadsStop (lldb::tid_t tid,
409                                      const std::function<void (lldb::tid_t tid)> &call_after_function);
410 
411         void
412         CallAfterRunningThreadsStopWithSkipTID (lldb::tid_t deferred_signal_tid,
413                                                 lldb::tid_t skip_stop_request_tid,
414                                                 const std::function<void (lldb::tid_t tid)> &call_after_function);
415 
416         Error
417         Detach(lldb::tid_t tid);
418 
419         Error
420         RequestThreadStop (const lldb::pid_t pid, const lldb::tid_t tid);
421     };
422 
423 } // namespace process_linux
424 } // namespace lldb_private
425 
426 #endif // #ifndef liblldb_NativeProcessLinux_H_
427