//===-- ProcessMonitor.cpp ------------------------------------ -*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // C Includes #include #include #include #include #include #include #include #include // C++ Includes // Other libraries and framework includes #include "lldb/Core/Debugger.h" #include "lldb/Core/Error.h" #include "lldb/Core/RegisterValue.h" #include "lldb/Core/Scalar.h" #include "lldb/Host/Host.h" #include "lldb/Target/Thread.h" #include "lldb/Target/RegisterContext.h" #include "lldb/Utility/PseudoTerminal.h" #include "LinuxThread.h" #include "ProcessLinux.h" #include "ProcessLinuxLog.h" #include "ProcessMonitor.h" #define DEBUG_PTRACE_MAXBYTES 20 using namespace lldb_private; // FIXME: this code is host-dependent with respect to types and // endianness and needs to be fixed. For example, lldb::addr_t is // hard-coded to uint64_t, but on a 32-bit Linux host, ptrace requires // 32-bit pointer arguments. This code uses casts to work around the // problem. // We disable the tracing of ptrace calls for integration builds to // avoid the additional indirection and checks. #ifndef LLDB_CONFIGURATION_BUILDANDINTEGRATION static void DisplayBytes (lldb_private::StreamString &s, void *bytes, uint32_t count) { uint8_t *ptr = (uint8_t *)bytes; const uint32_t loop_count = std::min(DEBUG_PTRACE_MAXBYTES, count); for(uint32_t i=0; iPrintf("PTRACE_POKETEXT %s", buf.GetData()); break; } case PTRACE_POKEDATA: { DisplayBytes(buf, &data, 8); verbose_log->Printf("PTRACE_POKEDATA %s", buf.GetData()); break; } case PTRACE_POKEUSER: { DisplayBytes(buf, &data, 8); verbose_log->Printf("PTRACE_POKEUSER %s", buf.GetData()); break; } case PTRACE_SETREGS: { DisplayBytes(buf, data, sizeof(user_regs_struct)); verbose_log->Printf("PTRACE_SETREGS %s", buf.GetData()); break; } case PTRACE_SETFPREGS: { DisplayBytes(buf, data, sizeof(user_fpregs_struct)); verbose_log->Printf("PTRACE_SETFPREGS %s", buf.GetData()); break; } case PTRACE_SETSIGINFO: { DisplayBytes(buf, data, sizeof(siginfo_t)); verbose_log->Printf("PTRACE_SETSIGINFO %s", buf.GetData()); break; } default: { } } } } // Wrapper for ptrace to catch errors and log calls. extern long PtraceWrapper(__ptrace_request req, pid_t pid, void *addr, void *data, const char* reqName, const char* file, int line) { long int result; LogSP log (ProcessLinuxLog::GetLogIfAllCategoriesSet (LINUX_LOG_PTRACE)); if (log) log->Printf("ptrace(%s, %u, %p, %p) called from file %s line %d", reqName, pid, addr, data, file, line); PtraceDisplayBytes(req, data); errno = 0; result = ptrace(req, pid, addr, data); PtraceDisplayBytes(req, data); if (log && (result == -1 || errno != 0)) { const char* str; switch (errno) { case ESRCH: str = "ESRCH"; break; case EINVAL: str = "EINVAL"; break; case EBUSY: str = "EBUSY"; break; case EPERM: str = "EPERM"; break; default: str = ""; } log->Printf("ptrace() failed; errno=%d (%s)", errno, str); } return result; } #define PTRACE(req, pid, addr, data) \ PtraceWrapper((req), (pid), (addr), (data), #req, __FILE__, __LINE__) #else #define PTRACE ptrace #endif //------------------------------------------------------------------------------ // Static implementations of ProcessMonitor::ReadMemory and // ProcessMonitor::WriteMemory. This enables mutual recursion between these // functions without needed to go thru the thread funnel. static size_t DoReadMemory(lldb::pid_t pid, unsigned word_size, lldb::addr_t vm_addr, void *buf, size_t size, Error &error) { unsigned char *dst = static_cast(buf); size_t bytes_read; size_t remainder; long data; LogSP log (ProcessLinuxLog::GetLogIfAllCategoriesSet (LINUX_LOG_ALL)); if (log) ProcessLinuxLog::IncNestLevel(); if (log && ProcessLinuxLog::AtTopNestLevel() && log->GetMask().Test(LINUX_LOG_MEMORY)) log->Printf ("ProcessMonitor::%s(%d, %d, %p, %p, %d, _)", __FUNCTION__, pid, word_size, (void*)vm_addr, buf, size); assert(sizeof(data) >= word_size); assert(sizeof(void*) == word_size); for (bytes_read = 0; bytes_read < size; bytes_read += remainder) { errno = 0; data = PTRACE(PTRACE_PEEKDATA, pid, (void*)vm_addr, NULL); if (data == -1L && errno) { error.SetErrorToErrno(); if (log) ProcessLinuxLog::DecNestLevel(); return bytes_read; } remainder = size - bytes_read; remainder = remainder > word_size ? word_size : remainder; // Copy the data into our buffer if (log) memset(dst, 0, sizeof(dst)); for (unsigned i = 0; i < remainder; ++i) dst[i] = ((data >> i*8) & 0xFF); if (log && ProcessLinuxLog::AtTopNestLevel() && (log->GetMask().Test(LINUX_LOG_MEMORY_DATA_LONG) || (log->GetMask().Test(LINUX_LOG_MEMORY_DATA_SHORT) && size <= LINUX_LOG_MEMORY_SHORT_BYTES))) log->Printf ("ProcessMonitor::%s() [%p]:0x%lx (0x%lx)", __FUNCTION__, (void*)vm_addr, *(unsigned long*)dst, (unsigned long)data); vm_addr += word_size; dst += word_size; } if (log) ProcessLinuxLog::DecNestLevel(); return bytes_read; } static size_t DoWriteMemory(lldb::pid_t pid, unsigned word_size, lldb::addr_t vm_addr, const void *buf, size_t size, Error &error) { const unsigned char *src = static_cast(buf); size_t bytes_written = 0; size_t remainder; LogSP log (ProcessLinuxLog::GetLogIfAllCategoriesSet (LINUX_LOG_ALL)); if (log) ProcessLinuxLog::IncNestLevel(); if (log && ProcessLinuxLog::AtTopNestLevel() && log->GetMask().Test(LINUX_LOG_MEMORY)) log->Printf ("ProcessMonitor::%s(%d, %d, %p, %p, %d, _)", __FUNCTION__, pid, word_size, (void*)vm_addr, buf, size); assert(sizeof(void*) == word_size); for (bytes_written = 0; bytes_written < size; bytes_written += remainder) { remainder = size - bytes_written; remainder = remainder > word_size ? word_size : remainder; if (remainder == word_size) { unsigned long data = 0; assert(sizeof(data) >= word_size); for (unsigned i = 0; i < word_size; ++i) data |= (unsigned long)src[i] << i*8; if (log && ProcessLinuxLog::AtTopNestLevel() && (log->GetMask().Test(LINUX_LOG_MEMORY_DATA_LONG) || (log->GetMask().Test(LINUX_LOG_MEMORY_DATA_SHORT) && size <= LINUX_LOG_MEMORY_SHORT_BYTES))) log->Printf ("ProcessMonitor::%s() [%p]:0x%lx (0x%lx)", __FUNCTION__, (void*)vm_addr, *(unsigned long*)src, data); if (PTRACE(PTRACE_POKEDATA, pid, (void*)vm_addr, (void*)data)) { error.SetErrorToErrno(); if (log) ProcessLinuxLog::DecNestLevel(); return bytes_written; } } else { unsigned char buff[8]; if (DoReadMemory(pid, word_size, vm_addr, buff, word_size, error) != word_size) { if (log) ProcessLinuxLog::DecNestLevel(); return bytes_written; } memcpy(buff, src, remainder); if (DoWriteMemory(pid, word_size, vm_addr, buff, word_size, error) != word_size) { if (log) ProcessLinuxLog::DecNestLevel(); return bytes_written; } if (log && ProcessLinuxLog::AtTopNestLevel() && (log->GetMask().Test(LINUX_LOG_MEMORY_DATA_LONG) || (log->GetMask().Test(LINUX_LOG_MEMORY_DATA_SHORT) && size <= LINUX_LOG_MEMORY_SHORT_BYTES))) log->Printf ("ProcessMonitor::%s() [%p]:0x%lx (0x%lx)", __FUNCTION__, (void*)vm_addr, *(unsigned long*)src, *(unsigned long*)buff); } vm_addr += word_size; src += word_size; } if (log) ProcessLinuxLog::DecNestLevel(); return bytes_written; } // Simple helper function to ensure flags are enabled on the given file // descriptor. static bool EnsureFDFlags(int fd, int flags, Error &error) { int status; if ((status = fcntl(fd, F_GETFL)) == -1) { error.SetErrorToErrno(); return false; } if (fcntl(fd, F_SETFL, status | flags) == -1) { error.SetErrorToErrno(); return false; } return true; } //------------------------------------------------------------------------------ /// @class Operation /// @brief Represents a ProcessMonitor operation. /// /// Under Linux, it is not possible to ptrace() from any other thread but the /// one that spawned or attached to the process from the start. Therefore, when /// a ProcessMonitor is asked to deliver or change the state of an inferior /// process the operation must be "funneled" to a specific thread to perform the /// task. The Operation class provides an abstract base for all services the /// ProcessMonitor must perform via the single virtual function Execute, thus /// encapsulating the code that needs to run in the privileged context. class Operation { public: virtual void Execute(ProcessMonitor *monitor) = 0; }; //------------------------------------------------------------------------------ /// @class ReadOperation /// @brief Implements ProcessMonitor::ReadMemory. class ReadOperation : public Operation { public: ReadOperation(lldb::addr_t addr, void *buff, size_t size, Error &error, size_t &result) : m_addr(addr), m_buff(buff), m_size(size), m_error(error), m_result(result) { } void Execute(ProcessMonitor *monitor); private: lldb::addr_t m_addr; void *m_buff; size_t m_size; Error &m_error; size_t &m_result; }; void ReadOperation::Execute(ProcessMonitor *monitor) { const unsigned word_size = monitor->GetProcess().GetAddressByteSize(); lldb::pid_t pid = monitor->GetPID(); m_result = DoReadMemory(pid, word_size, m_addr, m_buff, m_size, m_error); } //------------------------------------------------------------------------------ /// @class ReadOperation /// @brief Implements ProcessMonitor::WriteMemory. class WriteOperation : public Operation { public: WriteOperation(lldb::addr_t addr, const void *buff, size_t size, Error &error, size_t &result) : m_addr(addr), m_buff(buff), m_size(size), m_error(error), m_result(result) { } void Execute(ProcessMonitor *monitor); private: lldb::addr_t m_addr; const void *m_buff; size_t m_size; Error &m_error; size_t &m_result; }; void WriteOperation::Execute(ProcessMonitor *monitor) { const unsigned word_size = monitor->GetProcess().GetAddressByteSize(); lldb::pid_t pid = monitor->GetPID(); m_result = DoWriteMemory(pid, word_size, m_addr, m_buff, m_size, m_error); } //------------------------------------------------------------------------------ /// @class ReadRegOperation /// @brief Implements ProcessMonitor::ReadRegisterValue. class ReadRegOperation : public Operation { public: ReadRegOperation(unsigned offset, RegisterValue &value, bool &result) : m_offset(offset), m_value(value), m_result(result) { } void Execute(ProcessMonitor *monitor); private: unsigned m_offset; RegisterValue &m_value; bool &m_result; }; void ReadRegOperation::Execute(ProcessMonitor *monitor) { lldb::pid_t pid = monitor->GetPID(); LogSP log (ProcessLinuxLog::GetLogIfAllCategoriesSet (LINUX_LOG_REGISTERS)); // Set errno to zero so that we can detect a failed peek. errno = 0; lldb::addr_t data = PTRACE(PTRACE_PEEKUSER, pid, (void*)m_offset, NULL); if (data == -1UL && errno) m_result = false; else { m_value = data; m_result = true; } if (log) log->Printf ("ProcessMonitor::%s() reg %s: 0x%x", __FUNCTION__, LinuxThread::GetRegisterNameFromOffset(m_offset), data); } //------------------------------------------------------------------------------ /// @class WriteRegOperation /// @brief Implements ProcessMonitor::WriteRegisterValue. class WriteRegOperation : public Operation { public: WriteRegOperation(unsigned offset, const RegisterValue &value, bool &result) : m_offset(offset), m_value(value), m_result(result) { } void Execute(ProcessMonitor *monitor); private: unsigned m_offset; const RegisterValue &m_value; bool &m_result; }; void WriteRegOperation::Execute(ProcessMonitor *monitor) { void* buf; lldb::pid_t pid = monitor->GetPID(); LogSP log (ProcessLinuxLog::GetLogIfAllCategoriesSet (LINUX_LOG_REGISTERS)); if (sizeof(void*) == sizeof(uint64_t)) buf = (void*) m_value.GetAsUInt64(); else { assert(sizeof(void*) == sizeof(uint32_t)); buf = (void*) m_value.GetAsUInt32(); } if (log) log->Printf ("ProcessMonitor::%s() reg %s: %p", __FUNCTION__, LinuxThread::GetRegisterNameFromOffset(m_offset), buf); if (PTRACE(PTRACE_POKEUSER, pid, (void*)m_offset, buf)) m_result = false; else m_result = true; } //------------------------------------------------------------------------------ /// @class ReadGPROperation /// @brief Implements ProcessMonitor::ReadGPR. class ReadGPROperation : public Operation { public: ReadGPROperation(void *buf, bool &result) : m_buf(buf), m_result(result) { } void Execute(ProcessMonitor *monitor); private: void *m_buf; bool &m_result; }; void ReadGPROperation::Execute(ProcessMonitor *monitor) { if (PTRACE(PTRACE_GETREGS, monitor->GetPID(), NULL, m_buf) < 0) m_result = false; else m_result = true; } //------------------------------------------------------------------------------ /// @class ReadFPROperation /// @brief Implements ProcessMonitor::ReadFPR. class ReadFPROperation : public Operation { public: ReadFPROperation(void *buf, bool &result) : m_buf(buf), m_result(result) { } void Execute(ProcessMonitor *monitor); private: void *m_buf; bool &m_result; }; void ReadFPROperation::Execute(ProcessMonitor *monitor) { if (PTRACE(PTRACE_GETFPREGS, monitor->GetPID(), NULL, m_buf) < 0) m_result = false; else m_result = true; } //------------------------------------------------------------------------------ /// @class WriteGPROperation /// @brief Implements ProcessMonitor::WriteGPR. class WriteGPROperation : public Operation { public: WriteGPROperation(void *buf, bool &result) : m_buf(buf), m_result(result) { } void Execute(ProcessMonitor *monitor); private: void *m_buf; bool &m_result; }; void WriteGPROperation::Execute(ProcessMonitor *monitor) { if (PTRACE(PTRACE_SETREGS, monitor->GetPID(), NULL, m_buf) < 0) m_result = false; else m_result = true; } //------------------------------------------------------------------------------ /// @class WriteFPROperation /// @brief Implements ProcessMonitor::WriteFPR. class WriteFPROperation : public Operation { public: WriteFPROperation(void *buf, bool &result) : m_buf(buf), m_result(result) { } void Execute(ProcessMonitor *monitor); private: void *m_buf; bool &m_result; }; void WriteFPROperation::Execute(ProcessMonitor *monitor) { if (PTRACE(PTRACE_SETFPREGS, monitor->GetPID(), NULL, m_buf) < 0) m_result = false; else m_result = true; } //------------------------------------------------------------------------------ /// @class ResumeOperation /// @brief Implements ProcessMonitor::Resume. class ResumeOperation : public Operation { public: ResumeOperation(lldb::tid_t tid, uint32_t signo, bool &result) : m_tid(tid), m_signo(signo), m_result(result) { } void Execute(ProcessMonitor *monitor); private: lldb::tid_t m_tid; uint32_t m_signo; bool &m_result; }; void ResumeOperation::Execute(ProcessMonitor *monitor) { int data = 0; if (m_signo != LLDB_INVALID_SIGNAL_NUMBER) data = m_signo; if (PTRACE(PTRACE_CONT, m_tid, NULL, (void*)data)) m_result = false; else m_result = true; } //------------------------------------------------------------------------------ /// @class ResumeOperation /// @brief Implements ProcessMonitor::SingleStep. class SingleStepOperation : public Operation { public: SingleStepOperation(lldb::tid_t tid, uint32_t signo, bool &result) : m_tid(tid), m_signo(signo), m_result(result) { } void Execute(ProcessMonitor *monitor); private: lldb::tid_t m_tid; uint32_t m_signo; bool &m_result; }; void SingleStepOperation::Execute(ProcessMonitor *monitor) { int data = 0; if (m_signo != LLDB_INVALID_SIGNAL_NUMBER) data = m_signo; if (PTRACE(PTRACE_SINGLESTEP, m_tid, NULL, (void*)data)) m_result = false; else m_result = true; } //------------------------------------------------------------------------------ /// @class SiginfoOperation /// @brief Implements ProcessMonitor::GetSignalInfo. class SiginfoOperation : public Operation { public: SiginfoOperation(lldb::tid_t tid, void *info, bool &result) : m_tid(tid), m_info(info), m_result(result) { } void Execute(ProcessMonitor *monitor); private: lldb::tid_t m_tid; void *m_info; bool &m_result; }; void SiginfoOperation::Execute(ProcessMonitor *monitor) { if (PTRACE(PTRACE_GETSIGINFO, m_tid, NULL, m_info)) m_result = false; else m_result = true; } //------------------------------------------------------------------------------ /// @class EventMessageOperation /// @brief Implements ProcessMonitor::GetEventMessage. class EventMessageOperation : public Operation { public: EventMessageOperation(lldb::tid_t tid, unsigned long *message, bool &result) : m_tid(tid), m_message(message), m_result(result) { } void Execute(ProcessMonitor *monitor); private: lldb::tid_t m_tid; unsigned long *m_message; bool &m_result; }; void EventMessageOperation::Execute(ProcessMonitor *monitor) { if (PTRACE(PTRACE_GETEVENTMSG, m_tid, NULL, m_message)) m_result = false; else m_result = true; } //------------------------------------------------------------------------------ /// @class KillOperation /// @brief Implements ProcessMonitor::BringProcessIntoLimbo. class KillOperation : public Operation { public: KillOperation(bool &result) : m_result(result) { } void Execute(ProcessMonitor *monitor); private: bool &m_result; }; void KillOperation::Execute(ProcessMonitor *monitor) { lldb::pid_t pid = monitor->GetPID(); if (PTRACE(PTRACE_KILL, pid, NULL, NULL)) m_result = false; else m_result = true; } ProcessMonitor::OperationArgs::OperationArgs(ProcessMonitor *monitor) : m_monitor(monitor) { sem_init(&m_semaphore, 0, 0); } ProcessMonitor::OperationArgs::~OperationArgs() { sem_destroy(&m_semaphore); } ProcessMonitor::LaunchArgs::LaunchArgs(ProcessMonitor *monitor, lldb_private::Module *module, char const **argv, char const **envp, const char *stdin_path, const char *stdout_path, const char *stderr_path) : OperationArgs(monitor), m_module(module), m_argv(argv), m_envp(envp), m_stdin_path(stdin_path), m_stdout_path(stdout_path), m_stderr_path(stderr_path) { } ProcessMonitor::LaunchArgs::~LaunchArgs() { } ProcessMonitor::AttachArgs::AttachArgs(ProcessMonitor *monitor, lldb::pid_t pid) : OperationArgs(monitor), m_pid(pid) { } ProcessMonitor::AttachArgs::~AttachArgs() { } //------------------------------------------------------------------------------ /// The basic design of the ProcessMonitor is built around two threads. /// /// One thread (@see SignalThread) simply blocks on a call to waitpid() looking /// for changes in the debugee state. When a change is detected a /// ProcessMessage is sent to the associated ProcessLinux instance. This thread /// "drives" state changes in the debugger. /// /// The second thread (@see OperationThread) is responsible for two things 1) /// launching or attaching to the inferior process, and then 2) servicing /// operations such as register reads/writes, stepping, etc. See the comments /// on the Operation class for more info as to why this is needed. ProcessMonitor::ProcessMonitor(ProcessLinux *process, Module *module, const char *argv[], const char *envp[], const char *stdin_path, const char *stdout_path, const char *stderr_path, lldb_private::Error &error) : m_process(process), m_operation_thread(LLDB_INVALID_HOST_THREAD), m_pid(LLDB_INVALID_PROCESS_ID), m_terminal_fd(-1), m_monitor_thread(LLDB_INVALID_HOST_THREAD), m_client_fd(-1), m_server_fd(-1) { std::auto_ptr args; args.reset(new LaunchArgs(this, module, argv, envp, stdin_path, stdout_path, stderr_path)); // Server/client descriptors. if (!EnableIPC()) { error.SetErrorToGenericError(); error.SetErrorString("Monitor failed to initialize."); } StartLaunchOpThread(args.get(), error); if (!error.Success()) return; WAIT_AGAIN: // Wait for the operation thread to initialize. if (sem_wait(&args->m_semaphore)) { if (errno == EINTR) goto WAIT_AGAIN; else { error.SetErrorToErrno(); return; } } // Check that the launch was a success. if (!args->m_error.Success()) { StopLaunchOpThread(); error = args->m_error; return; } // Finally, start monitoring the child process for change in state. m_monitor_thread = Host::StartMonitoringChildProcess( ProcessMonitor::MonitorCallback, this, GetPID(), true); if (!IS_VALID_LLDB_HOST_THREAD(m_monitor_thread)) { error.SetErrorToGenericError(); error.SetErrorString("Process launch failed."); return; } } ProcessMonitor::ProcessMonitor(ProcessLinux *process, lldb::pid_t pid, lldb_private::Error &error) : m_process(process), m_operation_thread(LLDB_INVALID_HOST_THREAD), m_pid(LLDB_INVALID_PROCESS_ID), m_terminal_fd(-1), m_monitor_thread(LLDB_INVALID_HOST_THREAD), m_client_fd(-1), m_server_fd(-1) { std::auto_ptr args; args.reset(new AttachArgs(this, pid)); // Server/client descriptors. if (!EnableIPC()) { error.SetErrorToGenericError(); error.SetErrorString("Monitor failed to initialize."); } StartAttachOpThread(args.get(), error); if (!error.Success()) return; WAIT_AGAIN: // Wait for the operation thread to initialize. if (sem_wait(&args->m_semaphore)) { if (errno == EINTR) goto WAIT_AGAIN; else { error.SetErrorToErrno(); return; } } // Check that the launch was a success. if (!args->m_error.Success()) { StopAttachOpThread(); error = args->m_error; return; } // Finally, start monitoring the child process for change in state. m_monitor_thread = Host::StartMonitoringChildProcess( ProcessMonitor::MonitorCallback, this, GetPID(), true); if (!IS_VALID_LLDB_HOST_THREAD(m_monitor_thread)) { error.SetErrorToGenericError(); error.SetErrorString("Process attach failed."); return; } } ProcessMonitor::~ProcessMonitor() { StopMonitor(); } //------------------------------------------------------------------------------ // Thread setup and tear down. void ProcessMonitor::StartLaunchOpThread(LaunchArgs *args, Error &error) { static const char *g_thread_name = "lldb.process.linux.operation"; if (IS_VALID_LLDB_HOST_THREAD(m_operation_thread)) return; m_operation_thread = Host::ThreadCreate(g_thread_name, LaunchOpThread, args, &error); } void ProcessMonitor::StopLaunchOpThread() { lldb::thread_result_t result; if (!IS_VALID_LLDB_HOST_THREAD(m_operation_thread)) return; Host::ThreadCancel(m_operation_thread, NULL); Host::ThreadJoin(m_operation_thread, &result, NULL); } void * ProcessMonitor::LaunchOpThread(void *arg) { LaunchArgs *args = static_cast(arg); if (!Launch(args)) { sem_post(&args->m_semaphore); return NULL; } ServeOperation(args); return NULL; } bool ProcessMonitor::Launch(LaunchArgs *args) { ProcessMonitor *monitor = args->m_monitor; ProcessLinux &process = monitor->GetProcess(); const char **argv = args->m_argv; const char **envp = args->m_envp; const char *stdin_path = args->m_stdin_path; const char *stdout_path = args->m_stdout_path; const char *stderr_path = args->m_stderr_path; lldb_utility::PseudoTerminal terminal; const size_t err_len = 1024; char err_str[err_len]; lldb::pid_t pid; lldb::ThreadSP inferior; LogSP log (ProcessLinuxLog::GetLogIfAllCategoriesSet (LINUX_LOG_PROCESS)); // Propagate the environment if one is not supplied. if (envp == NULL || envp[0] == NULL) envp = const_cast(environ); // Pseudo terminal setup. if (!terminal.OpenFirstAvailableMaster(O_RDWR | O_NOCTTY, err_str, err_len)) { args->m_error.SetErrorToGenericError(); args->m_error.SetErrorString("Could not open controlling TTY."); goto FINISH; } if ((pid = terminal.Fork(err_str, err_len)) < 0) { args->m_error.SetErrorToGenericError(); args->m_error.SetErrorString("Process fork failed."); goto FINISH; } // Recognized child exit status codes. enum { ePtraceFailed = 1, eDupStdinFailed, eDupStdoutFailed, eDupStderrFailed, eExecFailed }; // Child process. if (pid == 0) { // Trace this process. if (PTRACE(PTRACE_TRACEME, 0, NULL, NULL) < 0) exit(ePtraceFailed); // Do not inherit setgid powers. setgid(getgid()); // Let us have our own process group. setpgid(0, 0); // Dup file descriptors if needed. // // FIXME: If two or more of the paths are the same we needlessly open // the same file multiple times. if (stdin_path != NULL && stdin_path[0]) if (!DupDescriptor(stdin_path, STDIN_FILENO, O_RDONLY)) exit(eDupStdinFailed); if (stdout_path != NULL && stdout_path[0]) if (!DupDescriptor(stdout_path, STDOUT_FILENO, O_WRONLY | O_CREAT)) exit(eDupStdoutFailed); if (stderr_path != NULL && stderr_path[0]) if (!DupDescriptor(stderr_path, STDERR_FILENO, O_WRONLY | O_CREAT)) exit(eDupStderrFailed); // Execute. We should never return. execve(argv[0], const_cast(argv), const_cast(envp)); exit(eExecFailed); } // Wait for the child process to to trap on its call to execve. pid_t wpid; int status; if ((wpid = waitpid(pid, &status, 0)) < 0) { args->m_error.SetErrorToErrno(); goto FINISH; } else if (WIFEXITED(status)) { // open, dup or execve likely failed for some reason. args->m_error.SetErrorToGenericError(); switch (WEXITSTATUS(status)) { case ePtraceFailed: args->m_error.SetErrorString("Child ptrace failed."); break; case eDupStdinFailed: args->m_error.SetErrorString("Child open stdin failed."); break; case eDupStdoutFailed: args->m_error.SetErrorString("Child open stdout failed."); break; case eDupStderrFailed: args->m_error.SetErrorString("Child open stderr failed."); break; case eExecFailed: args->m_error.SetErrorString("Child exec failed."); break; default: args->m_error.SetErrorString("Child returned unknown exit status."); break; } goto FINISH; } assert(WIFSTOPPED(status) && wpid == pid && "Could not sync with inferior process."); // Have the child raise an event on exit. This is used to keep the child in // limbo until it is destroyed. if (PTRACE(PTRACE_SETOPTIONS, pid, NULL, (void*)PTRACE_O_TRACEEXIT) < 0) { args->m_error.SetErrorToErrno(); goto FINISH; } // Release the master terminal descriptor and pass it off to the // ProcessMonitor instance. Similarly stash the inferior pid. monitor->m_terminal_fd = terminal.ReleaseMasterFileDescriptor(); monitor->m_pid = pid; // Set the terminal fd to be in non blocking mode (it simplifies the // implementation of ProcessLinux::GetSTDOUT to have a non-blocking // descriptor to read from). if (!EnsureFDFlags(monitor->m_terminal_fd, O_NONBLOCK, args->m_error)) goto FINISH; // Update the process thread list with this new thread and mark it as // current. // FIXME: should we be letting UpdateThreadList handle this? // FIXME: by using pids instead of tids, we can only support one thread. inferior.reset(new LinuxThread(process, pid)); if (log) log->Printf ("ProcessMonitor::%s() adding pid = %i", __FUNCTION__, pid); process.GetThreadList().AddThread(inferior); // Let our process instance know the thread has stopped. process.SendMessage(ProcessMessage::Trace(pid)); FINISH: return args->m_error.Success(); } bool ProcessMonitor::EnableIPC() { int fd[2]; if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd)) return false; m_client_fd = fd[0]; m_server_fd = fd[1]; return true; } void ProcessMonitor::StartAttachOpThread(AttachArgs *args, lldb_private::Error &error) { static const char *g_thread_name = "lldb.process.linux.operation"; if (IS_VALID_LLDB_HOST_THREAD(m_operation_thread)) return; m_operation_thread = Host::ThreadCreate(g_thread_name, AttachOpThread, args, &error); } void ProcessMonitor::StopAttachOpThread() { assert(!"Not implemented yet!!!"); } void * ProcessMonitor::AttachOpThread(void *arg) { AttachArgs *args = static_cast(arg); if (!Attach(args)) return NULL; ServeOperation(args); return NULL; } bool ProcessMonitor::Attach(AttachArgs *args) { lldb::pid_t pid = args->m_pid; ProcessMonitor *monitor = args->m_monitor; ProcessLinux &process = monitor->GetProcess(); lldb::ThreadSP inferior; LogSP log (ProcessLinuxLog::GetLogIfAllCategoriesSet (LINUX_LOG_PROCESS)); if (pid <= 1) { args->m_error.SetErrorToGenericError(); args->m_error.SetErrorString("Attaching to process 1 is not allowed."); goto FINISH; } // Attach to the requested process. if (PTRACE(PTRACE_ATTACH, pid, NULL, NULL) < 0) { args->m_error.SetErrorToErrno(); goto FINISH; } int status; if ((status = waitpid(pid, NULL, 0)) < 0) { args->m_error.SetErrorToErrno(); goto FINISH; } // Update the process thread list with the attached thread and // mark it as current. inferior.reset(new LinuxThread(process, pid)); if (log) log->Printf ("ProcessMonitor::%s() adding tid = %i", __FUNCTION__, pid); process.GetThreadList().AddThread(inferior); process.GetThreadList().SetSelectedThreadByID(pid); // Let our process instance know the thread has stopped. process.SendMessage(ProcessMessage::Trace(pid)); FINISH: return args->m_error.Success(); } bool ProcessMonitor::MonitorCallback(void *callback_baton, lldb::pid_t pid, int signal, int status) { ProcessMessage message; ProcessMonitor *monitor = static_cast(callback_baton); ProcessLinux *process = monitor->m_process; assert(process); bool stop_monitoring; siginfo_t info; if (!monitor->GetSignalInfo(pid, &info)) stop_monitoring = true; // pid is gone. Bail. else { switch (info.si_signo) { case SIGTRAP: message = MonitorSIGTRAP(monitor, &info, pid); break; default: message = MonitorSignal(monitor, &info, pid); break; } process->SendMessage(message); stop_monitoring = message.GetKind() == ProcessMessage::eExitMessage; } return stop_monitoring; } ProcessMessage ProcessMonitor::MonitorSIGTRAP(ProcessMonitor *monitor, const struct siginfo *info, lldb::pid_t pid) { ProcessMessage message; assert(monitor); assert(info && info->si_signo == SIGTRAP && "Unexpected child signal!"); switch (info->si_code) { default: assert(false && "Unexpected SIGTRAP code!"); break; case (SIGTRAP | (PTRACE_EVENT_EXIT << 8)): { // The inferior process is about to exit. Maintain the process in a // state of "limbo" until we are explicitly commanded to detach, // destroy, resume, etc. unsigned long data = 0; if (!monitor->GetEventMessage(pid, &data)) data = -1; message = ProcessMessage::Limbo(pid, (data >> 8)); break; } case 0: case TRAP_TRACE: message = ProcessMessage::Trace(pid); break; case SI_KERNEL: case TRAP_BRKPT: message = ProcessMessage::Break(pid); break; } return message; } ProcessMessage ProcessMonitor::MonitorSignal(ProcessMonitor *monitor, const struct siginfo *info, lldb::pid_t pid) { ProcessMessage message; int signo = info->si_signo; // POSIX says that process behaviour is undefined after it ignores a SIGFPE, // SIGILL, SIGSEGV, or SIGBUS *unless* that signal was generated by a // kill(2) or raise(3). Similarly for tgkill(2) on Linux. // // IOW, user generated signals never generate what we consider to be a // "crash". // // Similarly, ACK signals generated by this monitor. if (info->si_code == SI_TKILL || info->si_code == SI_USER) { if (info->si_pid == getpid()) return ProcessMessage::SignalDelivered(pid, signo); else return ProcessMessage::Signal(pid, signo); } if (signo == SIGSEGV) { lldb::addr_t fault_addr = reinterpret_cast(info->si_addr); ProcessMessage::CrashReason reason = GetCrashReasonForSIGSEGV(info); return ProcessMessage::Crash(pid, reason, signo, fault_addr); } if (signo == SIGILL) { lldb::addr_t fault_addr = reinterpret_cast(info->si_addr); ProcessMessage::CrashReason reason = GetCrashReasonForSIGILL(info); return ProcessMessage::Crash(pid, reason, signo, fault_addr); } if (signo == SIGFPE) { lldb::addr_t fault_addr = reinterpret_cast(info->si_addr); ProcessMessage::CrashReason reason = GetCrashReasonForSIGFPE(info); return ProcessMessage::Crash(pid, reason, signo, fault_addr); } if (signo == SIGBUS) { lldb::addr_t fault_addr = reinterpret_cast(info->si_addr); ProcessMessage::CrashReason reason = GetCrashReasonForSIGBUS(info); return ProcessMessage::Crash(pid, reason, signo, fault_addr); } // Everything else is "normal" and does not require any special action on // our part. return ProcessMessage::Signal(pid, signo); } ProcessMessage::CrashReason ProcessMonitor::GetCrashReasonForSIGSEGV(const struct siginfo *info) { ProcessMessage::CrashReason reason; assert(info->si_signo == SIGSEGV); reason = ProcessMessage::eInvalidCrashReason; switch (info->si_code) { default: assert(false && "unexpected si_code for SIGSEGV"); break; case SEGV_MAPERR: reason = ProcessMessage::eInvalidAddress; break; case SEGV_ACCERR: reason = ProcessMessage::ePrivilegedAddress; break; } return reason; } ProcessMessage::CrashReason ProcessMonitor::GetCrashReasonForSIGILL(const struct siginfo *info) { ProcessMessage::CrashReason reason; assert(info->si_signo == SIGILL); reason = ProcessMessage::eInvalidCrashReason; switch (info->si_code) { default: assert(false && "unexpected si_code for SIGILL"); break; case ILL_ILLOPC: reason = ProcessMessage::eIllegalOpcode; break; case ILL_ILLOPN: reason = ProcessMessage::eIllegalOperand; break; case ILL_ILLADR: reason = ProcessMessage::eIllegalAddressingMode; break; case ILL_ILLTRP: reason = ProcessMessage::eIllegalTrap; break; case ILL_PRVOPC: reason = ProcessMessage::ePrivilegedOpcode; break; case ILL_PRVREG: reason = ProcessMessage::ePrivilegedRegister; break; case ILL_COPROC: reason = ProcessMessage::eCoprocessorError; break; case ILL_BADSTK: reason = ProcessMessage::eInternalStackError; break; } return reason; } ProcessMessage::CrashReason ProcessMonitor::GetCrashReasonForSIGFPE(const struct siginfo *info) { ProcessMessage::CrashReason reason; assert(info->si_signo == SIGFPE); reason = ProcessMessage::eInvalidCrashReason; switch (info->si_code) { default: assert(false && "unexpected si_code for SIGFPE"); break; case FPE_INTDIV: reason = ProcessMessage::eIntegerDivideByZero; break; case FPE_INTOVF: reason = ProcessMessage::eIntegerOverflow; break; case FPE_FLTDIV: reason = ProcessMessage::eFloatDivideByZero; break; case FPE_FLTOVF: reason = ProcessMessage::eFloatOverflow; break; case FPE_FLTUND: reason = ProcessMessage::eFloatUnderflow; break; case FPE_FLTRES: reason = ProcessMessage::eFloatInexactResult; break; case FPE_FLTINV: reason = ProcessMessage::eFloatInvalidOperation; break; case FPE_FLTSUB: reason = ProcessMessage::eFloatSubscriptRange; break; } return reason; } ProcessMessage::CrashReason ProcessMonitor::GetCrashReasonForSIGBUS(const struct siginfo *info) { ProcessMessage::CrashReason reason; assert(info->si_signo == SIGBUS); reason = ProcessMessage::eInvalidCrashReason; switch (info->si_code) { default: assert(false && "unexpected si_code for SIGBUS"); break; case BUS_ADRALN: reason = ProcessMessage::eIllegalAlignment; break; case BUS_ADRERR: reason = ProcessMessage::eIllegalAddress; break; case BUS_OBJERR: reason = ProcessMessage::eHardwareError; break; } return reason; } void ProcessMonitor::ServeOperation(OperationArgs *args) { int status; pollfd fdset; ProcessMonitor *monitor = args->m_monitor; fdset.fd = monitor->m_server_fd; fdset.events = POLLIN | POLLPRI; fdset.revents = 0; // We are finised with the arguments and are ready to go. Sync with the // parent thread and start serving operations on the inferior. sem_post(&args->m_semaphore); for (;;) { if ((status = poll(&fdset, 1, -1)) < 0) { switch (errno) { default: assert(false && "Unexpected poll() failure!"); continue; case EINTR: continue; // Just poll again. case EBADF: return; // Connection terminated. } } assert(status == 1 && "Too many descriptors!"); if (fdset.revents & POLLIN) { Operation *op = NULL; READ_AGAIN: if ((status = read(fdset.fd, &op, sizeof(op))) < 0) { // There is only one acceptable failure. assert(errno == EINTR); goto READ_AGAIN; } assert(status == sizeof(op)); op->Execute(monitor); write(fdset.fd, &op, sizeof(op)); } } } void ProcessMonitor::DoOperation(Operation *op) { int status; Operation *ack = NULL; Mutex::Locker lock(m_server_mutex); // FIXME: Do proper error checking here. write(m_client_fd, &op, sizeof(op)); READ_AGAIN: if ((status = read(m_client_fd, &ack, sizeof(ack))) < 0) { // If interrupted by a signal handler try again. Otherwise the monitor // thread probably died and we have a stale file descriptor -- abort the // operation. if (errno == EINTR) goto READ_AGAIN; return; } assert(status == sizeof(ack)); assert(ack == op && "Invalid monitor thread response!"); } size_t ProcessMonitor::ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size, Error &error) { size_t result; ReadOperation op(vm_addr, buf, size, error, result); DoOperation(&op); return result; } size_t ProcessMonitor::WriteMemory(lldb::addr_t vm_addr, const void *buf, size_t size, lldb_private::Error &error) { size_t result; WriteOperation op(vm_addr, buf, size, error, result); DoOperation(&op); return result; } bool ProcessMonitor::ReadRegisterValue(unsigned offset, RegisterValue &value) { bool result; ReadRegOperation op(offset, value, result); DoOperation(&op); return result; } bool ProcessMonitor::WriteRegisterValue(unsigned offset, const RegisterValue &value) { bool result; WriteRegOperation op(offset, value, result); DoOperation(&op); return result; } bool ProcessMonitor::ReadGPR(void *buf) { bool result; ReadGPROperation op(buf, result); DoOperation(&op); return result; } bool ProcessMonitor::ReadFPR(void *buf) { bool result; ReadFPROperation op(buf, result); DoOperation(&op); return result; } bool ProcessMonitor::WriteGPR(void *buf) { bool result; WriteGPROperation op(buf, result); DoOperation(&op); return result; } bool ProcessMonitor::WriteFPR(void *buf) { bool result; WriteFPROperation op(buf, result); DoOperation(&op); return result; } bool ProcessMonitor::Resume(lldb::tid_t tid, uint32_t signo) { bool result; ResumeOperation op(tid, signo, result); DoOperation(&op); return result; } bool ProcessMonitor::SingleStep(lldb::tid_t tid, uint32_t signo) { bool result; SingleStepOperation op(tid, signo, result); DoOperation(&op); return result; } bool ProcessMonitor::BringProcessIntoLimbo() { bool result; KillOperation op(result); DoOperation(&op); return result; } bool ProcessMonitor::GetSignalInfo(lldb::tid_t tid, void *siginfo) { bool result; SiginfoOperation op(tid, siginfo, result); DoOperation(&op); return result; } bool ProcessMonitor::GetEventMessage(lldb::tid_t tid, unsigned long *message) { bool result; EventMessageOperation op(tid, message, result); DoOperation(&op); return result; } bool ProcessMonitor::Detach() { bool result; KillOperation op(result); DoOperation(&op); StopMonitor(); return result; } bool ProcessMonitor::DupDescriptor(const char *path, int fd, int flags) { int target_fd = open(path, flags, 0666); if (target_fd == -1) return false; return (dup2(target_fd, fd) == -1) ? false : true; } void ProcessMonitor::StopMonitoringChildProcess() { lldb::thread_result_t thread_result; if (IS_VALID_LLDB_HOST_THREAD(m_monitor_thread)) { Host::ThreadCancel(m_monitor_thread, NULL); Host::ThreadJoin(m_monitor_thread, &thread_result, NULL); m_monitor_thread = LLDB_INVALID_HOST_THREAD; } } void ProcessMonitor::StopMonitor() { StopMonitoringChildProcess(); StopLaunchOpThread(); CloseFD(m_terminal_fd); CloseFD(m_client_fd); CloseFD(m_server_fd); } void ProcessMonitor::CloseFD(int &fd) { if (fd != -1) { close(fd); fd = -1; } }