1be691f3bSpatrick //===-- NativeProcessFreeBSD.cpp ------------------------------------------===//
2be691f3bSpatrick //
3be691f3bSpatrick // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4be691f3bSpatrick // See https://llvm.org/LICENSE.txt for license information.
5be691f3bSpatrick // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6be691f3bSpatrick //
7be691f3bSpatrick //===----------------------------------------------------------------------===//
8be691f3bSpatrick
9be691f3bSpatrick #include "NativeProcessFreeBSD.h"
10be691f3bSpatrick
11be691f3bSpatrick // clang-format off
12be691f3bSpatrick #include <sys/types.h>
13be691f3bSpatrick #include <sys/ptrace.h>
14be691f3bSpatrick #include <sys/sysctl.h>
15be691f3bSpatrick #include <sys/user.h>
16be691f3bSpatrick #include <sys/wait.h>
17be691f3bSpatrick #include <machine/elf.h>
18be691f3bSpatrick // clang-format on
19be691f3bSpatrick
20be691f3bSpatrick #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
21be691f3bSpatrick #include "lldb/Host/HostProcess.h"
22be691f3bSpatrick #include "lldb/Host/posix/ProcessLauncherPosixFork.h"
23be691f3bSpatrick #include "lldb/Target/Process.h"
24be691f3bSpatrick #include "lldb/Utility/State.h"
25be691f3bSpatrick #include "llvm/Support/Errno.h"
26be691f3bSpatrick
27be691f3bSpatrick using namespace lldb;
28be691f3bSpatrick using namespace lldb_private;
29be691f3bSpatrick using namespace lldb_private::process_freebsd;
30be691f3bSpatrick using namespace llvm;
31be691f3bSpatrick
32be691f3bSpatrick // Simple helper function to ensure flags are enabled on the given file
33be691f3bSpatrick // descriptor.
EnsureFDFlags(int fd,int flags)34be691f3bSpatrick static Status EnsureFDFlags(int fd, int flags) {
35be691f3bSpatrick Status error;
36be691f3bSpatrick
37be691f3bSpatrick int status = fcntl(fd, F_GETFL);
38be691f3bSpatrick if (status == -1) {
39be691f3bSpatrick error.SetErrorToErrno();
40be691f3bSpatrick return error;
41be691f3bSpatrick }
42be691f3bSpatrick
43be691f3bSpatrick if (fcntl(fd, F_SETFL, status | flags) == -1) {
44be691f3bSpatrick error.SetErrorToErrno();
45be691f3bSpatrick return error;
46be691f3bSpatrick }
47be691f3bSpatrick
48be691f3bSpatrick return error;
49be691f3bSpatrick }
50be691f3bSpatrick
51be691f3bSpatrick // Public Static Methods
52be691f3bSpatrick
53be691f3bSpatrick llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
Launch(ProcessLaunchInfo & launch_info,NativeDelegate & native_delegate,MainLoop & mainloop) const54be691f3bSpatrick NativeProcessFreeBSD::Factory::Launch(ProcessLaunchInfo &launch_info,
55be691f3bSpatrick NativeDelegate &native_delegate,
56be691f3bSpatrick MainLoop &mainloop) const {
57*f6aab3d8Srobert Log *log = GetLog(POSIXLog::Process);
58be691f3bSpatrick
59be691f3bSpatrick Status status;
60be691f3bSpatrick ::pid_t pid = ProcessLauncherPosixFork()
61be691f3bSpatrick .LaunchProcess(launch_info, status)
62be691f3bSpatrick .GetProcessId();
63be691f3bSpatrick LLDB_LOG(log, "pid = {0:x}", pid);
64be691f3bSpatrick if (status.Fail()) {
65be691f3bSpatrick LLDB_LOG(log, "failed to launch process: {0}", status);
66be691f3bSpatrick return status.ToError();
67be691f3bSpatrick }
68be691f3bSpatrick
69be691f3bSpatrick // Wait for the child process to trap on its call to execve.
70be691f3bSpatrick int wstatus;
71be691f3bSpatrick ::pid_t wpid = llvm::sys::RetryAfterSignal(-1, ::waitpid, pid, &wstatus, 0);
72be691f3bSpatrick assert(wpid == pid);
73be691f3bSpatrick (void)wpid;
74be691f3bSpatrick if (!WIFSTOPPED(wstatus)) {
75be691f3bSpatrick LLDB_LOG(log, "Could not sync with inferior process: wstatus={1}",
76be691f3bSpatrick WaitStatus::Decode(wstatus));
77be691f3bSpatrick return llvm::make_error<StringError>("Could not sync with inferior process",
78be691f3bSpatrick llvm::inconvertibleErrorCode());
79be691f3bSpatrick }
80be691f3bSpatrick LLDB_LOG(log, "inferior started, now in stopped state");
81be691f3bSpatrick
82be691f3bSpatrick ProcessInstanceInfo Info;
83be691f3bSpatrick if (!Host::GetProcessInfo(pid, Info)) {
84be691f3bSpatrick return llvm::make_error<StringError>("Cannot get process architecture",
85be691f3bSpatrick llvm::inconvertibleErrorCode());
86be691f3bSpatrick }
87be691f3bSpatrick
88be691f3bSpatrick // Set the architecture to the exe architecture.
89be691f3bSpatrick LLDB_LOG(log, "pid = {0:x}, detected architecture {1}", pid,
90be691f3bSpatrick Info.GetArchitecture().GetArchitectureName());
91be691f3bSpatrick
92be691f3bSpatrick std::unique_ptr<NativeProcessFreeBSD> process_up(new NativeProcessFreeBSD(
93be691f3bSpatrick pid, launch_info.GetPTY().ReleasePrimaryFileDescriptor(), native_delegate,
94be691f3bSpatrick Info.GetArchitecture(), mainloop));
95be691f3bSpatrick
96be691f3bSpatrick status = process_up->SetupTrace();
97be691f3bSpatrick if (status.Fail())
98be691f3bSpatrick return status.ToError();
99be691f3bSpatrick
100be691f3bSpatrick for (const auto &thread : process_up->m_threads)
101be691f3bSpatrick static_cast<NativeThreadFreeBSD &>(*thread).SetStoppedBySignal(SIGSTOP);
102be691f3bSpatrick process_up->SetState(StateType::eStateStopped, false);
103be691f3bSpatrick
104be691f3bSpatrick return std::move(process_up);
105be691f3bSpatrick }
106be691f3bSpatrick
107be691f3bSpatrick llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
Attach(lldb::pid_t pid,NativeProcessProtocol::NativeDelegate & native_delegate,MainLoop & mainloop) const108be691f3bSpatrick NativeProcessFreeBSD::Factory::Attach(
109be691f3bSpatrick lldb::pid_t pid, NativeProcessProtocol::NativeDelegate &native_delegate,
110be691f3bSpatrick MainLoop &mainloop) const {
111*f6aab3d8Srobert Log *log = GetLog(POSIXLog::Process);
112be691f3bSpatrick LLDB_LOG(log, "pid = {0:x}", pid);
113be691f3bSpatrick
114be691f3bSpatrick // Retrieve the architecture for the running process.
115be691f3bSpatrick ProcessInstanceInfo Info;
116be691f3bSpatrick if (!Host::GetProcessInfo(pid, Info)) {
117be691f3bSpatrick return llvm::make_error<StringError>("Cannot get process architecture",
118be691f3bSpatrick llvm::inconvertibleErrorCode());
119be691f3bSpatrick }
120be691f3bSpatrick
121be691f3bSpatrick std::unique_ptr<NativeProcessFreeBSD> process_up(new NativeProcessFreeBSD(
122be691f3bSpatrick pid, -1, native_delegate, Info.GetArchitecture(), mainloop));
123be691f3bSpatrick
124be691f3bSpatrick Status status = process_up->Attach();
125be691f3bSpatrick if (!status.Success())
126be691f3bSpatrick return status.ToError();
127be691f3bSpatrick
128be691f3bSpatrick return std::move(process_up);
129be691f3bSpatrick }
130be691f3bSpatrick
131be691f3bSpatrick NativeProcessFreeBSD::Extension
GetSupportedExtensions() const132be691f3bSpatrick NativeProcessFreeBSD::Factory::GetSupportedExtensions() const {
133*f6aab3d8Srobert return
134*f6aab3d8Srobert #if defined(PT_COREDUMP)
135*f6aab3d8Srobert Extension::savecore |
136*f6aab3d8Srobert #endif
137*f6aab3d8Srobert Extension::multiprocess | Extension::fork | Extension::vfork |
138*f6aab3d8Srobert Extension::pass_signals | Extension::auxv | Extension::libraries_svr4 |
139*f6aab3d8Srobert Extension::siginfo_read;
140be691f3bSpatrick }
141be691f3bSpatrick
142be691f3bSpatrick // Public Instance Methods
143be691f3bSpatrick
NativeProcessFreeBSD(::pid_t pid,int terminal_fd,NativeDelegate & delegate,const ArchSpec & arch,MainLoop & mainloop)144be691f3bSpatrick NativeProcessFreeBSD::NativeProcessFreeBSD(::pid_t pid, int terminal_fd,
145be691f3bSpatrick NativeDelegate &delegate,
146be691f3bSpatrick const ArchSpec &arch,
147be691f3bSpatrick MainLoop &mainloop)
148be691f3bSpatrick : NativeProcessELF(pid, terminal_fd, delegate), m_arch(arch),
149be691f3bSpatrick m_main_loop(mainloop) {
150be691f3bSpatrick if (m_terminal_fd != -1) {
151be691f3bSpatrick Status status = EnsureFDFlags(m_terminal_fd, O_NONBLOCK);
152be691f3bSpatrick assert(status.Success());
153be691f3bSpatrick }
154be691f3bSpatrick
155be691f3bSpatrick Status status;
156be691f3bSpatrick m_sigchld_handle = mainloop.RegisterSignal(
157be691f3bSpatrick SIGCHLD, [this](MainLoopBase &) { SigchldHandler(); }, status);
158be691f3bSpatrick assert(m_sigchld_handle && status.Success());
159be691f3bSpatrick }
160be691f3bSpatrick
161be691f3bSpatrick // Handles all waitpid events from the inferior process.
MonitorCallback(lldb::pid_t pid,int signal)162be691f3bSpatrick void NativeProcessFreeBSD::MonitorCallback(lldb::pid_t pid, int signal) {
163be691f3bSpatrick switch (signal) {
164be691f3bSpatrick case SIGTRAP:
165be691f3bSpatrick return MonitorSIGTRAP(pid);
166be691f3bSpatrick case SIGSTOP:
167be691f3bSpatrick return MonitorSIGSTOP(pid);
168be691f3bSpatrick default:
169be691f3bSpatrick return MonitorSignal(pid, signal);
170be691f3bSpatrick }
171be691f3bSpatrick }
172be691f3bSpatrick
MonitorExited(lldb::pid_t pid,WaitStatus status)173be691f3bSpatrick void NativeProcessFreeBSD::MonitorExited(lldb::pid_t pid, WaitStatus status) {
174*f6aab3d8Srobert Log *log = GetLog(POSIXLog::Process);
175be691f3bSpatrick
176be691f3bSpatrick LLDB_LOG(log, "got exit signal({0}) , pid = {1}", status, pid);
177be691f3bSpatrick
178be691f3bSpatrick /* Stop Tracking All Threads attached to Process */
179be691f3bSpatrick m_threads.clear();
180be691f3bSpatrick
181be691f3bSpatrick SetExitStatus(status, true);
182be691f3bSpatrick
183be691f3bSpatrick // Notify delegate that our process has exited.
184be691f3bSpatrick SetState(StateType::eStateExited, true);
185be691f3bSpatrick }
186be691f3bSpatrick
MonitorSIGSTOP(lldb::pid_t pid)187be691f3bSpatrick void NativeProcessFreeBSD::MonitorSIGSTOP(lldb::pid_t pid) {
188be691f3bSpatrick /* Stop all Threads attached to Process */
189be691f3bSpatrick for (const auto &thread : m_threads) {
190be691f3bSpatrick static_cast<NativeThreadFreeBSD &>(*thread).SetStoppedBySignal(SIGSTOP,
191be691f3bSpatrick nullptr);
192be691f3bSpatrick }
193be691f3bSpatrick SetState(StateType::eStateStopped, true);
194be691f3bSpatrick }
195be691f3bSpatrick
MonitorSIGTRAP(lldb::pid_t pid)196be691f3bSpatrick void NativeProcessFreeBSD::MonitorSIGTRAP(lldb::pid_t pid) {
197*f6aab3d8Srobert Log *log = GetLog(POSIXLog::Process);
198be691f3bSpatrick struct ptrace_lwpinfo info;
199be691f3bSpatrick
200be691f3bSpatrick const auto siginfo_err = PtraceWrapper(PT_LWPINFO, pid, &info, sizeof(info));
201be691f3bSpatrick if (siginfo_err.Fail()) {
202be691f3bSpatrick LLDB_LOG(log, "PT_LWPINFO failed {0}", siginfo_err);
203be691f3bSpatrick return;
204be691f3bSpatrick }
205be691f3bSpatrick assert(info.pl_event == PL_EVENT_SIGNAL);
206be691f3bSpatrick
207be691f3bSpatrick LLDB_LOG(log, "got SIGTRAP, pid = {0}, lwpid = {1}, flags = {2:x}", pid,
208be691f3bSpatrick info.pl_lwpid, info.pl_flags);
209be691f3bSpatrick NativeThreadFreeBSD *thread = nullptr;
210be691f3bSpatrick
211be691f3bSpatrick if (info.pl_flags & (PL_FLAG_BORN | PL_FLAG_EXITED)) {
212be691f3bSpatrick if (info.pl_flags & PL_FLAG_BORN) {
213be691f3bSpatrick LLDB_LOG(log, "monitoring new thread, tid = {0}", info.pl_lwpid);
214be691f3bSpatrick NativeThreadFreeBSD &t = AddThread(info.pl_lwpid);
215be691f3bSpatrick
216be691f3bSpatrick // Technically, the FreeBSD kernel copies the debug registers to new
217be691f3bSpatrick // threads. However, there is a non-negligible delay between acquiring
218be691f3bSpatrick // the DR values and reporting the new thread during which the user may
219be691f3bSpatrick // establish a new watchpoint. In order to ensure that watchpoints
220be691f3bSpatrick // established during this period are propagated to new threads,
221be691f3bSpatrick // explicitly copy the DR value at the time the new thread is reported.
222be691f3bSpatrick //
223be691f3bSpatrick // See also: https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=250954
224be691f3bSpatrick
225be691f3bSpatrick llvm::Error error = t.CopyWatchpointsFrom(
226be691f3bSpatrick static_cast<NativeThreadFreeBSD &>(*GetCurrentThread()));
227be691f3bSpatrick if (error) {
228be691f3bSpatrick LLDB_LOG_ERROR(log, std::move(error),
229be691f3bSpatrick "failed to copy watchpoints to new thread {1}: {0}",
230be691f3bSpatrick info.pl_lwpid);
231be691f3bSpatrick SetState(StateType::eStateInvalid);
232be691f3bSpatrick return;
233be691f3bSpatrick }
234be691f3bSpatrick } else /*if (info.pl_flags & PL_FLAG_EXITED)*/ {
235be691f3bSpatrick LLDB_LOG(log, "thread exited, tid = {0}", info.pl_lwpid);
236be691f3bSpatrick RemoveThread(info.pl_lwpid);
237be691f3bSpatrick }
238be691f3bSpatrick
239be691f3bSpatrick Status error =
240be691f3bSpatrick PtraceWrapper(PT_CONTINUE, pid, reinterpret_cast<void *>(1), 0);
241be691f3bSpatrick if (error.Fail())
242be691f3bSpatrick SetState(StateType::eStateInvalid);
243be691f3bSpatrick return;
244be691f3bSpatrick }
245be691f3bSpatrick
246be691f3bSpatrick if (info.pl_flags & PL_FLAG_EXEC) {
247be691f3bSpatrick Status error = ReinitializeThreads();
248be691f3bSpatrick if (error.Fail()) {
249be691f3bSpatrick SetState(StateType::eStateInvalid);
250be691f3bSpatrick return;
251be691f3bSpatrick }
252be691f3bSpatrick
253be691f3bSpatrick // Let our delegate know we have just exec'd.
254be691f3bSpatrick NotifyDidExec();
255be691f3bSpatrick
256be691f3bSpatrick for (const auto &thread : m_threads)
257be691f3bSpatrick static_cast<NativeThreadFreeBSD &>(*thread).SetStoppedByExec();
258*f6aab3d8Srobert SetCurrentThreadID(m_threads.front()->GetID());
259be691f3bSpatrick SetState(StateType::eStateStopped, true);
260be691f3bSpatrick return;
261be691f3bSpatrick }
262be691f3bSpatrick
263be691f3bSpatrick if (info.pl_lwpid > 0) {
264be691f3bSpatrick for (const auto &t : m_threads) {
265be691f3bSpatrick if (t->GetID() == static_cast<lldb::tid_t>(info.pl_lwpid))
266be691f3bSpatrick thread = static_cast<NativeThreadFreeBSD *>(t.get());
267be691f3bSpatrick static_cast<NativeThreadFreeBSD *>(t.get())->SetStoppedWithNoReason();
268be691f3bSpatrick }
269be691f3bSpatrick if (!thread)
270be691f3bSpatrick LLDB_LOG(log, "thread not found in m_threads, pid = {0}, LWP = {1}", pid,
271be691f3bSpatrick info.pl_lwpid);
272be691f3bSpatrick }
273be691f3bSpatrick
274be691f3bSpatrick if (info.pl_flags & PL_FLAG_FORKED) {
275be691f3bSpatrick assert(thread);
276be691f3bSpatrick MonitorClone(info.pl_child_pid, info.pl_flags & PL_FLAG_VFORKED, *thread);
277be691f3bSpatrick return;
278be691f3bSpatrick }
279be691f3bSpatrick
280be691f3bSpatrick if (info.pl_flags & PL_FLAG_VFORK_DONE) {
281be691f3bSpatrick assert(thread);
282be691f3bSpatrick if ((m_enabled_extensions & Extension::vfork) == Extension::vfork) {
283be691f3bSpatrick thread->SetStoppedByVForkDone();
284be691f3bSpatrick SetState(StateType::eStateStopped, true);
285be691f3bSpatrick } else {
286be691f3bSpatrick Status error =
287be691f3bSpatrick PtraceWrapper(PT_CONTINUE, pid, reinterpret_cast<void *>(1), 0);
288be691f3bSpatrick if (error.Fail())
289be691f3bSpatrick SetState(StateType::eStateInvalid);
290be691f3bSpatrick }
291be691f3bSpatrick return;
292be691f3bSpatrick }
293be691f3bSpatrick
294be691f3bSpatrick if (info.pl_flags & PL_FLAG_SI) {
295be691f3bSpatrick assert(info.pl_siginfo.si_signo == SIGTRAP);
296be691f3bSpatrick LLDB_LOG(log, "SIGTRAP siginfo: si_code = {0}, pid = {1}",
297be691f3bSpatrick info.pl_siginfo.si_code, info.pl_siginfo.si_pid);
298be691f3bSpatrick
299be691f3bSpatrick switch (info.pl_siginfo.si_code) {
300be691f3bSpatrick case TRAP_BRKPT:
301be691f3bSpatrick LLDB_LOG(log, "SIGTRAP/TRAP_BRKPT: si_addr: {0}",
302be691f3bSpatrick info.pl_siginfo.si_addr);
303be691f3bSpatrick
304be691f3bSpatrick if (thread) {
305be691f3bSpatrick auto thread_info =
306be691f3bSpatrick m_threads_stepping_with_breakpoint.find(thread->GetID());
307be691f3bSpatrick if (thread_info != m_threads_stepping_with_breakpoint.end()) {
308be691f3bSpatrick thread->SetStoppedByTrace();
309be691f3bSpatrick Status brkpt_error = RemoveBreakpoint(thread_info->second);
310be691f3bSpatrick if (brkpt_error.Fail())
311be691f3bSpatrick LLDB_LOG(log, "pid = {0} remove stepping breakpoint: {1}",
312be691f3bSpatrick thread_info->first, brkpt_error);
313be691f3bSpatrick m_threads_stepping_with_breakpoint.erase(thread_info);
314be691f3bSpatrick } else
315be691f3bSpatrick thread->SetStoppedByBreakpoint();
316be691f3bSpatrick FixupBreakpointPCAsNeeded(*thread);
317*f6aab3d8Srobert SetCurrentThreadID(thread->GetID());
318be691f3bSpatrick }
319be691f3bSpatrick SetState(StateType::eStateStopped, true);
320be691f3bSpatrick return;
321be691f3bSpatrick case TRAP_TRACE:
322be691f3bSpatrick LLDB_LOG(log, "SIGTRAP/TRAP_TRACE: si_addr: {0}",
323be691f3bSpatrick info.pl_siginfo.si_addr);
324be691f3bSpatrick
325be691f3bSpatrick if (thread) {
326be691f3bSpatrick auto ®ctx = static_cast<NativeRegisterContextFreeBSD &>(
327be691f3bSpatrick thread->GetRegisterContext());
328be691f3bSpatrick uint32_t wp_index = LLDB_INVALID_INDEX32;
329be691f3bSpatrick Status error = regctx.GetWatchpointHitIndex(
330be691f3bSpatrick wp_index, reinterpret_cast<uintptr_t>(info.pl_siginfo.si_addr));
331be691f3bSpatrick if (error.Fail())
332be691f3bSpatrick LLDB_LOG(log,
333be691f3bSpatrick "received error while checking for watchpoint hits, pid = "
334be691f3bSpatrick "{0}, LWP = {1}, error = {2}",
335be691f3bSpatrick pid, info.pl_lwpid, error);
336be691f3bSpatrick if (wp_index != LLDB_INVALID_INDEX32) {
337be691f3bSpatrick regctx.ClearWatchpointHit(wp_index);
338be691f3bSpatrick thread->SetStoppedByWatchpoint(wp_index);
339*f6aab3d8Srobert SetCurrentThreadID(thread->GetID());
340be691f3bSpatrick SetState(StateType::eStateStopped, true);
341be691f3bSpatrick break;
342be691f3bSpatrick }
343be691f3bSpatrick
344be691f3bSpatrick thread->SetStoppedByTrace();
345*f6aab3d8Srobert SetCurrentThreadID(thread->GetID());
346be691f3bSpatrick }
347be691f3bSpatrick
348be691f3bSpatrick SetState(StateType::eStateStopped, true);
349be691f3bSpatrick return;
350be691f3bSpatrick }
351be691f3bSpatrick }
352be691f3bSpatrick
353be691f3bSpatrick // Either user-generated SIGTRAP or an unknown event that would
354be691f3bSpatrick // otherwise leave the debugger hanging.
355be691f3bSpatrick LLDB_LOG(log, "unknown SIGTRAP, passing to generic handler");
356be691f3bSpatrick MonitorSignal(pid, SIGTRAP);
357be691f3bSpatrick }
358be691f3bSpatrick
MonitorSignal(lldb::pid_t pid,int signal)359be691f3bSpatrick void NativeProcessFreeBSD::MonitorSignal(lldb::pid_t pid, int signal) {
360*f6aab3d8Srobert Log *log = GetLog(POSIXLog::Process);
361be691f3bSpatrick struct ptrace_lwpinfo info;
362be691f3bSpatrick
363be691f3bSpatrick const auto siginfo_err = PtraceWrapper(PT_LWPINFO, pid, &info, sizeof(info));
364be691f3bSpatrick if (siginfo_err.Fail()) {
365be691f3bSpatrick LLDB_LOG(log, "PT_LWPINFO failed {0}", siginfo_err);
366be691f3bSpatrick return;
367be691f3bSpatrick }
368be691f3bSpatrick assert(info.pl_event == PL_EVENT_SIGNAL);
369be691f3bSpatrick // TODO: do we need to handle !PL_FLAG_SI?
370be691f3bSpatrick assert(info.pl_flags & PL_FLAG_SI);
371be691f3bSpatrick assert(info.pl_siginfo.si_signo == signal);
372be691f3bSpatrick
373be691f3bSpatrick for (const auto &abs_thread : m_threads) {
374be691f3bSpatrick NativeThreadFreeBSD &thread =
375be691f3bSpatrick static_cast<NativeThreadFreeBSD &>(*abs_thread);
376be691f3bSpatrick assert(info.pl_lwpid >= 0);
377be691f3bSpatrick if (info.pl_lwpid == 0 ||
378*f6aab3d8Srobert static_cast<lldb::tid_t>(info.pl_lwpid) == thread.GetID()) {
379be691f3bSpatrick thread.SetStoppedBySignal(info.pl_siginfo.si_signo, &info.pl_siginfo);
380*f6aab3d8Srobert SetCurrentThreadID(thread.GetID());
381*f6aab3d8Srobert } else
382be691f3bSpatrick thread.SetStoppedWithNoReason();
383be691f3bSpatrick }
384be691f3bSpatrick SetState(StateType::eStateStopped, true);
385be691f3bSpatrick }
386be691f3bSpatrick
PtraceWrapper(int req,lldb::pid_t pid,void * addr,int data,int * result)387be691f3bSpatrick Status NativeProcessFreeBSD::PtraceWrapper(int req, lldb::pid_t pid, void *addr,
388be691f3bSpatrick int data, int *result) {
389*f6aab3d8Srobert Log *log = GetLog(POSIXLog::Ptrace);
390be691f3bSpatrick Status error;
391be691f3bSpatrick int ret;
392be691f3bSpatrick
393be691f3bSpatrick errno = 0;
394be691f3bSpatrick ret =
395be691f3bSpatrick ptrace(req, static_cast<::pid_t>(pid), static_cast<caddr_t>(addr), data);
396be691f3bSpatrick
397be691f3bSpatrick if (ret == -1)
398be691f3bSpatrick error.SetErrorToErrno();
399be691f3bSpatrick
400be691f3bSpatrick if (result)
401be691f3bSpatrick *result = ret;
402be691f3bSpatrick
403be691f3bSpatrick LLDB_LOG(log, "ptrace({0}, {1}, {2}, {3})={4:x}", req, pid, addr, data, ret);
404be691f3bSpatrick
405be691f3bSpatrick if (error.Fail())
406be691f3bSpatrick LLDB_LOG(log, "ptrace() failed: {0}", error);
407be691f3bSpatrick
408be691f3bSpatrick return error;
409be691f3bSpatrick }
410be691f3bSpatrick
411be691f3bSpatrick llvm::Expected<llvm::ArrayRef<uint8_t>>
GetSoftwareBreakpointTrapOpcode(size_t size_hint)412be691f3bSpatrick NativeProcessFreeBSD::GetSoftwareBreakpointTrapOpcode(size_t size_hint) {
413be691f3bSpatrick static const uint8_t g_arm_opcode[] = {0xfe, 0xde, 0xff, 0xe7};
414be691f3bSpatrick static const uint8_t g_thumb_opcode[] = {0x01, 0xde};
415be691f3bSpatrick
416be691f3bSpatrick switch (GetArchitecture().GetMachine()) {
417be691f3bSpatrick case llvm::Triple::arm:
418be691f3bSpatrick switch (size_hint) {
419be691f3bSpatrick case 2:
420*f6aab3d8Srobert return llvm::ArrayRef(g_thumb_opcode);
421be691f3bSpatrick case 4:
422*f6aab3d8Srobert return llvm::ArrayRef(g_arm_opcode);
423be691f3bSpatrick default:
424be691f3bSpatrick return llvm::createStringError(llvm::inconvertibleErrorCode(),
425be691f3bSpatrick "Unrecognised trap opcode size hint!");
426be691f3bSpatrick }
427be691f3bSpatrick default:
428be691f3bSpatrick return NativeProcessProtocol::GetSoftwareBreakpointTrapOpcode(size_hint);
429be691f3bSpatrick }
430be691f3bSpatrick }
431be691f3bSpatrick
Resume(const ResumeActionList & resume_actions)432be691f3bSpatrick Status NativeProcessFreeBSD::Resume(const ResumeActionList &resume_actions) {
433*f6aab3d8Srobert Log *log = GetLog(POSIXLog::Process);
434be691f3bSpatrick LLDB_LOG(log, "pid {0}", GetID());
435be691f3bSpatrick
436be691f3bSpatrick Status ret;
437be691f3bSpatrick
438be691f3bSpatrick int signal = 0;
439be691f3bSpatrick for (const auto &abs_thread : m_threads) {
440be691f3bSpatrick assert(abs_thread && "thread list should not contain NULL threads");
441be691f3bSpatrick NativeThreadFreeBSD &thread =
442be691f3bSpatrick static_cast<NativeThreadFreeBSD &>(*abs_thread);
443be691f3bSpatrick
444be691f3bSpatrick const ResumeAction *action =
445be691f3bSpatrick resume_actions.GetActionForThread(thread.GetID(), true);
446be691f3bSpatrick // we need to explicit issue suspend requests, so it is simpler to map it
447be691f3bSpatrick // into proper action
448be691f3bSpatrick ResumeAction suspend_action{thread.GetID(), eStateSuspended,
449be691f3bSpatrick LLDB_INVALID_SIGNAL_NUMBER};
450be691f3bSpatrick
451be691f3bSpatrick if (action == nullptr) {
452be691f3bSpatrick LLDB_LOG(log, "no action specified for pid {0} tid {1}", GetID(),
453be691f3bSpatrick thread.GetID());
454be691f3bSpatrick action = &suspend_action;
455be691f3bSpatrick }
456be691f3bSpatrick
457be691f3bSpatrick LLDB_LOG(
458be691f3bSpatrick log,
459be691f3bSpatrick "processing resume action state {0} signal {1} for pid {2} tid {3}",
460be691f3bSpatrick action->state, action->signal, GetID(), thread.GetID());
461be691f3bSpatrick
462be691f3bSpatrick switch (action->state) {
463be691f3bSpatrick case eStateRunning:
464be691f3bSpatrick ret = thread.Resume();
465be691f3bSpatrick break;
466be691f3bSpatrick case eStateStepping:
467be691f3bSpatrick ret = thread.SingleStep();
468be691f3bSpatrick break;
469be691f3bSpatrick case eStateSuspended:
470be691f3bSpatrick case eStateStopped:
471be691f3bSpatrick if (action->signal != LLDB_INVALID_SIGNAL_NUMBER)
472be691f3bSpatrick return Status("Passing signal to suspended thread unsupported");
473be691f3bSpatrick
474be691f3bSpatrick ret = thread.Suspend();
475be691f3bSpatrick break;
476be691f3bSpatrick
477be691f3bSpatrick default:
478be691f3bSpatrick return Status(
479be691f3bSpatrick "NativeProcessFreeBSD::%s (): unexpected state %s specified "
480be691f3bSpatrick "for pid %" PRIu64 ", tid %" PRIu64,
481be691f3bSpatrick __FUNCTION__, StateAsCString(action->state), GetID(), thread.GetID());
482be691f3bSpatrick }
483be691f3bSpatrick
484be691f3bSpatrick if (!ret.Success())
485be691f3bSpatrick return ret;
486be691f3bSpatrick if (action->signal != LLDB_INVALID_SIGNAL_NUMBER)
487be691f3bSpatrick signal = action->signal;
488be691f3bSpatrick }
489be691f3bSpatrick
490be691f3bSpatrick ret =
491be691f3bSpatrick PtraceWrapper(PT_CONTINUE, GetID(), reinterpret_cast<void *>(1), signal);
492be691f3bSpatrick if (ret.Success())
493be691f3bSpatrick SetState(eStateRunning, true);
494be691f3bSpatrick return ret;
495be691f3bSpatrick }
496be691f3bSpatrick
Halt()497be691f3bSpatrick Status NativeProcessFreeBSD::Halt() {
498be691f3bSpatrick Status error;
499be691f3bSpatrick
500*f6aab3d8Srobert // Do not try to stop a process that's already stopped, this may cause
501*f6aab3d8Srobert // the SIGSTOP to get queued and stop the process again once resumed.
502*f6aab3d8Srobert if (StateIsStoppedState(m_state, false))
503*f6aab3d8Srobert return error;
504be691f3bSpatrick if (kill(GetID(), SIGSTOP) != 0)
505be691f3bSpatrick error.SetErrorToErrno();
506be691f3bSpatrick return error;
507be691f3bSpatrick }
508be691f3bSpatrick
Detach()509be691f3bSpatrick Status NativeProcessFreeBSD::Detach() {
510be691f3bSpatrick Status error;
511be691f3bSpatrick
512be691f3bSpatrick // Stop monitoring the inferior.
513be691f3bSpatrick m_sigchld_handle.reset();
514be691f3bSpatrick
515be691f3bSpatrick // Tell ptrace to detach from the process.
516be691f3bSpatrick if (GetID() == LLDB_INVALID_PROCESS_ID)
517be691f3bSpatrick return error;
518be691f3bSpatrick
519be691f3bSpatrick return PtraceWrapper(PT_DETACH, GetID());
520be691f3bSpatrick }
521be691f3bSpatrick
Signal(int signo)522be691f3bSpatrick Status NativeProcessFreeBSD::Signal(int signo) {
523be691f3bSpatrick Status error;
524be691f3bSpatrick
525be691f3bSpatrick if (kill(GetID(), signo))
526be691f3bSpatrick error.SetErrorToErrno();
527be691f3bSpatrick
528be691f3bSpatrick return error;
529be691f3bSpatrick }
530be691f3bSpatrick
Interrupt()531be691f3bSpatrick Status NativeProcessFreeBSD::Interrupt() { return Halt(); }
532be691f3bSpatrick
Kill()533be691f3bSpatrick Status NativeProcessFreeBSD::Kill() {
534*f6aab3d8Srobert Log *log = GetLog(POSIXLog::Process);
535be691f3bSpatrick LLDB_LOG(log, "pid {0}", GetID());
536be691f3bSpatrick
537be691f3bSpatrick Status error;
538be691f3bSpatrick
539be691f3bSpatrick switch (m_state) {
540be691f3bSpatrick case StateType::eStateInvalid:
541be691f3bSpatrick case StateType::eStateExited:
542be691f3bSpatrick case StateType::eStateCrashed:
543be691f3bSpatrick case StateType::eStateDetached:
544be691f3bSpatrick case StateType::eStateUnloaded:
545be691f3bSpatrick // Nothing to do - the process is already dead.
546be691f3bSpatrick LLDB_LOG(log, "ignored for PID {0} due to current state: {1}", GetID(),
547be691f3bSpatrick StateAsCString(m_state));
548be691f3bSpatrick return error;
549be691f3bSpatrick
550be691f3bSpatrick case StateType::eStateConnected:
551be691f3bSpatrick case StateType::eStateAttaching:
552be691f3bSpatrick case StateType::eStateLaunching:
553be691f3bSpatrick case StateType::eStateStopped:
554be691f3bSpatrick case StateType::eStateRunning:
555be691f3bSpatrick case StateType::eStateStepping:
556be691f3bSpatrick case StateType::eStateSuspended:
557be691f3bSpatrick // We can try to kill a process in these states.
558be691f3bSpatrick break;
559be691f3bSpatrick }
560be691f3bSpatrick
561be691f3bSpatrick return PtraceWrapper(PT_KILL, m_pid);
562be691f3bSpatrick }
563be691f3bSpatrick
GetMemoryRegionInfo(lldb::addr_t load_addr,MemoryRegionInfo & range_info)564be691f3bSpatrick Status NativeProcessFreeBSD::GetMemoryRegionInfo(lldb::addr_t load_addr,
565be691f3bSpatrick MemoryRegionInfo &range_info) {
566be691f3bSpatrick
567be691f3bSpatrick if (m_supports_mem_region == LazyBool::eLazyBoolNo) {
568be691f3bSpatrick // We're done.
569be691f3bSpatrick return Status("unsupported");
570be691f3bSpatrick }
571be691f3bSpatrick
572be691f3bSpatrick Status error = PopulateMemoryRegionCache();
573be691f3bSpatrick if (error.Fail()) {
574be691f3bSpatrick return error;
575be691f3bSpatrick }
576be691f3bSpatrick
577be691f3bSpatrick lldb::addr_t prev_base_address = 0;
578be691f3bSpatrick // FIXME start by finding the last region that is <= target address using
579be691f3bSpatrick // binary search. Data is sorted.
580be691f3bSpatrick // There can be a ton of regions on pthreads apps with lots of threads.
581be691f3bSpatrick for (auto it = m_mem_region_cache.begin(); it != m_mem_region_cache.end();
582be691f3bSpatrick ++it) {
583be691f3bSpatrick MemoryRegionInfo &proc_entry_info = it->first;
584be691f3bSpatrick // Sanity check assumption that memory map entries are ascending.
585be691f3bSpatrick assert((proc_entry_info.GetRange().GetRangeBase() >= prev_base_address) &&
586be691f3bSpatrick "descending memory map entries detected, unexpected");
587be691f3bSpatrick prev_base_address = proc_entry_info.GetRange().GetRangeBase();
588be691f3bSpatrick UNUSED_IF_ASSERT_DISABLED(prev_base_address);
589be691f3bSpatrick // If the target address comes before this entry, indicate distance to next
590be691f3bSpatrick // region.
591be691f3bSpatrick if (load_addr < proc_entry_info.GetRange().GetRangeBase()) {
592be691f3bSpatrick range_info.GetRange().SetRangeBase(load_addr);
593be691f3bSpatrick range_info.GetRange().SetByteSize(
594be691f3bSpatrick proc_entry_info.GetRange().GetRangeBase() - load_addr);
595be691f3bSpatrick range_info.SetReadable(MemoryRegionInfo::OptionalBool::eNo);
596be691f3bSpatrick range_info.SetWritable(MemoryRegionInfo::OptionalBool::eNo);
597be691f3bSpatrick range_info.SetExecutable(MemoryRegionInfo::OptionalBool::eNo);
598be691f3bSpatrick range_info.SetMapped(MemoryRegionInfo::OptionalBool::eNo);
599be691f3bSpatrick return error;
600be691f3bSpatrick } else if (proc_entry_info.GetRange().Contains(load_addr)) {
601be691f3bSpatrick // The target address is within the memory region we're processing here.
602be691f3bSpatrick range_info = proc_entry_info;
603be691f3bSpatrick return error;
604be691f3bSpatrick }
605be691f3bSpatrick // The target memory address comes somewhere after the region we just
606be691f3bSpatrick // parsed.
607be691f3bSpatrick }
608be691f3bSpatrick // If we made it here, we didn't find an entry that contained the given
609be691f3bSpatrick // address. Return the load_addr as start and the amount of bytes betwwen
610be691f3bSpatrick // load address and the end of the memory as size.
611be691f3bSpatrick range_info.GetRange().SetRangeBase(load_addr);
612be691f3bSpatrick range_info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS);
613be691f3bSpatrick range_info.SetReadable(MemoryRegionInfo::OptionalBool::eNo);
614be691f3bSpatrick range_info.SetWritable(MemoryRegionInfo::OptionalBool::eNo);
615be691f3bSpatrick range_info.SetExecutable(MemoryRegionInfo::OptionalBool::eNo);
616be691f3bSpatrick range_info.SetMapped(MemoryRegionInfo::OptionalBool::eNo);
617be691f3bSpatrick return error;
618be691f3bSpatrick }
619be691f3bSpatrick
PopulateMemoryRegionCache()620be691f3bSpatrick Status NativeProcessFreeBSD::PopulateMemoryRegionCache() {
621*f6aab3d8Srobert Log *log = GetLog(POSIXLog::Process);
622be691f3bSpatrick // If our cache is empty, pull the latest. There should always be at least
623be691f3bSpatrick // one memory region if memory region handling is supported.
624be691f3bSpatrick if (!m_mem_region_cache.empty()) {
625be691f3bSpatrick LLDB_LOG(log, "reusing {0} cached memory region entries",
626be691f3bSpatrick m_mem_region_cache.size());
627be691f3bSpatrick return Status();
628be691f3bSpatrick }
629be691f3bSpatrick
630be691f3bSpatrick int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_VMMAP, static_cast<int>(m_pid)};
631be691f3bSpatrick int ret;
632be691f3bSpatrick size_t len;
633be691f3bSpatrick
634be691f3bSpatrick ret = ::sysctl(mib, 4, nullptr, &len, nullptr, 0);
635be691f3bSpatrick if (ret != 0) {
636be691f3bSpatrick m_supports_mem_region = LazyBool::eLazyBoolNo;
637be691f3bSpatrick return Status("sysctl() for KERN_PROC_VMMAP failed");
638be691f3bSpatrick }
639be691f3bSpatrick
640be691f3bSpatrick std::unique_ptr<WritableMemoryBuffer> buf =
641be691f3bSpatrick llvm::WritableMemoryBuffer::getNewMemBuffer(len);
642be691f3bSpatrick ret = ::sysctl(mib, 4, buf->getBufferStart(), &len, nullptr, 0);
643be691f3bSpatrick if (ret != 0) {
644be691f3bSpatrick m_supports_mem_region = LazyBool::eLazyBoolNo;
645be691f3bSpatrick return Status("sysctl() for KERN_PROC_VMMAP failed");
646be691f3bSpatrick }
647be691f3bSpatrick
648be691f3bSpatrick char *bp = buf->getBufferStart();
649be691f3bSpatrick char *end = bp + len;
650be691f3bSpatrick while (bp < end) {
651be691f3bSpatrick auto *kv = reinterpret_cast<struct kinfo_vmentry *>(bp);
652be691f3bSpatrick if (kv->kve_structsize == 0)
653be691f3bSpatrick break;
654be691f3bSpatrick bp += kv->kve_structsize;
655be691f3bSpatrick
656be691f3bSpatrick MemoryRegionInfo info;
657be691f3bSpatrick info.Clear();
658be691f3bSpatrick info.GetRange().SetRangeBase(kv->kve_start);
659be691f3bSpatrick info.GetRange().SetRangeEnd(kv->kve_end);
660be691f3bSpatrick info.SetMapped(MemoryRegionInfo::OptionalBool::eYes);
661be691f3bSpatrick
662be691f3bSpatrick if (kv->kve_protection & VM_PROT_READ)
663be691f3bSpatrick info.SetReadable(MemoryRegionInfo::OptionalBool::eYes);
664be691f3bSpatrick else
665be691f3bSpatrick info.SetReadable(MemoryRegionInfo::OptionalBool::eNo);
666be691f3bSpatrick
667be691f3bSpatrick if (kv->kve_protection & VM_PROT_WRITE)
668be691f3bSpatrick info.SetWritable(MemoryRegionInfo::OptionalBool::eYes);
669be691f3bSpatrick else
670be691f3bSpatrick info.SetWritable(MemoryRegionInfo::OptionalBool::eNo);
671be691f3bSpatrick
672be691f3bSpatrick if (kv->kve_protection & VM_PROT_EXECUTE)
673be691f3bSpatrick info.SetExecutable(MemoryRegionInfo::OptionalBool::eYes);
674be691f3bSpatrick else
675be691f3bSpatrick info.SetExecutable(MemoryRegionInfo::OptionalBool::eNo);
676be691f3bSpatrick
677be691f3bSpatrick if (kv->kve_path[0])
678be691f3bSpatrick info.SetName(kv->kve_path);
679be691f3bSpatrick
680be691f3bSpatrick m_mem_region_cache.emplace_back(info,
681be691f3bSpatrick FileSpec(info.GetName().GetCString()));
682be691f3bSpatrick }
683be691f3bSpatrick
684be691f3bSpatrick if (m_mem_region_cache.empty()) {
685be691f3bSpatrick // No entries after attempting to read them. This shouldn't happen. Assume
686be691f3bSpatrick // we don't support map entries.
687be691f3bSpatrick LLDB_LOG(log, "failed to find any vmmap entries, assuming no support "
688be691f3bSpatrick "for memory region metadata retrieval");
689be691f3bSpatrick m_supports_mem_region = LazyBool::eLazyBoolNo;
690be691f3bSpatrick return Status("not supported");
691be691f3bSpatrick }
692be691f3bSpatrick LLDB_LOG(log, "read {0} memory region entries from process {1}",
693be691f3bSpatrick m_mem_region_cache.size(), GetID());
694be691f3bSpatrick // We support memory retrieval, remember that.
695be691f3bSpatrick m_supports_mem_region = LazyBool::eLazyBoolYes;
696be691f3bSpatrick
697be691f3bSpatrick return Status();
698be691f3bSpatrick }
699be691f3bSpatrick
UpdateThreads()700be691f3bSpatrick size_t NativeProcessFreeBSD::UpdateThreads() { return m_threads.size(); }
701be691f3bSpatrick
SetBreakpoint(lldb::addr_t addr,uint32_t size,bool hardware)702be691f3bSpatrick Status NativeProcessFreeBSD::SetBreakpoint(lldb::addr_t addr, uint32_t size,
703be691f3bSpatrick bool hardware) {
704be691f3bSpatrick if (hardware)
705be691f3bSpatrick return SetHardwareBreakpoint(addr, size);
706be691f3bSpatrick return SetSoftwareBreakpoint(addr, size);
707be691f3bSpatrick }
708be691f3bSpatrick
GetLoadedModuleFileSpec(const char * module_path,FileSpec & file_spec)709be691f3bSpatrick Status NativeProcessFreeBSD::GetLoadedModuleFileSpec(const char *module_path,
710be691f3bSpatrick FileSpec &file_spec) {
711be691f3bSpatrick Status error = PopulateMemoryRegionCache();
712be691f3bSpatrick if (error.Fail())
713be691f3bSpatrick return error;
714be691f3bSpatrick
715be691f3bSpatrick FileSpec module_file_spec(module_path);
716be691f3bSpatrick FileSystem::Instance().Resolve(module_file_spec);
717be691f3bSpatrick
718be691f3bSpatrick file_spec.Clear();
719be691f3bSpatrick for (const auto &it : m_mem_region_cache) {
720be691f3bSpatrick if (it.second.GetFilename() == module_file_spec.GetFilename()) {
721be691f3bSpatrick file_spec = it.second;
722be691f3bSpatrick return Status();
723be691f3bSpatrick }
724be691f3bSpatrick }
725be691f3bSpatrick return Status("Module file (%s) not found in process' memory map!",
726be691f3bSpatrick module_file_spec.GetFilename().AsCString());
727be691f3bSpatrick }
728be691f3bSpatrick
729be691f3bSpatrick Status
GetFileLoadAddress(const llvm::StringRef & file_name,lldb::addr_t & load_addr)730be691f3bSpatrick NativeProcessFreeBSD::GetFileLoadAddress(const llvm::StringRef &file_name,
731be691f3bSpatrick lldb::addr_t &load_addr) {
732be691f3bSpatrick load_addr = LLDB_INVALID_ADDRESS;
733be691f3bSpatrick Status error = PopulateMemoryRegionCache();
734be691f3bSpatrick if (error.Fail())
735be691f3bSpatrick return error;
736be691f3bSpatrick
737be691f3bSpatrick FileSpec file(file_name);
738be691f3bSpatrick for (const auto &it : m_mem_region_cache) {
739be691f3bSpatrick if (it.second == file) {
740be691f3bSpatrick load_addr = it.first.GetRange().GetRangeBase();
741be691f3bSpatrick return Status();
742be691f3bSpatrick }
743be691f3bSpatrick }
744be691f3bSpatrick return Status("No load address found for file %s.", file_name.str().c_str());
745be691f3bSpatrick }
746be691f3bSpatrick
SigchldHandler()747be691f3bSpatrick void NativeProcessFreeBSD::SigchldHandler() {
748*f6aab3d8Srobert Log *log = GetLog(POSIXLog::Process);
749be691f3bSpatrick int status;
750be691f3bSpatrick ::pid_t wait_pid =
751be691f3bSpatrick llvm::sys::RetryAfterSignal(-1, waitpid, GetID(), &status, WNOHANG);
752be691f3bSpatrick
753be691f3bSpatrick if (wait_pid == 0)
754be691f3bSpatrick return;
755be691f3bSpatrick
756be691f3bSpatrick if (wait_pid == -1) {
757be691f3bSpatrick Status error(errno, eErrorTypePOSIX);
758be691f3bSpatrick LLDB_LOG(log, "waitpid ({0}, &status, _) failed: {1}", GetID(), error);
759be691f3bSpatrick return;
760be691f3bSpatrick }
761be691f3bSpatrick
762be691f3bSpatrick WaitStatus wait_status = WaitStatus::Decode(status);
763be691f3bSpatrick bool exited = wait_status.type == WaitStatus::Exit ||
764be691f3bSpatrick (wait_status.type == WaitStatus::Signal &&
765be691f3bSpatrick wait_pid == static_cast<::pid_t>(GetID()));
766be691f3bSpatrick
767be691f3bSpatrick LLDB_LOG(log,
768be691f3bSpatrick "waitpid ({0}, &status, _) => pid = {1}, status = {2}, exited = {3}",
769be691f3bSpatrick GetID(), wait_pid, status, exited);
770be691f3bSpatrick
771be691f3bSpatrick if (exited)
772be691f3bSpatrick MonitorExited(wait_pid, wait_status);
773be691f3bSpatrick else {
774be691f3bSpatrick assert(wait_status.type == WaitStatus::Stop);
775be691f3bSpatrick MonitorCallback(wait_pid, wait_status.status);
776be691f3bSpatrick }
777be691f3bSpatrick }
778be691f3bSpatrick
HasThreadNoLock(lldb::tid_t thread_id)779be691f3bSpatrick bool NativeProcessFreeBSD::HasThreadNoLock(lldb::tid_t thread_id) {
780be691f3bSpatrick for (const auto &thread : m_threads) {
781be691f3bSpatrick assert(thread && "thread list should not contain NULL threads");
782be691f3bSpatrick if (thread->GetID() == thread_id) {
783be691f3bSpatrick // We have this thread.
784be691f3bSpatrick return true;
785be691f3bSpatrick }
786be691f3bSpatrick }
787be691f3bSpatrick
788be691f3bSpatrick // We don't have this thread.
789be691f3bSpatrick return false;
790be691f3bSpatrick }
791be691f3bSpatrick
AddThread(lldb::tid_t thread_id)792be691f3bSpatrick NativeThreadFreeBSD &NativeProcessFreeBSD::AddThread(lldb::tid_t thread_id) {
793*f6aab3d8Srobert Log *log = GetLog(POSIXLog::Thread);
794be691f3bSpatrick LLDB_LOG(log, "pid {0} adding thread with tid {1}", GetID(), thread_id);
795be691f3bSpatrick
796be691f3bSpatrick assert(thread_id > 0);
797be691f3bSpatrick assert(!HasThreadNoLock(thread_id) &&
798be691f3bSpatrick "attempted to add a thread by id that already exists");
799be691f3bSpatrick
800be691f3bSpatrick // If this is the first thread, save it as the current thread
801be691f3bSpatrick if (m_threads.empty())
802be691f3bSpatrick SetCurrentThreadID(thread_id);
803be691f3bSpatrick
804be691f3bSpatrick m_threads.push_back(std::make_unique<NativeThreadFreeBSD>(*this, thread_id));
805be691f3bSpatrick return static_cast<NativeThreadFreeBSD &>(*m_threads.back());
806be691f3bSpatrick }
807be691f3bSpatrick
RemoveThread(lldb::tid_t thread_id)808be691f3bSpatrick void NativeProcessFreeBSD::RemoveThread(lldb::tid_t thread_id) {
809*f6aab3d8Srobert Log *log = GetLog(POSIXLog::Thread);
810be691f3bSpatrick LLDB_LOG(log, "pid {0} removing thread with tid {1}", GetID(), thread_id);
811be691f3bSpatrick
812be691f3bSpatrick assert(thread_id > 0);
813be691f3bSpatrick assert(HasThreadNoLock(thread_id) &&
814be691f3bSpatrick "attempted to remove a thread that does not exist");
815be691f3bSpatrick
816be691f3bSpatrick for (auto it = m_threads.begin(); it != m_threads.end(); ++it) {
817be691f3bSpatrick if ((*it)->GetID() == thread_id) {
818be691f3bSpatrick m_threads.erase(it);
819be691f3bSpatrick break;
820be691f3bSpatrick }
821be691f3bSpatrick }
822*f6aab3d8Srobert
823*f6aab3d8Srobert if (GetCurrentThreadID() == thread_id)
824*f6aab3d8Srobert SetCurrentThreadID(m_threads.front()->GetID());
825be691f3bSpatrick }
826be691f3bSpatrick
Attach()827be691f3bSpatrick Status NativeProcessFreeBSD::Attach() {
828be691f3bSpatrick // Attach to the requested process.
829be691f3bSpatrick // An attach will cause the thread to stop with a SIGSTOP.
830be691f3bSpatrick Status status = PtraceWrapper(PT_ATTACH, m_pid);
831be691f3bSpatrick if (status.Fail())
832be691f3bSpatrick return status;
833be691f3bSpatrick
834be691f3bSpatrick int wstatus;
835be691f3bSpatrick // Need to use WALLSIG otherwise we receive an error with errno=ECHLD At this
836be691f3bSpatrick // point we should have a thread stopped if waitpid succeeds.
837be691f3bSpatrick if ((wstatus = llvm::sys::RetryAfterSignal(-1, waitpid, m_pid, nullptr, 0)) <
838be691f3bSpatrick 0)
839be691f3bSpatrick return Status(errno, eErrorTypePOSIX);
840be691f3bSpatrick
841be691f3bSpatrick // Initialize threads and tracing status
842be691f3bSpatrick // NB: this needs to be called before we set thread state
843be691f3bSpatrick status = SetupTrace();
844be691f3bSpatrick if (status.Fail())
845be691f3bSpatrick return status;
846be691f3bSpatrick
847be691f3bSpatrick for (const auto &thread : m_threads)
848be691f3bSpatrick static_cast<NativeThreadFreeBSD &>(*thread).SetStoppedBySignal(SIGSTOP);
849be691f3bSpatrick
850be691f3bSpatrick // Let our process instance know the thread has stopped.
851be691f3bSpatrick SetCurrentThreadID(m_threads.front()->GetID());
852be691f3bSpatrick SetState(StateType::eStateStopped, false);
853be691f3bSpatrick return Status();
854be691f3bSpatrick }
855be691f3bSpatrick
ReadMemory(lldb::addr_t addr,void * buf,size_t size,size_t & bytes_read)856be691f3bSpatrick Status NativeProcessFreeBSD::ReadMemory(lldb::addr_t addr, void *buf,
857be691f3bSpatrick size_t size, size_t &bytes_read) {
858be691f3bSpatrick unsigned char *dst = static_cast<unsigned char *>(buf);
859be691f3bSpatrick struct ptrace_io_desc io;
860be691f3bSpatrick
861*f6aab3d8Srobert Log *log = GetLog(POSIXLog::Memory);
862be691f3bSpatrick LLDB_LOG(log, "addr = {0}, buf = {1}, size = {2}", addr, buf, size);
863be691f3bSpatrick
864be691f3bSpatrick bytes_read = 0;
865be691f3bSpatrick io.piod_op = PIOD_READ_D;
866be691f3bSpatrick io.piod_len = size;
867be691f3bSpatrick
868be691f3bSpatrick do {
869be691f3bSpatrick io.piod_offs = (void *)(addr + bytes_read);
870be691f3bSpatrick io.piod_addr = dst + bytes_read;
871be691f3bSpatrick
872be691f3bSpatrick Status error = NativeProcessFreeBSD::PtraceWrapper(PT_IO, GetID(), &io);
873be691f3bSpatrick if (error.Fail() || io.piod_len == 0)
874be691f3bSpatrick return error;
875be691f3bSpatrick
876be691f3bSpatrick bytes_read += io.piod_len;
877be691f3bSpatrick io.piod_len = size - bytes_read;
878be691f3bSpatrick } while (bytes_read < size);
879be691f3bSpatrick
880be691f3bSpatrick return Status();
881be691f3bSpatrick }
882be691f3bSpatrick
WriteMemory(lldb::addr_t addr,const void * buf,size_t size,size_t & bytes_written)883be691f3bSpatrick Status NativeProcessFreeBSD::WriteMemory(lldb::addr_t addr, const void *buf,
884be691f3bSpatrick size_t size, size_t &bytes_written) {
885be691f3bSpatrick const unsigned char *src = static_cast<const unsigned char *>(buf);
886be691f3bSpatrick Status error;
887be691f3bSpatrick struct ptrace_io_desc io;
888be691f3bSpatrick
889*f6aab3d8Srobert Log *log = GetLog(POSIXLog::Memory);
890be691f3bSpatrick LLDB_LOG(log, "addr = {0}, buf = {1}, size = {2}", addr, buf, size);
891be691f3bSpatrick
892be691f3bSpatrick bytes_written = 0;
893be691f3bSpatrick io.piod_op = PIOD_WRITE_D;
894be691f3bSpatrick io.piod_len = size;
895be691f3bSpatrick
896be691f3bSpatrick do {
897be691f3bSpatrick io.piod_addr =
898be691f3bSpatrick const_cast<void *>(static_cast<const void *>(src + bytes_written));
899be691f3bSpatrick io.piod_offs = (void *)(addr + bytes_written);
900be691f3bSpatrick
901be691f3bSpatrick Status error = NativeProcessFreeBSD::PtraceWrapper(PT_IO, GetID(), &io);
902be691f3bSpatrick if (error.Fail() || io.piod_len == 0)
903be691f3bSpatrick return error;
904be691f3bSpatrick
905be691f3bSpatrick bytes_written += io.piod_len;
906be691f3bSpatrick io.piod_len = size - bytes_written;
907be691f3bSpatrick } while (bytes_written < size);
908be691f3bSpatrick
909be691f3bSpatrick return error;
910be691f3bSpatrick }
911be691f3bSpatrick
912be691f3bSpatrick llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
GetAuxvData() const913be691f3bSpatrick NativeProcessFreeBSD::GetAuxvData() const {
914be691f3bSpatrick int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_AUXV, static_cast<int>(GetID())};
915be691f3bSpatrick size_t auxv_size = AT_COUNT * sizeof(Elf_Auxinfo);
916be691f3bSpatrick std::unique_ptr<WritableMemoryBuffer> buf =
917be691f3bSpatrick llvm::WritableMemoryBuffer::getNewMemBuffer(auxv_size);
918be691f3bSpatrick
919be691f3bSpatrick if (::sysctl(mib, 4, buf->getBufferStart(), &auxv_size, nullptr, 0) != 0)
920be691f3bSpatrick return std::error_code(errno, std::generic_category());
921be691f3bSpatrick
922be691f3bSpatrick return buf;
923be691f3bSpatrick }
924be691f3bSpatrick
SetupTrace()925be691f3bSpatrick Status NativeProcessFreeBSD::SetupTrace() {
926be691f3bSpatrick // Enable event reporting
927be691f3bSpatrick int events;
928be691f3bSpatrick Status status =
929be691f3bSpatrick PtraceWrapper(PT_GET_EVENT_MASK, GetID(), &events, sizeof(events));
930be691f3bSpatrick if (status.Fail())
931be691f3bSpatrick return status;
932be691f3bSpatrick events |= PTRACE_LWP | PTRACE_FORK | PTRACE_VFORK;
933be691f3bSpatrick status = PtraceWrapper(PT_SET_EVENT_MASK, GetID(), &events, sizeof(events));
934be691f3bSpatrick if (status.Fail())
935be691f3bSpatrick return status;
936be691f3bSpatrick
937be691f3bSpatrick return ReinitializeThreads();
938be691f3bSpatrick }
939be691f3bSpatrick
ReinitializeThreads()940be691f3bSpatrick Status NativeProcessFreeBSD::ReinitializeThreads() {
941be691f3bSpatrick // Clear old threads
942be691f3bSpatrick m_threads.clear();
943be691f3bSpatrick
944be691f3bSpatrick int num_lwps;
945be691f3bSpatrick Status error = PtraceWrapper(PT_GETNUMLWPS, GetID(), nullptr, 0, &num_lwps);
946be691f3bSpatrick if (error.Fail())
947be691f3bSpatrick return error;
948be691f3bSpatrick
949be691f3bSpatrick std::vector<lwpid_t> lwp_ids;
950be691f3bSpatrick lwp_ids.resize(num_lwps);
951be691f3bSpatrick error = PtraceWrapper(PT_GETLWPLIST, GetID(), lwp_ids.data(),
952be691f3bSpatrick lwp_ids.size() * sizeof(lwpid_t), &num_lwps);
953be691f3bSpatrick if (error.Fail())
954be691f3bSpatrick return error;
955be691f3bSpatrick
956be691f3bSpatrick // Reinitialize from scratch threads and register them in process
957be691f3bSpatrick for (lwpid_t lwp : lwp_ids)
958be691f3bSpatrick AddThread(lwp);
959be691f3bSpatrick
960be691f3bSpatrick return error;
961be691f3bSpatrick }
962be691f3bSpatrick
SupportHardwareSingleStepping() const963be691f3bSpatrick bool NativeProcessFreeBSD::SupportHardwareSingleStepping() const {
964be691f3bSpatrick return !m_arch.IsMIPS();
965be691f3bSpatrick }
966be691f3bSpatrick
MonitorClone(::pid_t child_pid,bool is_vfork,NativeThreadFreeBSD & parent_thread)967be691f3bSpatrick void NativeProcessFreeBSD::MonitorClone(::pid_t child_pid, bool is_vfork,
968be691f3bSpatrick NativeThreadFreeBSD &parent_thread) {
969*f6aab3d8Srobert Log *log = GetLog(POSIXLog::Process);
970be691f3bSpatrick LLDB_LOG(log, "fork, child_pid={0}", child_pid);
971be691f3bSpatrick
972be691f3bSpatrick int status;
973be691f3bSpatrick ::pid_t wait_pid =
974be691f3bSpatrick llvm::sys::RetryAfterSignal(-1, ::waitpid, child_pid, &status, 0);
975be691f3bSpatrick if (wait_pid != child_pid) {
976be691f3bSpatrick LLDB_LOG(log,
977be691f3bSpatrick "waiting for pid {0} failed. Assuming the pid has "
978be691f3bSpatrick "disappeared in the meantime",
979be691f3bSpatrick child_pid);
980be691f3bSpatrick return;
981be691f3bSpatrick }
982be691f3bSpatrick if (WIFEXITED(status)) {
983be691f3bSpatrick LLDB_LOG(log,
984be691f3bSpatrick "waiting for pid {0} returned an 'exited' event. Not "
985be691f3bSpatrick "tracking it.",
986be691f3bSpatrick child_pid);
987be691f3bSpatrick return;
988be691f3bSpatrick }
989be691f3bSpatrick
990be691f3bSpatrick struct ptrace_lwpinfo info;
991be691f3bSpatrick const auto siginfo_err = PtraceWrapper(PT_LWPINFO, child_pid, &info, sizeof(info));
992be691f3bSpatrick if (siginfo_err.Fail()) {
993be691f3bSpatrick LLDB_LOG(log, "PT_LWPINFO failed {0}", siginfo_err);
994be691f3bSpatrick return;
995be691f3bSpatrick }
996be691f3bSpatrick assert(info.pl_event == PL_EVENT_SIGNAL);
997be691f3bSpatrick lldb::tid_t child_tid = info.pl_lwpid;
998be691f3bSpatrick
999be691f3bSpatrick std::unique_ptr<NativeProcessFreeBSD> child_process{
1000be691f3bSpatrick new NativeProcessFreeBSD(static_cast<::pid_t>(child_pid), m_terminal_fd,
1001be691f3bSpatrick m_delegate, m_arch, m_main_loop)};
1002be691f3bSpatrick if (!is_vfork)
1003be691f3bSpatrick child_process->m_software_breakpoints = m_software_breakpoints;
1004be691f3bSpatrick
1005be691f3bSpatrick Extension expected_ext = is_vfork ? Extension::vfork : Extension::fork;
1006be691f3bSpatrick if ((m_enabled_extensions & expected_ext) == expected_ext) {
1007be691f3bSpatrick child_process->SetupTrace();
1008be691f3bSpatrick for (const auto &thread : child_process->m_threads)
1009be691f3bSpatrick static_cast<NativeThreadFreeBSD &>(*thread).SetStoppedBySignal(SIGSTOP);
1010be691f3bSpatrick child_process->SetState(StateType::eStateStopped, false);
1011be691f3bSpatrick
1012be691f3bSpatrick m_delegate.NewSubprocess(this, std::move(child_process));
1013be691f3bSpatrick if (is_vfork)
1014be691f3bSpatrick parent_thread.SetStoppedByVFork(child_pid, child_tid);
1015be691f3bSpatrick else
1016be691f3bSpatrick parent_thread.SetStoppedByFork(child_pid, child_tid);
1017be691f3bSpatrick SetState(StateType::eStateStopped, true);
1018be691f3bSpatrick } else {
1019be691f3bSpatrick child_process->Detach();
1020be691f3bSpatrick Status pt_error =
1021be691f3bSpatrick PtraceWrapper(PT_CONTINUE, GetID(), reinterpret_cast<void *>(1), 0);
1022be691f3bSpatrick if (pt_error.Fail()) {
1023be691f3bSpatrick LLDB_LOG_ERROR(log, pt_error.ToError(),
1024be691f3bSpatrick "unable to resume parent process {1}: {0}", GetID());
1025be691f3bSpatrick SetState(StateType::eStateInvalid);
1026be691f3bSpatrick }
1027be691f3bSpatrick }
1028be691f3bSpatrick }
1029*f6aab3d8Srobert
1030*f6aab3d8Srobert llvm::Expected<std::string>
SaveCore(llvm::StringRef path_hint)1031*f6aab3d8Srobert NativeProcessFreeBSD::SaveCore(llvm::StringRef path_hint) {
1032*f6aab3d8Srobert #if defined(PT_COREDUMP)
1033*f6aab3d8Srobert using namespace llvm::sys::fs;
1034*f6aab3d8Srobert
1035*f6aab3d8Srobert llvm::SmallString<128> path{path_hint};
1036*f6aab3d8Srobert Status error;
1037*f6aab3d8Srobert struct ptrace_coredump pc = {};
1038*f6aab3d8Srobert
1039*f6aab3d8Srobert // Try with the suggested path first. If there is no suggested path or it
1040*f6aab3d8Srobert // failed to open, use a temporary file.
1041*f6aab3d8Srobert if (path.empty() ||
1042*f6aab3d8Srobert openFile(path, pc.pc_fd, CD_CreateNew, FA_Write, OF_None)) {
1043*f6aab3d8Srobert if (std::error_code errc =
1044*f6aab3d8Srobert createTemporaryFile("lldb", "core", pc.pc_fd, path))
1045*f6aab3d8Srobert return llvm::createStringError(errc, "Unable to create a temporary file");
1046*f6aab3d8Srobert }
1047*f6aab3d8Srobert error = PtraceWrapper(PT_COREDUMP, GetID(), &pc, sizeof(pc));
1048*f6aab3d8Srobert
1049*f6aab3d8Srobert std::error_code close_err = closeFile(pc.pc_fd);
1050*f6aab3d8Srobert if (error.Fail())
1051*f6aab3d8Srobert return error.ToError();
1052*f6aab3d8Srobert if (close_err)
1053*f6aab3d8Srobert return llvm::createStringError(
1054*f6aab3d8Srobert close_err, "Unable to close the core dump after writing");
1055*f6aab3d8Srobert return path.str().str();
1056*f6aab3d8Srobert #else // !defined(PT_COREDUMP)
1057*f6aab3d8Srobert return llvm::createStringError(
1058*f6aab3d8Srobert llvm::inconvertibleErrorCode(),
1059*f6aab3d8Srobert "PT_COREDUMP not supported in the FreeBSD version used to build LLDB");
1060*f6aab3d8Srobert #endif
1061*f6aab3d8Srobert }
1062