#include "defs.h"
#include "nbsd-nat.h"
+#include "nat/netbsd-nat.h"
#include "gdbthread.h"
#include "nbsd-tdep.h"
#include "inferior.h"
#include <sys/types.h>
#include <sys/ptrace.h>
#include <sys/sysctl.h>
+#include <sys/wait.h>
/* Return the name of a file that can be opened to get the symbols for
the child process identified by PID. */
char *
nbsd_nat_target::pid_to_exec_file (int pid)
{
- static char buf[PATH_MAX];
- size_t buflen;
- int mib[4] = {CTL_KERN, KERN_PROC_ARGS, pid, KERN_PROC_PATHNAME};
- buflen = sizeof (buf);
- if (sysctl (mib, ARRAY_SIZE (mib), buf, &buflen, NULL, 0))
- return NULL;
- return buf;
+ return const_cast<char *> (netbsd_nat::pid_to_exec_file (pid));
}
/* Return the current directory for the process identified by PID. */
int mib[4] = {CTL_KERN, KERN_PROC_ARGS, pid, KERN_PROC_ARGV};
size_t size = 0;
- if (sysctl (mib, ARRAY_SIZE (mib), NULL, &size, NULL, 0) == -1 || size == 0)
+ if (::sysctl (mib, ARRAY_SIZE (mib), NULL, &size, NULL, 0) == -1 || size == 0)
return nullptr;
gdb::unique_xmalloc_ptr<char[]> args (XNEWVAR (char, size));
- if (sysctl (mib, ARRAY_SIZE (mib), args.get (), &size, NULL, 0) == -1
+ if (::sysctl (mib, ARRAY_SIZE (mib), args.get (), &size, NULL, 0) == -1
|| size == 0)
return nullptr;
return args;
}
-/* Generic thread (LWP) lister within a specified process. The callback
- parameters is a C++ function that is called for each detected thread. */
-
-static bool
-nbsd_thread_lister (const pid_t pid,
- gdb::function_view<bool (const struct kinfo_lwp *)>
- callback)
-{
- int mib[5] = {CTL_KERN, KERN_LWP, pid, sizeof (struct kinfo_lwp), 0};
- size_t size;
-
- if (sysctl (mib, ARRAY_SIZE (mib), NULL, &size, NULL, 0) == -1 || size == 0)
- perror_with_name (("sysctl"));
-
- mib[4] = size / sizeof (size_t);
-
- gdb::unique_xmalloc_ptr<struct kinfo_lwp[]> kl
- ((struct kinfo_lwp *) xcalloc (size, 1));
-
- if (sysctl (mib, ARRAY_SIZE (mib), kl.get (), &size, NULL, 0) == -1
- || size == 0)
- perror_with_name (("sysctl"));
-
- for (size_t i = 0; i < size / sizeof (struct kinfo_lwp); i++)
- {
- struct kinfo_lwp *l = &kl[i];
-
- /* Return true if the specified thread is alive. */
- auto lwp_alive
- = [] (struct kinfo_lwp *lwp)
- {
- switch (lwp->l_stat)
- {
- case LSSLEEP:
- case LSRUN:
- case LSONPROC:
- case LSSTOP:
- case LSSUSPENDED:
- return true;
- default:
- return false;
- }
- };
-
- /* Ignore embryonic or demised threads. */
- if (!lwp_alive (l))
- continue;
-
- if (callback (l))
- return true;
- }
-
- return false;
-}
-
/* Return true if PTID is still active in the inferior. */
bool
nbsd_nat_target::thread_alive (ptid_t ptid)
{
- pid_t pid = ptid.pid ();
- int lwp = ptid.lwp ();
-
- auto fn
- = [&lwp] (const struct kinfo_lwp *kl)
- {
- return kl->l_lid == lwp;
- };
-
- return nbsd_thread_lister (pid, fn);
+ return netbsd_nat::thread_alive (ptid);
}
/* Return the name assigned to a thread by an application. Returns
nbsd_nat_target::thread_name (struct thread_info *thr)
{
ptid_t ptid = thr->ptid;
- pid_t pid = ptid.pid ();
- int lwp = ptid.lwp ();
-
- static char buf[KI_LNAMELEN] = {};
-
- auto fn
- = [&lwp] (const struct kinfo_lwp *kl)
- {
- if (kl->l_lid == lwp)
- {
- xsnprintf (buf, sizeof buf, "%s", kl->l_name);
- return true;
- }
- return false;
- };
-
- if (nbsd_thread_lister (pid, fn))
- return buf;
- else
- return NULL;
+ return netbsd_nat::thread_name (ptid);
}
/* Implement the "post_attach" target_ops method. */
nbsd_add_threads (nbsd_nat_target *target, pid_t pid)
{
auto fn
- = [&target, &pid] (const struct kinfo_lwp *kl)
+ = [&target] (ptid_t ptid)
{
- ptid_t ptid = ptid_t (pid, kl->l_lid, 0);
if (!in_thread_list (target, ptid))
{
if (inferior_ptid.lwp () == 0)
else
add_thread (target, ptid);
}
- return false;
};
- nbsd_thread_lister (pid, fn);
+ netbsd_nat::for_each_thread (pid, fn);
+}
+
+/* Implement the "post_startup_inferior" target_ops method. */
+
+void
+nbsd_nat_target::post_startup_inferior (ptid_t ptid)
+{
+ netbsd_nat::enable_proc_events (ptid.pid ());
}
/* Implement the "post_attach" target_ops method. */
void
nbsd_nat_target::post_attach (int pid)
{
+ netbsd_nat::enable_proc_events (pid);
nbsd_add_threads (this, pid);
}
void
nbsd_nat_target::update_thread_list ()
{
- prune_threads ();
-
- nbsd_add_threads (this, inferior_ptid.pid ());
+ delete_exited_threads ();
}
/* Convert PTID to a string. */
return true;
}
+
+/* Resume execution of a specified PTID, that points to a process or a thread
+ within a process. If one thread is specified, all other threads are
+ suspended. If STEP is nonzero, single-step it. If SIGNAL is nonzero,
+ give it that signal. */
+
+static void
+nbsd_resume(nbsd_nat_target *target, ptid_t ptid, int step,
+ enum gdb_signal signal)
+{
+ int request;
+
+ gdb_assert (minus_one_ptid != ptid);
+
+ if (ptid.lwp_p ())
+ {
+ /* If ptid is a specific LWP, suspend all other LWPs in the process. */
+ inferior *inf = find_inferior_ptid (target, ptid);
+
+ for (thread_info *tp : inf->non_exited_threads ())
+ {
+ if (tp->ptid.lwp () == ptid.lwp ())
+ request = PT_RESUME;
+ else
+ request = PT_SUSPEND;
+
+ if (ptrace (request, tp->ptid.pid (), NULL, tp->ptid.lwp ()) == -1)
+ perror_with_name (("ptrace"));
+ }
+ }
+ else
+ {
+ /* If ptid is a wildcard, resume all matching threads (they won't run
+ until the process is continued however). */
+ for (thread_info *tp : all_non_exited_threads (target, ptid))
+ if (ptrace (PT_RESUME, tp->ptid.pid (), NULL, tp->ptid.lwp ()) == -1)
+ perror_with_name (("ptrace"));
+ }
+
+ if (step)
+ {
+ for (thread_info *tp : all_non_exited_threads (target, ptid))
+ if (ptrace (PT_SETSTEP, tp->ptid.pid (), NULL, tp->ptid.lwp ()) == -1)
+ perror_with_name (("ptrace"));
+ }
+ else
+ {
+ for (thread_info *tp : all_non_exited_threads (target, ptid))
+ if (ptrace (PT_CLEARSTEP, tp->ptid.pid (), NULL, tp->ptid.lwp ()) == -1)
+ perror_with_name (("ptrace"));
+ }
+
+ if (catch_syscall_enabled () > 0)
+ request = PT_SYSCALL;
+ else
+ request = PT_CONTINUE;
+
+ /* An address of (void *)1 tells ptrace to continue from
+ where it was. If GDB wanted it to start some other way, we have
+ already written a new program counter value to the child. */
+ if (ptrace (request, ptid.pid (), (void *)1, gdb_signal_to_host (signal)) == -1)
+ perror_with_name (("ptrace"));
+}
+
+/* Resume execution of thread PTID, or all threads of all inferiors
+ if PTID is -1. If STEP is nonzero, single-step it. If SIGNAL is nonzero,
+ give it that signal. */
+
+void
+nbsd_nat_target::resume (ptid_t ptid, int step, enum gdb_signal signal)
+{
+ if (minus_one_ptid != ptid)
+ nbsd_resume (this, ptid, step, signal);
+ else
+ {
+ for (inferior *inf : all_non_exited_inferiors (this))
+ nbsd_resume (this, ptid_t (inf->pid, 0, 0), step, signal);
+ }
+}
+
+/* Implement a safe wrapper around waitpid(). */
+
+static pid_t
+nbsd_wait (ptid_t ptid, struct target_waitstatus *ourstatus,
+ target_wait_flags options)
+{
+ pid_t pid;
+ int status;
+
+ set_sigint_trap ();
+
+ do
+ {
+ /* The common code passes WNOHANG that leads to crashes, overwrite it. */
+ pid = waitpid (ptid.pid (), &status, 0);
+ }
+ while (pid == -1 && errno == EINTR);
+
+ clear_sigint_trap ();
+
+ if (pid == -1)
+ perror_with_name (_("Child process unexpectedly missing"));
+
+ store_waitstatus (ourstatus, status);
+ return pid;
+}
+
+/* Wait for the child specified by PTID to do something. Return the
+ process ID of the child, or MINUS_ONE_PTID in case of error; store
+ the status in *OURSTATUS. */
+
+ptid_t
+nbsd_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
+ target_wait_flags target_options)
+{
+ pid_t pid = nbsd_wait (ptid, ourstatus, target_options);
+ ptid_t wptid = ptid_t (pid);
+
+ /* If the child stopped, keep investigating its status. */
+ if (ourstatus->kind != TARGET_WAITKIND_STOPPED)
+ return wptid;
+
+ /* Extract the event and thread that received a signal. */
+ ptrace_siginfo_t psi;
+ if (ptrace (PT_GET_SIGINFO, pid, &psi, sizeof (psi)) == -1)
+ perror_with_name (("ptrace"));
+
+ /* Pick child's siginfo_t. */
+ siginfo_t *si = &psi.psi_siginfo;
+
+ int lwp = psi.psi_lwpid;
+
+ int signo = si->si_signo;
+ const int code = si->si_code;
+
+ /* Construct PTID with a specified thread that received the event.
+ If a signal was targeted to the whole process, lwp is 0. */
+ wptid = ptid_t (pid, lwp, 0);
+
+ /* Bail out on non-debugger oriented signals.. */
+ if (signo != SIGTRAP)
+ return wptid;
+
+ /* Stop examining non-debugger oriented SIGTRAP codes. */
+ if (code <= SI_USER || code == SI_NOINFO)
+ return wptid;
+
+ /* Process state for threading events */
+ ptrace_state_t pst = {};
+ if (code == TRAP_LWP)
+ {
+ if (ptrace (PT_GET_PROCESS_STATE, pid, &pst, sizeof (pst)) == -1)
+ perror_with_name (("ptrace"));
+ }
+
+ if (code == TRAP_LWP && pst.pe_report_event == PTRACE_LWP_EXIT)
+ {
+ /* If GDB attaches to a multi-threaded process, exiting
+ threads might be skipped during post_attach that
+ have not yet reported their PTRACE_LWP_EXIT event.
+ Ignore exited events for an unknown LWP. */
+ thread_info *thr = find_thread_ptid (this, wptid);
+ if (thr == nullptr)
+ ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
+ else
+ {
+ ourstatus->kind = TARGET_WAITKIND_THREAD_EXITED;
+ /* NetBSD does not store an LWP exit status. */
+ ourstatus->value.integer = 0;
+
+ if (print_thread_events)
+ printf_unfiltered (_("[%s exited]\n"),
+ target_pid_to_str (wptid).c_str ());
+ delete_thread (thr);
+ }
+
+ /* The GDB core expects that the rest of the threads are running. */
+ if (ptrace (PT_CONTINUE, pid, (void *) 1, 0) == -1)
+ perror_with_name (("ptrace"));
+
+ return wptid;
+ }
+
+ if (in_thread_list (this, ptid_t (pid)))
+ thread_change_ptid (this, ptid_t (pid), wptid);
+
+ if (code == TRAP_LWP && pst.pe_report_event == PTRACE_LWP_CREATE)
+ {
+ /* If GDB attaches to a multi-threaded process, newborn
+ threads might be added by nbsd_add_threads that have
+ not yet reported their PTRACE_LWP_CREATE event. Ignore
+ born events for an already-known LWP. */
+ if (in_thread_list (this, wptid))
+ ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
+ else
+ {
+ add_thread (this, wptid);
+ ourstatus->kind = TARGET_WAITKIND_THREAD_CREATED;
+ }
+ return wptid;
+ }
+
+ if (code == TRAP_EXEC)
+ {
+ ourstatus->kind = TARGET_WAITKIND_EXECD;
+ ourstatus->value.execd_pathname = xstrdup (pid_to_exec_file (pid));
+ return wptid;
+ }
+
+ if (code == TRAP_TRACE)
+ {
+ /* Unhandled at this level. */
+ return wptid;
+ }
+
+ if (code == TRAP_SCE || code == TRAP_SCX)
+ {
+ int sysnum = si->si_sysnum;
+
+ if (!catch_syscall_enabled () || !catching_syscall_number (sysnum))
+ {
+ /* If the core isn't interested in this event, ignore it. */
+ ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
+ return wptid;
+ }
+
+ ourstatus->kind =
+ (code == TRAP_SCE) ? TARGET_WAITKIND_SYSCALL_ENTRY :
+ TARGET_WAITKIND_SYSCALL_RETURN;
+ ourstatus->value.syscall_number = sysnum;
+ return wptid;
+ }
+
+ if (code == TRAP_BRKPT)
+ {
+ /* Unhandled at this level. */
+ return wptid;
+ }
+
+ /* Unclassified SIGTRAP event. */
+ ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
+ return wptid;
+}
+
+/* Implement the "insert_exec_catchpoint" target_ops method. */
+
+int
+nbsd_nat_target::insert_exec_catchpoint (int pid)
+{
+ /* Nothing to do. */
+ return 0;
+}
+
+/* Implement the "remove_exec_catchpoint" target_ops method. */
+
+int
+nbsd_nat_target::remove_exec_catchpoint (int pid)
+{
+ /* Nothing to do. */
+ return 0;
+}
+
+/* Implement the "set_syscall_catchpoint" target_ops method. */
+
+int
+nbsd_nat_target::set_syscall_catchpoint (int pid, bool needed,
+ int any_count,
+ gdb::array_view<const int> syscall_counts)
+{
+ /* Ignore the arguments. inf-ptrace.c will use PT_SYSCALL which
+ will catch all system call entries and exits. The system calls
+ are filtered by GDB rather than the kernel. */
+ return 0;
+}
+
+/* Implement the "supports_multi_process" target_ops method. */
+
+bool
+nbsd_nat_target::supports_multi_process ()
+{
+ return true;
+}
+
+/* Implement the "xfer_partial" target_ops method. */
+
+enum target_xfer_status
+nbsd_nat_target::xfer_partial (enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len)
+{
+ pid_t pid = inferior_ptid.pid ();
+
+ switch (object)
+ {
+ case TARGET_OBJECT_SIGNAL_INFO:
+ {
+ len = netbsd_nat::qxfer_siginfo(pid, annex, readbuf, writebuf, offset,
+ len);
+
+ if (len == -1)
+ return TARGET_XFER_E_IO;
+
+ *xfered_len = len;
+ return TARGET_XFER_OK;
+ }
+ default:
+ return inf_ptrace_target::xfer_partial (object, annex,
+ readbuf, writebuf, offset,
+ len, xfered_len);
+ }
+}
+
+/* Implement the "supports_dumpcore" target_ops method. */
+
+bool
+nbsd_nat_target::supports_dumpcore ()
+{
+ return true;
+}
+
+/* Implement the "dumpcore" target_ops method. */
+
+void
+nbsd_nat_target::dumpcore (const char *filename)
+{
+ pid_t pid = inferior_ptid.pid ();
+
+ if (ptrace (PT_DUMPCORE, pid, const_cast<char *>(filename),
+ strlen (filename)) == -1)
+ perror_with_name (("ptrace"));
+}