mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-05 08:14:19 +08:00
00340e1b91
This patch adds a new "event" struct serial type, that is an abstraction specifically for waking up blocking waits/selects, implemented on top of a pipe on POSIX, and on top of a native Windows event (CreateEvent, etc.) on Windows. This will be used to plug signal handler / mainline code races. For example, GDB can indefinitely delay handling a quit request if the user presses Ctrl-C between the last QUIT call and the next (blocking) gdb_select call in the event loop: QUIT; <<< press ctrl-c here and end up blocked in gdb_select indefinitely. gdb_select (...); // whoops, SIGINT was already handled, no EINTR. A global alone (either the quit flag, or the "ready" flag of the async signal handlers in the event loop) is not sufficient. To plug races such as these on POSIX systems, we have to register some waitable file descriptor in the set of files gdb_select waits on, and write to it from the signal handler. This is classically a pipe, and the pattern called the self-pipe trick. On Linux, it could be a more efficient eventfd instead, but I'm sticking with a pipe for simplifity, as we need it for portability anyway. (Alternatively, we could use pselect/ppoll, and block signals until the pselect. The latter is not a design I think GDB could use, because we want the QUIT macro to be super cheap, as it is used in loops. Plus, Windows.) This is a "struct serial" because Windows's gdb_select relies on that. Windows's gdb_select, our "select" replacement, knows how to wait on all kinds of handles (regular files, pipes, sockets, console, etc.) unlike the native Windows "select" function, which can only wait on sockets. Each file descriptor for a "serial" type that is not normally waitable with WaitForMultipleObjects must have a corresponding struct serial instance. gdb_select then internally looks up the struct serial instance that wraps each file descriptor, and asks it for the corresponding Windows waitable handle. We could use serial_pipe() to create a "struct serial"-wrapped pipe that is usable everywhere, including Windows. That's what currently python/python.c uses for cross-thread posting of events. However, serial_write and serial_readchar are not designed to be async-signal-safe on POSIX hosts. It's easier to bypass those when setting/clearing the event source. And writing and a serial pipe is a bit heavy weight on Windows. gdb_select requires an extra thread to wait on the pipe and several Windows events, when a single manual-reset Windows event, with no extra thread is sufficient. The intended usage is simply: - Call make_serial_event to create a serial event object. - From the signal handler call serial_event_set to set the event. - From mainline code, have select/poll wait for serial_event_fd(), in addition to whatever other files you're about to wait for. gdb/ChangeLog: 2016-04-12 Pedro Alves <palves@redhat.com> * Makefile.in (SFILES): Add ser-event.c. (HFILES_NO_SRCDIR): Add ser-event.h. (COMMON_OBS): Add ser-event.o. * ser-event.c, ser-event.h: New files. * serial.c (new_serial): New function, factored out from (serial_fdopen_ops): ... this. (serial_open_ops_1): New function, factored out from (serial_open): ... this. (serial_open_ops): New function. * serial.h (struct serial): Forware declare. (serial_open_ops): New declaration.
221 lines
5.4 KiB
C
221 lines
5.4 KiB
C
/* Serial interface for a selectable event.
|
|
Copyright (C) 2016 Free Software Foundation, Inc.
|
|
|
|
This file is part of GDB.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
#include "defs.h"
|
|
#include "ser-event.h"
|
|
#include "serial.h"
|
|
#include "common/filestuff.h"
|
|
|
|
/* On POSIX hosts, a serial_event is basically an abstraction for the
|
|
classical self-pipe trick.
|
|
|
|
On Windows, a serial_event is a wrapper around a native Windows
|
|
event object. Because we want to interface with gdb_select, which
|
|
takes file descriptors, we need to wrap that Windows event object
|
|
in a file descriptor. As _open_osfhandle can not be used with
|
|
event objects, we instead create a dummy file wrap that in a file
|
|
descriptor with _open_osfhandle, and pass that as selectable
|
|
descriptor to callers. As Windows' gdb_select converts file
|
|
descriptors back to Windows handles by calling serial->wait_handle,
|
|
nothing ever actually waits on that file descriptor. */
|
|
|
|
struct serial_event_state
|
|
{
|
|
#ifdef USE_WIN32API
|
|
/* The Windows event object, created with CreateEvent. */
|
|
HANDLE event;
|
|
#else
|
|
/* The write side of the pipe. The read side is in
|
|
serial->fd. */
|
|
int write_fd;
|
|
#endif
|
|
};
|
|
|
|
/* Open a new serial event. */
|
|
|
|
static int
|
|
serial_event_open (struct serial *scb, const char *name)
|
|
{
|
|
struct serial_event_state *state;
|
|
|
|
state = XNEW (struct serial_event_state);
|
|
scb->state = state;
|
|
|
|
#ifndef USE_WIN32API
|
|
{
|
|
int fds[2];
|
|
|
|
if (gdb_pipe_cloexec (fds) == -1)
|
|
internal_error (__FILE__, __LINE__,
|
|
"creating serial event pipe failed.");
|
|
|
|
fcntl (fds[0], F_SETFL, O_NONBLOCK);
|
|
fcntl (fds[1], F_SETFL, O_NONBLOCK);
|
|
|
|
scb->fd = fds[0];
|
|
state->write_fd = fds[1];
|
|
}
|
|
#else
|
|
{
|
|
/* A dummy file object that can be wrapped in a file descriptor.
|
|
We don't need to store this handle because closing the file
|
|
descriptor automatically closes this. */
|
|
HANDLE dummy_file;
|
|
|
|
/* A manual-reset event. */
|
|
state->event = CreateEvent (0, TRUE, FALSE, 0);
|
|
|
|
/* The dummy file handle. Created just so we have something
|
|
wrappable in a file descriptor. */
|
|
dummy_file = CreateFile ("nul", 0, 0, NULL, OPEN_EXISTING, 0, NULL);
|
|
scb->fd = _open_osfhandle ((intptr_t) dummy_file, 0);
|
|
}
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
serial_event_close (struct serial *scb)
|
|
{
|
|
struct serial_event_state *state = (struct serial_event_state *) scb->state;
|
|
|
|
close (scb->fd);
|
|
#ifndef USE_WIN32API
|
|
close (state->write_fd);
|
|
#else
|
|
CloseHandle (state->event);
|
|
#endif
|
|
|
|
scb->fd = -1;
|
|
|
|
xfree (state);
|
|
scb->state = NULL;
|
|
}
|
|
|
|
#ifdef USE_WIN32API
|
|
|
|
/* Implementation of the wait_handle method. Returns the native
|
|
Windows event object handle. */
|
|
|
|
static void
|
|
serial_event_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
|
|
{
|
|
struct serial_event_state *state = (struct serial_event_state *) scb->state;
|
|
|
|
*read = state->event;
|
|
}
|
|
|
|
#endif
|
|
|
|
/* The serial_ops for struct serial_event objects. Note we never
|
|
register this serial type with serial_add_interface, because this
|
|
is internal implementation detail never to be used by remote
|
|
targets for protocol transport. */
|
|
|
|
static const struct serial_ops serial_event_ops =
|
|
{
|
|
"event",
|
|
serial_event_open,
|
|
serial_event_close,
|
|
NULL, /* fdopen */
|
|
NULL, /* readchar */
|
|
NULL, /* write */
|
|
NULL, /* flush_output */
|
|
NULL, /* flush_input */
|
|
NULL, /* send_break */
|
|
NULL, /* go_raw */
|
|
NULL, /* get_tty_state */
|
|
NULL, /* copy_tty_state */
|
|
NULL, /* set_tty_state */
|
|
NULL, /* print_tty_state */
|
|
NULL, /* noflush_set_tty_state */
|
|
NULL, /* setbaudrate */
|
|
NULL, /* setstopbits */
|
|
NULL, /* setparity */
|
|
NULL, /* drain_output */
|
|
NULL, /* async */
|
|
NULL, /* read_prim */
|
|
NULL, /* write_prim */
|
|
NULL, /* avail */
|
|
#ifdef USE_WIN32API
|
|
serial_event_wait_handle,
|
|
#endif
|
|
};
|
|
|
|
/* See ser-event.h. */
|
|
|
|
struct serial_event *
|
|
make_serial_event (void)
|
|
{
|
|
return (struct serial_event *) serial_open_ops (&serial_event_ops);
|
|
}
|
|
|
|
/* See ser-event.h. */
|
|
|
|
int
|
|
serial_event_fd (struct serial_event *event)
|
|
{
|
|
struct serial *ser = (struct serial *) event;
|
|
|
|
return ser->fd;
|
|
}
|
|
|
|
/* See ser-event.h. */
|
|
|
|
void
|
|
serial_event_set (struct serial_event *event)
|
|
{
|
|
struct serial *ser = (struct serial *) event;
|
|
struct serial_event_state *state = (struct serial_event_state *) ser->state;
|
|
#ifndef USE_WIN32API
|
|
int r;
|
|
char c = '+'; /* Anything. */
|
|
|
|
do
|
|
{
|
|
r = write (state->write_fd, &c, 1);
|
|
}
|
|
while (r < 0 && errno == EINTR);
|
|
#else
|
|
SetEvent (state->event);
|
|
#endif
|
|
}
|
|
|
|
/* See ser-event.h. */
|
|
|
|
void
|
|
serial_event_clear (struct serial_event *event)
|
|
{
|
|
struct serial *ser = (struct serial *) event;
|
|
struct serial_event_state *state = (struct serial_event_state *) ser->state;
|
|
#ifndef USE_WIN32API
|
|
int r;
|
|
|
|
do
|
|
{
|
|
char c;
|
|
|
|
r = read (ser->fd, &c, 1);
|
|
}
|
|
while (r > 0 || (r < 0 && errno == EINTR));
|
|
#else
|
|
ResetEvent (state->event);
|
|
#endif
|
|
}
|