ProcessMonitor.h revision 269024
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 22namespace lldb_private 23{ 24class Error; 25class Module; 26class Scalar; 27} // End lldb_private namespace. 28 29class ProcessFreeBSD; 30class 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. 44class ProcessMonitor 45{ 46public: 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 bool 108 ReadRegisterValue(lldb::tid_t tid, unsigned offset, const char *reg_name, 109 unsigned size, lldb_private::RegisterValue &value); 110 111 /// Writes the given value to the register identified by the given 112 /// (architecture dependent) offset. 113 /// 114 /// This method is provided for use by RegisterContextFreeBSD derivatives. 115 bool 116 WriteRegisterValue(lldb::tid_t tid, unsigned offset, const char *reg_name, 117 const lldb_private::RegisterValue &value); 118 119 /// Reads the contents from the debug register identified by the given 120 /// (architecture dependent) offset. 121 /// 122 /// This method is provided for use by RegisterContextFreeBSD derivatives. 123 bool 124 ReadDebugRegisterValue(lldb::tid_t tid, unsigned offset, 125 const char *reg_name, unsigned size, 126 lldb_private::RegisterValue &value); 127 128 /// Writes the given value to the debug register identified by the given 129 /// (architecture dependent) offset. 130 /// 131 /// This method is provided for use by RegisterContextFreeBSD derivatives. 132 bool 133 WriteDebugRegisterValue(lldb::tid_t tid, unsigned offset, 134 const char *reg_name, 135 const lldb_private::RegisterValue &value); 136 /// Reads all general purpose registers into the specified buffer. 137 bool 138 ReadGPR(lldb::tid_t tid, void *buf, size_t buf_size); 139 140 /// Reads all floating point registers into the specified buffer. 141 bool 142 ReadFPR(lldb::tid_t tid, void *buf, size_t buf_size); 143 144 /// Reads the specified register set into the specified buffer. 145 /// 146 /// This method is provided for use by RegisterContextFreeBSD derivatives. 147 bool 148 ReadRegisterSet(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset); 149 150 /// Writes all general purpose registers into the specified buffer. 151 bool 152 WriteGPR(lldb::tid_t tid, void *buf, size_t buf_size); 153 154 /// Writes all floating point registers into the specified buffer. 155 bool 156 WriteFPR(lldb::tid_t tid, void *buf, size_t buf_size); 157 158 /// Writes the specified register set into the specified buffer. 159 /// 160 /// This method is provided for use by RegisterContextFreeBSD derivatives. 161 bool 162 WriteRegisterSet(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset); 163 164 /// Reads the value of the thread-specific pointer for a given thread ID. 165 bool 166 ReadThreadPointer(lldb::tid_t tid, lldb::addr_t &value); 167 168 /// Returns current thread IDs in process 169 size_t 170 GetCurrentThreadIDs(std::vector<lldb::tid_t> &thread_ids); 171 172 /// Writes a ptrace_lwpinfo structure corresponding to the given thread ID 173 /// to the memory region pointed to by @p lwpinfo. 174 bool 175 GetLwpInfo(lldb::tid_t tid, void *lwpinfo, int &error_no); 176 177 /// Suspends or unsuspends a thread prior to process resume or step. 178 bool 179 ThreadSuspend(lldb::tid_t tid, bool suspend); 180 181 /// Writes the raw event message code (vis-a-vis PTRACE_GETEVENTMSG) 182 /// corresponding to the given thread IDto the memory pointed to by @p 183 /// message. 184 bool 185 GetEventMessage(lldb::tid_t tid, unsigned long *message); 186 187 /// Resumes the process. If @p signo is anything but 188 /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the process. 189 bool 190 Resume(lldb::tid_t unused, uint32_t signo); 191 192 /// Single steps the process. If @p signo is anything but 193 /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the process. 194 bool 195 SingleStep(lldb::tid_t unused, uint32_t signo); 196 197 /// Sends the inferior process a PTRACE_KILL signal. The inferior will 198 /// still exists and can be interrogated. Once resumed it will exit as 199 /// though it received a SIGKILL. 200 bool 201 BringProcessIntoLimbo(); 202 203 lldb_private::Error 204 Detach(lldb::tid_t tid); 205 206 void 207 StopMonitor(); 208 209 // Waits for the initial stop message from a new thread. 210 bool 211 WaitForInitialTIDStop(lldb::tid_t tid); 212 213private: 214 ProcessFreeBSD *m_process; 215 216 lldb::thread_t m_operation_thread; 217 lldb::thread_t m_monitor_thread; 218 lldb::pid_t m_pid; 219 220 int m_terminal_fd; 221 222 // current operation which must be executed on the privileged thread 223 Operation *m_operation; 224 lldb_private::Mutex m_operation_mutex; 225 226 // semaphores notified when Operation is ready to be processed and when 227 // the operation is complete. 228 sem_t m_operation_pending; 229 sem_t m_operation_done; 230 231 struct OperationArgs 232 { 233 OperationArgs(ProcessMonitor *monitor); 234 235 ~OperationArgs(); 236 237 ProcessMonitor *m_monitor; // The monitor performing the attach. 238 sem_t m_semaphore; // Posted to once operation complete. 239 lldb_private::Error m_error; // Set if process operation failed. 240 }; 241 242 /// @class LauchArgs 243 /// 244 /// @brief Simple structure to pass data to the thread responsible for 245 /// launching a child process. 246 struct LaunchArgs : OperationArgs 247 { 248 LaunchArgs(ProcessMonitor *monitor, 249 lldb_private::Module *module, 250 char const **argv, 251 char const **envp, 252 const char *stdin_path, 253 const char *stdout_path, 254 const char *stderr_path, 255 const char *working_dir); 256 257 ~LaunchArgs(); 258 259 lldb_private::Module *m_module; // The executable image to launch. 260 char const **m_argv; // Process arguments. 261 char const **m_envp; // Process environment. 262 const char *m_stdin_path; // Redirect stdin or NULL. 263 const char *m_stdout_path; // Redirect stdout or NULL. 264 const char *m_stderr_path; // Redirect stderr or NULL. 265 const char *m_working_dir; // Working directory or NULL. 266 }; 267 268 void 269 StartLaunchOpThread(LaunchArgs *args, lldb_private::Error &error); 270 271 static void * 272 LaunchOpThread(void *arg); 273 274 static bool 275 Launch(LaunchArgs *args); 276 277 struct AttachArgs : OperationArgs 278 { 279 AttachArgs(ProcessMonitor *monitor, 280 lldb::pid_t pid); 281 282 ~AttachArgs(); 283 284 lldb::pid_t m_pid; // pid of the process to be attached. 285 }; 286 287 void 288 StartAttachOpThread(AttachArgs *args, lldb_private::Error &error); 289 290 static void * 291 AttachOpThread(void *args); 292 293 static bool 294 Attach(AttachArgs *args); 295 296 static void 297 ServeOperation(OperationArgs *args); 298 299 static bool 300 DupDescriptor(const char *path, int fd, int flags); 301 302 static bool 303 MonitorCallback(void *callback_baton, 304 lldb::pid_t pid, bool exited, int signal, int status); 305 306 static ProcessMessage 307 MonitorSIGTRAP(ProcessMonitor *monitor, 308 const siginfo_t *info, lldb::pid_t pid); 309 310 static ProcessMessage 311 MonitorSignal(ProcessMonitor *monitor, 312 const siginfo_t *info, lldb::pid_t pid); 313 314 static ProcessMessage::CrashReason 315 GetCrashReasonForSIGSEGV(const siginfo_t *info); 316 317 static ProcessMessage::CrashReason 318 GetCrashReasonForSIGILL(const siginfo_t *info); 319 320 static ProcessMessage::CrashReason 321 GetCrashReasonForSIGFPE(const siginfo_t *info); 322 323 static ProcessMessage::CrashReason 324 GetCrashReasonForSIGBUS(const siginfo_t *info); 325 326 void 327 DoOperation(Operation *op); 328 329 /// Stops the child monitor thread. 330 void 331 StopMonitoringChildProcess(); 332 333 /// Stops the operation thread used to attach/launch a process. 334 void 335 StopOpThread(); 336}; 337 338#endif // #ifndef liblldb_ProcessMonitor_H_ 339