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, size_t size, size_t &bytes_read) override;
88 
89         Error
90         ReadMemoryWithoutTrap(lldb::addr_t addr, void *buf, size_t size, size_t &bytes_read) override;
91 
92         Error
93         WriteMemory(lldb::addr_t addr, const void *buf, size_t size, size_t &bytes_written) override;
94 
95         Error
96         AllocateMemory(size_t size, uint32_t permissions, lldb::addr_t &addr) override;
97 
98         Error
99         DeallocateMemory (lldb::addr_t addr) override;
100 
101         lldb::addr_t
102         GetSharedLibraryInfoAddress () override;
103 
104         size_t
105         UpdateThreads () override;
106 
107         bool
108         GetArchitecture (ArchSpec &arch) const override;
109 
110         Error
111         SetBreakpoint (lldb::addr_t addr, uint32_t size, bool hardware) override;
112 
113         void
114         DoStopIDBumped (uint32_t newBumpId) override;
115 
116         void
117         Terminate () override;
118 
119         // ---------------------------------------------------------------------
120         // Interface used by NativeRegisterContext-derived classes.
121         // ---------------------------------------------------------------------
122 
123         /// Reads the contents from the register identified by the given (architecture
124         /// dependent) offset.
125         ///
126         /// This method is provided for use by RegisterContextLinux derivatives.
127         Error
128         ReadRegisterValue(lldb::tid_t tid, unsigned offset, const char *reg_name,
129                           unsigned size, RegisterValue &value);
130 
131         /// Writes the given value to the register identified by the given
132         /// (architecture dependent) offset.
133         ///
134         /// This method is provided for use by RegisterContextLinux derivatives.
135         Error
136         WriteRegisterValue(lldb::tid_t tid, unsigned offset, const char *reg_name,
137                            const RegisterValue &value);
138 
139         /// Reads all general purpose registers into the specified buffer.
140         Error
141         ReadGPR(lldb::tid_t tid, void *buf, size_t buf_size);
142 
143         /// Reads generic floating point registers into the specified buffer.
144         Error
145         ReadFPR(lldb::tid_t tid, void *buf, size_t buf_size);
146 
147         /// Reads the specified register set into the specified buffer.
148         /// For instance, the extended floating-point register set.
149         Error
150         ReadRegisterSet(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset);
151 
152         /// Writes all general purpose registers into the specified buffer.
153         Error
154         WriteGPR(lldb::tid_t tid, void *buf, size_t buf_size);
155 
156         /// Writes generic floating point registers into the specified buffer.
157         Error
158         WriteFPR(lldb::tid_t tid, void *buf, size_t buf_size);
159 
160         /// Writes the specified register set into the specified buffer.
161         /// For instance, the extended floating-point register set.
162         Error
163         WriteRegisterSet(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset);
164 
165         Error
166         GetLoadedModuleFileSpec(const char* module_path, FileSpec& file_spec) override;
167 
168     protected:
169         // ---------------------------------------------------------------------
170         // NativeProcessProtocol protected interface
171         // ---------------------------------------------------------------------
172         Error
173         GetSoftwareBreakpointTrapOpcode (size_t trap_opcode_size_hint, size_t &actual_opcode_size, const uint8_t *&trap_opcode_bytes) override;
174 
175     private:
176 
177         class Monitor;
178 
179         ArchSpec m_arch;
180 
181         std::unique_ptr<Monitor> m_monitor_up;
182 
183         LazyBool m_supports_mem_region;
184         std::vector<MemoryRegionInfo> m_mem_region_cache;
185         Mutex m_mem_region_cache_mutex;
186 
187         std::unique_ptr<ThreadStateCoordinator> m_coordinator_up;
188         HostThread m_coordinator_thread;
189 
190         // List of thread ids stepping with a breakpoint with the address of
191         // the relevan breakpoint
192         std::map<lldb::tid_t, lldb::addr_t> m_threads_stepping_with_breakpoint;
193 
194         /// @class LauchArgs
195         ///
196         /// @brief Simple structure to pass data to the thread responsible for
197         /// launching a child process.
198         struct LaunchArgs
199         {
200             LaunchArgs(Module *module,
201                     char const **argv,
202                     char const **envp,
203                     const std::string &stdin_path,
204                     const std::string &stdout_path,
205                     const std::string &stderr_path,
206                     const char *working_dir,
207                     const ProcessLaunchInfo &launch_info);
208 
209             ~LaunchArgs();
210 
211             Module *m_module;                 // The executable image to launch.
212             char const **m_argv;              // Process arguments.
213             char const **m_envp;              // Process environment.
214             const std::string &m_stdin_path;  // Redirect stdin if not empty.
215             const std::string &m_stdout_path; // Redirect stdout if not empty.
216             const std::string &m_stderr_path; // Redirect stderr if not empty.
217             const char *m_working_dir;        // Working directory or NULL.
218             const ProcessLaunchInfo &m_launch_info;
219         };
220 
221         typedef std::function<::pid_t(Error &)> InitialOperation;
222 
223         // ---------------------------------------------------------------------
224         // Private Instance Methods
225         // ---------------------------------------------------------------------
226         NativeProcessLinux ();
227 
228         /// Launches an inferior process ready for debugging.  Forms the
229         /// implementation of Process::DoLaunch.
230         void
231         LaunchInferior (
232             Module *module,
233             char const *argv[],
234             char const *envp[],
235             const std::string &stdin_path,
236             const std::string &stdout_path,
237             const std::string &stderr_path,
238             const char *working_dir,
239             const ProcessLaunchInfo &launch_info,
240             Error &error);
241 
242         /// Attaches to an existing process.  Forms the
243         /// implementation of Process::DoAttach
244         void
245         AttachToInferior (lldb::pid_t pid, Error &error);
246 
247         void
248         StartMonitorThread(const InitialOperation &operation, Error &error);
249 
250         ::pid_t
251         Launch(LaunchArgs *args, Error &error);
252 
253         ::pid_t
254         Attach(lldb::pid_t pid, Error &error);
255 
256         static Error
257         SetDefaultPtraceOpts(const lldb::pid_t);
258 
259         static bool
260         DupDescriptor(const char *path, int fd, int flags);
261 
262         static void *
263         MonitorThread(void *baton);
264 
265         void
266         MonitorCallback(lldb::pid_t pid, bool exited, int signal, int status);
267 
268         void
269         WaitForNewThread(::pid_t tid);
270 
271         void
272         MonitorSIGTRAP(const siginfo_t *info, lldb::pid_t pid);
273 
274         void
275         MonitorTrace(lldb::pid_t pid, NativeThreadProtocolSP thread_sp);
276 
277         void
278         MonitorBreakpoint(lldb::pid_t pid, NativeThreadProtocolSP thread_sp);
279 
280         void
281         MonitorWatchpoint(lldb::pid_t pid, NativeThreadProtocolSP thread_sp, uint32_t wp_index);
282 
283         void
284         MonitorSignal(const siginfo_t *info, lldb::pid_t pid, bool exited);
285 
286         bool
287         SupportHardwareSingleStepping() const;
288 
289         Error
290         SetupSoftwareSingleStepping(NativeThreadProtocolSP thread_sp);
291 
292 #if 0
293         static ::ProcessMessage::CrashReason
294         GetCrashReasonForSIGSEGV(const siginfo_t *info);
295 
296         static ::ProcessMessage::CrashReason
297         GetCrashReasonForSIGILL(const siginfo_t *info);
298 
299         static ::ProcessMessage::CrashReason
300         GetCrashReasonForSIGFPE(const siginfo_t *info);
301 
302         static ::ProcessMessage::CrashReason
303         GetCrashReasonForSIGBUS(const siginfo_t *info);
304 #endif
305 
306         Error
307         StartCoordinatorThread ();
308 
309         static void*
310         CoordinatorThread (void *arg);
311 
312         void
313         StopCoordinatorThread ();
314 
315         /// Stops monitoring the child process thread.
316         void
317         StopMonitor();
318 
319         bool
320         HasThreadNoLock (lldb::tid_t thread_id);
321 
322         NativeThreadProtocolSP
323         MaybeGetThreadNoLock (lldb::tid_t thread_id);
324 
325         bool
326         StopTrackingThread (lldb::tid_t thread_id);
327 
328         NativeThreadProtocolSP
329         AddThread (lldb::tid_t thread_id);
330 
331         Error
332         GetSoftwareBreakpointPCOffset (NativeRegisterContextSP context_sp, uint32_t &actual_opcode_size);
333 
334         Error
335         FixupBreakpointPCAsNeeded (NativeThreadProtocolSP &thread_sp);
336 
337         /// Writes a siginfo_t structure corresponding to the given thread ID to the
338         /// memory region pointed to by @p siginfo.
339         Error
340         GetSignalInfo(lldb::tid_t tid, void *siginfo);
341 
342         /// Writes the raw event message code (vis-a-vis PTRACE_GETEVENTMSG)
343         /// corresponding to the given thread ID to the memory pointed to by @p
344         /// message.
345         Error
346         GetEventMessage(lldb::tid_t tid, unsigned long *message);
347 
348         /// Resumes the given thread.  If @p signo is anything but
349         /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the thread.
350         Error
351         Resume(lldb::tid_t tid, uint32_t signo);
352 
353         /// Single steps the given thread.  If @p signo is anything but
354         /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the thread.
355         Error
356         SingleStep(lldb::tid_t tid, uint32_t signo);
357 
358         // ThreadStateCoordinator helper methods.
359         void
360         NotifyThreadCreateStopped (lldb::tid_t tid);
361 
362         void
363         NotifyThreadCreateRunning (lldb::tid_t tid);
364 
365         void
366         NotifyThreadDeath (lldb::tid_t tid);
367 
368         void
369         NotifyThreadStop (lldb::tid_t tid);
370 
371         void
372         CallAfterRunningThreadsStop (lldb::tid_t tid,
373                                      const std::function<void (lldb::tid_t tid)> &call_after_function);
374 
375         void
376         CallAfterRunningThreadsStopWithSkipTID (lldb::tid_t deferred_signal_tid,
377                                                 lldb::tid_t skip_stop_request_tid,
378                                                 const std::function<void (lldb::tid_t tid)> &call_after_function);
379 
380         Error
381         Detach(lldb::tid_t tid);
382 
383         Error
384         RequestThreadStop (const lldb::pid_t pid, const lldb::tid_t tid);
385     };
386 
387 } // namespace process_linux
388 } // namespace lldb_private
389 
390 #endif // #ifndef liblldb_NativeProcessLinux_H_
391