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 //===----------------------------------------------------------------------===//
17 #include <sys/ptrace.h>
18 #include <sys/socket.h>
19 #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/Target/Thread.h"
29 #include "lldb/Target/RegisterContext.h"
30 #include "lldb/Utility/PseudoTerminal.h"
33 #include "POSIXThread.h"
34 #include "ProcessFreeBSD.h"
35 #include "ProcessPOSIXLog.h"
36 #include "ProcessMonitor.h"
39 extern char ** environ;
43 using namespace lldb_private;
45 // We disable the tracing of ptrace calls for integration builds to
46 // avoid the additional indirection and checks.
47 #ifndef LLDB_CONFIGURATION_BUILDANDINTEGRATION
48 // Wrapper for ptrace to catch errors and log calls.
54 case PIOD_READ_D: return "READ_D";
55 case PIOD_WRITE_D: return "WRITE_D";
56 case PIOD_READ_I: return "READ_I";
57 case PIOD_WRITE_I: return "WRITE_I";
58 default: return "Unknown op";
62 // Wrapper for ptrace to catch errors and log calls.
63 // Note that ptrace sets errno on error because -1 is reserved as a valid result.
65 PtraceWrapper(int req, lldb::pid_t pid, void *addr, int data,
66 const char* reqName, const char* file, int line)
70 Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
73 log->Printf("ptrace(%s, %" PRIu64 ", %p, %x) called from file %s line %d",
74 reqName, pid, addr, data, file, line);
76 struct ptrace_io_desc *pi = (struct ptrace_io_desc *) addr;
78 log->Printf("PT_IO: op=%s offs=%zx size=%zu",
79 Get_PT_IO_OP(pi->piod_op), (size_t)pi->piod_offs, pi->piod_len);
83 //PtraceDisplayBytes(req, data);
86 result = ptrace(req, pid, (caddr_t) addr, data);
88 //PtraceDisplayBytes(req, data);
90 if (log && errno != 0)
95 case ESRCH: str = "ESRCH"; break;
96 case EINVAL: str = "EINVAL"; break;
97 case EBUSY: str = "EBUSY"; break;
98 case EPERM: str = "EPERM"; break;
99 default: str = "<unknown>";
101 log->Printf("ptrace() failed; errno=%d (%s)", errno, str);
106 if (req == PT_GETREGS) {
107 struct reg *r = (struct reg *) addr;
109 log->Printf("PT_GETREGS: ip=0x%lx", r->r_rip);
110 log->Printf("PT_GETREGS: sp=0x%lx", r->r_rsp);
111 log->Printf("PT_GETREGS: bp=0x%lx", r->r_rbp);
112 log->Printf("PT_GETREGS: ax=0x%lx", r->r_rax);
115 if (req == PT_GETDBREGS || req == PT_SETDBREGS) {
116 struct dbreg *r = (struct dbreg *) addr;
117 char setget = (req == PT_GETDBREGS) ? 'G' : 'S';
119 for (int i = 0; i <= 7; i++)
120 log->Printf("PT_%cETDBREGS: dr[%d]=0x%lx", setget, i, r->dr[i]);
127 // Wrapper for ptrace when logging is not required.
128 // Sets errno to 0 prior to calling ptrace.
130 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.
150 DoReadMemory(lldb::pid_t pid, lldb::addr_t vm_addr, void *buf, size_t size,
153 struct ptrace_io_desc pi_desc;
155 pi_desc.piod_op = PIOD_READ_D;
156 pi_desc.piod_offs = (void *)vm_addr;
157 pi_desc.piod_addr = buf;
158 pi_desc.piod_len = size;
160 if (PTRACE(PT_IO, pid, (caddr_t)&pi_desc, 0) < 0)
161 error.SetErrorToErrno();
162 return pi_desc.piod_len;
166 DoWriteMemory(lldb::pid_t pid, lldb::addr_t vm_addr, const void *buf,
167 size_t size, Error &error)
169 struct ptrace_io_desc pi_desc;
171 pi_desc.piod_op = PIOD_WRITE_D;
172 pi_desc.piod_offs = (void *)vm_addr;
173 pi_desc.piod_addr = (void *)buf;
174 pi_desc.piod_len = size;
176 if (PTRACE(PT_IO, pid, (caddr_t)&pi_desc, 0) < 0)
177 error.SetErrorToErrno();
178 return pi_desc.piod_len;
181 // Simple helper function to ensure flags are enabled on the given file
184 EnsureFDFlags(int fd, int flags, Error &error)
188 if ((status = fcntl(fd, F_GETFL)) == -1)
190 error.SetErrorToErrno();
194 if (fcntl(fd, F_SETFL, status | flags) == -1)
196 error.SetErrorToErrno();
203 //------------------------------------------------------------------------------
205 /// @brief Represents a ProcessMonitor operation.
207 /// Under FreeBSD, it is not possible to ptrace() from any other thread but the
208 /// one that spawned or attached to the process from the start. Therefore, when
209 /// a ProcessMonitor is asked to deliver or change the state of an inferior
210 /// process the operation must be "funneled" to a specific thread to perform the
211 /// task. The Operation class provides an abstract base for all services the
212 /// ProcessMonitor must perform via the single virtual function Execute, thus
213 /// encapsulating the code that needs to run in the privileged context.
217 virtual ~Operation() {}
218 virtual void Execute(ProcessMonitor *monitor) = 0;
221 //------------------------------------------------------------------------------
222 /// @class ReadOperation
223 /// @brief Implements ProcessMonitor::ReadMemory.
224 class ReadOperation : public Operation
227 ReadOperation(lldb::addr_t addr, void *buff, size_t size,
228 Error &error, size_t &result)
229 : m_addr(addr), m_buff(buff), m_size(size),
230 m_error(error), m_result(result)
233 void Execute(ProcessMonitor *monitor);
244 ReadOperation::Execute(ProcessMonitor *monitor)
246 lldb::pid_t pid = monitor->GetPID();
248 m_result = DoReadMemory(pid, m_addr, m_buff, m_size, m_error);
251 //------------------------------------------------------------------------------
252 /// @class WriteOperation
253 /// @brief Implements ProcessMonitor::WriteMemory.
254 class WriteOperation : public Operation
257 WriteOperation(lldb::addr_t addr, const void *buff, size_t size,
258 Error &error, size_t &result)
259 : m_addr(addr), m_buff(buff), m_size(size),
260 m_error(error), m_result(result)
263 void Execute(ProcessMonitor *monitor);
274 WriteOperation::Execute(ProcessMonitor *monitor)
276 lldb::pid_t pid = monitor->GetPID();
278 m_result = DoWriteMemory(pid, m_addr, m_buff, m_size, m_error);
281 //------------------------------------------------------------------------------
282 /// @class ReadRegOperation
283 /// @brief Implements ProcessMonitor::ReadRegisterValue.
284 class ReadRegOperation : public Operation
287 ReadRegOperation(lldb::tid_t tid, unsigned offset, unsigned size,
288 RegisterValue &value, bool &result)
289 : m_tid(tid), m_offset(offset), m_size(size),
290 m_value(value), m_result(result)
293 void Execute(ProcessMonitor *monitor);
299 RegisterValue &m_value;
304 ReadRegOperation::Execute(ProcessMonitor *monitor)
309 if ((rc = PTRACE(PT_GETREGS, m_tid, (caddr_t)®s, 0)) < 0) {
312 if (m_size == sizeof(uintptr_t))
313 m_value = *(uintptr_t *)(((caddr_t)®s) + m_offset);
315 memcpy(&m_value, (((caddr_t)®s) + m_offset), m_size);
320 //------------------------------------------------------------------------------
321 /// @class WriteRegOperation
322 /// @brief Implements ProcessMonitor::WriteRegisterValue.
323 class WriteRegOperation : public Operation
326 WriteRegOperation(lldb::tid_t tid, unsigned offset,
327 const RegisterValue &value, bool &result)
328 : m_tid(tid), m_offset(offset),
329 m_value(value), m_result(result)
332 void Execute(ProcessMonitor *monitor);
337 const RegisterValue &m_value;
342 WriteRegOperation::Execute(ProcessMonitor *monitor)
346 if (PTRACE(PT_GETREGS, m_tid, (caddr_t)®s, 0) < 0) {
350 *(uintptr_t *)(((caddr_t)®s) + m_offset) = (uintptr_t)m_value.GetAsUInt64();
351 if (PTRACE(PT_SETREGS, m_tid, (caddr_t)®s, 0) < 0)
357 //------------------------------------------------------------------------------
358 /// @class ReadDebugRegOperation
359 /// @brief Implements ProcessMonitor::ReadDebugRegisterValue.
360 class ReadDebugRegOperation : public Operation
363 ReadDebugRegOperation(lldb::tid_t tid, unsigned offset, unsigned size,
364 RegisterValue &value, bool &result)
365 : m_tid(tid), m_offset(offset), m_size(size),
366 m_value(value), m_result(result)
369 void Execute(ProcessMonitor *monitor);
375 RegisterValue &m_value;
380 ReadDebugRegOperation::Execute(ProcessMonitor *monitor)
385 if ((rc = PTRACE(PT_GETDBREGS, m_tid, (caddr_t)®s, 0)) < 0) {
388 if (m_size == sizeof(uintptr_t))
389 m_value = *(uintptr_t *)(((caddr_t)®s) + m_offset);
391 memcpy(&m_value, (((caddr_t)®s) + m_offset), m_size);
396 //------------------------------------------------------------------------------
397 /// @class WriteDebugRegOperation
398 /// @brief Implements ProcessMonitor::WriteDebugRegisterValue.
399 class WriteDebugRegOperation : public Operation
402 WriteDebugRegOperation(lldb::tid_t tid, unsigned offset,
403 const RegisterValue &value, bool &result)
404 : m_tid(tid), m_offset(offset),
405 m_value(value), m_result(result)
408 void Execute(ProcessMonitor *monitor);
413 const RegisterValue &m_value;
418 WriteDebugRegOperation::Execute(ProcessMonitor *monitor)
422 if (PTRACE(PT_GETDBREGS, m_tid, (caddr_t)®s, 0) < 0) {
426 *(uintptr_t *)(((caddr_t)®s) + m_offset) = (uintptr_t)m_value.GetAsUInt64();
427 if (PTRACE(PT_SETDBREGS, m_tid, (caddr_t)®s, 0) < 0)
433 //------------------------------------------------------------------------------
434 /// @class ReadGPROperation
435 /// @brief Implements ProcessMonitor::ReadGPR.
436 class ReadGPROperation : public Operation
439 ReadGPROperation(lldb::tid_t tid, void *buf, bool &result)
440 : m_tid(tid), m_buf(buf), m_result(result)
443 void Execute(ProcessMonitor *monitor);
452 ReadGPROperation::Execute(ProcessMonitor *monitor)
457 rc = PTRACE(PT_GETREGS, m_tid, (caddr_t)m_buf, 0);
464 //------------------------------------------------------------------------------
465 /// @class ReadFPROperation
466 /// @brief Implements ProcessMonitor::ReadFPR.
467 class ReadFPROperation : public Operation
470 ReadFPROperation(lldb::tid_t tid, void *buf, bool &result)
471 : m_tid(tid), m_buf(buf), m_result(result)
474 void Execute(ProcessMonitor *monitor);
483 ReadFPROperation::Execute(ProcessMonitor *monitor)
485 if (PTRACE(PT_GETFPREGS, m_tid, (caddr_t)m_buf, 0) < 0)
491 //------------------------------------------------------------------------------
492 /// @class WriteGPROperation
493 /// @brief Implements ProcessMonitor::WriteGPR.
494 class WriteGPROperation : public Operation
497 WriteGPROperation(lldb::tid_t tid, void *buf, bool &result)
498 : m_tid(tid), m_buf(buf), m_result(result)
501 void Execute(ProcessMonitor *monitor);
510 WriteGPROperation::Execute(ProcessMonitor *monitor)
512 if (PTRACE(PT_SETREGS, m_tid, (caddr_t)m_buf, 0) < 0)
518 //------------------------------------------------------------------------------
519 /// @class WriteFPROperation
520 /// @brief Implements ProcessMonitor::WriteFPR.
521 class WriteFPROperation : public Operation
524 WriteFPROperation(lldb::tid_t tid, void *buf, bool &result)
525 : m_tid(tid), m_buf(buf), m_result(result)
528 void Execute(ProcessMonitor *monitor);
537 WriteFPROperation::Execute(ProcessMonitor *monitor)
539 if (PTRACE(PT_SETFPREGS, m_tid, (caddr_t)m_buf, 0) < 0)
545 //------------------------------------------------------------------------------
546 /// @class ResumeOperation
547 /// @brief Implements ProcessMonitor::Resume.
548 class ResumeOperation : public Operation
551 ResumeOperation(uint32_t signo, bool &result) :
552 m_signo(signo), m_result(result) { }
554 void Execute(ProcessMonitor *monitor);
562 ResumeOperation::Execute(ProcessMonitor *monitor)
564 lldb::pid_t pid = monitor->GetPID();
567 if (m_signo != LLDB_INVALID_SIGNAL_NUMBER)
570 if (PTRACE(PT_CONTINUE, pid, (caddr_t)1, data))
572 Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_PROCESS));
575 log->Printf ("ResumeOperation (%" PRIu64 ") failed: %s", pid, strerror(errno));
582 //------------------------------------------------------------------------------
583 /// @class SingleStepOperation
584 /// @brief Implements ProcessMonitor::SingleStep.
585 class SingleStepOperation : public Operation
588 SingleStepOperation(uint32_t signo, bool &result)
589 : m_signo(signo), m_result(result) { }
591 void Execute(ProcessMonitor *monitor);
599 SingleStepOperation::Execute(ProcessMonitor *monitor)
601 lldb::pid_t pid = monitor->GetPID();
604 if (m_signo != LLDB_INVALID_SIGNAL_NUMBER)
607 if (PTRACE(PT_STEP, pid, NULL, data))
613 //------------------------------------------------------------------------------
614 /// @class LwpInfoOperation
615 /// @brief Implements ProcessMonitor::GetLwpInfo.
616 class LwpInfoOperation : public Operation
619 LwpInfoOperation(lldb::tid_t tid, void *info, bool &result, int &ptrace_err)
620 : m_tid(tid), m_info(info), m_result(result), m_err(ptrace_err) { }
622 void Execute(ProcessMonitor *monitor);
632 LwpInfoOperation::Execute(ProcessMonitor *monitor)
634 struct ptrace_lwpinfo plwp;
636 if (PTRACE(PT_LWPINFO, m_tid, (caddr_t)&plwp, sizeof(plwp))) {
640 memcpy(m_info, &plwp, sizeof(plwp));
645 //------------------------------------------------------------------------------
646 /// @class ThreadSuspendOperation
647 /// @brief Implements ProcessMonitor::ThreadSuspend.
648 class ThreadSuspendOperation : public Operation
651 ThreadSuspendOperation(lldb::tid_t tid, bool suspend, bool &result)
652 : m_tid(tid), m_suspend(suspend), m_result(result) { }
654 void Execute(ProcessMonitor *monitor);
663 ThreadSuspendOperation::Execute(ProcessMonitor *monitor)
665 m_result = !PTRACE(m_suspend ? PT_SUSPEND : PT_RESUME, m_tid, NULL, 0);
670 //------------------------------------------------------------------------------
671 /// @class EventMessageOperation
672 /// @brief Implements ProcessMonitor::GetEventMessage.
673 class EventMessageOperation : public Operation
676 EventMessageOperation(lldb::tid_t tid, unsigned long *message, bool &result)
677 : m_tid(tid), m_message(message), m_result(result) { }
679 void Execute(ProcessMonitor *monitor);
683 unsigned long *m_message;
688 EventMessageOperation::Execute(ProcessMonitor *monitor)
690 struct ptrace_lwpinfo plwp;
692 if (PTRACE(PT_LWPINFO, m_tid, (caddr_t)&plwp, sizeof(plwp)))
695 if (plwp.pl_flags & PL_FLAG_FORKED) {
696 *m_message = plwp.pl_child_pid;
703 //------------------------------------------------------------------------------
704 /// @class KillOperation
705 /// @brief Implements ProcessMonitor::BringProcessIntoLimbo.
706 class KillOperation : public Operation
709 KillOperation(bool &result) : m_result(result) { }
711 void Execute(ProcessMonitor *monitor);
718 KillOperation::Execute(ProcessMonitor *monitor)
720 lldb::pid_t pid = monitor->GetPID();
722 if (PTRACE(PT_KILL, pid, NULL, 0))
728 //------------------------------------------------------------------------------
729 /// @class DetachOperation
730 /// @brief Implements ProcessMonitor::BringProcessIntoLimbo.
731 class DetachOperation : public Operation
734 DetachOperation(Error &result) : m_error(result) { }
736 void Execute(ProcessMonitor *monitor);
743 DetachOperation::Execute(ProcessMonitor *monitor)
745 lldb::pid_t pid = monitor->GetPID();
747 if (PTRACE(PT_DETACH, pid, NULL, 0) < 0)
748 m_error.SetErrorToErrno();
752 ProcessMonitor::OperationArgs::OperationArgs(ProcessMonitor *monitor)
755 sem_init(&m_semaphore, 0, 0);
758 ProcessMonitor::OperationArgs::~OperationArgs()
760 sem_destroy(&m_semaphore);
763 ProcessMonitor::LaunchArgs::LaunchArgs(ProcessMonitor *monitor,
764 lldb_private::Module *module,
767 const char *stdin_path,
768 const char *stdout_path,
769 const char *stderr_path,
770 const char *working_dir)
771 : OperationArgs(monitor),
775 m_stdin_path(stdin_path),
776 m_stdout_path(stdout_path),
777 m_stderr_path(stderr_path),
778 m_working_dir(working_dir) { }
780 ProcessMonitor::LaunchArgs::~LaunchArgs()
783 ProcessMonitor::AttachArgs::AttachArgs(ProcessMonitor *monitor,
785 : OperationArgs(monitor), m_pid(pid) { }
787 ProcessMonitor::AttachArgs::~AttachArgs()
790 //------------------------------------------------------------------------------
791 /// The basic design of the ProcessMonitor is built around two threads.
793 /// One thread (@see SignalThread) simply blocks on a call to waitpid() looking
794 /// for changes in the debugee state. When a change is detected a
795 /// ProcessMessage is sent to the associated ProcessFreeBSD instance. This thread
796 /// "drives" state changes in the debugger.
798 /// The second thread (@see OperationThread) is responsible for two things 1)
799 /// launching or attaching to the inferior process, and then 2) servicing
800 /// operations such as register reads/writes, stepping, etc. See the comments
801 /// on the Operation class for more info as to why this is needed.
802 ProcessMonitor::ProcessMonitor(ProcessPOSIX *process,
806 const char *stdin_path,
807 const char *stdout_path,
808 const char *stderr_path,
809 const char *working_dir,
810 lldb_private::Error &error)
811 : m_process(static_cast<ProcessFreeBSD *>(process)),
812 m_operation_thread(LLDB_INVALID_HOST_THREAD),
813 m_monitor_thread(LLDB_INVALID_HOST_THREAD),
814 m_pid(LLDB_INVALID_PROCESS_ID),
818 std::unique_ptr<LaunchArgs> args(new LaunchArgs(this, module, argv, envp,
819 stdin_path, stdout_path, stderr_path,
823 sem_init(&m_operation_pending, 0, 0);
824 sem_init(&m_operation_done, 0, 0);
826 StartLaunchOpThread(args.get(), error);
827 if (!error.Success())
831 // Wait for the operation thread to initialize.
832 if (sem_wait(&args->m_semaphore))
838 error.SetErrorToErrno();
843 // Check that the launch was a success.
844 if (!args->m_error.Success())
847 error = args->m_error;
851 // Finally, start monitoring the child process for change in state.
852 m_monitor_thread = Host::StartMonitoringChildProcess(
853 ProcessMonitor::MonitorCallback, this, GetPID(), true);
854 if (!IS_VALID_LLDB_HOST_THREAD(m_monitor_thread))
856 error.SetErrorToGenericError();
857 error.SetErrorString("Process launch failed.");
862 ProcessMonitor::ProcessMonitor(ProcessPOSIX *process,
864 lldb_private::Error &error)
865 : m_process(static_cast<ProcessFreeBSD *>(process)),
866 m_operation_thread(LLDB_INVALID_HOST_THREAD),
867 m_monitor_thread(LLDB_INVALID_HOST_THREAD),
872 sem_init(&m_operation_pending, 0, 0);
873 sem_init(&m_operation_done, 0, 0);
876 std::unique_ptr<AttachArgs> args(new AttachArgs(this, pid));
878 StartAttachOpThread(args.get(), error);
879 if (!error.Success())
883 // Wait for the operation thread to initialize.
884 if (sem_wait(&args->m_semaphore))
890 error.SetErrorToErrno();
895 // Check that the attach was a success.
896 if (!args->m_error.Success())
899 error = args->m_error;
903 // Finally, start monitoring the child process for change in state.
904 m_monitor_thread = Host::StartMonitoringChildProcess(
905 ProcessMonitor::MonitorCallback, this, GetPID(), true);
906 if (!IS_VALID_LLDB_HOST_THREAD(m_monitor_thread))
908 error.SetErrorToGenericError();
909 error.SetErrorString("Process attach failed.");
914 ProcessMonitor::~ProcessMonitor()
919 //------------------------------------------------------------------------------
920 // Thread setup and tear down.
922 ProcessMonitor::StartLaunchOpThread(LaunchArgs *args, Error &error)
924 static const char *g_thread_name = "lldb.process.freebsd.operation";
926 if (IS_VALID_LLDB_HOST_THREAD(m_operation_thread))
930 Host::ThreadCreate(g_thread_name, LaunchOpThread, args, &error);
934 ProcessMonitor::LaunchOpThread(void *arg)
936 LaunchArgs *args = static_cast<LaunchArgs*>(arg);
939 sem_post(&args->m_semaphore);
943 ServeOperation(args);
948 ProcessMonitor::Launch(LaunchArgs *args)
950 ProcessMonitor *monitor = args->m_monitor;
951 ProcessFreeBSD &process = monitor->GetProcess();
952 const char **argv = args->m_argv;
953 const char **envp = args->m_envp;
954 const char *stdin_path = args->m_stdin_path;
955 const char *stdout_path = args->m_stdout_path;
956 const char *stderr_path = args->m_stderr_path;
957 const char *working_dir = args->m_working_dir;
959 lldb_utility::PseudoTerminal terminal;
960 const size_t err_len = 1024;
961 char err_str[err_len];
964 // Propagate the environment if one is not supplied.
965 if (envp == NULL || envp[0] == NULL)
966 envp = const_cast<const char **>(environ);
968 if ((pid = terminal.Fork(err_str, err_len)) == -1)
970 args->m_error.SetErrorToGenericError();
971 args->m_error.SetErrorString("Process fork failed.");
975 // Recognized child exit status codes.
989 // Trace this process.
990 if (PTRACE(PT_TRACE_ME, 0, NULL, 0) < 0)
993 // Do not inherit setgid powers.
994 if (setgid(getgid()) != 0)
997 // Let us have our own process group.
1000 // Dup file descriptors if needed.
1002 // FIXME: If two or more of the paths are the same we needlessly open
1003 // the same file multiple times.
1004 if (stdin_path != NULL && stdin_path[0])
1005 if (!DupDescriptor(stdin_path, STDIN_FILENO, O_RDONLY))
1006 exit(eDupStdinFailed);
1008 if (stdout_path != NULL && stdout_path[0])
1009 if (!DupDescriptor(stdout_path, STDOUT_FILENO, O_WRONLY | O_CREAT))
1010 exit(eDupStdoutFailed);
1012 if (stderr_path != NULL && stderr_path[0])
1013 if (!DupDescriptor(stderr_path, STDERR_FILENO, O_WRONLY | O_CREAT))
1014 exit(eDupStderrFailed);
1016 // Change working directory
1017 if (working_dir != NULL && working_dir[0])
1018 if (0 != ::chdir(working_dir))
1021 // Execute. We should never return.
1023 const_cast<char *const *>(argv),
1024 const_cast<char *const *>(envp));
1028 // Wait for the child process to to trap on its call to execve.
1031 if ((wpid = waitpid(pid, &status, 0)) < 0)
1033 args->m_error.SetErrorToErrno();
1036 else if (WIFEXITED(status))
1038 // open, dup or execve likely failed for some reason.
1039 args->m_error.SetErrorToGenericError();
1040 switch (WEXITSTATUS(status))
1043 args->m_error.SetErrorString("Child ptrace failed.");
1045 case eDupStdinFailed:
1046 args->m_error.SetErrorString("Child open stdin failed.");
1048 case eDupStdoutFailed:
1049 args->m_error.SetErrorString("Child open stdout failed.");
1051 case eDupStderrFailed:
1052 args->m_error.SetErrorString("Child open stderr failed.");
1055 args->m_error.SetErrorString("Child failed to set working directory.");
1058 args->m_error.SetErrorString("Child exec failed.");
1061 args->m_error.SetErrorString("Child setgid failed.");
1064 args->m_error.SetErrorString("Child returned unknown exit status.");
1069 assert(WIFSTOPPED(status) && wpid == (::pid_t)pid &&
1070 "Could not sync with inferior process.");
1073 // Have the child raise an event on exit. This is used to keep the child in
1074 // limbo until it is destroyed.
1075 if (PTRACE(PTRACE_SETOPTIONS, pid, NULL, PTRACE_O_TRACEEXIT) < 0)
1077 args->m_error.SetErrorToErrno();
1081 // Release the master terminal descriptor and pass it off to the
1082 // ProcessMonitor instance. Similarly stash the inferior pid.
1083 monitor->m_terminal_fd = terminal.ReleaseMasterFileDescriptor();
1084 monitor->m_pid = pid;
1086 // Set the terminal fd to be in non blocking mode (it simplifies the
1087 // implementation of ProcessFreeBSD::GetSTDOUT to have a non-blocking
1088 // descriptor to read from).
1089 if (!EnsureFDFlags(monitor->m_terminal_fd, O_NONBLOCK, args->m_error))
1092 process.SendMessage(ProcessMessage::Attach(pid));
1095 return args->m_error.Success();
1099 ProcessMonitor::StartAttachOpThread(AttachArgs *args, lldb_private::Error &error)
1101 static const char *g_thread_name = "lldb.process.freebsd.operation";
1103 if (IS_VALID_LLDB_HOST_THREAD(m_operation_thread))
1106 m_operation_thread =
1107 Host::ThreadCreate(g_thread_name, AttachOpThread, args, &error);
1111 ProcessMonitor::AttachOpThread(void *arg)
1113 AttachArgs *args = static_cast<AttachArgs*>(arg);
1118 ServeOperation(args);
1123 ProcessMonitor::Attach(AttachArgs *args)
1125 lldb::pid_t pid = args->m_pid;
1127 ProcessMonitor *monitor = args->m_monitor;
1128 ProcessFreeBSD &process = monitor->GetProcess();
1132 args->m_error.SetErrorToGenericError();
1133 args->m_error.SetErrorString("Attaching to process 1 is not allowed.");
1137 // Attach to the requested process.
1138 if (PTRACE(PT_ATTACH, pid, NULL, 0) < 0)
1140 args->m_error.SetErrorToErrno();
1145 if ((status = waitpid(pid, NULL, 0)) < 0)
1147 args->m_error.SetErrorToErrno();
1151 process.SendMessage(ProcessMessage::Attach(pid));
1154 return args->m_error.Success();
1158 ProcessMonitor::GetCurrentThreadIDs(std::vector<lldb::tid_t>&thread_ids)
1165 tdcnt = PTRACE(PT_GETNUMLWPS, m_pid, NULL, 0);
1168 tids = (lwpid_t *)malloc(tdcnt * sizeof(*tids));
1171 if (PTRACE(PT_GETLWPLIST, m_pid, (void *)tids, tdcnt) < 0) {
1175 thread_ids = std::vector<lldb::tid_t>(tids, tids + tdcnt);
1177 return thread_ids.size();
1181 ProcessMonitor::MonitorCallback(void *callback_baton,
1187 ProcessMessage message;
1188 ProcessMonitor *monitor = static_cast<ProcessMonitor*>(callback_baton);
1189 ProcessFreeBSD *process = monitor->m_process;
1191 bool stop_monitoring;
1192 struct ptrace_lwpinfo plwp;
1195 Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_PROCESS));
1200 log->Printf ("ProcessMonitor::%s() got exit signal, tid = %" PRIu64, __FUNCTION__, pid);
1201 message = ProcessMessage::Exit(pid, status);
1202 process->SendMessage(message);
1203 return pid == process->GetID();
1206 if (!monitor->GetLwpInfo(pid, &plwp, ptrace_err))
1207 stop_monitoring = true; // pid is gone. Bail.
1209 switch (plwp.pl_siginfo.si_signo)
1212 message = MonitorSIGTRAP(monitor, &plwp.pl_siginfo, plwp.pl_lwpid);
1216 message = MonitorSignal(monitor, &plwp.pl_siginfo, plwp.pl_lwpid);
1220 process->SendMessage(message);
1221 stop_monitoring = message.GetKind() == ProcessMessage::eExitMessage;
1224 return stop_monitoring;
1228 ProcessMonitor::MonitorSIGTRAP(ProcessMonitor *monitor,
1229 const siginfo_t *info, lldb::tid_t tid)
1231 ProcessMessage message;
1233 Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_PROCESS));
1236 assert(info && info->si_signo == SIGTRAP && "Unexpected child signal!");
1238 switch (info->si_code)
1241 assert(false && "Unexpected SIGTRAP code!");
1244 case (SIGTRAP /* | (PTRACE_EVENT_EXIT << 8) */):
1246 // The inferior process is about to exit. Maintain the process in a
1247 // state of "limbo" until we are explicitly commanded to detach,
1248 // destroy, resume, etc.
1249 unsigned long data = 0;
1250 if (!monitor->GetEventMessage(tid, &data))
1253 log->Printf ("ProcessMonitor::%s() received exit? event, data = %lx, tid = %" PRIu64, __FUNCTION__, data, tid);
1254 message = ProcessMessage::Limbo(tid, (data >> 8));
1261 log->Printf ("ProcessMonitor::%s() received trace event, tid = %" PRIu64 " : si_code = %d", __FUNCTION__, tid, info->si_code);
1262 message = ProcessMessage::Trace(tid);
1268 log->Printf ("ProcessMonitor::%s() received breakpoint event, tid = %" PRIu64, __FUNCTION__, tid);
1269 message = ProcessMessage::Break(tid);
1277 ProcessMonitor::MonitorSignal(ProcessMonitor *monitor,
1278 const siginfo_t *info, lldb::tid_t tid)
1280 ProcessMessage message;
1281 int signo = info->si_signo;
1283 Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_PROCESS));
1285 // POSIX says that process behaviour is undefined after it ignores a SIGFPE,
1286 // SIGILL, SIGSEGV, or SIGBUS *unless* that signal was generated by a
1287 // kill(2) or raise(3). Similarly for tgkill(2) on FreeBSD.
1289 // IOW, user generated signals never generate what we consider to be a
1292 // Similarly, ACK signals generated by this monitor.
1293 if (info->si_code == SI_USER)
1296 log->Printf ("ProcessMonitor::%s() received signal %s with code %s, pid = %d",
1298 monitor->m_process->GetUnixSignals().GetSignalAsCString (signo),
1301 if (info->si_pid == getpid())
1302 return ProcessMessage::SignalDelivered(tid, signo);
1304 return ProcessMessage::Signal(tid, signo);
1308 log->Printf ("ProcessMonitor::%s() received signal %s", __FUNCTION__, monitor->m_process->GetUnixSignals().GetSignalAsCString (signo));
1310 if (signo == SIGSEGV) {
1311 lldb::addr_t fault_addr = reinterpret_cast<lldb::addr_t>(info->si_addr);
1312 ProcessMessage::CrashReason reason = GetCrashReasonForSIGSEGV(info);
1313 return ProcessMessage::Crash(tid, reason, signo, fault_addr);
1316 if (signo == SIGILL) {
1317 lldb::addr_t fault_addr = reinterpret_cast<lldb::addr_t>(info->si_addr);
1318 ProcessMessage::CrashReason reason = GetCrashReasonForSIGILL(info);
1319 return ProcessMessage::Crash(tid, reason, signo, fault_addr);
1322 if (signo == SIGFPE) {
1323 lldb::addr_t fault_addr = reinterpret_cast<lldb::addr_t>(info->si_addr);
1324 ProcessMessage::CrashReason reason = GetCrashReasonForSIGFPE(info);
1325 return ProcessMessage::Crash(tid, reason, signo, fault_addr);
1328 if (signo == SIGBUS) {
1329 lldb::addr_t fault_addr = reinterpret_cast<lldb::addr_t>(info->si_addr);
1330 ProcessMessage::CrashReason reason = GetCrashReasonForSIGBUS(info);
1331 return ProcessMessage::Crash(tid, reason, signo, fault_addr);
1334 // Everything else is "normal" and does not require any special action on
1336 return ProcessMessage::Signal(tid, signo);
1339 ProcessMessage::CrashReason
1340 ProcessMonitor::GetCrashReasonForSIGSEGV(const siginfo_t *info)
1342 ProcessMessage::CrashReason reason;
1343 assert(info->si_signo == SIGSEGV);
1345 reason = ProcessMessage::eInvalidCrashReason;
1347 switch (info->si_code)
1350 assert(false && "unexpected si_code for SIGSEGV");
1353 reason = ProcessMessage::eInvalidAddress;
1356 reason = ProcessMessage::ePrivilegedAddress;
1363 ProcessMessage::CrashReason
1364 ProcessMonitor::GetCrashReasonForSIGILL(const siginfo_t *info)
1366 ProcessMessage::CrashReason reason;
1367 assert(info->si_signo == SIGILL);
1369 reason = ProcessMessage::eInvalidCrashReason;
1371 switch (info->si_code)
1374 assert(false && "unexpected si_code for SIGILL");
1377 reason = ProcessMessage::eIllegalOpcode;
1380 reason = ProcessMessage::eIllegalOperand;
1383 reason = ProcessMessage::eIllegalAddressingMode;
1386 reason = ProcessMessage::eIllegalTrap;
1389 reason = ProcessMessage::ePrivilegedOpcode;
1392 reason = ProcessMessage::ePrivilegedRegister;
1395 reason = ProcessMessage::eCoprocessorError;
1398 reason = ProcessMessage::eInternalStackError;
1405 ProcessMessage::CrashReason
1406 ProcessMonitor::GetCrashReasonForSIGFPE(const siginfo_t *info)
1408 ProcessMessage::CrashReason reason;
1409 assert(info->si_signo == SIGFPE);
1411 reason = ProcessMessage::eInvalidCrashReason;
1413 switch (info->si_code)
1416 assert(false && "unexpected si_code for SIGFPE");
1419 reason = ProcessMessage::eIntegerDivideByZero;
1422 reason = ProcessMessage::eIntegerOverflow;
1425 reason = ProcessMessage::eFloatDivideByZero;
1428 reason = ProcessMessage::eFloatOverflow;
1431 reason = ProcessMessage::eFloatUnderflow;
1434 reason = ProcessMessage::eFloatInexactResult;
1437 reason = ProcessMessage::eFloatInvalidOperation;
1440 reason = ProcessMessage::eFloatSubscriptRange;
1447 ProcessMessage::CrashReason
1448 ProcessMonitor::GetCrashReasonForSIGBUS(const siginfo_t *info)
1450 ProcessMessage::CrashReason reason;
1451 assert(info->si_signo == SIGBUS);
1453 reason = ProcessMessage::eInvalidCrashReason;
1455 switch (info->si_code)
1458 assert(false && "unexpected si_code for SIGBUS");
1461 reason = ProcessMessage::eIllegalAlignment;
1464 reason = ProcessMessage::eIllegalAddress;
1467 reason = ProcessMessage::eHardwareError;
1475 ProcessMonitor::ServeOperation(OperationArgs *args)
1477 ProcessMonitor *monitor = args->m_monitor;
1479 // We are finised with the arguments and are ready to go. Sync with the
1480 // parent thread and start serving operations on the inferior.
1481 sem_post(&args->m_semaphore);
1485 // wait for next pending operation
1486 sem_wait(&monitor->m_operation_pending);
1488 monitor->m_operation->Execute(monitor);
1490 // notify calling thread that operation is complete
1491 sem_post(&monitor->m_operation_done);
1496 ProcessMonitor::DoOperation(Operation *op)
1498 Mutex::Locker lock(m_operation_mutex);
1502 // notify operation thread that an operation is ready to be processed
1503 sem_post(&m_operation_pending);
1505 // wait for operation to complete
1506 sem_wait(&m_operation_done);
1510 ProcessMonitor::ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
1514 ReadOperation op(vm_addr, buf, size, error, result);
1520 ProcessMonitor::WriteMemory(lldb::addr_t vm_addr, const void *buf, size_t size,
1521 lldb_private::Error &error)
1524 WriteOperation op(vm_addr, buf, size, error, result);
1530 ProcessMonitor::ReadRegisterValue(lldb::tid_t tid, unsigned offset, const char* reg_name,
1531 unsigned size, RegisterValue &value)
1534 ReadRegOperation op(tid, offset, size, value, result);
1540 ProcessMonitor::WriteRegisterValue(lldb::tid_t tid, unsigned offset,
1541 const char* reg_name, const RegisterValue &value)
1544 WriteRegOperation op(tid, offset, value, result);
1550 ProcessMonitor::ReadDebugRegisterValue(lldb::tid_t tid, unsigned offset,
1551 const char *reg_name, unsigned size,
1552 lldb_private::RegisterValue &value)
1555 ReadDebugRegOperation op(tid, offset, size, value, result);
1561 ProcessMonitor::WriteDebugRegisterValue(lldb::tid_t tid, unsigned offset,
1562 const char *reg_name,
1563 const lldb_private::RegisterValue &value)
1566 WriteDebugRegOperation op(tid, offset, value, result);
1572 ProcessMonitor::ReadGPR(lldb::tid_t tid, void *buf, size_t buf_size)
1575 ReadGPROperation op(tid, buf, result);
1581 ProcessMonitor::ReadFPR(lldb::tid_t tid, void *buf, size_t buf_size)
1584 ReadFPROperation op(tid, buf, result);
1590 ProcessMonitor::ReadRegisterSet(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset)
1596 ProcessMonitor::WriteGPR(lldb::tid_t tid, void *buf, size_t buf_size)
1599 WriteGPROperation op(tid, buf, result);
1605 ProcessMonitor::WriteFPR(lldb::tid_t tid, void *buf, size_t buf_size)
1608 WriteFPROperation op(tid, buf, result);
1614 ProcessMonitor::WriteRegisterSet(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset)
1620 ProcessMonitor::ReadThreadPointer(lldb::tid_t tid, lldb::addr_t &value)
1626 ProcessMonitor::Resume(lldb::tid_t unused, uint32_t signo)
1629 Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_PROCESS));
1632 log->Printf ("ProcessMonitor::%s() resuming pid %" PRIu64 " with signal %s", __FUNCTION__, GetPID(),
1633 m_process->GetUnixSignals().GetSignalAsCString (signo));
1634 ResumeOperation op(signo, result);
1637 log->Printf ("ProcessMonitor::%s() resuming result = %s", __FUNCTION__, result ? "true" : "false");
1642 ProcessMonitor::SingleStep(lldb::tid_t unused, uint32_t signo)
1645 SingleStepOperation op(signo, result);
1651 ProcessMonitor::BringProcessIntoLimbo()
1654 KillOperation op(result);
1660 ProcessMonitor::GetLwpInfo(lldb::tid_t tid, void *lwpinfo, int &ptrace_err)
1663 LwpInfoOperation op(tid, lwpinfo, result, ptrace_err);
1669 ProcessMonitor::ThreadSuspend(lldb::tid_t tid, bool suspend)
1672 ThreadSuspendOperation op(tid, suspend, result);
1678 ProcessMonitor::GetEventMessage(lldb::tid_t tid, unsigned long *message)
1681 EventMessageOperation op(tid, message, result);
1687 ProcessMonitor::Detach(lldb::tid_t tid)
1689 lldb_private::Error error;
1690 if (tid != LLDB_INVALID_THREAD_ID)
1692 DetachOperation op(error);
1699 ProcessMonitor::DupDescriptor(const char *path, int fd, int flags)
1701 int target_fd = open(path, flags, 0666);
1703 if (target_fd == -1)
1706 return (dup2(target_fd, fd) == -1) ? false : true;
1710 ProcessMonitor::StopMonitoringChildProcess()
1712 lldb::thread_result_t thread_result;
1714 if (IS_VALID_LLDB_HOST_THREAD(m_monitor_thread))
1716 Host::ThreadCancel(m_monitor_thread, NULL);
1717 Host::ThreadJoin(m_monitor_thread, &thread_result, NULL);
1718 m_monitor_thread = LLDB_INVALID_HOST_THREAD;
1723 ProcessMonitor::StopMonitor()
1725 StopMonitoringChildProcess();
1727 sem_destroy(&m_operation_pending);
1728 sem_destroy(&m_operation_done);
1730 // Note: ProcessPOSIX passes the m_terminal_fd file descriptor to
1731 // Process::SetSTDIOFileDescriptor, which in turn transfers ownership of
1732 // the descriptor to a ConnectionFileDescriptor object. Consequently
1733 // even though still has the file descriptor, we shouldn't close it here.
1736 // FIXME: On Linux, when a new thread is created, we receive to notifications,
1737 // (1) a SIGTRAP|PTRACE_EVENT_CLONE from the main process thread with the
1738 // child thread id as additional information, and (2) a SIGSTOP|SI_USER from
1739 // the new child thread indicating that it has is stopped because we attached.
1740 // We have no guarantee of the order in which these arrive, but we need both
1741 // before we are ready to proceed. We currently keep a list of threads which
1742 // have sent the initial SIGSTOP|SI_USER event. Then when we receive the
1743 // SIGTRAP|PTRACE_EVENT_CLONE notification, if the initial stop has not occurred
1744 // we call ProcessMonitor::WaitForInitialTIDStop() to wait for it.
1746 // Right now, the above logic is in ProcessPOSIX, so we need a definition of
1747 // this function in the FreeBSD ProcessMonitor implementation even if it isn't
1748 // logically needed.
1750 // We really should figure out what actually happens on FreeBSD and move the
1751 // Linux-specific logic out of ProcessPOSIX as needed.
1754 ProcessMonitor::WaitForInitialTIDStop(lldb::tid_t tid)
1760 ProcessMonitor::StopOpThread()
1762 lldb::thread_result_t result;
1764 if (!IS_VALID_LLDB_HOST_THREAD(m_operation_thread))
1767 Host::ThreadCancel(m_operation_thread, NULL);
1768 Host::ThreadJoin(m_operation_thread, &result, NULL);
1769 m_operation_thread = LLDB_INVALID_HOST_THREAD;