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 //===----------------------------------------------------------------------===//
15 #include <sys/ptrace.h>
16 #include <sys/socket.h>
17 #include <sys/types.h>
21 #include "lldb/Host/Host.h"
22 #include "lldb/Host/PseudoTerminal.h"
23 #include "lldb/Host/ThreadLauncher.h"
24 #include "lldb/Target/RegisterContext.h"
25 #include "lldb/Target/Thread.h"
26 #include "lldb/Target/UnixSignals.h"
27 #include "lldb/Utility/RegisterValue.h"
28 #include "lldb/Utility/Scalar.h"
29 #include "lldb/Utility/Status.h"
30 #include "llvm/Support/Errno.h"
32 #include "FreeBSDThread.h"
33 #include "Plugins/Process/POSIX/CrashReason.h"
34 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
35 #include "ProcessFreeBSD.h"
36 #include "ProcessMonitor.h"
39 using namespace lldb_private;
41 // We disable the tracing of ptrace calls for integration builds to avoid the
42 // additional indirection and checks.
43 #ifndef LLDB_CONFIGURATION_BUILDANDINTEGRATION
44 // Wrapper for ptrace to catch errors and log calls.
46 const char *Get_PT_IO_OP(int op) {
61 // Wrapper for ptrace to catch errors and log calls. Note that ptrace sets
62 // errno on error because -1 is reserved as a valid result.
63 extern long PtraceWrapper(int req, lldb::pid_t pid, void *addr, int data,
64 const char *reqName, const char *file, int line) {
67 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
70 log->Printf("ptrace(%s, %" PRIu64 ", %p, %x) called from file %s line %d",
71 reqName, pid, addr, data, file, line);
73 struct ptrace_io_desc *pi = (struct ptrace_io_desc *)addr;
75 log->Printf("PT_IO: op=%s offs=%zx size=%zu", Get_PT_IO_OP(pi->piod_op),
76 (size_t)pi->piod_offs, pi->piod_len);
80 // PtraceDisplayBytes(req, data);
83 result = ptrace(req, pid, (caddr_t)addr, data);
85 // PtraceDisplayBytes(req, data);
87 if (log && errno != 0) {
105 log->Printf("ptrace() failed; errno=%d (%s)", errno, str);
110 if (req == PT_GETREGS) {
111 struct reg *r = (struct reg *)addr;
113 log->Printf("PT_GETREGS: rip=0x%lx rsp=0x%lx rbp=0x%lx rax=0x%lx",
114 r->r_rip, r->r_rsp, r->r_rbp, r->r_rax);
116 if (req == PT_GETDBREGS || req == PT_SETDBREGS) {
117 struct dbreg *r = (struct dbreg *)addr;
118 char setget = (req == PT_GETDBREGS) ? 'G' : 'S';
120 for (int i = 0; i <= 7; i++)
121 log->Printf("PT_%cETDBREGS: dr[%d]=0x%lx", setget, i, r->dr[i]);
129 // Wrapper for ptrace when logging is not required. Sets errno to 0 prior to
131 extern long PtraceWrapper(int req, lldb::pid_t pid, void *addr, int data) {
134 result = ptrace(req, pid, (caddr_t)addr, data);
138 #define PTRACE(req, pid, addr, data) \
139 PtraceWrapper((req), (pid), (addr), (data), #req, __FILE__, __LINE__)
141 PtraceWrapper((req), (pid), (addr), (data))
144 //------------------------------------------------------------------------------
145 // Static implementations of ProcessMonitor::ReadMemory and
146 // ProcessMonitor::WriteMemory. This enables mutual recursion between these
147 // functions without needed to go thru the thread funnel.
149 static size_t DoReadMemory(lldb::pid_t pid, lldb::addr_t vm_addr, void *buf,
150 size_t size, Status &error) {
151 struct ptrace_io_desc pi_desc;
153 pi_desc.piod_op = PIOD_READ_D;
154 pi_desc.piod_offs = (void *)vm_addr;
155 pi_desc.piod_addr = buf;
156 pi_desc.piod_len = size;
158 if (PTRACE(PT_IO, pid, (caddr_t)&pi_desc, 0) < 0) {
159 error.SetErrorToErrno();
162 return pi_desc.piod_len;
165 static size_t DoWriteMemory(lldb::pid_t pid, lldb::addr_t vm_addr,
166 const void *buf, size_t size, Status &error) {
167 struct ptrace_io_desc pi_desc;
169 pi_desc.piod_op = PIOD_WRITE_D;
170 pi_desc.piod_offs = (void *)vm_addr;
171 pi_desc.piod_addr = (void *)buf;
172 pi_desc.piod_len = size;
174 if (PTRACE(PT_IO, pid, (caddr_t)&pi_desc, 0) < 0) {
175 error.SetErrorToErrno();
178 return pi_desc.piod_len;
181 // Simple helper function to ensure flags are enabled on the given file
183 static bool EnsureFDFlags(int fd, int flags, Status &error) {
186 if ((status = fcntl(fd, F_GETFL)) == -1) {
187 error.SetErrorToErrno();
191 if (fcntl(fd, F_SETFL, status | flags) == -1) {
192 error.SetErrorToErrno();
199 //------------------------------------------------------------------------------
201 /// Represents a ProcessMonitor operation.
203 /// Under FreeBSD, it is not possible to ptrace() from any other thread but
204 /// the one that spawned or attached to the process from the start.
205 /// Therefore, when a ProcessMonitor is asked to deliver or change the state
206 /// of an inferior process the operation must be "funneled" to a specific
207 /// thread to perform the task. The Operation class provides an abstract base
208 /// for all services the ProcessMonitor must perform via the single virtual
209 /// function Execute, thus encapsulating the code that needs to run in the
210 /// privileged context.
213 virtual ~Operation() {}
214 virtual void Execute(ProcessMonitor *monitor) = 0;
217 //------------------------------------------------------------------------------
218 /// @class ReadOperation
219 /// Implements ProcessMonitor::ReadMemory.
220 class ReadOperation : public Operation {
222 ReadOperation(lldb::addr_t addr, void *buff, size_t size, Status &error,
224 : m_addr(addr), m_buff(buff), m_size(size), m_error(error),
227 void Execute(ProcessMonitor *monitor);
237 void ReadOperation::Execute(ProcessMonitor *monitor) {
238 lldb::pid_t pid = monitor->GetPID();
240 m_result = DoReadMemory(pid, m_addr, m_buff, m_size, m_error);
243 //------------------------------------------------------------------------------
244 /// @class WriteOperation
245 /// Implements ProcessMonitor::WriteMemory.
246 class WriteOperation : public Operation {
248 WriteOperation(lldb::addr_t addr, const void *buff, size_t size,
249 Status &error, size_t &result)
250 : m_addr(addr), m_buff(buff), m_size(size), m_error(error),
253 void Execute(ProcessMonitor *monitor);
263 void WriteOperation::Execute(ProcessMonitor *monitor) {
264 lldb::pid_t pid = monitor->GetPID();
266 m_result = DoWriteMemory(pid, m_addr, m_buff, m_size, m_error);
269 //------------------------------------------------------------------------------
270 /// @class ReadRegOperation
271 /// Implements ProcessMonitor::ReadRegisterValue.
272 class ReadRegOperation : public Operation {
274 ReadRegOperation(lldb::tid_t tid, unsigned offset, unsigned size,
275 RegisterValue &value, bool &result)
276 : m_tid(tid), m_offset(offset), m_size(size), m_value(value),
279 void Execute(ProcessMonitor *monitor);
285 RegisterValue &m_value;
289 void ReadRegOperation::Execute(ProcessMonitor *monitor) {
293 if ((rc = PTRACE(PT_GETREGS, m_tid, (caddr_t)®s, 0)) < 0) {
296 // 'struct reg' contains only 32- or 64-bit register values. Punt on
297 // others. Also, not all entries may be uintptr_t sized, such as 32-bit
298 // processes on powerpc64 (probably the same for i386 on amd64)
299 if (m_size == sizeof(uint32_t))
300 m_value = *(uint32_t *)(((caddr_t)®s) + m_offset);
301 else if (m_size == sizeof(uint64_t))
302 m_value = *(uint64_t *)(((caddr_t)®s) + m_offset);
304 memcpy((void *)&m_value, (((caddr_t)®s) + m_offset), m_size);
309 //------------------------------------------------------------------------------
310 /// @class WriteRegOperation
311 /// Implements ProcessMonitor::WriteRegisterValue.
312 class WriteRegOperation : public Operation {
314 WriteRegOperation(lldb::tid_t tid, unsigned offset,
315 const RegisterValue &value, bool &result)
316 : m_tid(tid), m_offset(offset), m_value(value), m_result(result) {}
318 void Execute(ProcessMonitor *monitor);
323 const RegisterValue &m_value;
327 void WriteRegOperation::Execute(ProcessMonitor *monitor) {
330 if (PTRACE(PT_GETREGS, m_tid, (caddr_t)®s, 0) < 0) {
334 *(uintptr_t *)(((caddr_t)®s) + m_offset) =
335 (uintptr_t)m_value.GetAsUInt64();
336 if (PTRACE(PT_SETREGS, m_tid, (caddr_t)®s, 0) < 0)
342 //------------------------------------------------------------------------------
343 /// @class ReadDebugRegOperation
344 /// Implements ProcessMonitor::ReadDebugRegisterValue.
345 class ReadDebugRegOperation : public Operation {
347 ReadDebugRegOperation(lldb::tid_t tid, unsigned offset, unsigned size,
348 RegisterValue &value, bool &result)
349 : m_tid(tid), m_offset(offset), m_size(size), m_value(value),
352 void Execute(ProcessMonitor *monitor);
358 RegisterValue &m_value;
362 void ReadDebugRegOperation::Execute(ProcessMonitor *monitor) {
366 if ((rc = PTRACE(PT_GETDBREGS, m_tid, (caddr_t)®s, 0)) < 0) {
369 if (m_size == sizeof(uintptr_t))
370 m_value = *(uintptr_t *)(((caddr_t)®s) + m_offset);
372 memcpy((void *)&m_value, (((caddr_t)®s) + m_offset), m_size);
377 //------------------------------------------------------------------------------
378 /// @class WriteDebugRegOperation
379 /// Implements ProcessMonitor::WriteDebugRegisterValue.
380 class WriteDebugRegOperation : public Operation {
382 WriteDebugRegOperation(lldb::tid_t tid, unsigned offset,
383 const RegisterValue &value, bool &result)
384 : m_tid(tid), m_offset(offset), m_value(value), m_result(result) {}
386 void Execute(ProcessMonitor *monitor);
391 const RegisterValue &m_value;
395 void WriteDebugRegOperation::Execute(ProcessMonitor *monitor) {
398 if (PTRACE(PT_GETDBREGS, m_tid, (caddr_t)®s, 0) < 0) {
402 *(uintptr_t *)(((caddr_t)®s) + m_offset) =
403 (uintptr_t)m_value.GetAsUInt64();
404 if (PTRACE(PT_SETDBREGS, m_tid, (caddr_t)®s, 0) < 0)
410 //------------------------------------------------------------------------------
411 /// @class ReadGPROperation
412 /// Implements ProcessMonitor::ReadGPR.
413 class ReadGPROperation : public Operation {
415 ReadGPROperation(lldb::tid_t tid, void *buf, bool &result)
416 : m_tid(tid), m_buf(buf), m_result(result) {}
418 void Execute(ProcessMonitor *monitor);
426 void ReadGPROperation::Execute(ProcessMonitor *monitor) {
430 rc = PTRACE(PT_GETREGS, m_tid, (caddr_t)m_buf, 0);
437 //------------------------------------------------------------------------------
438 /// @class ReadFPROperation
439 /// Implements ProcessMonitor::ReadFPR.
440 class ReadFPROperation : public Operation {
442 ReadFPROperation(lldb::tid_t tid, void *buf, bool &result)
443 : m_tid(tid), m_buf(buf), m_result(result) {}
445 void Execute(ProcessMonitor *monitor);
453 void ReadFPROperation::Execute(ProcessMonitor *monitor) {
454 if (PTRACE(PT_GETFPREGS, m_tid, (caddr_t)m_buf, 0) < 0)
460 //------------------------------------------------------------------------------
461 /// @class WriteGPROperation
462 /// Implements ProcessMonitor::WriteGPR.
463 class WriteGPROperation : public Operation {
465 WriteGPROperation(lldb::tid_t tid, void *buf, bool &result)
466 : m_tid(tid), m_buf(buf), m_result(result) {}
468 void Execute(ProcessMonitor *monitor);
476 void WriteGPROperation::Execute(ProcessMonitor *monitor) {
477 if (PTRACE(PT_SETREGS, m_tid, (caddr_t)m_buf, 0) < 0)
483 //------------------------------------------------------------------------------
484 /// @class WriteFPROperation
485 /// Implements ProcessMonitor::WriteFPR.
486 class WriteFPROperation : public Operation {
488 WriteFPROperation(lldb::tid_t tid, void *buf, bool &result)
489 : m_tid(tid), m_buf(buf), m_result(result) {}
491 void Execute(ProcessMonitor *monitor);
499 void WriteFPROperation::Execute(ProcessMonitor *monitor) {
500 if (PTRACE(PT_SETFPREGS, m_tid, (caddr_t)m_buf, 0) < 0)
506 //------------------------------------------------------------------------------
507 /// @class ResumeOperation
508 /// Implements ProcessMonitor::Resume.
509 class ResumeOperation : public Operation {
511 ResumeOperation(uint32_t signo, bool &result)
512 : m_signo(signo), m_result(result) {}
514 void Execute(ProcessMonitor *monitor);
521 void ResumeOperation::Execute(ProcessMonitor *monitor) {
522 lldb::pid_t pid = monitor->GetPID();
525 if (m_signo != LLDB_INVALID_SIGNAL_NUMBER)
528 if (PTRACE(PT_CONTINUE, pid, (caddr_t)1, data)) {
529 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
530 LLDB_LOG(log, "ResumeOperation ({0}) failed: {1}", pid,
531 llvm::sys::StrError(errno));
537 //------------------------------------------------------------------------------
538 /// @class SingleStepOperation
539 /// Implements ProcessMonitor::SingleStep.
540 class SingleStepOperation : public Operation {
542 SingleStepOperation(uint32_t signo, bool &result)
543 : m_signo(signo), m_result(result) {}
545 void Execute(ProcessMonitor *monitor);
552 void SingleStepOperation::Execute(ProcessMonitor *monitor) {
553 lldb::pid_t pid = monitor->GetPID();
556 if (m_signo != LLDB_INVALID_SIGNAL_NUMBER)
559 if (PTRACE(PT_STEP, pid, NULL, data))
565 //------------------------------------------------------------------------------
566 /// @class LwpInfoOperation
567 /// Implements ProcessMonitor::GetLwpInfo.
568 class LwpInfoOperation : public Operation {
570 LwpInfoOperation(lldb::tid_t tid, void *info, bool &result, int &ptrace_err)
571 : m_tid(tid), m_info(info), m_result(result), m_err(ptrace_err) {}
573 void Execute(ProcessMonitor *monitor);
582 void LwpInfoOperation::Execute(ProcessMonitor *monitor) {
583 struct ptrace_lwpinfo plwp;
585 if (PTRACE(PT_LWPINFO, m_tid, (caddr_t)&plwp, sizeof(plwp))) {
589 memcpy(m_info, &plwp, sizeof(plwp));
594 //------------------------------------------------------------------------------
595 /// @class ThreadSuspendOperation
596 /// Implements ProcessMonitor::ThreadSuspend.
597 class ThreadSuspendOperation : public Operation {
599 ThreadSuspendOperation(lldb::tid_t tid, bool suspend, bool &result)
600 : m_tid(tid), m_suspend(suspend), m_result(result) {}
602 void Execute(ProcessMonitor *monitor);
610 void ThreadSuspendOperation::Execute(ProcessMonitor *monitor) {
611 m_result = !PTRACE(m_suspend ? PT_SUSPEND : PT_RESUME, m_tid, NULL, 0);
614 //------------------------------------------------------------------------------
615 /// @class EventMessageOperation
616 /// Implements ProcessMonitor::GetEventMessage.
617 class EventMessageOperation : public Operation {
619 EventMessageOperation(lldb::tid_t tid, unsigned long *message, bool &result)
620 : m_tid(tid), m_message(message), m_result(result) {}
622 void Execute(ProcessMonitor *monitor);
626 unsigned long *m_message;
630 void EventMessageOperation::Execute(ProcessMonitor *monitor) {
631 struct ptrace_lwpinfo plwp;
633 if (PTRACE(PT_LWPINFO, m_tid, (caddr_t)&plwp, sizeof(plwp)))
636 if (plwp.pl_flags & PL_FLAG_FORKED) {
637 *m_message = plwp.pl_child_pid;
644 //------------------------------------------------------------------------------
645 /// @class KillOperation
646 /// Implements ProcessMonitor::Kill.
647 class KillOperation : public Operation {
649 KillOperation(bool &result) : m_result(result) {}
651 void Execute(ProcessMonitor *monitor);
657 void KillOperation::Execute(ProcessMonitor *monitor) {
658 lldb::pid_t pid = monitor->GetPID();
660 if (PTRACE(PT_KILL, pid, NULL, 0))
666 //------------------------------------------------------------------------------
667 /// @class DetachOperation
668 /// Implements ProcessMonitor::Detach.
669 class DetachOperation : public Operation {
671 DetachOperation(Status &result) : m_error(result) {}
673 void Execute(ProcessMonitor *monitor);
679 void DetachOperation::Execute(ProcessMonitor *monitor) {
680 lldb::pid_t pid = monitor->GetPID();
682 if (PTRACE(PT_DETACH, pid, NULL, 0) < 0)
683 m_error.SetErrorToErrno();
686 ProcessMonitor::OperationArgs::OperationArgs(ProcessMonitor *monitor)
687 : m_monitor(monitor) {
688 sem_init(&m_semaphore, 0, 0);
691 ProcessMonitor::OperationArgs::~OperationArgs() { sem_destroy(&m_semaphore); }
693 ProcessMonitor::LaunchArgs::LaunchArgs(ProcessMonitor *monitor,
694 lldb_private::Module *module,
695 char const **argv, Environment env,
696 const FileSpec &stdin_file_spec,
697 const FileSpec &stdout_file_spec,
698 const FileSpec &stderr_file_spec,
699 const FileSpec &working_dir)
700 : OperationArgs(monitor), m_module(module), m_argv(argv),
701 m_env(std::move(env)), m_stdin_file_spec(stdin_file_spec),
702 m_stdout_file_spec(stdout_file_spec),
703 m_stderr_file_spec(stderr_file_spec), m_working_dir(working_dir) {}
705 ProcessMonitor::LaunchArgs::~LaunchArgs() {}
707 ProcessMonitor::AttachArgs::AttachArgs(ProcessMonitor *monitor, lldb::pid_t pid)
708 : OperationArgs(monitor), m_pid(pid) {}
710 ProcessMonitor::AttachArgs::~AttachArgs() {}
712 //------------------------------------------------------------------------------
713 /// The basic design of the ProcessMonitor is built around two threads.
715 /// One thread (@see SignalThread) simply blocks on a call to waitpid()
716 /// looking for changes in the debugee state. When a change is detected a
717 /// ProcessMessage is sent to the associated ProcessFreeBSD instance. This
718 /// thread "drives" state changes in the debugger.
720 /// The second thread (@see OperationThread) is responsible for two things 1)
721 /// launching or attaching to the inferior process, and then 2) servicing
722 /// operations such as register reads/writes, stepping, etc. See the comments
723 /// on the Operation class for more info as to why this is needed.
724 ProcessMonitor::ProcessMonitor(
725 ProcessFreeBSD *process, Module *module, const char *argv[],
726 Environment env, const FileSpec &stdin_file_spec,
727 const FileSpec &stdout_file_spec, const FileSpec &stderr_file_spec,
728 const FileSpec &working_dir,
729 const lldb_private::ProcessLaunchInfo & /* launch_info */,
730 lldb_private::Status &error)
731 : m_process(static_cast<ProcessFreeBSD *>(process)),
732 m_pid(LLDB_INVALID_PROCESS_ID), m_terminal_fd(-1), m_operation(0) {
733 using namespace std::placeholders;
735 std::unique_ptr<LaunchArgs> args(
736 new LaunchArgs(this, module, argv, std::move(env), stdin_file_spec,
737 stdout_file_spec, stderr_file_spec, working_dir));
739 sem_init(&m_operation_pending, 0, 0);
740 sem_init(&m_operation_done, 0, 0);
742 StartLaunchOpThread(args.get(), error);
743 if (!error.Success())
746 if (llvm::sys::RetryAfterSignal(-1, sem_wait, &args->m_semaphore) == -1) {
747 error.SetErrorToErrno();
751 // Check that the launch was a success.
752 if (!args->m_error.Success()) {
754 error = args->m_error;
758 // Finally, start monitoring the child process for change in state.
759 m_monitor_thread = Host::StartMonitoringChildProcess(
760 std::bind(&ProcessMonitor::MonitorCallback, this, _1, _2, _3, _4),
762 if (!m_monitor_thread.IsJoinable()) {
763 error.SetErrorToGenericError();
764 error.SetErrorString("Process launch failed.");
769 ProcessMonitor::ProcessMonitor(ProcessFreeBSD *process, lldb::pid_t pid,
770 lldb_private::Status &error)
771 : m_process(static_cast<ProcessFreeBSD *>(process)), m_pid(pid),
772 m_terminal_fd(-1), m_operation(0) {
773 using namespace std::placeholders;
775 sem_init(&m_operation_pending, 0, 0);
776 sem_init(&m_operation_done, 0, 0);
778 std::unique_ptr<AttachArgs> args(new AttachArgs(this, pid));
780 StartAttachOpThread(args.get(), error);
781 if (!error.Success())
784 if (llvm::sys::RetryAfterSignal(-1, sem_wait, &args->m_semaphore) == -1) {
785 error.SetErrorToErrno();
789 // Check that the attach was a success.
790 if (!args->m_error.Success()) {
792 error = args->m_error;
796 // Finally, start monitoring the child process for change in state.
797 m_monitor_thread = Host::StartMonitoringChildProcess(
798 std::bind(&ProcessMonitor::MonitorCallback, this, _1, _2, _3, _4),
800 if (!m_monitor_thread.IsJoinable()) {
801 error.SetErrorToGenericError();
802 error.SetErrorString("Process attach failed.");
807 ProcessMonitor::~ProcessMonitor() { StopMonitor(); }
809 //------------------------------------------------------------------------------
810 // Thread setup and tear down.
811 void ProcessMonitor::StartLaunchOpThread(LaunchArgs *args, Status &error) {
812 static const char *g_thread_name = "lldb.process.freebsd.operation";
814 if (m_operation_thread.IsJoinable())
818 ThreadLauncher::LaunchThread(g_thread_name, LaunchOpThread, args, &error);
821 void *ProcessMonitor::LaunchOpThread(void *arg) {
822 LaunchArgs *args = static_cast<LaunchArgs *>(arg);
825 sem_post(&args->m_semaphore);
829 ServeOperation(args);
833 bool ProcessMonitor::Launch(LaunchArgs *args) {
834 ProcessMonitor *monitor = args->m_monitor;
835 ProcessFreeBSD &process = monitor->GetProcess();
836 const char **argv = args->m_argv;
837 const FileSpec &stdin_file_spec = args->m_stdin_file_spec;
838 const FileSpec &stdout_file_spec = args->m_stdout_file_spec;
839 const FileSpec &stderr_file_spec = args->m_stderr_file_spec;
840 const FileSpec &working_dir = args->m_working_dir;
842 PseudoTerminal terminal;
843 const size_t err_len = 1024;
844 char err_str[err_len];
847 // Propagate the environment if one is not supplied.
848 Environment::Envp envp =
849 (args->m_env.empty() ? Host::GetEnvironment() : args->m_env).getEnvp();
851 if ((pid = terminal.Fork(err_str, err_len)) == -1) {
852 args->m_error.SetErrorToGenericError();
853 args->m_error.SetErrorString("Process fork failed.");
857 // Recognized child exit status codes.
870 // Trace this process.
871 if (PTRACE(PT_TRACE_ME, 0, NULL, 0) < 0)
874 // terminal has already dupped the tty descriptors to stdin/out/err. This
875 // closes original fd from which they were copied (and avoids leaking
876 // descriptors to the debugged process.
877 terminal.CloseSlaveFileDescriptor();
879 // Do not inherit setgid powers.
880 if (setgid(getgid()) != 0)
883 // Let us have our own process group.
886 // Dup file descriptors if needed.
888 // FIXME: If two or more of the paths are the same we needlessly open
889 // the same file multiple times.
891 if (!DupDescriptor(stdin_file_spec, STDIN_FILENO, O_RDONLY))
892 exit(eDupStdinFailed);
894 if (stdout_file_spec)
895 if (!DupDescriptor(stdout_file_spec, STDOUT_FILENO, O_WRONLY | O_CREAT))
896 exit(eDupStdoutFailed);
898 if (stderr_file_spec)
899 if (!DupDescriptor(stderr_file_spec, STDERR_FILENO, O_WRONLY | O_CREAT))
900 exit(eDupStderrFailed);
902 // Change working directory
903 if (working_dir && 0 != ::chdir(working_dir.GetCString()))
906 // Execute. We should never return.
907 execve(argv[0], const_cast<char *const *>(argv), envp);
911 // Wait for the child process to to trap on its call to execve.
914 if ((wpid = waitpid(pid, &status, 0)) < 0) {
915 args->m_error.SetErrorToErrno();
917 } else if (WIFEXITED(status)) {
918 // open, dup or execve likely failed for some reason.
919 args->m_error.SetErrorToGenericError();
920 switch (WEXITSTATUS(status)) {
922 args->m_error.SetErrorString("Child ptrace failed.");
924 case eDupStdinFailed:
925 args->m_error.SetErrorString("Child open stdin failed.");
927 case eDupStdoutFailed:
928 args->m_error.SetErrorString("Child open stdout failed.");
930 case eDupStderrFailed:
931 args->m_error.SetErrorString("Child open stderr failed.");
934 args->m_error.SetErrorString("Child failed to set working directory.");
937 args->m_error.SetErrorString("Child exec failed.");
940 args->m_error.SetErrorString("Child setgid failed.");
943 args->m_error.SetErrorString("Child returned unknown exit status.");
948 assert(WIFSTOPPED(status) && wpid == (::pid_t)pid &&
949 "Could not sync with inferior process.");
952 // Have the child raise an event on exit. This is used to keep the child in
953 // limbo until it is destroyed.
954 if (PTRACE(PTRACE_SETOPTIONS, pid, NULL, PTRACE_O_TRACEEXIT) < 0) {
955 args->m_error.SetErrorToErrno();
959 // Release the master terminal descriptor and pass it off to the
960 // ProcessMonitor instance. Similarly stash the inferior pid.
961 monitor->m_terminal_fd = terminal.ReleaseMasterFileDescriptor();
962 monitor->m_pid = pid;
964 // Set the terminal fd to be in non blocking mode (it simplifies the
965 // implementation of ProcessFreeBSD::GetSTDOUT to have a non-blocking
966 // descriptor to read from).
967 if (!EnsureFDFlags(monitor->m_terminal_fd, O_NONBLOCK, args->m_error))
970 process.SendMessage(ProcessMessage::Attach(pid));
973 return args->m_error.Success();
976 void ProcessMonitor::StartAttachOpThread(AttachArgs *args,
977 lldb_private::Status &error) {
978 static const char *g_thread_name = "lldb.process.freebsd.operation";
980 if (m_operation_thread.IsJoinable())
984 ThreadLauncher::LaunchThread(g_thread_name, AttachOpThread, args, &error);
987 void *ProcessMonitor::AttachOpThread(void *arg) {
988 AttachArgs *args = static_cast<AttachArgs *>(arg);
992 ServeOperation(args);
996 void ProcessMonitor::Attach(AttachArgs *args) {
997 lldb::pid_t pid = args->m_pid;
999 ProcessMonitor *monitor = args->m_monitor;
1000 ProcessFreeBSD &process = monitor->GetProcess();
1003 args->m_error.SetErrorToGenericError();
1004 args->m_error.SetErrorString("Attaching to process 1 is not allowed.");
1008 // Attach to the requested process.
1009 if (PTRACE(PT_ATTACH, pid, NULL, 0) < 0) {
1010 args->m_error.SetErrorToErrno();
1015 if ((status = waitpid(pid, NULL, 0)) < 0) {
1016 args->m_error.SetErrorToErrno();
1020 process.SendMessage(ProcessMessage::Attach(pid));
1024 ProcessMonitor::GetCurrentThreadIDs(std::vector<lldb::tid_t> &thread_ids) {
1030 tdcnt = PTRACE(PT_GETNUMLWPS, m_pid, NULL, 0);
1033 tids = (lwpid_t *)malloc(tdcnt * sizeof(*tids));
1036 if (PTRACE(PT_GETLWPLIST, m_pid, (void *)tids, tdcnt) < 0) {
1040 thread_ids = std::vector<lldb::tid_t>(tids, tids + tdcnt);
1042 return thread_ids.size();
1045 bool ProcessMonitor::MonitorCallback(ProcessMonitor *monitor, lldb::pid_t pid,
1046 bool exited, int signal, int status) {
1047 ProcessMessage message;
1048 ProcessFreeBSD *process = monitor->m_process;
1050 bool stop_monitoring;
1051 struct ptrace_lwpinfo plwp;
1054 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
1058 log->Printf("ProcessMonitor::%s() got exit signal, tid = %" PRIu64,
1060 message = ProcessMessage::Exit(pid, status);
1061 process->SendMessage(message);
1062 return pid == process->GetID();
1065 if (!monitor->GetLwpInfo(pid, &plwp, ptrace_err))
1066 stop_monitoring = true; // pid is gone. Bail.
1068 switch (plwp.pl_siginfo.si_signo) {
1070 message = MonitorSIGTRAP(monitor, &plwp.pl_siginfo, plwp.pl_lwpid);
1074 message = MonitorSignal(monitor, &plwp.pl_siginfo, plwp.pl_lwpid);
1078 process->SendMessage(message);
1079 stop_monitoring = message.GetKind() == ProcessMessage::eExitMessage;
1082 return stop_monitoring;
1085 ProcessMessage ProcessMonitor::MonitorSIGTRAP(ProcessMonitor *monitor,
1086 const siginfo_t *info,
1088 ProcessMessage message;
1090 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
1093 assert(info && info->si_signo == SIGTRAP && "Unexpected child signal!");
1095 switch (info->si_code) {
1097 assert(false && "Unexpected SIGTRAP code!");
1100 case (SIGTRAP /* | (PTRACE_EVENT_EXIT << 8) */): {
1101 // The inferior process is about to exit. Maintain the process in a state
1102 // of "limbo" until we are explicitly commanded to detach, destroy, resume,
1104 unsigned long data = 0;
1105 if (!monitor->GetEventMessage(tid, &data))
1108 log->Printf("ProcessMonitor::%s() received exit? event, data = %lx, tid "
1110 __FUNCTION__, data, tid);
1111 message = ProcessMessage::Limbo(tid, (data >> 8));
1118 // Map TRAP_CAP to a trace trap in the absense of a more specific handler.
1122 log->Printf("ProcessMonitor::%s() received trace event, tid = %" PRIu64
1124 __FUNCTION__, tid, info->si_code);
1125 message = ProcessMessage::Trace(tid);
1130 if (monitor->m_process->IsSoftwareStepBreakpoint(tid)) {
1132 log->Printf("ProcessMonitor::%s() received sw single step breakpoint "
1133 "event, tid = %" PRIu64,
1135 message = ProcessMessage::Trace(tid);
1139 "ProcessMonitor::%s() received breakpoint event, tid = %" PRIu64,
1141 message = ProcessMessage::Break(tid);
1149 ProcessMessage ProcessMonitor::MonitorSignal(ProcessMonitor *monitor,
1150 const siginfo_t *info,
1152 ProcessMessage message;
1153 int signo = info->si_signo;
1155 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
1157 // POSIX says that process behaviour is undefined after it ignores a SIGFPE,
1158 // SIGILL, SIGSEGV, or SIGBUS *unless* that signal was generated by a kill(2)
1159 // or raise(3). Similarly for tgkill(2) on FreeBSD.
1161 // IOW, user generated signals never generate what we consider to be a
1164 // Similarly, ACK signals generated by this monitor.
1165 if (info->si_code == SI_USER) {
1168 "ProcessMonitor::%s() received signal %s with code %s, pid = %d",
1170 monitor->m_process->GetUnixSignals()->GetSignalAsCString(signo),
1171 "SI_USER", info->si_pid);
1172 if (info->si_pid == getpid())
1173 return ProcessMessage::SignalDelivered(tid, signo);
1175 return ProcessMessage::Signal(tid, signo);
1180 "ProcessMonitor::%s() received signal %s", __FUNCTION__,
1181 monitor->m_process->GetUnixSignals()->GetSignalAsCString(signo));
1188 lldb::addr_t fault_addr = reinterpret_cast<lldb::addr_t>(info->si_addr);
1189 const auto reason = GetCrashReason(*info);
1190 if (reason != CrashReason::eInvalidCrashReason) {
1191 return ProcessMessage::Crash(tid, reason, signo, fault_addr);
1192 } // else; Use atleast si_signo info for other si_code
1195 // Everything else is "normal" and does not require any special action on our
1197 return ProcessMessage::Signal(tid, signo);
1200 void ProcessMonitor::ServeOperation(OperationArgs *args) {
1201 ProcessMonitor *monitor = args->m_monitor;
1203 // We are finised with the arguments and are ready to go. Sync with the
1204 // parent thread and start serving operations on the inferior.
1205 sem_post(&args->m_semaphore);
1208 // wait for next pending operation
1209 sem_wait(&monitor->m_operation_pending);
1211 monitor->m_operation->Execute(monitor);
1213 // notify calling thread that operation is complete
1214 sem_post(&monitor->m_operation_done);
1218 void ProcessMonitor::DoOperation(Operation *op) {
1219 std::lock_guard<std::mutex> guard(m_operation_mutex);
1223 // notify operation thread that an operation is ready to be processed
1224 sem_post(&m_operation_pending);
1226 // wait for operation to complete
1227 sem_wait(&m_operation_done);
1230 size_t ProcessMonitor::ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
1233 ReadOperation op(vm_addr, buf, size, error, result);
1238 size_t ProcessMonitor::WriteMemory(lldb::addr_t vm_addr, const void *buf,
1239 size_t size, lldb_private::Status &error) {
1241 WriteOperation op(vm_addr, buf, size, error, result);
1246 bool ProcessMonitor::ReadRegisterValue(lldb::tid_t tid, unsigned offset,
1247 const char *reg_name, unsigned size,
1248 RegisterValue &value) {
1250 ReadRegOperation op(tid, offset, size, value, result);
1255 bool ProcessMonitor::WriteRegisterValue(lldb::tid_t tid, unsigned offset,
1256 const char *reg_name,
1257 const RegisterValue &value) {
1259 WriteRegOperation op(tid, offset, value, result);
1264 bool ProcessMonitor::ReadDebugRegisterValue(
1265 lldb::tid_t tid, unsigned offset, const char *reg_name, unsigned size,
1266 lldb_private::RegisterValue &value) {
1268 ReadDebugRegOperation op(tid, offset, size, value, result);
1273 bool ProcessMonitor::WriteDebugRegisterValue(
1274 lldb::tid_t tid, unsigned offset, const char *reg_name,
1275 const lldb_private::RegisterValue &value) {
1277 WriteDebugRegOperation op(tid, offset, value, result);
1282 bool ProcessMonitor::ReadGPR(lldb::tid_t tid, void *buf, size_t buf_size) {
1284 ReadGPROperation op(tid, buf, result);
1289 bool ProcessMonitor::ReadFPR(lldb::tid_t tid, void *buf, size_t buf_size) {
1291 ReadFPROperation op(tid, buf, result);
1296 bool ProcessMonitor::ReadRegisterSet(lldb::tid_t tid, void *buf,
1297 size_t buf_size, unsigned int regset) {
1301 bool ProcessMonitor::WriteGPR(lldb::tid_t tid, void *buf, size_t buf_size) {
1303 WriteGPROperation op(tid, buf, result);
1308 bool ProcessMonitor::WriteFPR(lldb::tid_t tid, void *buf, size_t buf_size) {
1310 WriteFPROperation op(tid, buf, result);
1315 bool ProcessMonitor::WriteRegisterSet(lldb::tid_t tid, void *buf,
1316 size_t buf_size, unsigned int regset) {
1320 bool ProcessMonitor::ReadThreadPointer(lldb::tid_t tid, lldb::addr_t &value) {
1324 bool ProcessMonitor::Resume(lldb::tid_t unused, uint32_t signo) {
1326 Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
1329 const char *signame =
1330 m_process->GetUnixSignals()->GetSignalAsCString(signo);
1331 if (signame == nullptr)
1333 log->Printf("ProcessMonitor::%s() resuming pid %" PRIu64 " with signal %s",
1334 __FUNCTION__, GetPID(), signame);
1336 ResumeOperation op(signo, result);
1339 log->Printf("ProcessMonitor::%s() resuming result = %s", __FUNCTION__,
1340 result ? "true" : "false");
1344 bool ProcessMonitor::SingleStep(lldb::tid_t unused, uint32_t signo) {
1346 SingleStepOperation op(signo, result);
1351 bool ProcessMonitor::Kill() {
1353 KillOperation op(result);
1358 bool ProcessMonitor::GetLwpInfo(lldb::tid_t tid, void *lwpinfo,
1361 LwpInfoOperation op(tid, lwpinfo, result, ptrace_err);
1366 bool ProcessMonitor::ThreadSuspend(lldb::tid_t tid, bool suspend) {
1368 ThreadSuspendOperation op(tid, suspend, result);
1373 bool ProcessMonitor::GetEventMessage(lldb::tid_t tid, unsigned long *message) {
1375 EventMessageOperation op(tid, message, result);
1380 lldb_private::Status ProcessMonitor::Detach(lldb::tid_t tid) {
1381 lldb_private::Status error;
1382 if (tid != LLDB_INVALID_THREAD_ID) {
1383 DetachOperation op(error);
1389 bool ProcessMonitor::DupDescriptor(const FileSpec &file_spec, int fd,
1391 int target_fd = open(file_spec.GetCString(), flags, 0666);
1393 if (target_fd == -1)
1396 if (dup2(target_fd, fd) == -1)
1399 return (close(target_fd) == -1) ? false : true;
1402 void ProcessMonitor::StopMonitoringChildProcess() {
1403 if (m_monitor_thread.IsJoinable()) {
1404 m_monitor_thread.Cancel();
1405 m_monitor_thread.Join(nullptr);
1406 m_monitor_thread.Reset();
1410 void ProcessMonitor::StopMonitor() {
1411 StopMonitoringChildProcess();
1413 sem_destroy(&m_operation_pending);
1414 sem_destroy(&m_operation_done);
1415 if (m_terminal_fd >= 0) {
1416 close(m_terminal_fd);
1421 // FIXME: On Linux, when a new thread is created, we receive to notifications,
1422 // (1) a SIGTRAP|PTRACE_EVENT_CLONE from the main process thread with the child
1423 // thread id as additional information, and (2) a SIGSTOP|SI_USER from the new
1424 // child thread indicating that it has is stopped because we attached. We have
1425 // no guarantee of the order in which these arrive, but we need both before we
1426 // are ready to proceed. We currently keep a list of threads which have sent
1427 // the initial SIGSTOP|SI_USER event. Then when we receive the
1428 // SIGTRAP|PTRACE_EVENT_CLONE notification, if the initial stop has not
1429 // occurred we call ProcessMonitor::WaitForInitialTIDStop() to wait for it.
1431 // Right now, the above logic is in ProcessPOSIX, so we need a definition of
1432 // this function in the FreeBSD ProcessMonitor implementation even if it isn't
1433 // logically needed.
1435 // We really should figure out what actually happens on FreeBSD and move the
1436 // Linux-specific logic out of ProcessPOSIX as needed.
1438 bool ProcessMonitor::WaitForInitialTIDStop(lldb::tid_t tid) { return true; }
1440 void ProcessMonitor::StopOpThread() {
1441 if (!m_operation_thread.IsJoinable())
1444 m_operation_thread.Cancel();
1445 m_operation_thread.Join(nullptr);
1446 m_operation_thread.Reset();