[PATCH v2 13/13] inf-ptrace: Add an event_pipe to be used for async mode in subclasses.
John Baldwin
jhb@FreeBSD.org
Tue Aug 3 18:50:00 GMT 2021
Subclasses of inf_ptrace_target have to opt-in to using the event_pipe
by implementing the can_async_p and async methods. For subclasses
which do this, inf_ptrace_target provides is_async_p, async_wait_fd
and closes the pipe in the close target method.
inf_ptrace_target also provides wrapper routines around the event pipe
(async_file_open, async_file_close, async_file_flush, and
async_file_mark) for use in target methods such as async.
inf_ptrace_target also exports a static async_file_mark_if_open
function which can be used in SIGCHLD signal handlers.
---
gdb/fbsd-nat.c | 50 ++++---------------
gdb/fbsd-nat.h | 4 --
gdb/inf-ptrace.c | 15 ++++++
gdb/inf-ptrace.h | 24 +++++++++
gdb/linux-nat.c | 126 ++++++++++-------------------------------------
gdb/linux-nat.h | 4 --
6 files changed, 75 insertions(+), 148 deletions(-)
diff --git a/gdb/fbsd-nat.c b/gdb/fbsd-nat.c
index 34713151cbe..7c6632cf258 100644
--- a/gdb/fbsd-nat.c
+++ b/gdb/fbsd-nat.c
@@ -20,7 +20,6 @@
#include "defs.h"
#include "gdbsupport/byte-vector.h"
#include "gdbsupport/event-loop.h"
-#include "gdbsupport/event-pipe.h"
#include "gdbcore.h"
#include "inferior.h"
#include "regcache.h"
@@ -931,8 +930,6 @@ fbsd_nat_target::update_thread_list ()
/* Async mode support. */
-static event_pipe fbsd_nat_event_pipe;
-
/* Implement the "can_async_p" target method. */
bool
@@ -943,22 +940,6 @@ fbsd_nat_target::can_async_p ()
return target_async_permitted;
}
-/* Implement the "is_async_p" target method. */
-
-bool
-fbsd_nat_target::is_async_p ()
-{
- return fbsd_nat_event_pipe.is_open ();
-}
-
-/* Implement the "async_wait_fd" target method. */
-
-int
-fbsd_nat_target::async_wait_fd ()
-{
- return fbsd_nat_event_pipe.event_fd ();
-}
-
/* SIGCHLD handler notifies the event-loop in async mode. */
static void
@@ -966,8 +947,7 @@ sigchld_handler (int signo)
{
int old_errno = errno;
- if (fbsd_nat_event_pipe.is_open ())
- fbsd_nat_event_pipe.mark ();
+ fbsd_nat_target::async_file_mark_if_open ();
errno = old_errno;
}
@@ -998,36 +978,24 @@ fbsd_nat_target::async (int enable)
if (enable)
{
- if (!fbsd_nat_event_pipe.open ())
+ if (!async_file_open ())
internal_error (__FILE__, __LINE__, "failed to create event pipe.");
- add_file_handler (fbsd_nat_event_pipe.event_fd (),
- handle_target_event, NULL, "fbsd-nat");
+ add_file_handler (async_wait_fd (), handle_target_event, NULL, "fbsd-nat");
/* Trigger a poll in case there are pending events to
handle. */
- fbsd_nat_event_pipe.mark ();
+ async_file_mark ();
}
else
{
- delete_file_handler (fbsd_nat_event_pipe.event_fd ());
- fbsd_nat_event_pipe.close ();
+ delete_file_handler (async_wait_fd ());
+ async_file_close ();
}
gdb_sigmask (SIG_SETMASK, &prev_mask, NULL);
}
-/* Implement the "close" target method. */
-
-void
-fbsd_nat_target::close ()
-{
- if (is_async_p ())
- async (0);
-
- inf_ptrace_target::close ();
-}
-
#ifdef TDP_RFPPWAIT
/*
To catch fork events, PT_FOLLOW_FORK is set on every traced process
@@ -1494,7 +1462,7 @@ fbsd_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
/* Ensure any subsequent events trigger a new event in the loop. */
if (is_async_p ())
- fbsd_nat_event_pipe.flush ();
+ async_file_flush ();
wptid = wait_1 (ptid, ourstatus, target_options);
@@ -1502,7 +1470,7 @@ fbsd_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
another event pending. Trigger the event pipe so that that the
event loop keeps polling until no event is returned. */
if (is_async_p () && ourstatus->kind != TARGET_WAITKIND_IGNORE)
- fbsd_nat_event_pipe.mark ();
+ async_file_mark ();
fbsd_nat_debug_printf ("returning [%s], [%s]",
target_pid_to_str (wptid).c_str (),
@@ -1647,7 +1615,7 @@ fbsd_nat_target::follow_fork (ptid_t child_ptid, target_waitkind fork_kind,
/* If we're in async mode, need to tell the event loop
there's something here to process. */
if (is_async_p ())
- fbsd_nat_event_pipe.mark ();
+ async_file_mark ();
}
#endif
}
diff --git a/gdb/fbsd-nat.h b/gdb/fbsd-nat.h
index ad7f76bca40..4620750fc20 100644
--- a/gdb/fbsd-nat.h
+++ b/gdb/fbsd-nat.h
@@ -67,13 +67,9 @@ class fbsd_nat_target : public inf_ptrace_target
void update_thread_list () override;
bool can_async_p () override;
- bool is_async_p () override;
- int async_wait_fd () override;
void async (int) override;
- void close () override;
-
thread_control_capabilities get_thread_control_capabilities () override
{ return tc_schedlock; }
diff --git a/gdb/inf-ptrace.c b/gdb/inf-ptrace.c
index fb734234d8e..a63bebfb2b4 100644
--- a/gdb/inf-ptrace.c
+++ b/gdb/inf-ptrace.c
@@ -48,6 +48,9 @@ gdb_ptrace (PTRACE_TYPE_ARG1 request, ptid_t ptid, PTRACE_TYPE_ARG3 addr,
#endif
}
+/* The event pipe registered as a waitable file in the event loop. */
+event_pipe inf_ptrace_target::event_pipe;
+
inf_ptrace_target::~inf_ptrace_target ()
{}
@@ -533,3 +536,15 @@ inf_ptrace_target::pid_to_str (ptid_t ptid)
{
return normal_pid_to_str (ptid);
}
+
+/* Implement the "close" target method. */
+
+void
+inf_ptrace_target::close ()
+{
+ /* Unregister from the event loop. */
+ if (is_async_p ())
+ async (0);
+
+ inf_child_target::close ();
+}
diff --git a/gdb/inf-ptrace.h b/gdb/inf-ptrace.h
index 8aded9b60db..bdea7a9ac71 100644
--- a/gdb/inf-ptrace.h
+++ b/gdb/inf-ptrace.h
@@ -20,6 +20,7 @@
#ifndef INF_PTRACE_H
#define INF_PTRACE_H
+#include "gdbsupport/event-pipe.h"
#include "inf-child.h"
/* An abstract prototype ptrace target. The client can override it
@@ -33,6 +34,8 @@ struct inf_ptrace_target : public inf_child_target
void detach (inferior *inf, int) override;
+ void close () override;
+
void resume (ptid_t, int, enum gdb_signal) override;
ptid_t wait (ptid_t, struct target_waitstatus *, target_wait_flags) override;
@@ -57,9 +60,30 @@ struct inf_ptrace_target : public inf_child_target
ULONGEST offset, ULONGEST len,
ULONGEST *xfered_len) override;
+ bool is_async_p () override { return event_pipe.is_open (); }
+
+ int async_wait_fd () override { return event_pipe.event_fd (); }
+
+ /* Helper routine used from SIGCHLD handlers to signal the async
+ event pipe. */
+ static void async_file_mark_if_open ()
+ {
+ if (event_pipe.is_open ())
+ event_pipe.mark ();
+ }
+
protected:
+ /* Helper routines for interacting with the async event pipe. */
+ bool async_file_open () { return event_pipe.open (); }
+ void async_file_close () { event_pipe.close (); }
+ void async_file_flush () { event_pipe.flush (); }
+ void async_file_mark () { event_pipe.mark (); }
+
/* Cleanup the inferior after a successful ptrace detach. */
void detach_success (inferior *inf);
+
+private:
+ static class event_pipe event_pipe;
};
#ifndef __NetBSD__
diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c
index b80fa25c902..831153929be 100644
--- a/gdb/linux-nat.c
+++ b/gdb/linux-nat.c
@@ -48,7 +48,6 @@
#include <fcntl.h> /* for O_RDONLY */
#include "inf-loop.h"
#include "gdbsupport/event-loop.h"
-#include "gdbsupport/event-pipe.h"
#include "event-top.h"
#include <pwd.h>
#include <sys/types.h>
@@ -216,32 +215,6 @@ static struct simple_pid_list *stopped_pids;
/* Whether target_thread_events is in effect. */
static int report_thread_events;
-/* Async mode support. */
-
-/* The event pipe registered as a waitable file in the event loop. */
-static event_pipe linux_nat_event_pipe;
-
-/* True if we're currently in async mode. */
-#define linux_is_async_p() (linux_nat_event_pipe.is_open ())
-
-/* Flush the event pipe. */
-
-static void
-async_file_flush (void)
-{
- linux_nat_event_pipe.flush ();
-}
-
-/* Put something (anything, doesn't matter what, or how much) in event
- pipe, so that the select/poll in the event-loop realizes we have
- something to process. */
-
-static void
-async_file_mark (void)
-{
- linux_nat_event_pipe.mark ();
-}
-
static int kill_lwp (int lwpid, int signo);
static int stop_callback (struct lwp_info *lp);
@@ -4107,14 +4080,6 @@ linux_nat_target::static_tracepoint_markers_by_strid (const char *strid)
return markers;
}
-/* target_is_async_p implementation. */
-
-bool
-linux_nat_target::is_async_p ()
-{
- return linux_is_async_p ();
-}
-
/* target_can_async_p implementation. */
bool
@@ -4164,10 +4129,11 @@ sigchld_handler (int signo)
if (debug_linux_nat)
gdb_stdlog->write_async_safe ("sigchld\n", sizeof ("sigchld\n") - 1);
- if (signo == SIGCHLD
- && linux_nat_event_pipe.is_open ())
- async_file_mark (); /* Let the event loop know that there are
- events to handle. */
+ if (signo == SIGCHLD)
+ {
+ /* Let the event loop know that there are events to handle. */
+ linux_nat_target::async_file_mark_if_open ();
+ }
errno = old_errno;
}
@@ -4180,67 +4146,39 @@ handle_target_event (int error, gdb_client_data client_data)
inferior_event_handler (INF_REG_EVENT);
}
-/* Create/destroy the target events pipe. Returns previous state. */
-
-static int
-linux_async_pipe (int enable)
-{
- int previous = linux_is_async_p ();
-
- if (previous != enable)
- {
- sigset_t prev_mask;
-
- /* Block child signals while we create/destroy the pipe, as
- their handler writes to it. */
- block_child_signals (&prev_mask);
-
- if (enable)
- {
- if (!linux_nat_event_pipe.open ())
- internal_error (__FILE__, __LINE__,
- "creating event pipe failed.");
- }
- else
- {
- linux_nat_event_pipe.close ();
- }
-
- restore_child_signals_mask (&prev_mask);
- }
-
- return previous;
-}
-
-int
-linux_nat_target::async_wait_fd ()
-{
- return linux_nat_event_pipe.event_fd ();
-}
-
/* target_async implementation. */
void
linux_nat_target::async (int enable)
{
+ if ((enable != 0) == is_async_p ())
+ return;
+
+ sigset_t prev_mask;
+
+ /* Block child signals while we create/destroy the pipe, as their
+ handler writes to it. */
+ block_child_signals (&prev_mask);
+
if (enable)
{
- if (!linux_async_pipe (1))
- {
- add_file_handler (linux_nat_event_pipe.event_fd (),
- handle_target_event, NULL,
- "linux-nat");
- /* There may be pending events to handle. Tell the event loop
- to poll them. */
- async_file_mark ();
- }
+ if (!async_file_open ())
+ internal_error (__FILE__, __LINE__, "creating event pipe failed.");
+
+ add_file_handler (async_wait_fd (), handle_target_event, NULL,
+ "linux-nat");
+
+ /* There may be pending events to handle. Tell the event loop
+ to poll them. */
+ async_file_mark ();
}
else
{
- delete_file_handler (linux_nat_event_pipe.event_fd ());
- linux_async_pipe (0);
+ delete_file_handler (async_wait_fd ());
+ async_file_close ();
}
- return;
+
+ restore_child_signals_mask (&prev_mask);
}
/* Stop an LWP, and push a GDB_SIGNAL_0 stop status if no other
@@ -4288,16 +4226,6 @@ linux_nat_target::stop (ptid_t ptid)
iterate_over_lwps (ptid, linux_nat_stop_lwp);
}
-void
-linux_nat_target::close ()
-{
- /* Unregister from the event loop. */
- if (is_async_p ())
- async (0);
-
- inf_ptrace_target::close ();
-}
-
/* When requests are passed down from the linux-nat layer to the
single threaded inf-ptrace layer, ptids of (lwpid,0,0) form are
used. The address space pointer is stored in the inferior object,
diff --git a/gdb/linux-nat.h b/gdb/linux-nat.h
index ee36c56519b..f61790f732a 100644
--- a/gdb/linux-nat.h
+++ b/gdb/linux-nat.h
@@ -83,16 +83,12 @@ class linux_nat_target : public inf_ptrace_target
void thread_events (int) override;
bool can_async_p () override;
- bool is_async_p () override;
bool supports_non_stop () override;
bool always_non_stop_p () override;
- int async_wait_fd () override;
void async (int) override;
- void close () override;
-
void stop (ptid_t) override;
bool supports_multi_process () override;
--
2.31.1
More information about the Gdb-patches
mailing list