1 //===-- ProcessMonitor.cpp ------------------------------------ -*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
16 #include <sys/ptrace.h>
17 #include <sys/socket.h>
18 #include <sys/types.h>
23 // Other libraries and framework includes
24 #include "lldb/Core/Error.h"
25 #include "lldb/Core/RegisterValue.h"
26 #include "lldb/Core/Scalar.h"
27 #include "lldb/Host/Host.h"
28 #include "lldb/Host/ThreadLauncher.h"
29 #include "lldb/Target/RegisterContext.h"
30 #include "lldb/Target/Thread.h"
31 #include "lldb/Target/UnixSignals.h"
32 #include "lldb/Utility/PseudoTerminal.h"
34 #include "FreeBSDThread.h"
35 #include "Plugins/Process/POSIX/CrashReason.h"
36 #include "ProcessFreeBSD.h"
37 #include "ProcessMonitor.h"
38 #include "ProcessPOSIXLog.h"
41 extern char **environ;
45 using namespace lldb_private;
47 // We disable the tracing of ptrace calls for integration builds to
48 // avoid the additional indirection and checks.
49 #ifndef LLDB_CONFIGURATION_BUILDANDINTEGRATION
50 // Wrapper for ptrace to catch errors and log calls.
52 const char *Get_PT_IO_OP(int op) {
67 // Wrapper for ptrace to catch errors and log calls.
68 // Note that ptrace sets errno on error because -1 is reserved as a valid
70 extern long PtraceWrapper(int req, lldb::pid_t pid, void *addr, int data,
71 const char *reqName, const char *file, int line) {
74 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
77 log->Printf("ptrace(%s, %" PRIu64 ", %p, %x) called from file %s line %d",
78 reqName, pid, addr, data, file, line);
80 struct ptrace_io_desc *pi = (struct ptrace_io_desc *)addr;
82 log->Printf("PT_IO: op=%s offs=%zx size=%zu", Get_PT_IO_OP(pi->piod_op),
83 (size_t)pi->piod_offs, pi->piod_len);
87 // PtraceDisplayBytes(req, data);
90 result = ptrace(req, pid, (caddr_t)addr, data);
92 // PtraceDisplayBytes(req, data);
94 if (log && errno != 0) {
112 log->Printf("ptrace() failed; errno=%d (%s)", errno, str);
117 if (req == PT_GETREGS) {
118 struct reg *r = (struct reg *)addr;
120 log->Printf("PT_GETREGS: rip=0x%lx rsp=0x%lx rbp=0x%lx rax=0x%lx",
121 r->r_rip, r->r_rsp, r->r_rbp, r->r_rax);
123 if (req == PT_GETDBREGS || req == PT_SETDBREGS) {
124 struct dbreg *r = (struct dbreg *)addr;
125 char setget = (req == PT_GETDBREGS) ? 'G' : 'S';
127 for (int i = 0; i <= 7; i++)
128 log->Printf("PT_%cETDBREGS: dr[%d]=0x%lx", setget, i, r->dr[i]);
136 // Wrapper for ptrace when logging is not required.
137 // Sets errno to 0 prior to calling ptrace.
138 extern long PtraceWrapper(int req, lldb::pid_t pid, void *addr, int data) {
141 result = ptrace(req, pid, (caddr_t)addr, data);
145 #define PTRACE(req, pid, addr, data) \
146 PtraceWrapper((req), (pid), (addr), (data), #req, __FILE__, __LINE__)
148 PtraceWrapper((req), (pid), (addr), (data))
151 //------------------------------------------------------------------------------
152 // Static implementations of ProcessMonitor::ReadMemory and
153 // ProcessMonitor::WriteMemory. This enables mutual recursion between these
154 // functions without needed to go thru the thread funnel.
156 static size_t DoReadMemory(lldb::pid_t pid, lldb::addr_t vm_addr, void *buf,
157 size_t size, Error &error) {
158 struct ptrace_io_desc pi_desc;
160 pi_desc.piod_op = PIOD_READ_D;
161 pi_desc.piod_offs = (void *)vm_addr;
162 pi_desc.piod_addr = buf;
163 pi_desc.piod_len = size;
165 if (PTRACE(PT_IO, pid, (caddr_t)&pi_desc, 0) < 0)
166 error.SetErrorToErrno();
167 return pi_desc.piod_len;
170 static size_t DoWriteMemory(lldb::pid_t pid, lldb::addr_t vm_addr,
171 const void *buf, size_t size, Error &error) {
172 struct ptrace_io_desc pi_desc;
174 pi_desc.piod_op = PIOD_WRITE_D;
175 pi_desc.piod_offs = (void *)vm_addr;
176 pi_desc.piod_addr = (void *)buf;
177 pi_desc.piod_len = size;
179 if (PTRACE(PT_IO, pid, (caddr_t)&pi_desc, 0) < 0)
180 error.SetErrorToErrno();
181 return pi_desc.piod_len;
184 // Simple helper function to ensure flags are enabled on the given file
186 static bool EnsureFDFlags(int fd, int flags, Error &error) {
189 if ((status = fcntl(fd, F_GETFL)) == -1) {
190 error.SetErrorToErrno();
194 if (fcntl(fd, F_SETFL, status | flags) == -1) {
195 error.SetErrorToErrno();
202 //------------------------------------------------------------------------------
204 /// @brief Represents a ProcessMonitor operation.
206 /// Under FreeBSD, it is not possible to ptrace() from any other thread but the
207 /// one that spawned or attached to the process from the start. Therefore, when
208 /// a ProcessMonitor is asked to deliver or change the state of an inferior
209 /// process the operation must be "funneled" to a specific thread to perform the
210 /// task. The Operation class provides an abstract base for all services the
211 /// ProcessMonitor must perform via the single virtual function Execute, thus
212 /// encapsulating the code that needs to run in the privileged context.
215 virtual ~Operation() {}
216 virtual void Execute(ProcessMonitor *monitor) = 0;
219 //------------------------------------------------------------------------------
220 /// @class ReadOperation
221 /// @brief Implements ProcessMonitor::ReadMemory.
222 class ReadOperation : public Operation {
224 ReadOperation(lldb::addr_t addr, void *buff, size_t size, Error &error,
226 : m_addr(addr), m_buff(buff), m_size(size), m_error(error),
229 void Execute(ProcessMonitor *monitor);
239 void ReadOperation::Execute(ProcessMonitor *monitor) {
240 lldb::pid_t pid = monitor->GetPID();
242 m_result = DoReadMemory(pid, m_addr, m_buff, m_size, m_error);
245 //------------------------------------------------------------------------------
246 /// @class WriteOperation
247 /// @brief Implements ProcessMonitor::WriteMemory.
248 class WriteOperation : public Operation {
250 WriteOperation(lldb::addr_t addr, const void *buff, size_t size, Error &error,
252 : m_addr(addr), m_buff(buff), m_size(size), m_error(error),
255 void Execute(ProcessMonitor *monitor);
265 void WriteOperation::Execute(ProcessMonitor *monitor) {
266 lldb::pid_t pid = monitor->GetPID();
268 m_result = DoWriteMemory(pid, m_addr, m_buff, m_size, m_error);
271 //------------------------------------------------------------------------------
272 /// @class ReadRegOperation
273 /// @brief Implements ProcessMonitor::ReadRegisterValue.
274 class ReadRegOperation : public Operation {
276 ReadRegOperation(lldb::tid_t tid, unsigned offset, unsigned size,
277 RegisterValue &value, bool &result)
278 : m_tid(tid), m_offset(offset), m_size(size), m_value(value),
281 void Execute(ProcessMonitor *monitor);
287 RegisterValue &m_value;
291 void ReadRegOperation::Execute(ProcessMonitor *monitor) {
295 if ((rc = PTRACE(PT_GETREGS, m_tid, (caddr_t)®s, 0)) < 0) {
298 // 'struct reg' contains only 32- or 64-bit register values. Punt on
299 // others. Also, not all entries may be uintptr_t sized, such as 32-bit
300 // processes on powerpc64 (probably the same for i386 on amd64)
301 if (m_size == sizeof(uint32_t))
302 m_value = *(uint32_t *)(((caddr_t)®s) + m_offset);
303 else if (m_size == sizeof(uint64_t))
304 m_value = *(uint64_t *)(((caddr_t)®s) + m_offset);
306 memcpy((void *)&m_value, (((caddr_t)®s) + m_offset), m_size);
311 //------------------------------------------------------------------------------
312 /// @class WriteRegOperation
313 /// @brief Implements ProcessMonitor::WriteRegisterValue.
314 class WriteRegOperation : public Operation {
316 WriteRegOperation(lldb::tid_t tid, unsigned offset,
317 const RegisterValue &value, bool &result)
318 : m_tid(tid), m_offset(offset), m_value(value), m_result(result) {}
320 void Execute(ProcessMonitor *monitor);
325 const RegisterValue &m_value;
329 void WriteRegOperation::Execute(ProcessMonitor *monitor) {
332 if (PTRACE(PT_GETREGS, m_tid, (caddr_t)®s, 0) < 0) {
336 *(uintptr_t *)(((caddr_t)®s) + m_offset) =
337 (uintptr_t)m_value.GetAsUInt64();
338 if (PTRACE(PT_SETREGS, m_tid, (caddr_t)®s, 0) < 0)
344 //------------------------------------------------------------------------------
345 /// @class ReadDebugRegOperation
346 /// @brief Implements ProcessMonitor::ReadDebugRegisterValue.
347 class ReadDebugRegOperation : public Operation {
349 ReadDebugRegOperation(lldb::tid_t tid, unsigned offset, unsigned size,
350 RegisterValue &value, bool &result)
351 : m_tid(tid), m_offset(offset), m_size(size), m_value(value),
354 void Execute(ProcessMonitor *monitor);
360 RegisterValue &m_value;
364 void ReadDebugRegOperation::Execute(ProcessMonitor *monitor) {
368 if ((rc = PTRACE(PT_GETDBREGS, m_tid, (caddr_t)®s, 0)) < 0) {
371 if (m_size == sizeof(uintptr_t))
372 m_value = *(uintptr_t *)(((caddr_t)®s) + m_offset);
374 memcpy((void *)&m_value, (((caddr_t)®s) + m_offset), m_size);
379 //------------------------------------------------------------------------------
380 /// @class WriteDebugRegOperation
381 /// @brief Implements ProcessMonitor::WriteDebugRegisterValue.
382 class WriteDebugRegOperation : public Operation {
384 WriteDebugRegOperation(lldb::tid_t tid, unsigned offset,
385 const RegisterValue &value, bool &result)
386 : m_tid(tid), m_offset(offset), m_value(value), m_result(result) {}
388 void Execute(ProcessMonitor *monitor);
393 const RegisterValue &m_value;
397 void WriteDebugRegOperation::Execute(ProcessMonitor *monitor) {
400 if (PTRACE(PT_GETDBREGS, m_tid, (caddr_t)®s, 0) < 0) {
404 *(uintptr_t *)(((caddr_t)®s) + m_offset) =
405 (uintptr_t)m_value.GetAsUInt64();
406 if (PTRACE(PT_SETDBREGS, m_tid, (caddr_t)®s, 0) < 0)
412 //------------------------------------------------------------------------------
413 /// @class ReadGPROperation
414 /// @brief Implements ProcessMonitor::ReadGPR.
415 class ReadGPROperation : public Operation {
417 ReadGPROperation(lldb::tid_t tid, void *buf, bool &result)
418 : m_tid(tid), m_buf(buf), m_result(result) {}
420 void Execute(ProcessMonitor *monitor);
428 void ReadGPROperation::Execute(ProcessMonitor *monitor) {
432 rc = PTRACE(PT_GETREGS, m_tid, (caddr_t)m_buf, 0);
439 //------------------------------------------------------------------------------
440 /// @class ReadFPROperation
441 /// @brief Implements ProcessMonitor::ReadFPR.
442 class ReadFPROperation : public Operation {
444 ReadFPROperation(lldb::tid_t tid, void *buf, bool &result)
445 : m_tid(tid), m_buf(buf), m_result(result) {}
447 void Execute(ProcessMonitor *monitor);
455 void ReadFPROperation::Execute(ProcessMonitor *monitor) {
456 if (PTRACE(PT_GETFPREGS, m_tid, (caddr_t)m_buf, 0) < 0)
462 //------------------------------------------------------------------------------
463 /// @class WriteGPROperation
464 /// @brief Implements ProcessMonitor::WriteGPR.
465 class WriteGPROperation : public Operation {
467 WriteGPROperation(lldb::tid_t tid, void *buf, bool &result)
468 : m_tid(tid), m_buf(buf), m_result(result) {}
470 void Execute(ProcessMonitor *monitor);
478 void WriteGPROperation::Execute(ProcessMonitor *monitor) {
479 if (PTRACE(PT_SETREGS, m_tid, (caddr_t)m_buf, 0) < 0)
485 //------------------------------------------------------------------------------
486 /// @class WriteFPROperation
487 /// @brief Implements ProcessMonitor::WriteFPR.
488 class WriteFPROperation : public Operation {
490 WriteFPROperation(lldb::tid_t tid, void *buf, bool &result)
491 : m_tid(tid), m_buf(buf), m_result(result) {}
493 void Execute(ProcessMonitor *monitor);
501 void WriteFPROperation::Execute(ProcessMonitor *monitor) {
502 if (PTRACE(PT_SETFPREGS, m_tid, (caddr_t)m_buf, 0) < 0)
508 //------------------------------------------------------------------------------
509 /// @class ResumeOperation
510 /// @brief Implements ProcessMonitor::Resume.
511 class ResumeOperation : public Operation {
513 ResumeOperation(uint32_t signo, bool &result)
514 : m_signo(signo), m_result(result) {}
516 void Execute(ProcessMonitor *monitor);
523 void ResumeOperation::Execute(ProcessMonitor *monitor) {
524 lldb::pid_t pid = monitor->GetPID();
527 if (m_signo != LLDB_INVALID_SIGNAL_NUMBER)
530 if (PTRACE(PT_CONTINUE, pid, (caddr_t)1, data)) {
531 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
534 log->Printf("ResumeOperation (%" PRIu64 ") failed: %s", pid,
541 //------------------------------------------------------------------------------
542 /// @class SingleStepOperation
543 /// @brief Implements ProcessMonitor::SingleStep.
544 class SingleStepOperation : public Operation {
546 SingleStepOperation(uint32_t signo, bool &result)
547 : m_signo(signo), m_result(result) {}
549 void Execute(ProcessMonitor *monitor);
556 void SingleStepOperation::Execute(ProcessMonitor *monitor) {
557 lldb::pid_t pid = monitor->GetPID();
560 if (m_signo != LLDB_INVALID_SIGNAL_NUMBER)
563 if (PTRACE(PT_STEP, pid, NULL, data))
569 //------------------------------------------------------------------------------
570 /// @class LwpInfoOperation
571 /// @brief Implements ProcessMonitor::GetLwpInfo.
572 class LwpInfoOperation : public Operation {
574 LwpInfoOperation(lldb::tid_t tid, void *info, bool &result, int &ptrace_err)
575 : m_tid(tid), m_info(info), m_result(result), m_err(ptrace_err) {}
577 void Execute(ProcessMonitor *monitor);
586 void LwpInfoOperation::Execute(ProcessMonitor *monitor) {
587 struct ptrace_lwpinfo plwp;
589 if (PTRACE(PT_LWPINFO, m_tid, (caddr_t)&plwp, sizeof(plwp))) {
593 memcpy(m_info, &plwp, sizeof(plwp));
598 //------------------------------------------------------------------------------
599 /// @class ThreadSuspendOperation
600 /// @brief Implements ProcessMonitor::ThreadSuspend.
601 class ThreadSuspendOperation : public Operation {
603 ThreadSuspendOperation(lldb::tid_t tid, bool suspend, bool &result)
604 : m_tid(tid), m_suspend(suspend), m_result(result) {}
606 void Execute(ProcessMonitor *monitor);
614 void ThreadSuspendOperation::Execute(ProcessMonitor *monitor) {
615 m_result = !PTRACE(m_suspend ? PT_SUSPEND : PT_RESUME, m_tid, NULL, 0);
618 //------------------------------------------------------------------------------
619 /// @class EventMessageOperation
620 /// @brief Implements ProcessMonitor::GetEventMessage.
621 class EventMessageOperation : public Operation {
623 EventMessageOperation(lldb::tid_t tid, unsigned long *message, bool &result)
624 : m_tid(tid), m_message(message), m_result(result) {}
626 void Execute(ProcessMonitor *monitor);
630 unsigned long *m_message;
634 void EventMessageOperation::Execute(ProcessMonitor *monitor) {
635 struct ptrace_lwpinfo plwp;
637 if (PTRACE(PT_LWPINFO, m_tid, (caddr_t)&plwp, sizeof(plwp)))
640 if (plwp.pl_flags & PL_FLAG_FORKED) {
641 *m_message = plwp.pl_child_pid;
648 //------------------------------------------------------------------------------
649 /// @class KillOperation
650 /// @brief Implements ProcessMonitor::Kill.
651 class KillOperation : public Operation {
653 KillOperation(bool &result) : m_result(result) {}
655 void Execute(ProcessMonitor *monitor);
661 void KillOperation::Execute(ProcessMonitor *monitor) {
662 lldb::pid_t pid = monitor->GetPID();
664 if (PTRACE(PT_KILL, pid, NULL, 0))
670 //------------------------------------------------------------------------------
671 /// @class DetachOperation
672 /// @brief Implements ProcessMonitor::Detach.
673 class DetachOperation : public Operation {
675 DetachOperation(Error &result) : m_error(result) {}
677 void Execute(ProcessMonitor *monitor);
683 void DetachOperation::Execute(ProcessMonitor *monitor) {
684 lldb::pid_t pid = monitor->GetPID();
686 if (PTRACE(PT_DETACH, pid, NULL, 0) < 0)
687 m_error.SetErrorToErrno();
690 ProcessMonitor::OperationArgs::OperationArgs(ProcessMonitor *monitor)
691 : m_monitor(monitor) {
692 sem_init(&m_semaphore, 0, 0);
695 ProcessMonitor::OperationArgs::~OperationArgs() { sem_destroy(&m_semaphore); }
697 ProcessMonitor::LaunchArgs::LaunchArgs(ProcessMonitor *monitor,
698 lldb_private::Module *module,
699 char const **argv, char const **envp,
700 const FileSpec &stdin_file_spec,
701 const FileSpec &stdout_file_spec,
702 const FileSpec &stderr_file_spec,
703 const FileSpec &working_dir)
704 : OperationArgs(monitor), m_module(module), m_argv(argv), m_envp(envp),
705 m_stdin_file_spec(stdin_file_spec), m_stdout_file_spec(stdout_file_spec),
706 m_stderr_file_spec(stderr_file_spec), m_working_dir(working_dir) {}
708 ProcessMonitor::LaunchArgs::~LaunchArgs() {}
710 ProcessMonitor::AttachArgs::AttachArgs(ProcessMonitor *monitor, lldb::pid_t pid)
711 : OperationArgs(monitor), m_pid(pid) {}
713 ProcessMonitor::AttachArgs::~AttachArgs() {}
715 //------------------------------------------------------------------------------
716 /// The basic design of the ProcessMonitor is built around two threads.
718 /// One thread (@see SignalThread) simply blocks on a call to waitpid() looking
719 /// for changes in the debugee state. When a change is detected a
720 /// ProcessMessage is sent to the associated ProcessFreeBSD instance. This
722 /// "drives" state changes in the debugger.
724 /// The second thread (@see OperationThread) is responsible for two things 1)
725 /// launching or attaching to the inferior process, and then 2) servicing
726 /// operations such as register reads/writes, stepping, etc. See the comments
727 /// on the Operation class for more info as to why this is needed.
728 ProcessMonitor::ProcessMonitor(
729 ProcessFreeBSD *process, Module *module, const char *argv[],
730 const char *envp[], const FileSpec &stdin_file_spec,
731 const FileSpec &stdout_file_spec, const FileSpec &stderr_file_spec,
732 const FileSpec &working_dir,
733 const lldb_private::ProcessLaunchInfo & /* launch_info */,
734 lldb_private::Error &error)
735 : m_process(static_cast<ProcessFreeBSD *>(process)),
736 m_pid(LLDB_INVALID_PROCESS_ID), m_terminal_fd(-1), m_operation(0) {
737 using namespace std::placeholders;
739 std::unique_ptr<LaunchArgs> args(
740 new LaunchArgs(this, module, argv, envp, stdin_file_spec,
741 stdout_file_spec, stderr_file_spec, working_dir));
743 sem_init(&m_operation_pending, 0, 0);
744 sem_init(&m_operation_done, 0, 0);
746 StartLaunchOpThread(args.get(), error);
747 if (!error.Success())
751 // Wait for the operation thread to initialize.
752 if (sem_wait(&args->m_semaphore)) {
756 error.SetErrorToErrno();
761 // Check that the launch was a success.
762 if (!args->m_error.Success()) {
764 error = args->m_error;
768 // Finally, start monitoring the child process for change in state.
769 m_monitor_thread = Host::StartMonitoringChildProcess(
770 std::bind(&ProcessMonitor::MonitorCallback, this, _1, _2, _3, _4),
772 if (!m_monitor_thread.IsJoinable()) {
773 error.SetErrorToGenericError();
774 error.SetErrorString("Process launch failed.");
779 ProcessMonitor::ProcessMonitor(ProcessFreeBSD *process, lldb::pid_t pid,
780 lldb_private::Error &error)
781 : m_process(static_cast<ProcessFreeBSD *>(process)), m_pid(pid),
782 m_terminal_fd(-1), m_operation(0) {
783 using namespace std::placeholders;
785 sem_init(&m_operation_pending, 0, 0);
786 sem_init(&m_operation_done, 0, 0);
788 std::unique_ptr<AttachArgs> args(new AttachArgs(this, pid));
790 StartAttachOpThread(args.get(), error);
791 if (!error.Success())
795 // Wait for the operation thread to initialize.
796 if (sem_wait(&args->m_semaphore)) {
800 error.SetErrorToErrno();
805 // Check that the attach was a success.
806 if (!args->m_error.Success()) {
808 error = args->m_error;
812 // Finally, start monitoring the child process for change in state.
813 m_monitor_thread = Host::StartMonitoringChildProcess(
814 std::bind(&ProcessMonitor::MonitorCallback, this, _1, _2, _3, _4),
816 if (!m_monitor_thread.IsJoinable()) {
817 error.SetErrorToGenericError();
818 error.SetErrorString("Process attach failed.");
823 ProcessMonitor::~ProcessMonitor() { StopMonitor(); }
825 //------------------------------------------------------------------------------
826 // Thread setup and tear down.
827 void ProcessMonitor::StartLaunchOpThread(LaunchArgs *args, Error &error) {
828 static const char *g_thread_name = "lldb.process.freebsd.operation";
830 if (m_operation_thread.IsJoinable())
834 ThreadLauncher::LaunchThread(g_thread_name, LaunchOpThread, args, &error);
837 void *ProcessMonitor::LaunchOpThread(void *arg) {
838 LaunchArgs *args = static_cast<LaunchArgs *>(arg);
841 sem_post(&args->m_semaphore);
845 ServeOperation(args);
849 bool ProcessMonitor::Launch(LaunchArgs *args) {
850 ProcessMonitor *monitor = args->m_monitor;
851 ProcessFreeBSD &process = monitor->GetProcess();
852 const char **argv = args->m_argv;
853 const char **envp = args->m_envp;
854 const FileSpec &stdin_file_spec = args->m_stdin_file_spec;
855 const FileSpec &stdout_file_spec = args->m_stdout_file_spec;
856 const FileSpec &stderr_file_spec = args->m_stderr_file_spec;
857 const FileSpec &working_dir = args->m_working_dir;
859 lldb_utility::PseudoTerminal terminal;
860 const size_t err_len = 1024;
861 char err_str[err_len];
864 // Propagate the environment if one is not supplied.
865 if (envp == NULL || envp[0] == NULL)
866 envp = const_cast<const char **>(environ);
868 if ((pid = terminal.Fork(err_str, err_len)) == -1) {
869 args->m_error.SetErrorToGenericError();
870 args->m_error.SetErrorString("Process fork failed.");
874 // Recognized child exit status codes.
887 // Trace this process.
888 if (PTRACE(PT_TRACE_ME, 0, NULL, 0) < 0)
891 // terminal has already dupped the tty descriptors to stdin/out/err.
892 // This closes original fd from which they were copied (and avoids
893 // leaking descriptors to the debugged process.
894 terminal.CloseSlaveFileDescriptor();
896 // Do not inherit setgid powers.
897 if (setgid(getgid()) != 0)
900 // Let us have our own process group.
903 // Dup file descriptors if needed.
905 // FIXME: If two or more of the paths are the same we needlessly open
906 // the same file multiple times.
908 if (!DupDescriptor(stdin_file_spec, STDIN_FILENO, O_RDONLY))
909 exit(eDupStdinFailed);
911 if (stdout_file_spec)
912 if (!DupDescriptor(stdout_file_spec, STDOUT_FILENO, O_WRONLY | O_CREAT))
913 exit(eDupStdoutFailed);
915 if (stderr_file_spec)
916 if (!DupDescriptor(stderr_file_spec, STDERR_FILENO, O_WRONLY | O_CREAT))
917 exit(eDupStderrFailed);
919 // Change working directory
920 if (working_dir && 0 != ::chdir(working_dir.GetCString()))
923 // Execute. We should never return.
924 execve(argv[0], const_cast<char *const *>(argv),
925 const_cast<char *const *>(envp));
929 // Wait for the child process to to trap on its call to execve.
932 if ((wpid = waitpid(pid, &status, 0)) < 0) {
933 args->m_error.SetErrorToErrno();
935 } else if (WIFEXITED(status)) {
936 // open, dup or execve likely failed for some reason.
937 args->m_error.SetErrorToGenericError();
938 switch (WEXITSTATUS(status)) {
940 args->m_error.SetErrorString("Child ptrace failed.");
942 case eDupStdinFailed:
943 args->m_error.SetErrorString("Child open stdin failed.");
945 case eDupStdoutFailed:
946 args->m_error.SetErrorString("Child open stdout failed.");
948 case eDupStderrFailed:
949 args->m_error.SetErrorString("Child open stderr failed.");
952 args->m_error.SetErrorString("Child failed to set working directory.");
955 args->m_error.SetErrorString("Child exec failed.");
958 args->m_error.SetErrorString("Child setgid failed.");
961 args->m_error.SetErrorString("Child returned unknown exit status.");
966 assert(WIFSTOPPED(status) && wpid == (::pid_t)pid &&
967 "Could not sync with inferior process.");
970 // Have the child raise an event on exit. This is used to keep the child in
971 // limbo until it is destroyed.
972 if (PTRACE(PTRACE_SETOPTIONS, pid, NULL, PTRACE_O_TRACEEXIT) < 0) {
973 args->m_error.SetErrorToErrno();
977 // Release the master terminal descriptor and pass it off to the
978 // ProcessMonitor instance. Similarly stash the inferior pid.
979 monitor->m_terminal_fd = terminal.ReleaseMasterFileDescriptor();
980 monitor->m_pid = pid;
982 // Set the terminal fd to be in non blocking mode (it simplifies the
983 // implementation of ProcessFreeBSD::GetSTDOUT to have a non-blocking
984 // descriptor to read from).
985 if (!EnsureFDFlags(monitor->m_terminal_fd, O_NONBLOCK, args->m_error))
988 process.SendMessage(ProcessMessage::Attach(pid));
991 return args->m_error.Success();
994 void ProcessMonitor::StartAttachOpThread(AttachArgs *args,
995 lldb_private::Error &error) {
996 static const char *g_thread_name = "lldb.process.freebsd.operation";
998 if (m_operation_thread.IsJoinable())
1001 m_operation_thread =
1002 ThreadLauncher::LaunchThread(g_thread_name, AttachOpThread, args, &error);
1005 void *ProcessMonitor::AttachOpThread(void *arg) {
1006 AttachArgs *args = static_cast<AttachArgs *>(arg);
1010 ServeOperation(args);
1014 void ProcessMonitor::Attach(AttachArgs *args) {
1015 lldb::pid_t pid = args->m_pid;
1017 ProcessMonitor *monitor = args->m_monitor;
1018 ProcessFreeBSD &process = monitor->GetProcess();
1021 args->m_error.SetErrorToGenericError();
1022 args->m_error.SetErrorString("Attaching to process 1 is not allowed.");
1026 // Attach to the requested process.
1027 if (PTRACE(PT_ATTACH, pid, NULL, 0) < 0) {
1028 args->m_error.SetErrorToErrno();
1033 if ((status = waitpid(pid, NULL, 0)) < 0) {
1034 args->m_error.SetErrorToErrno();
1038 process.SendMessage(ProcessMessage::Attach(pid));
1042 ProcessMonitor::GetCurrentThreadIDs(std::vector<lldb::tid_t> &thread_ids) {
1048 tdcnt = PTRACE(PT_GETNUMLWPS, m_pid, NULL, 0);
1051 tids = (lwpid_t *)malloc(tdcnt * sizeof(*tids));
1054 if (PTRACE(PT_GETLWPLIST, m_pid, (void *)tids, tdcnt) < 0) {
1058 thread_ids = std::vector<lldb::tid_t>(tids, tids + tdcnt);
1060 return thread_ids.size();
1063 bool ProcessMonitor::MonitorCallback(ProcessMonitor *monitor, lldb::pid_t pid,
1064 bool exited, int signal, int status) {
1065 ProcessMessage message;
1066 ProcessFreeBSD *process = monitor->m_process;
1068 bool stop_monitoring;
1069 struct ptrace_lwpinfo plwp;
1072 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
1076 log->Printf("ProcessMonitor::%s() got exit signal, tid = %" PRIu64,
1078 message = ProcessMessage::Exit(pid, status);
1079 process->SendMessage(message);
1080 return pid == process->GetID();
1083 if (!monitor->GetLwpInfo(pid, &plwp, ptrace_err))
1084 stop_monitoring = true; // pid is gone. Bail.
1086 switch (plwp.pl_siginfo.si_signo) {
1088 message = MonitorSIGTRAP(monitor, &plwp.pl_siginfo, plwp.pl_lwpid);
1092 message = MonitorSignal(monitor, &plwp.pl_siginfo, plwp.pl_lwpid);
1096 process->SendMessage(message);
1097 stop_monitoring = message.GetKind() == ProcessMessage::eExitMessage;
1100 return stop_monitoring;
1103 ProcessMessage ProcessMonitor::MonitorSIGTRAP(ProcessMonitor *monitor,
1104 const siginfo_t *info,
1106 ProcessMessage message;
1108 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
1111 assert(info && info->si_signo == SIGTRAP && "Unexpected child signal!");
1113 switch (info->si_code) {
1115 assert(false && "Unexpected SIGTRAP code!");
1118 case (SIGTRAP /* | (PTRACE_EVENT_EXIT << 8) */): {
1119 // The inferior process is about to exit. Maintain the process in a
1120 // state of "limbo" until we are explicitly commanded to detach,
1121 // destroy, resume, etc.
1122 unsigned long data = 0;
1123 if (!monitor->GetEventMessage(tid, &data))
1126 log->Printf("ProcessMonitor::%s() received exit? event, data = %lx, tid "
1128 __FUNCTION__, data, tid);
1129 message = ProcessMessage::Limbo(tid, (data >> 8));
1136 log->Printf("ProcessMonitor::%s() received trace event, tid = %" PRIu64
1138 __FUNCTION__, tid, info->si_code);
1139 message = ProcessMessage::Trace(tid);
1146 "ProcessMonitor::%s() received breakpoint event, tid = %" PRIu64,
1148 message = ProcessMessage::Break(tid);
1155 ProcessMessage ProcessMonitor::MonitorSignal(ProcessMonitor *monitor,
1156 const siginfo_t *info,
1158 ProcessMessage message;
1159 int signo = info->si_signo;
1161 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
1163 // POSIX says that process behaviour is undefined after it ignores a SIGFPE,
1164 // SIGILL, SIGSEGV, or SIGBUS *unless* that signal was generated by a
1165 // kill(2) or raise(3). Similarly for tgkill(2) on FreeBSD.
1167 // IOW, user generated signals never generate what we consider to be a
1170 // Similarly, ACK signals generated by this monitor.
1171 if (info->si_code == SI_USER) {
1174 "ProcessMonitor::%s() received signal %s with code %s, pid = %d",
1176 monitor->m_process->GetUnixSignals()->GetSignalAsCString(signo),
1177 "SI_USER", info->si_pid);
1178 if (info->si_pid == getpid())
1179 return ProcessMessage::SignalDelivered(tid, signo);
1181 return ProcessMessage::Signal(tid, signo);
1186 "ProcessMonitor::%s() received signal %s", __FUNCTION__,
1187 monitor->m_process->GetUnixSignals()->GetSignalAsCString(signo));
1194 lldb::addr_t fault_addr = reinterpret_cast<lldb::addr_t>(info->si_addr);
1195 const auto reason = GetCrashReason(*info);
1196 return ProcessMessage::Crash(tid, reason, signo, fault_addr);
1199 // Everything else is "normal" and does not require any special action on
1201 return ProcessMessage::Signal(tid, signo);
1204 void ProcessMonitor::ServeOperation(OperationArgs *args) {
1205 ProcessMonitor *monitor = args->m_monitor;
1207 // We are finised with the arguments and are ready to go. Sync with the
1208 // parent thread and start serving operations on the inferior.
1209 sem_post(&args->m_semaphore);
1212 // wait for next pending operation
1213 sem_wait(&monitor->m_operation_pending);
1215 monitor->m_operation->Execute(monitor);
1217 // notify calling thread that operation is complete
1218 sem_post(&monitor->m_operation_done);
1222 void ProcessMonitor::DoOperation(Operation *op) {
1223 std::lock_guard<std::mutex> guard(m_operation_mutex);
1227 // notify operation thread that an operation is ready to be processed
1228 sem_post(&m_operation_pending);
1230 // wait for operation to complete
1231 sem_wait(&m_operation_done);
1234 size_t ProcessMonitor::ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
1237 ReadOperation op(vm_addr, buf, size, error, result);
1242 size_t ProcessMonitor::WriteMemory(lldb::addr_t vm_addr, const void *buf,
1243 size_t size, lldb_private::Error &error) {
1245 WriteOperation op(vm_addr, buf, size, error, result);
1250 bool ProcessMonitor::ReadRegisterValue(lldb::tid_t tid, unsigned offset,
1251 const char *reg_name, unsigned size,
1252 RegisterValue &value) {
1254 ReadRegOperation op(tid, offset, size, value, result);
1259 bool ProcessMonitor::WriteRegisterValue(lldb::tid_t tid, unsigned offset,
1260 const char *reg_name,
1261 const RegisterValue &value) {
1263 WriteRegOperation op(tid, offset, value, result);
1268 bool ProcessMonitor::ReadDebugRegisterValue(
1269 lldb::tid_t tid, unsigned offset, const char *reg_name, unsigned size,
1270 lldb_private::RegisterValue &value) {
1272 ReadDebugRegOperation op(tid, offset, size, value, result);
1277 bool ProcessMonitor::WriteDebugRegisterValue(
1278 lldb::tid_t tid, unsigned offset, const char *reg_name,
1279 const lldb_private::RegisterValue &value) {
1281 WriteDebugRegOperation op(tid, offset, value, result);
1286 bool ProcessMonitor::ReadGPR(lldb::tid_t tid, void *buf, size_t buf_size) {
1288 ReadGPROperation op(tid, buf, result);
1293 bool ProcessMonitor::ReadFPR(lldb::tid_t tid, void *buf, size_t buf_size) {
1295 ReadFPROperation op(tid, buf, result);
1300 bool ProcessMonitor::ReadRegisterSet(lldb::tid_t tid, void *buf,
1301 size_t buf_size, unsigned int regset) {
1305 bool ProcessMonitor::WriteGPR(lldb::tid_t tid, void *buf, size_t buf_size) {
1307 WriteGPROperation op(tid, buf, result);
1312 bool ProcessMonitor::WriteFPR(lldb::tid_t tid, void *buf, size_t buf_size) {
1314 WriteFPROperation op(tid, buf, result);
1319 bool ProcessMonitor::WriteRegisterSet(lldb::tid_t tid, void *buf,
1320 size_t buf_size, unsigned int regset) {
1324 bool ProcessMonitor::ReadThreadPointer(lldb::tid_t tid, lldb::addr_t &value) {
1328 bool ProcessMonitor::Resume(lldb::tid_t unused, uint32_t signo) {
1330 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
1333 const char *signame =
1334 m_process->GetUnixSignals()->GetSignalAsCString(signo);
1335 if (signame == nullptr)
1337 log->Printf("ProcessMonitor::%s() resuming pid %" PRIu64 " with signal %s",
1338 __FUNCTION__, GetPID(), signame);
1340 ResumeOperation op(signo, result);
1343 log->Printf("ProcessMonitor::%s() resuming result = %s", __FUNCTION__,
1344 result ? "true" : "false");
1348 bool ProcessMonitor::SingleStep(lldb::tid_t unused, uint32_t signo) {
1350 SingleStepOperation op(signo, result);
1355 bool ProcessMonitor::Kill() {
1357 KillOperation op(result);
1362 bool ProcessMonitor::GetLwpInfo(lldb::tid_t tid, void *lwpinfo,
1365 LwpInfoOperation op(tid, lwpinfo, result, ptrace_err);
1370 bool ProcessMonitor::ThreadSuspend(lldb::tid_t tid, bool suspend) {
1372 ThreadSuspendOperation op(tid, suspend, result);
1377 bool ProcessMonitor::GetEventMessage(lldb::tid_t tid, unsigned long *message) {
1379 EventMessageOperation op(tid, message, result);
1384 lldb_private::Error ProcessMonitor::Detach(lldb::tid_t tid) {
1385 lldb_private::Error error;
1386 if (tid != LLDB_INVALID_THREAD_ID) {
1387 DetachOperation op(error);
1393 bool ProcessMonitor::DupDescriptor(const FileSpec &file_spec, int fd,
1395 int target_fd = open(file_spec.GetCString(), flags, 0666);
1397 if (target_fd == -1)
1400 if (dup2(target_fd, fd) == -1)
1403 return (close(target_fd) == -1) ? false : true;
1406 void ProcessMonitor::StopMonitoringChildProcess() {
1407 if (m_monitor_thread.IsJoinable()) {
1408 m_monitor_thread.Cancel();
1409 m_monitor_thread.Join(nullptr);
1410 m_monitor_thread.Reset();
1414 void ProcessMonitor::StopMonitor() {
1415 StopMonitoringChildProcess();
1417 sem_destroy(&m_operation_pending);
1418 sem_destroy(&m_operation_done);
1419 if (m_terminal_fd >= 0) {
1420 close(m_terminal_fd);
1425 // FIXME: On Linux, when a new thread is created, we receive to notifications,
1426 // (1) a SIGTRAP|PTRACE_EVENT_CLONE from the main process thread with the
1427 // child thread id as additional information, and (2) a SIGSTOP|SI_USER from
1428 // the new child thread indicating that it has is stopped because we attached.
1429 // We have no guarantee of the order in which these arrive, but we need both
1430 // before we are ready to proceed. We currently keep a list of threads which
1431 // have sent the initial SIGSTOP|SI_USER event. Then when we receive the
1432 // SIGTRAP|PTRACE_EVENT_CLONE notification, if the initial stop has not occurred
1433 // we call ProcessMonitor::WaitForInitialTIDStop() to wait for it.
1435 // Right now, the above logic is in ProcessPOSIX, so we need a definition of
1436 // this function in the FreeBSD ProcessMonitor implementation even if it isn't
1437 // logically needed.
1439 // We really should figure out what actually happens on FreeBSD and move the
1440 // Linux-specific logic out of ProcessPOSIX as needed.
1442 bool ProcessMonitor::WaitForInitialTIDStop(lldb::tid_t tid) { return true; }
1444 void ProcessMonitor::StopOpThread() {
1445 if (!m_operation_thread.IsJoinable())
1448 m_operation_thread.Cancel();
1449 m_operation_thread.Join(nullptr);
1450 m_operation_thread.Reset();