1 //===-- ProcessMonitor.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_ProcessMonitor_H_ 11 #define liblldb_ProcessMonitor_H_ 12 13 // C Includes 14 #include <semaphore.h> 15 #include <signal.h> 16 17 // C++ Includes 18 // Other libraries and framework includes 19 #include "lldb/lldb-types.h" 20 #include "lldb/Host/Mutex.h" 21 22 namespace lldb_private 23 { 24 class Error; 25 class Module; 26 class Scalar; 27 } // End lldb_private namespace. 28 29 class ProcessFreeBSD; 30 class Operation; 31 32 /// @class ProcessMonitor 33 /// @brief Manages communication with the inferior (debugee) process. 34 /// 35 /// Upon construction, this class prepares and launches an inferior process for 36 /// debugging. 37 /// 38 /// Changes in the inferior process state are propagated to the associated 39 /// ProcessFreeBSD instance by calling ProcessFreeBSD::SendMessage with the 40 /// appropriate ProcessMessage events. 41 /// 42 /// A purposely minimal set of operations are provided to interrogate and change 43 /// the inferior process state. 44 class ProcessMonitor 45 { 46 public: 47 48 /// Launches an inferior process ready for debugging. Forms the 49 /// implementation of Process::DoLaunch. 50 ProcessMonitor(ProcessPOSIX *process, 51 lldb_private::Module *module, 52 char const *argv[], 53 char const *envp[], 54 const char *stdin_path, 55 const char *stdout_path, 56 const char *stderr_path, 57 const char *working_dir, 58 lldb_private::Error &error); 59 60 ProcessMonitor(ProcessPOSIX *process, 61 lldb::pid_t pid, 62 lldb_private::Error &error); 63 64 ~ProcessMonitor(); 65 66 /// Provides the process number of debugee. 67 lldb::pid_t 68 GetPID() const { return m_pid; } 69 70 /// Returns the process associated with this ProcessMonitor. 71 ProcessFreeBSD & 72 GetProcess() { return *m_process; } 73 74 /// Returns a file descriptor to the controlling terminal of the inferior 75 /// process. 76 /// 77 /// Reads from this file descriptor yield both the standard output and 78 /// standard error of this debugee. Even if stderr and stdout were 79 /// redirected on launch it may still happen that data is available on this 80 /// descriptor (if the inferior process opens /dev/tty, for example). 81 /// 82 /// If this monitor was attached to an existing process this method returns 83 /// -1. 84 int 85 GetTerminalFD() const { return m_terminal_fd; } 86 87 /// Reads @p size bytes from address @vm_adder in the inferior process 88 /// address space. 89 /// 90 /// This method is provided to implement Process::DoReadMemory. 91 size_t 92 ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size, 93 lldb_private::Error &error); 94 95 /// Writes @p size bytes from address @p vm_adder in the inferior process 96 /// address space. 97 /// 98 /// This method is provided to implement Process::DoWriteMemory. 99 size_t 100 WriteMemory(lldb::addr_t vm_addr, const void *buf, size_t size, 101 lldb_private::Error &error); 102 103 /// Reads the contents from the register identified by the given (architecture 104 /// dependent) offset. 105 /// 106 /// This method is provided for use by RegisterContextFreeBSD derivatives. 107 /// FIXME: The FreeBSD implementation of this function should use tid in order 108 /// to enable support for debugging threaded programs. 109 bool 110 ReadRegisterValue(lldb::tid_t tid, unsigned offset, const char *reg_name, 111 unsigned size, lldb_private::RegisterValue &value); 112 113 /// Writes the given value to the register identified by the given 114 /// (architecture dependent) offset. 115 /// 116 /// This method is provided for use by RegisterContextFreeBSD derivatives. 117 /// FIXME: The FreeBSD implementation of this function should use tid in order 118 /// to enable support for debugging threaded programs. 119 bool 120 WriteRegisterValue(lldb::tid_t tid, unsigned offset, const char *reg_name, 121 const lldb_private::RegisterValue &value); 122 123 /// Reads all general purpose registers into the specified buffer. 124 /// FIXME: The FreeBSD implementation of this function should use tid in order 125 /// to enable support for debugging threaded programs. 126 bool 127 ReadGPR(lldb::tid_t tid, void *buf, size_t buf_size); 128 129 /// Reads all floating point registers into the specified buffer. 130 /// FIXME: The FreeBSD implementation of this function should use tid in order 131 /// to enable support for debugging threaded programs. 132 bool 133 ReadFPR(lldb::tid_t tid, void *buf, size_t buf_size); 134 135 /// Reads the specified register set into the specified buffer. 136 /// 137 /// This method is provided for use by RegisterContextFreeBSD derivatives. 138 /// FIXME: The FreeBSD implementation of this function should use tid in order 139 /// to enable support for debugging threaded programs. 140 bool 141 ReadRegisterSet(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset); 142 143 /// Writes all general purpose registers into the specified buffer. 144 /// FIXME: The FreeBSD implementation of this function should use tid in order 145 /// to enable support for debugging threaded programs. 146 bool 147 WriteGPR(lldb::tid_t tid, void *buf, size_t buf_size); 148 149 /// Writes all floating point registers into the specified buffer. 150 /// FIXME: The FreeBSD implementation of this function should use tid in order 151 /// to enable support for debugging threaded programs. 152 bool 153 WriteFPR(lldb::tid_t tid, void *buf, size_t buf_size); 154 155 /// Writes the specified register set into the specified buffer. 156 /// 157 /// This method is provided for use by RegisterContextFreeBSD derivatives. 158 /// FIXME: The FreeBSD implementation of this function should use tid in order 159 /// to enable support for debugging threaded programs. 160 bool 161 WriteRegisterSet(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset); 162 163 /// Writes a ptrace_lwpinfo structure corresponding to the given thread ID 164 /// to the memory region pointed to by @p lwpinfo. 165 bool 166 GetLwpInfo(lldb::tid_t tid, void *lwpinfo, int &error_no); 167 168 /// Writes the raw event message code (vis-a-vis PTRACE_GETEVENTMSG) 169 /// corresponding to the given thread IDto the memory pointed to by @p 170 /// message. 171 bool 172 GetEventMessage(lldb::tid_t tid, unsigned long *message); 173 174 /// Resumes the given thread. If @p signo is anything but 175 /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the thread. 176 bool 177 Resume(lldb::tid_t tid, uint32_t signo); 178 179 /// Single steps the given thread. If @p signo is anything but 180 /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the thread. 181 bool 182 SingleStep(lldb::tid_t tid, uint32_t signo); 183 184 /// Sends the inferior process a PTRACE_KILL signal. The inferior will 185 /// still exists and can be interrogated. Once resumed it will exit as 186 /// though it received a SIGKILL. 187 bool 188 BringProcessIntoLimbo(); 189 190 lldb_private::Error 191 Detach(lldb::tid_t tid); 192 193 void 194 StopMonitor(); 195 196 private: 197 ProcessFreeBSD *m_process; 198 199 lldb::thread_t m_operation_thread; 200 lldb::thread_t m_monitor_thread; 201 lldb::pid_t m_pid; 202 203 204 lldb_private::Mutex m_server_mutex; 205 int m_terminal_fd; 206 int m_client_fd; 207 int m_server_fd; 208 209 struct OperationArgs 210 { 211 OperationArgs(ProcessMonitor *monitor); 212 213 ~OperationArgs(); 214 215 ProcessMonitor *m_monitor; // The monitor performing the attach. 216 sem_t m_semaphore; // Posted to once operation complete. 217 lldb_private::Error m_error; // Set if process operation failed. 218 }; 219 220 /// @class LauchArgs 221 /// 222 /// @brief Simple structure to pass data to the thread responsible for 223 /// launching a child process. 224 struct LaunchArgs : OperationArgs 225 { 226 LaunchArgs(ProcessMonitor *monitor, 227 lldb_private::Module *module, 228 char const **argv, 229 char const **envp, 230 const char *stdin_path, 231 const char *stdout_path, 232 const char *stderr_path, 233 const char *working_dir); 234 235 ~LaunchArgs(); 236 237 lldb_private::Module *m_module; // The executable image to launch. 238 char const **m_argv; // Process arguments. 239 char const **m_envp; // Process environment. 240 const char *m_stdin_path; // Redirect stdin or NULL. 241 const char *m_stdout_path; // Redirect stdout or NULL. 242 const char *m_stderr_path; // Redirect stderr or NULL. 243 const char *m_working_dir; // Working directory or NULL. 244 }; 245 246 void 247 StartLaunchOpThread(LaunchArgs *args, lldb_private::Error &error); 248 249 static void * 250 LaunchOpThread(void *arg); 251 252 static bool 253 Launch(LaunchArgs *args); 254 255 bool 256 EnableIPC(); 257 258 struct AttachArgs : OperationArgs 259 { 260 AttachArgs(ProcessMonitor *monitor, 261 lldb::pid_t pid); 262 263 ~AttachArgs(); 264 265 lldb::pid_t m_pid; // pid of the process to be attached. 266 }; 267 268 void 269 StartAttachOpThread(AttachArgs *args, lldb_private::Error &error); 270 271 static void * 272 AttachOpThread(void *args); 273 274 static bool 275 Attach(AttachArgs *args); 276 277 static void 278 ServeOperation(OperationArgs *args); 279 280 static bool 281 DupDescriptor(const char *path, int fd, int flags); 282 283 static bool 284 MonitorCallback(void *callback_baton, 285 lldb::pid_t pid, bool exited, int signal, int status); 286 287 static ProcessMessage 288 MonitorSIGTRAP(ProcessMonitor *monitor, 289 const siginfo_t *info, lldb::pid_t pid); 290 291 static ProcessMessage 292 MonitorSignal(ProcessMonitor *monitor, 293 const siginfo_t *info, lldb::pid_t pid); 294 295 static ProcessMessage::CrashReason 296 GetCrashReasonForSIGSEGV(const siginfo_t *info); 297 298 static ProcessMessage::CrashReason 299 GetCrashReasonForSIGILL(const siginfo_t *info); 300 301 static ProcessMessage::CrashReason 302 GetCrashReasonForSIGFPE(const siginfo_t *info); 303 304 static ProcessMessage::CrashReason 305 GetCrashReasonForSIGBUS(const siginfo_t *info); 306 307 void 308 DoOperation(Operation *op); 309 310 /// Stops the child monitor thread. 311 void 312 StopMonitoringChildProcess(); 313 314 /// Stops the operation thread used to attach/launch a process. 315 void 316 StopOpThread(); 317 318 void 319 CloseFD(int &fd); 320 }; 321 322 #endif // #ifndef liblldb_ProcessMonitor_H_ 323
