/* Native-dependent code for FreeBSD.
- Copyright (C) 2002-2016 Free Software Foundation, Inc.
+ Copyright (C) 2002-2017 Free Software Foundation, Inc.
This file is part of GDB.
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
+#include "byte-vector.h"
#include "gdbcore.h"
#include "inferior.h"
#include "regcache.h"
#include <sys/types.h>
#include <sys/procfs.h>
#include <sys/ptrace.h>
+#include <sys/signal.h>
#include <sys/sysctl.h>
-#ifdef HAVE_KINFO_GETVMMAP
#include <sys/user.h>
+#ifdef HAVE_KINFO_GETVMMAP
#include <libutil.h>
+#else
+#include "filestuff.h"
#endif
#include "elf-bfd.h"
#include "fbsd-nat.h"
+#include <list>
+
/* Return the name of a file that can be opened to get the symbols for
the child process identified by PID. */
}
#ifdef HAVE_KINFO_GETVMMAP
+/* Deleter for std::unique_ptr that invokes free. */
+
+template <typename T>
+struct free_deleter
+{
+ void operator() (T *ptr) const { free (ptr); }
+};
+
/* Iterate over all the memory regions in the current inferior,
calling FUNC for each memory region. OBFD is passed as the last
argument to FUNC. */
find_memory_region_ftype func, void *obfd)
{
pid_t pid = ptid_get_pid (inferior_ptid);
- struct kinfo_vmentry *vmentl, *kve;
+ struct kinfo_vmentry *kve;
uint64_t size;
- struct cleanup *cleanup;
int i, nitems;
- vmentl = kinfo_getvmmap (pid, &nitems);
+ std::unique_ptr<struct kinfo_vmentry, free_deleter<struct kinfo_vmentry>>
+ vmentl (kinfo_getvmmap (pid, &nitems));
if (vmentl == NULL)
perror_with_name (_("Couldn't fetch VM map entries."));
- cleanup = make_cleanup (free, vmentl);
- for (i = 0; i < nitems; i++)
+ for (i = 0, kve = vmentl.get (); i < nitems; i++, kve++)
{
- kve = &vmentl[i];
-
/* Skip unreadable segments and those where MAP_NOCORE has been set. */
if (!(kve->kve_protection & KVME_PROT_READ)
|| kve->kve_flags & KVME_FLAG_NOCOREDUMP)
kve->kve_protection & KVME_PROT_WRITE,
kve->kve_protection & KVME_PROT_EXEC, 1, obfd);
}
- do_cleanups (cleanup);
return 0;
}
#else
find_memory_region_ftype func, void *obfd)
{
pid_t pid = ptid_get_pid (inferior_ptid);
- char *mapfilename;
- FILE *mapfile;
unsigned long start, end, size;
char protection[4];
int read, write, exec;
- struct cleanup *cleanup;
- mapfilename = xstrprintf ("/proc/%ld/map", (long) pid);
- cleanup = make_cleanup (xfree, mapfilename);
- mapfile = fopen (mapfilename, "r");
+ std::string mapfilename = string_printf ("/proc/%ld/map", (long) pid);
+ gdb_file_up mapfile (fopen (mapfilename.c_str (), "r"));
if (mapfile == NULL)
- error (_("Couldn't open %s."), mapfilename);
- make_cleanup_fclose (mapfile);
+ error (_("Couldn't open %s."), mapfilename.c_str ());
if (info_verbose)
fprintf_filtered (gdb_stdout,
- "Reading memory regions from %s\n", mapfilename);
+ "Reading memory regions from %s\n", mapfilename.c_str ());
/* Now iterate until end-of-file. */
- while (fbsd_read_mapping (mapfile, &start, &end, &protection[0]))
+ while (fbsd_read_mapping (mapfile.get (), &start, &end, &protection[0]))
{
size = end - start;
func (start, size, read, write, exec, 1, obfd);
}
- do_cleanups (cleanup);
return 0;
}
#endif
+#ifdef KERN_PROC_AUXV
+static enum target_xfer_status (*super_xfer_partial) (struct target_ops *ops,
+ enum target_object object,
+ const char *annex,
+ gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset,
+ ULONGEST len,
+ ULONGEST *xfered_len);
+
+#ifdef PT_LWPINFO
+/* Return the size of siginfo for the current inferior. */
+
+#ifdef __LP64__
+union sigval32 {
+ int sival_int;
+ uint32_t sival_ptr;
+};
+
+/* This structure matches the naming and layout of `siginfo_t' in
+ <sys/signal.h>. In particular, the `si_foo' macros defined in that
+ header can be used with both types to copy fields in the `_reason'
+ union. */
+
+struct siginfo32
+{
+ int si_signo;
+ int si_errno;
+ int si_code;
+ __pid_t si_pid;
+ __uid_t si_uid;
+ int si_status;
+ uint32_t si_addr;
+ union sigval32 si_value;
+ union
+ {
+ struct
+ {
+ int _trapno;
+ } _fault;
+ struct
+ {
+ int _timerid;
+ int _overrun;
+ } _timer;
+ struct
+ {
+ int _mqd;
+ } _mesgq;
+ struct
+ {
+ int32_t _band;
+ } _poll;
+ struct
+ {
+ int32_t __spare1__;
+ int __spare2__[7];
+ } __spare__;
+ } _reason;
+};
+#endif
+
+static size_t
+fbsd_siginfo_size ()
+{
+#ifdef __LP64__
+ struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
+
+ /* Is the inferior 32-bit? If so, use the 32-bit siginfo size. */
+ if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
+ return sizeof (struct siginfo32);
+#endif
+ return sizeof (siginfo_t);
+}
+
+/* Convert a native 64-bit siginfo object to a 32-bit object. Note
+ that FreeBSD doesn't support writing to $_siginfo, so this only
+ needs to convert one way. */
+
+static void
+fbsd_convert_siginfo (siginfo_t *si)
+{
+#ifdef __LP64__
+ struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
+
+ /* Is the inferior 32-bit? If not, nothing to do. */
+ if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word != 32)
+ return;
+
+ struct siginfo32 si32;
+
+ si32.si_signo = si->si_signo;
+ si32.si_errno = si->si_errno;
+ si32.si_code = si->si_code;
+ si32.si_pid = si->si_pid;
+ si32.si_uid = si->si_uid;
+ si32.si_status = si->si_status;
+ si32.si_addr = (uintptr_t) si->si_addr;
+
+ /* If sival_ptr is being used instead of sival_int on a big-endian
+ platform, then sival_int will be zero since it holds the upper
+ 32-bits of the pointer value. */
+#if _BYTE_ORDER == _BIG_ENDIAN
+ if (si->si_value.sival_int == 0)
+ si32.si_value.sival_ptr = (uintptr_t) si->si_value.sival_ptr;
+ else
+ si32.si_value.sival_int = si->si_value.sival_int;
+#else
+ si32.si_value.sival_int = si->si_value.sival_int;
+#endif
+
+ /* Always copy the spare fields and then possibly overwrite them for
+ signal-specific or code-specific fields. */
+ si32._reason.__spare__.__spare1__ = si->_reason.__spare__.__spare1__;
+ for (int i = 0; i < 7; i++)
+ si32._reason.__spare__.__spare2__[i] = si->_reason.__spare__.__spare2__[i];
+ switch (si->si_signo) {
+ case SIGILL:
+ case SIGFPE:
+ case SIGSEGV:
+ case SIGBUS:
+ si32.si_trapno = si->si_trapno;
+ break;
+ }
+ switch (si->si_code) {
+ case SI_TIMER:
+ si32.si_timerid = si->si_timerid;
+ si32.si_overrun = si->si_overrun;
+ break;
+ case SI_MESGQ:
+ si32.si_mqd = si->si_mqd;
+ break;
+ }
+
+ memcpy(si, &si32, sizeof (si32));
+#endif
+}
+#endif
+
+/* Implement the "to_xfer_partial target_ops" method. */
+
+static enum target_xfer_status
+fbsd_xfer_partial (struct target_ops *ops, enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
+{
+ pid_t pid = ptid_get_pid (inferior_ptid);
+
+ switch (object)
+ {
+#ifdef PT_LWPINFO
+ case TARGET_OBJECT_SIGNAL_INFO:
+ {
+ struct ptrace_lwpinfo pl;
+ size_t siginfo_size;
+
+ /* FreeBSD doesn't support writing to $_siginfo. */
+ if (writebuf != NULL)
+ return TARGET_XFER_E_IO;
+
+ if (inferior_ptid.lwp_p ())
+ pid = inferior_ptid.lwp ();
+
+ siginfo_size = fbsd_siginfo_size ();
+ if (offset > siginfo_size)
+ return TARGET_XFER_E_IO;
+
+ if (ptrace (PT_LWPINFO, pid, (PTRACE_TYPE_ARG3) &pl, sizeof (pl)) == -1)
+ return TARGET_XFER_E_IO;
+
+ if (!(pl.pl_flags & PL_FLAG_SI))
+ return TARGET_XFER_E_IO;
+
+ fbsd_convert_siginfo (&pl.pl_siginfo);
+ if (offset + len > siginfo_size)
+ len = siginfo_size - offset;
+
+ memcpy (readbuf, ((gdb_byte *) &pl.pl_siginfo) + offset, len);
+ *xfered_len = len;
+ return TARGET_XFER_OK;
+ }
+#endif
+ case TARGET_OBJECT_AUXV:
+ {
+ gdb::byte_vector buf_storage;
+ gdb_byte *buf;
+ size_t buflen;
+ int mib[4];
+
+ if (writebuf != NULL)
+ return TARGET_XFER_E_IO;
+ mib[0] = CTL_KERN;
+ mib[1] = KERN_PROC;
+ mib[2] = KERN_PROC_AUXV;
+ mib[3] = pid;
+ if (offset == 0)
+ {
+ buf = readbuf;
+ buflen = len;
+ }
+ else
+ {
+ buflen = offset + len;
+ buf_storage.resize (buflen);
+ buf = buf_storage.data ();
+ }
+ if (sysctl (mib, 4, buf, &buflen, NULL, 0) == 0)
+ {
+ if (offset != 0)
+ {
+ if (buflen > offset)
+ {
+ buflen -= offset;
+ memcpy (readbuf, buf + offset, buflen);
+ }
+ else
+ buflen = 0;
+ }
+ *xfered_len = buflen;
+ return (buflen == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
+ }
+ return TARGET_XFER_E_IO;
+ }
+ default:
+ return super_xfer_partial (ops, object, annex, readbuf, writebuf, offset,
+ len, xfered_len);
+ }
+}
+#endif
+
#ifdef PT_LWPINFO
static int debug_fbsd_lwp;
+static void (*super_resume) (struct target_ops *,
+ ptid_t,
+ int,
+ enum gdb_signal);
static ptid_t (*super_wait) (struct target_ops *,
ptid_t,
struct target_waitstatus *,
FreeBSD's first thread support was via a "reentrant" version of libc
(libc_r) that first shipped in 2.2.7. This library multiplexed all
of the threads in a process onto a single kernel thread. This
- library is supported via the bsd-uthread target.
+ library was supported via the bsd-uthread target.
FreeBSD 5.1 introduced two new threading libraries that made use of
multiple kernel threads. The first (libkse) scheduled M user
/* Convert PTID to a string. Returns the string in a static
buffer. */
-static char *
+static const char *
fbsd_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
lwpid_t lwp;
}
#endif
-#ifdef PT_LWP_EVENTS
-/* Enable LWP events for a specific process.
+/* Enable additional event reporting on new processes.
+
+ To catch fork events, PTRACE_FORK is set on every traced process
+ to enable stops on returns from fork or vfork. Note that both the
+ parent and child will always stop, even if system call stops are
+ not enabled.
- To catch LWP events, PT_LWP_EVENTS is set on every traced process.
+ To catch LWP events, PTRACE_EVENTS is set on every traced process.
This enables stops on the birth for new LWPs (excluding the "main" LWP)
and the death of LWPs (excluding the last LWP in a process). Note
that unlike fork events, the LWP that creates a new LWP does not
report an event. */
static void
-fbsd_enable_lwp_events (pid_t pid)
+fbsd_enable_proc_events (pid_t pid)
{
+#ifdef PT_GET_EVENT_MASK
+ int events;
+
+ if (ptrace (PT_GET_EVENT_MASK, pid, (PTRACE_TYPE_ARG3)&events,
+ sizeof (events)) == -1)
+ perror_with_name (("ptrace"));
+ events |= PTRACE_FORK | PTRACE_LWP;
+#ifdef PTRACE_VFORK
+ events |= PTRACE_VFORK;
+#endif
+ if (ptrace (PT_SET_EVENT_MASK, pid, (PTRACE_TYPE_ARG3)&events,
+ sizeof (events)) == -1)
+ perror_with_name (("ptrace"));
+#else
+#ifdef TDP_RFPPWAIT
+ if (ptrace (PT_FOLLOW_FORK, pid, (PTRACE_TYPE_ARG3)0, 1) == -1)
+ perror_with_name (("ptrace"));
+#endif
+#ifdef PT_LWP_EVENTS
if (ptrace (PT_LWP_EVENTS, pid, (PTRACE_TYPE_ARG3)0, 1) == -1)
perror_with_name (("ptrace"));
-}
#endif
+#endif
+}
/* Add threads for any new LWPs in a process.
static void
fbsd_add_threads (pid_t pid)
{
- struct cleanup *cleanup;
- lwpid_t *lwps;
int i, nlwps;
gdb_assert (!in_thread_list (pid_to_ptid (pid)));
if (nlwps == -1)
perror_with_name (("ptrace"));
- lwps = XCNEWVEC (lwpid_t, nlwps);
- cleanup = make_cleanup (xfree, lwps);
+ gdb::unique_xmalloc_ptr<lwpid_t[]> lwps (XCNEWVEC (lwpid_t, nlwps));
- nlwps = ptrace (PT_GETLWPLIST, pid, (caddr_t) lwps, nlwps);
+ nlwps = ptrace (PT_GETLWPLIST, pid, (caddr_t) lwps.get (), nlwps);
if (nlwps == -1)
perror_with_name (("ptrace"));
add_thread (ptid);
}
}
- do_cleanups (cleanup);
}
/* Implement the "to_update_thread_list" target_ops method. */
#endif
}
-static void (*super_resume) (struct target_ops *,
- ptid_t,
- int,
- enum gdb_signal);
-
-static int
-resume_one_thread_cb (struct thread_info *tp, void *data)
-{
- ptid_t *ptid = data;
- int request;
-
- if (ptid_get_pid (tp->ptid) != ptid_get_pid (*ptid))
- return 0;
-
- if (ptid_get_lwp (tp->ptid) == ptid_get_lwp (*ptid))
- request = PT_RESUME;
- else
- request = PT_SUSPEND;
-
- if (ptrace (request, ptid_get_lwp (tp->ptid), NULL, 0) == -1)
- perror_with_name (("ptrace"));
- return 0;
-}
-
-static int
-resume_all_threads_cb (struct thread_info *tp, void *data)
-{
- ptid_t *filter = data;
-
- if (!ptid_match (tp->ptid, *filter))
- return 0;
-
- if (ptrace (PT_RESUME, ptid_get_lwp (tp->ptid), NULL, 0) == -1)
- perror_with_name (("ptrace"));
- return 0;
-}
-
-/* Implement the "to_resume" target_ops method. */
-
-static void
-fbsd_resume (struct target_ops *ops,
- ptid_t ptid, int step, enum gdb_signal signo)
-{
-
- if (debug_fbsd_lwp)
- fprintf_unfiltered (gdb_stdlog,
- "FLWP: fbsd_resume for ptid (%d, %ld, %ld)\n",
- ptid_get_pid (ptid), ptid_get_lwp (ptid),
- ptid_get_tid (ptid));
- if (ptid_lwp_p (ptid))
- {
- /* If ptid is a specific LWP, suspend all other LWPs in the process. */
- iterate_over_threads (resume_one_thread_cb, &ptid);
- }
- else
- {
- /* If ptid is a wildcard, resume all matching threads (they won't run
- until the process is continued however). */
- iterate_over_threads (resume_all_threads_cb, &ptid);
- ptid = inferior_ptid;
- }
- super_resume (ops, ptid, step, signo);
-}
-
#ifdef TDP_RFPPWAIT
/*
To catch fork events, PT_FOLLOW_FORK is set on every traced process
sake. FreeBSD versions newer than 9.1 contain both fixes.
*/
-struct fbsd_fork_child_info
-{
- struct fbsd_fork_child_info *next;
- ptid_t child; /* Pid of new child. */
-};
-
-static struct fbsd_fork_child_info *fbsd_pending_children;
+static std::list<ptid_t> fbsd_pending_children;
/* Record a new child process event that is reported before the
corresponding fork event in the parent. */
static void
fbsd_remember_child (ptid_t pid)
{
- struct fbsd_fork_child_info *info = XCNEW (struct fbsd_fork_child_info);
-
- info->child = pid;
- info->next = fbsd_pending_children;
- fbsd_pending_children = info;
+ fbsd_pending_children.push_front (pid);
}
/* Check for a previously-recorded new child process event for PID.
static ptid_t
fbsd_is_child_pending (pid_t pid)
{
- struct fbsd_fork_child_info *info, *prev;
- ptid_t ptid;
+ for (auto it = fbsd_pending_children.begin ();
+ it != fbsd_pending_children.end (); it++)
+ if (it->pid () == pid)
+ {
+ ptid_t ptid = *it;
+ fbsd_pending_children.erase (it);
+ return ptid;
+ }
+ return null_ptid;
+}
+
+#ifndef PTRACE_VFORK
+static std::forward_list<ptid_t> fbsd_pending_vfork_done;
- prev = NULL;
- for (info = fbsd_pending_children; info; prev = info, info = info->next)
+/* Record a pending vfork done event. */
+
+static void
+fbsd_add_vfork_done (ptid_t pid)
+{
+ fbsd_pending_vfork_done.push_front (pid);
+}
+
+/* Check for a pending vfork done event for a specific PID. */
+
+static int
+fbsd_is_vfork_done_pending (pid_t pid)
+{
+ for (auto it = fbsd_pending_vfork_done.begin ();
+ it != fbsd_pending_vfork_done.end (); it++)
+ if (it->pid () == pid)
+ return 1;
+ return 0;
+}
+
+/* Check for a pending vfork done event. If one is found, remove it
+ from the list and return the PTID. */
+
+static ptid_t
+fbsd_next_vfork_done (void)
+{
+ if (!fbsd_pending_vfork_done.empty ())
{
- if (ptid_get_pid (info->child) == pid)
- {
- if (prev == NULL)
- fbsd_pending_children = info->next;
- else
- prev->next = info->next;
- ptid = info->child;
- xfree (info);
- return ptid;
- }
+ ptid_t ptid = fbsd_pending_vfork_done.front ();
+ fbsd_pending_vfork_done.pop_front ();
+ return ptid;
}
return null_ptid;
}
+#endif
+#endif
+
+/* Implement the "to_resume" target_ops method. */
+
+static void
+fbsd_resume (struct target_ops *ops,
+ ptid_t ptid, int step, enum gdb_signal signo)
+{
+#if defined(TDP_RFPPWAIT) && !defined(PTRACE_VFORK)
+ pid_t pid;
+
+ /* Don't PT_CONTINUE a process which has a pending vfork done event. */
+ if (ptid_equal (minus_one_ptid, ptid))
+ pid = ptid_get_pid (inferior_ptid);
+ else
+ pid = ptid_get_pid (ptid);
+ if (fbsd_is_vfork_done_pending (pid))
+ return;
#endif
+ if (debug_fbsd_lwp)
+ fprintf_unfiltered (gdb_stdlog,
+ "FLWP: fbsd_resume for ptid (%d, %ld, %ld)\n",
+ ptid_get_pid (ptid), ptid_get_lwp (ptid),
+ ptid_get_tid (ptid));
+ if (ptid_lwp_p (ptid))
+ {
+ /* If ptid is a specific LWP, suspend all other LWPs in the process. */
+ struct thread_info *tp;
+ int request;
+
+ ALL_NON_EXITED_THREADS (tp)
+ {
+ if (ptid_get_pid (tp->ptid) != ptid_get_pid (ptid))
+ continue;
+
+ if (ptid_get_lwp (tp->ptid) == ptid_get_lwp (ptid))
+ request = PT_RESUME;
+ else
+ request = PT_SUSPEND;
+
+ if (ptrace (request, ptid_get_lwp (tp->ptid), NULL, 0) == -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). */
+ struct thread_info *tp;
+
+ ALL_NON_EXITED_THREADS (tp)
+ {
+ if (!ptid_match (tp->ptid, ptid))
+ continue;
+
+ if (ptrace (PT_RESUME, ptid_get_lwp (tp->ptid), NULL, 0) == -1)
+ perror_with_name (("ptrace"));
+ }
+ ptid = inferior_ptid;
+ }
+ super_resume (ops, ptid, step, signo);
+}
+
/* 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. */
while (1)
{
+#ifndef PTRACE_VFORK
+ wptid = fbsd_next_vfork_done ();
+ if (!ptid_equal (wptid, null_ptid))
+ {
+ ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
+ return wptid;
+ }
+#endif
wptid = super_wait (ops, ptid, ourstatus, target_options);
if (ourstatus->kind == TARGET_WAITKIND_STOPPED)
{
#ifdef TDP_RFPPWAIT
if (pl.pl_flags & PL_FLAG_FORKED)
{
+#ifndef PTRACE_VFORK
struct kinfo_proc kp;
+#endif
ptid_t child_ptid;
pid_t child;
child = pl.pl_child_pid;
ourstatus->kind = TARGET_WAITKIND_FORKED;
+#ifdef PTRACE_VFORK
+ if (pl.pl_flags & PL_FLAG_VFORKED)
+ ourstatus->kind = TARGET_WAITKIND_VFORKED;
+#endif
/* Make sure the other end of the fork is stopped too. */
child_ptid = fbsd_is_child_pending (child);
child_ptid = ptid_build (child, pl.pl_lwpid, 0);
}
+ /* Enable additional events on the child process. */
+ fbsd_enable_proc_events (ptid_get_pid (child_ptid));
+
+#ifndef PTRACE_VFORK
/* For vfork, the child process will have the P_PPWAIT
flag set. */
fbsd_fetch_kinfo_proc (child, &kp);
if (kp.ki_flag & P_PPWAIT)
ourstatus->kind = TARGET_WAITKIND_VFORKED;
+#endif
ourstatus->value.related_pid = child_ptid;
return wptid;
fbsd_remember_child (wptid);
continue;
}
+
+#ifdef PTRACE_VFORK
+ if (pl.pl_flags & PL_FLAG_VFORK_DONE)
+ {
+ ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
+ return wptid;
+ }
+#endif
#endif
#ifdef PL_FLAG_EXEC
return wptid;
}
#endif
+
+ /* Note that PL_FLAG_SCE is set for any event reported while
+ a thread is executing a system call in the kernel. In
+ particular, signals that interrupt a sleep in a system
+ call will report this flag as part of their event. Stops
+ explicitly for system call entry and exit always use
+ SIGTRAP, so only treat SIGTRAP events as system call
+ entry/exit events. */
+ if (pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX)
+ && ourstatus->value.sig == SIGTRAP)
+ {
+#ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
+ if (catch_syscall_enabled ())
+ {
+ if (catching_syscall_number (pl.pl_syscall_code))
+ {
+ if (pl.pl_flags & PL_FLAG_SCE)
+ ourstatus->kind = TARGET_WAITKIND_SYSCALL_ENTRY;
+ else
+ ourstatus->kind = TARGET_WAITKIND_SYSCALL_RETURN;
+ ourstatus->value.syscall_number = pl.pl_syscall_code;
+ return wptid;
+ }
+ }
+#endif
+ /* If the core isn't interested in this event, just
+ continue the process explicitly and wait for another
+ event. Note that PT_SYSCALL is "sticky" on FreeBSD
+ and once system call stops are enabled on a process
+ it stops for all system call entries and exits. */
+ if (ptrace (PT_CONTINUE, pid, (caddr_t) 1, 0) == -1)
+ perror_with_name (("ptrace"));
+ continue;
+ }
}
return wptid;
}
fbsd_follow_fork (struct target_ops *ops, int follow_child,
int detach_fork)
{
- if (!follow_child)
+ if (!follow_child && detach_fork)
{
struct thread_info *tp = inferior_thread ();
pid_t child_pid = ptid_get_pid (tp->pending_follow.value.related_pid);
if (ptrace (PT_DETACH, child_pid, (PTRACE_TYPE_ARG3)1, 0) == -1)
perror_with_name (("ptrace"));
+
+#ifndef PTRACE_VFORK
+ if (tp->pending_follow.kind == TARGET_WAITKIND_VFORKED)
+ {
+ /* We can't insert breakpoints until the child process has
+ finished with the shared memory region. The parent
+ process doesn't wait for the child process to exit or
+ exec until after it has been resumed from the ptrace stop
+ to report the fork. Once it has been resumed it doesn't
+ stop again before returning to userland, so there is no
+ reliable way to wait on the parent.
+
+ We can't stay attached to the child to wait for an exec
+ or exit because it may invoke ptrace(PT_TRACE_ME)
+ (e.g. if the parent process is a debugger forking a new
+ child process).
+
+ In the end, the best we can do is to make sure it runs
+ for a little while. Hopefully it will be out of range of
+ any breakpoints we reinsert. Usually this is only the
+ single-step breakpoint at vfork's return point. */
+
+ usleep (10000);
+
+ /* Schedule a fake VFORK_DONE event to report on the next
+ wait. */
+ fbsd_add_vfork_done (inferior_ptid);
+ }
+#endif
}
return 0;
{
return 0;
}
-
-/* Enable fork tracing for a specific process.
-
- To catch fork events, PT_FOLLOW_FORK is set on every traced process
- to enable stops on returns from fork or vfork. Note that both the
- parent and child will always stop, even if system call stops are
- not enabled. */
-
-static void
-fbsd_enable_follow_fork (pid_t pid)
-{
- if (ptrace (PT_FOLLOW_FORK, pid, (PTRACE_TYPE_ARG3)0, 1) == -1)
- perror_with_name (("ptrace"));
-}
#endif
/* Implement the "to_post_startup_inferior" target_ops method. */
static void
fbsd_post_startup_inferior (struct target_ops *self, ptid_t pid)
{
-#ifdef TDP_RFPPWAIT
- fbsd_enable_follow_fork (ptid_get_pid (pid));
-#endif
-#ifdef PT_LWP_EVENTS
- fbsd_enable_lwp_events (ptid_get_pid (pid));
-#endif
+ fbsd_enable_proc_events (ptid_get_pid (pid));
}
/* Implement the "to_post_attach" target_ops method. */
static void
fbsd_post_attach (struct target_ops *self, int pid)
{
-#ifdef TDP_RFPPWAIT
- fbsd_enable_follow_fork (pid);
-#endif
-#ifdef PT_LWP_EVENTS
- fbsd_enable_lwp_events (pid);
-#endif
+ fbsd_enable_proc_events (pid);
fbsd_add_threads (pid);
}
return 0;
}
#endif
+
+#ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
+static int
+fbsd_set_syscall_catchpoint (struct target_ops *self, int pid, int needed,
+ int any_count, int table_size, int *table)
+{
+
+ /* 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;
+}
+#endif
#endif
void
{
t->to_pid_to_exec_file = fbsd_pid_to_exec_file;
t->to_find_memory_regions = fbsd_find_memory_regions;
+#ifdef KERN_PROC_AUXV
+ super_xfer_partial = t->to_xfer_partial;
+ t->to_xfer_partial = fbsd_xfer_partial;
+#endif
#ifdef PT_LWPINFO
t->to_thread_alive = fbsd_thread_alive;
t->to_pid_to_str = fbsd_pid_to_str;
t->to_insert_exec_catchpoint = fbsd_insert_exec_catchpoint;
t->to_remove_exec_catchpoint = fbsd_remove_exec_catchpoint;
#endif
+#ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
+ t->to_set_syscall_catchpoint = fbsd_set_syscall_catchpoint;
+#endif
#endif
add_target (t);
}
-/* Provide a prototype to silence -Wmissing-prototypes. */
-extern initialize_file_ftype _initialize_fbsd_nat;
-
void
_initialize_fbsd_nat (void)
{