/* 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.
#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 *,
}
#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.
#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 = (ptid_t *) 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 = (ptid_t *) 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_info
{
- struct fbsd_fork_child_info *next;
- ptid_t child; /* Pid of new child. */
+ struct fbsd_fork_info *next;
+ ptid_t ptid;
};
-static struct fbsd_fork_child_info *fbsd_pending_children;
+static struct fbsd_fork_info *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);
+ struct fbsd_fork_info *info = XCNEW (struct fbsd_fork_info);
- info->child = pid;
+ info->ptid = pid;
info->next = fbsd_pending_children;
fbsd_pending_children = info;
}
static ptid_t
fbsd_is_child_pending (pid_t pid)
{
- struct fbsd_fork_child_info *info, *prev;
+ struct fbsd_fork_info *info, *prev;
ptid_t ptid;
prev = NULL;
for (info = fbsd_pending_children; info; prev = info, info = info->next)
{
- if (ptid_get_pid (info->child) == pid)
+ if (ptid_get_pid (info->ptid) == pid)
{
if (prev == NULL)
fbsd_pending_children = info->next;
else
prev->next = info->next;
- ptid = info->child;
+ ptid = info->ptid;
xfree (info);
return ptid;
}
}
return null_ptid;
}
+
+#ifndef PTRACE_VFORK
+static struct fbsd_fork_info *fbsd_pending_vfork_done;
+
+/* Record a pending vfork done event. */
+
+static void
+fbsd_add_vfork_done (ptid_t pid)
+{
+ struct fbsd_fork_info *info = XCNEW (struct fbsd_fork_info);
+
+ info->ptid = pid;
+ info->next = fbsd_pending_vfork_done;
+ fbsd_pending_vfork_done = info;
+}
+
+/* Check for a pending vfork done event for a specific PID. */
+
+static int
+fbsd_is_vfork_done_pending (pid_t pid)
+{
+ struct fbsd_fork_info *info;
+
+ for (info = fbsd_pending_vfork_done; info != NULL; info = info->next)
+ {
+ if (ptid_get_pid (info->ptid) == 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)
+{
+ struct fbsd_fork_info *info;
+ ptid_t ptid;
+
+ if (fbsd_pending_vfork_done != NULL)
+ {
+ info = fbsd_pending_vfork_done;
+ fbsd_pending_vfork_done = info->next;
+ ptid = info->ptid;
+ xfree (info);
+ return ptid;
+ }
+ return null_ptid;
+}
+#endif
+#endif
+
+static int
+resume_one_thread_cb (struct thread_info *tp, void *data)
+{
+ ptid_t *ptid = (ptid_t *) 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 = (ptid_t *) 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 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. */
+ 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);
+}
+
/* 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
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);
}