contrib/llvm/tools/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.h

   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     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
 213 private:
 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_