2005-03-25 20:47:23 +01:00
|
|
|
/* Generic serial interface functions.
|
|
|
|
|
2020-01-01 07:20:01 +01:00
|
|
|
Copyright (C) 1992-2020 Free Software Foundation, Inc.
|
2005-03-25 20:47:23 +01:00
|
|
|
|
|
|
|
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
|
2007-08-23 20:08:50 +02:00
|
|
|
the Free Software Foundation; either version 3 of the License, or
|
2005-03-25 20:47:23 +01:00
|
|
|
(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
|
2007-08-23 20:08:50 +02:00
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
2005-03-25 20:47:23 +01:00
|
|
|
|
|
|
|
#include "defs.h"
|
|
|
|
#include "serial.h"
|
2005-04-22 23:23:28 +02:00
|
|
|
#include "ser-base.h"
|
2020-04-13 20:42:59 +02:00
|
|
|
#include "gdbsupport/event-loop.h"
|
2005-04-22 23:23:28 +02:00
|
|
|
|
2020-04-13 20:42:59 +02:00
|
|
|
#include "gdbsupport/gdb_select.h"
|
Rename common to gdbsupport
This is the next patch in the ongoing series to move gdbsever to the
top level.
This patch just renames the "common" directory. The idea is to do
this move in two parts: first rename the directory (this patch), then
move the directory to the top. This approach makes the patches a bit
more tractable.
I chose the name "gdbsupport" for the directory. However, as this
patch was largely written by sed, we could pick a new name without too
much difficulty.
Tested by the buildbot.
gdb/ChangeLog
2019-07-09 Tom Tromey <tom@tromey.com>
* contrib/ari/gdb_ari.sh: Change common to gdbsupport.
* configure: Rebuild.
* configure.ac: Change common to gdbsupport.
* gdbsupport: Rename from common.
* acinclude.m4: Change common to gdbsupport.
* Makefile.in (CONFIG_SRC_SUBDIR, COMMON_SFILES)
(HFILES_NO_SRCDIR, stamp-version, ALLDEPFILES): Change common to
gdbsupport.
* aarch64-tdep.c, ada-lang.c, ada-lang.h, agent.c, alloc.c,
amd64-darwin-tdep.c, amd64-dicos-tdep.c, amd64-fbsd-nat.c,
amd64-fbsd-tdep.c, amd64-linux-nat.c, amd64-linux-tdep.c,
amd64-nbsd-tdep.c, amd64-obsd-tdep.c, amd64-sol2-tdep.c,
amd64-tdep.c, amd64-windows-tdep.c, arch-utils.c,
arch/aarch64-insn.c, arch/aarch64.c, arch/aarch64.h, arch/amd64.c,
arch/amd64.h, arch/arm-get-next-pcs.c, arch/arm-linux.c,
arch/arm.c, arch/i386.c, arch/i386.h, arch/ppc-linux-common.c,
arch/riscv.c, arch/riscv.h, arch/tic6x.c, arm-tdep.c, auto-load.c,
auxv.c, ax-gdb.c, ax-general.c, ax.h, breakpoint.c, breakpoint.h,
btrace.c, btrace.h, build-id.c, build-id.h, c-lang.h, charset.c,
charset.h, cli/cli-cmds.c, cli/cli-cmds.h, cli/cli-decode.c,
cli/cli-dump.c, cli/cli-option.h, cli/cli-script.c,
coff-pe-read.c, command.h, compile/compile-c-support.c,
compile/compile-c.h, compile/compile-cplus-symbols.c,
compile/compile-cplus-types.c, compile/compile-cplus.h,
compile/compile-loc2c.c, compile/compile.c, completer.c,
completer.h, contrib/ari/gdb_ari.sh, corefile.c, corelow.c,
cp-support.c, cp-support.h, cp-valprint.c, csky-tdep.c, ctf.c,
darwin-nat.c, debug.c, defs.h, disasm-selftests.c, disasm.c,
disasm.h, dtrace-probe.c, dwarf-index-cache.c,
dwarf-index-cache.h, dwarf-index-write.c, dwarf2-frame.c,
dwarf2expr.c, dwarf2loc.c, dwarf2read.c, event-loop.c,
event-top.c, exceptions.c, exec.c, extension.h, fbsd-nat.c,
features/aarch64-core.c, features/aarch64-fpu.c,
features/aarch64-pauth.c, features/aarch64-sve.c,
features/i386/32bit-avx.c, features/i386/32bit-avx512.c,
features/i386/32bit-core.c, features/i386/32bit-linux.c,
features/i386/32bit-mpx.c, features/i386/32bit-pkeys.c,
features/i386/32bit-segments.c, features/i386/32bit-sse.c,
features/i386/64bit-avx.c, features/i386/64bit-avx512.c,
features/i386/64bit-core.c, features/i386/64bit-linux.c,
features/i386/64bit-mpx.c, features/i386/64bit-pkeys.c,
features/i386/64bit-segments.c, features/i386/64bit-sse.c,
features/i386/x32-core.c, features/riscv/32bit-cpu.c,
features/riscv/32bit-csr.c, features/riscv/32bit-fpu.c,
features/riscv/64bit-cpu.c, features/riscv/64bit-csr.c,
features/riscv/64bit-fpu.c, features/tic6x-c6xp.c,
features/tic6x-core.c, features/tic6x-gp.c, filename-seen-cache.h,
findcmd.c, findvar.c, fork-child.c, gcore.c, gdb_bfd.c, gdb_bfd.h,
gdb_proc_service.h, gdb_regex.c, gdb_select.h, gdb_usleep.c,
gdbarch-selftests.c, gdbthread.h, gdbtypes.h, gnu-nat.c,
go32-nat.c, guile/guile.c, guile/scm-ports.c,
guile/scm-safe-call.c, guile/scm-type.c, i386-fbsd-nat.c,
i386-fbsd-tdep.c, i386-go32-tdep.c, i386-linux-nat.c,
i386-linux-tdep.c, i386-tdep.c, i387-tdep.c,
ia64-libunwind-tdep.c, ia64-linux-nat.c, inf-child.c,
inf-ptrace.c, infcall.c, infcall.h, infcmd.c, inferior-iter.h,
inferior.c, inferior.h, inflow.c, inflow.h, infrun.c, infrun.h,
inline-frame.c, language.h, linespec.c, linux-fork.c, linux-nat.c,
linux-tdep.c, linux-thread-db.c, location.c, machoread.c,
macrotab.h, main.c, maint.c, maint.h, memattr.c, memrange.h,
mi/mi-cmd-break.h, mi/mi-cmd-env.c, mi/mi-cmd-stack.c,
mi/mi-cmd-var.c, mi/mi-interp.c, mi/mi-main.c, mi/mi-parse.h,
minsyms.c, mips-linux-tdep.c, namespace.h,
nat/aarch64-linux-hw-point.c, nat/aarch64-linux-hw-point.h,
nat/aarch64-linux.c, nat/aarch64-sve-linux-ptrace.c,
nat/amd64-linux-siginfo.c, nat/fork-inferior.c,
nat/linux-btrace.c, nat/linux-btrace.h, nat/linux-namespaces.c,
nat/linux-nat.h, nat/linux-osdata.c, nat/linux-personality.c,
nat/linux-procfs.c, nat/linux-ptrace.c, nat/linux-ptrace.h,
nat/linux-waitpid.c, nat/mips-linux-watch.c,
nat/mips-linux-watch.h, nat/ppc-linux.c, nat/x86-dregs.c,
nat/x86-dregs.h, nat/x86-linux-dregs.c, nat/x86-linux.c,
nto-procfs.c, nto-tdep.c, objfile-flags.h, objfiles.c, objfiles.h,
obsd-nat.c, observable.h, osdata.c, p-valprint.c, parse.c,
parser-defs.h, ppc-linux-nat.c, printcmd.c, probe.c, proc-api.c,
procfs.c, producer.c, progspace.h, psymtab.h,
python/py-framefilter.c, python/py-inferior.c, python/py-ref.h,
python/py-type.c, python/python.c, record-btrace.c, record-full.c,
record.c, record.h, regcache-dump.c, regcache.c, regcache.h,
remote-fileio.c, remote-fileio.h, remote-sim.c, remote.c,
riscv-tdep.c, rs6000-aix-tdep.c, rust-exp.y, s12z-tdep.c,
selftest-arch.c, ser-base.c, ser-event.c, ser-pipe.c, ser-tcp.c,
ser-unix.c, skip.c, solib-aix.c, solib-target.c, solib.c,
source-cache.c, source.c, source.h, sparc-nat.c, spu-linux-nat.c,
stack.c, stap-probe.c, symfile-add-flags.h, symfile.c, symfile.h,
symtab.c, symtab.h, target-descriptions.c, target-descriptions.h,
target-memory.c, target.c, target.h, target/waitstatus.c,
target/waitstatus.h, thread-iter.h, thread.c, tilegx-tdep.c,
top.c, top.h, tracefile-tfile.c, tracefile.c, tracepoint.c,
tracepoint.h, tui/tui-io.c, ui-file.c, ui-out.h,
unittests/array-view-selftests.c,
unittests/child-path-selftests.c, unittests/cli-utils-selftests.c,
unittests/common-utils-selftests.c,
unittests/copy_bitwise-selftests.c, unittests/environ-selftests.c,
unittests/format_pieces-selftests.c,
unittests/function-view-selftests.c,
unittests/lookup_name_info-selftests.c,
unittests/memory-map-selftests.c, unittests/memrange-selftests.c,
unittests/mkdir-recursive-selftests.c,
unittests/observable-selftests.c,
unittests/offset-type-selftests.c, unittests/optional-selftests.c,
unittests/parse-connection-spec-selftests.c,
unittests/ptid-selftests.c, unittests/rsp-low-selftests.c,
unittests/scoped_fd-selftests.c,
unittests/scoped_mmap-selftests.c,
unittests/scoped_restore-selftests.c,
unittests/string_view-selftests.c, unittests/style-selftests.c,
unittests/tracepoint-selftests.c, unittests/unpack-selftests.c,
unittests/utils-selftests.c, unittests/xml-utils-selftests.c,
utils.c, utils.h, valarith.c, valops.c, valprint.c, value.c,
value.h, varobj.c, varobj.h, windows-nat.c, x86-linux-nat.c,
xml-support.c, xml-support.h, xml-tdesc.h, xstormy16-tdep.c,
xtensa-linux-nat.c, dwarf2read.h: Change common to gdbsupport.
gdb/gdbserver/ChangeLog
2019-07-09 Tom Tromey <tom@tromey.com>
* configure: Rebuild.
* configure.ac: Change common to gdbsupport.
* acinclude.m4: Change common to gdbsupport.
* Makefile.in (SFILES, OBS, GDBREPLAY_OBS, IPA_OBJS)
(version-generated.c, gdbsupport/%-ipa.o, gdbsupport/%.o): Change
common to gdbsupport.
* ax.c, event-loop.c, fork-child.c, gdb_proc_service.h,
gdbreplay.c, gdbthread.h, hostio-errno.c, hostio.c, i387-fp.c,
inferiors.c, inferiors.h, linux-aarch64-tdesc-selftest.c,
linux-amd64-ipa.c, linux-i386-ipa.c, linux-low.c,
linux-tic6x-low.c, linux-x86-low.c, linux-x86-tdesc-selftest.c,
linux-x86-tdesc.c, lynx-i386-low.c, lynx-low.c, mem-break.h,
nto-x86-low.c, regcache.c, regcache.h, remote-utils.c, server.c,
server.h, spu-low.c, symbol.c, target.h, tdesc.c, tdesc.h,
thread-db.c, tracepoint.c, win32-i386-low.c, win32-low.c: Change
common to gdbsupport.
2019-05-06 04:29:24 +02:00
|
|
|
#include "gdbsupport/gdb_sys_time.h"
|
2005-04-21 07:34:33 +02:00
|
|
|
#ifdef USE_WIN32API
|
|
|
|
#include <winsock2.h>
|
|
|
|
#endif
|
2005-03-25 20:47:23 +01:00
|
|
|
|
2005-04-21 23:23:25 +02:00
|
|
|
|
2005-03-25 20:47:23 +01:00
|
|
|
static timer_handler_func push_event;
|
|
|
|
static handler_func fd_event;
|
|
|
|
|
|
|
|
/* Event handling for ASYNC serial code.
|
|
|
|
|
|
|
|
At any time the SERIAL device either: has an empty FIFO and is
|
|
|
|
waiting on a FD event; or has a non-empty FIFO/error condition and
|
|
|
|
is constantly scheduling timer events.
|
|
|
|
|
|
|
|
ASYNC only stops pestering its client when it is de-async'ed or it
|
2011-01-11 22:53:25 +01:00
|
|
|
is told to go away. */
|
2005-03-25 20:47:23 +01:00
|
|
|
|
|
|
|
/* Value of scb->async_state: */
|
|
|
|
enum {
|
|
|
|
/* >= 0 (TIMER_SCHEDULED) */
|
2011-01-11 22:53:25 +01:00
|
|
|
/* The ID of the currently scheduled timer event. This state is
|
2005-03-25 20:47:23 +01:00
|
|
|
rarely encountered. Timer events are one-off so as soon as the
|
2019-10-18 02:48:08 +02:00
|
|
|
event is delivered the state is changed to NOTHING_SCHEDULED. */
|
2005-03-25 20:47:23 +01:00
|
|
|
FD_SCHEDULED = -1,
|
|
|
|
/* The fd_event() handler is scheduled. It is called when ever the
|
2011-01-11 22:53:25 +01:00
|
|
|
file descriptor becomes ready. */
|
2005-03-25 20:47:23 +01:00
|
|
|
NOTHING_SCHEDULED = -2
|
|
|
|
/* Either no task is scheduled (just going into ASYNC mode) or a
|
|
|
|
timer event has just gone off and the current state has been
|
2011-01-11 22:53:25 +01:00
|
|
|
forced into nothing scheduled. */
|
2005-03-25 20:47:23 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Identify and schedule the next ASYNC task based on scb->async_state
|
|
|
|
and scb->buf* (the input FIFO). A state machine is used to avoid
|
|
|
|
the need to make redundant calls into the event-loop - the next
|
2011-01-11 22:53:25 +01:00
|
|
|
scheduled task is only changed when needed. */
|
2005-03-25 20:47:23 +01:00
|
|
|
|
2010-04-30 00:51:04 +02:00
|
|
|
static void
|
2005-03-25 20:47:23 +01:00
|
|
|
reschedule (struct serial *scb)
|
|
|
|
{
|
|
|
|
if (serial_is_async_p (scb))
|
|
|
|
{
|
|
|
|
int next_state;
|
2010-05-17 01:49:58 +02:00
|
|
|
|
2005-03-25 20:47:23 +01:00
|
|
|
switch (scb->async_state)
|
|
|
|
{
|
|
|
|
case FD_SCHEDULED:
|
|
|
|
if (scb->bufcnt == 0)
|
|
|
|
next_state = FD_SCHEDULED;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
delete_file_handler (scb->fd);
|
|
|
|
next_state = create_timer (0, push_event, scb);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case NOTHING_SCHEDULED:
|
|
|
|
if (scb->bufcnt == 0)
|
|
|
|
{
|
|
|
|
add_file_handler (scb->fd, fd_event, scb);
|
|
|
|
next_state = FD_SCHEDULED;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
next_state = create_timer (0, push_event, scb);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default: /* TIMER SCHEDULED */
|
|
|
|
if (scb->bufcnt == 0)
|
|
|
|
{
|
|
|
|
delete_timer (scb->async_state);
|
|
|
|
add_file_handler (scb->fd, fd_event, scb);
|
|
|
|
next_state = FD_SCHEDULED;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
next_state = scb->async_state;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (serial_debug_p (scb))
|
|
|
|
{
|
|
|
|
switch (next_state)
|
|
|
|
{
|
|
|
|
case FD_SCHEDULED:
|
|
|
|
if (scb->async_state != FD_SCHEDULED)
|
|
|
|
fprintf_unfiltered (gdb_stdlog, "[fd%d->fd-scheduled]\n",
|
|
|
|
scb->fd);
|
|
|
|
break;
|
|
|
|
default: /* TIMER SCHEDULED */
|
|
|
|
if (scb->async_state == FD_SCHEDULED)
|
|
|
|
fprintf_unfiltered (gdb_stdlog, "[fd%d->timer-scheduled]\n",
|
|
|
|
scb->fd);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
scb->async_state = next_state;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-11 22:36:53 +02:00
|
|
|
/* Run the SCB's async handle, and reschedule, if the handler doesn't
|
|
|
|
close SCB. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
run_async_handler_and_reschedule (struct serial *scb)
|
|
|
|
{
|
|
|
|
int is_open;
|
|
|
|
|
|
|
|
/* Take a reference, so a serial_close call within the handler
|
|
|
|
doesn't make SCB a dangling pointer. */
|
|
|
|
serial_ref (scb);
|
|
|
|
|
|
|
|
/* Run the handler. */
|
|
|
|
scb->async_handler (scb, scb->async_context);
|
|
|
|
|
|
|
|
is_open = serial_is_open (scb);
|
|
|
|
serial_unref (scb);
|
|
|
|
|
|
|
|
/* Get ready for more, if not already closed. */
|
|
|
|
if (is_open)
|
|
|
|
reschedule (scb);
|
|
|
|
}
|
|
|
|
|
2005-03-25 20:47:23 +01:00
|
|
|
/* FD_EVENT: This is scheduled when the input FIFO is empty (and there
|
|
|
|
is no pending error). As soon as data arrives, it is read into the
|
|
|
|
input FIFO and the client notified. The client should then drain
|
|
|
|
the FIFO using readchar(). If the FIFO isn't immediatly emptied,
|
2011-01-11 22:53:25 +01:00
|
|
|
push_event() is used to nag the client until it is. */
|
2005-03-25 20:47:23 +01:00
|
|
|
|
|
|
|
static void
|
|
|
|
fd_event (int error, void *context)
|
|
|
|
{
|
2015-09-25 20:08:07 +02:00
|
|
|
struct serial *scb = (struct serial *) context;
|
2005-03-25 20:47:23 +01:00
|
|
|
if (error != 0)
|
|
|
|
{
|
|
|
|
scb->bufcnt = SERIAL_ERROR;
|
|
|
|
}
|
|
|
|
else if (scb->bufcnt == 0)
|
|
|
|
{
|
|
|
|
/* Prime the input FIFO. The readchar() function is used to
|
|
|
|
pull characters out of the buffer. See also
|
2011-01-11 22:53:25 +01:00
|
|
|
generic_readchar(). */
|
2005-03-25 20:47:23 +01:00
|
|
|
int nr;
|
2016-04-12 17:49:31 +02:00
|
|
|
|
|
|
|
do
|
|
|
|
{
|
|
|
|
nr = scb->ops->read_prim (scb, BUFSIZ);
|
|
|
|
}
|
|
|
|
while (nr < 0 && errno == EINTR);
|
|
|
|
|
2005-03-25 20:47:23 +01:00
|
|
|
if (nr == 0)
|
|
|
|
{
|
|
|
|
scb->bufcnt = SERIAL_EOF;
|
|
|
|
}
|
|
|
|
else if (nr > 0)
|
|
|
|
{
|
|
|
|
scb->bufcnt = nr;
|
|
|
|
scb->bufp = scb->buf;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
scb->bufcnt = SERIAL_ERROR;
|
|
|
|
}
|
|
|
|
}
|
2012-06-11 22:36:53 +02:00
|
|
|
run_async_handler_and_reschedule (scb);
|
2005-03-25 20:47:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* PUSH_EVENT: The input FIFO is non-empty (or there is a pending
|
|
|
|
error). Nag the client until all the data has been read. In the
|
|
|
|
case of errors, the client will need to close or de-async the
|
2019-10-18 02:48:08 +02:00
|
|
|
device before nagging stops. */
|
2005-03-25 20:47:23 +01:00
|
|
|
|
|
|
|
static void
|
|
|
|
push_event (void *context)
|
|
|
|
{
|
2015-09-25 20:08:07 +02:00
|
|
|
struct serial *scb = (struct serial *) context;
|
2010-05-17 01:49:58 +02:00
|
|
|
|
2005-03-25 20:47:23 +01:00
|
|
|
scb->async_state = NOTHING_SCHEDULED; /* Timers are one-off */
|
2012-06-11 22:36:53 +02:00
|
|
|
run_async_handler_and_reschedule (scb);
|
2005-03-25 20:47:23 +01:00
|
|
|
}
|
|
|
|
|
2005-04-21 07:34:33 +02:00
|
|
|
/* Wait for input on scb, with timeout seconds. Returns 0 on success,
|
2011-01-11 22:53:25 +01:00
|
|
|
otherwise SERIAL_TIMEOUT or SERIAL_ERROR. */
|
2005-04-21 07:34:33 +02:00
|
|
|
|
PR remote/21188: Fix remote serial timeout
As Gareth McMullin <gareth@blacksphere.co.nz> reports at
<https://sourceware.org/ml/gdb-patches/2017-02/msg00560.html>, the
timeout mechanism in ser-unix.c was broken by commit 048094acc
("target remote: Don't rely on immediate_quit (introduce quit
handlers)").
Instead of applying a local fix, and since we now finally always use
interrupt_select [1], let's get rid of hardwire_readchar entirely, and
use ser_base_readchar instead, which has similar timeout handling,
except for the bug.
Smoke tested with:
$ socat -d -d pty,raw,echo=0 pty,raw,echo=0
2017/03/14 14:08:13 socat[4994] N PTY is /dev/pts/14
2017/03/14 14:08:13 socat[4994] N PTY is /dev/pts/15
2017/03/14 14:08:13 socat[4994] N starting data transfer loop with FDs [3,3] and [5,5]
$ gdbserver /dev/pts/14 PROG
$ gdb PROG -ex "tar rem /dev/pts/15"
and then a few continues/ctrl-c's, plus killing gdbserver and socat.
[1] - See FIXME comments being removed.
gdb/ChangeLog:
2017-03-17 Pedro Alves <palves@redhat.com>
PR remote/21188
* ser-base.c (ser_base_wait_for): Add comment.
(do_ser_base_readchar): Improve comment based on the ser-unix.c's
version.
* ser-unix.c (hardwire_raw): Remove reference to
scb->current_timeout.
(wait_for, do_hardwire_readchar, hardwire_readchar): Delete.
(hardwire_ops): Install ser_base_readchar instead of
hardwire_readchar.
* serial.h (struct serial) <current_timeout, timeout_remaining>:
Remove fields.
2017-03-17 17:08:12 +01:00
|
|
|
/* NOTE: Some of the code below is dead. The only possible values of
|
|
|
|
the TIMEOUT parameter are ONE and ZERO. OTOH, we should probably
|
|
|
|
get rid of the deprecated_ui_loop_hook call in do_ser_base_readchar
|
|
|
|
instead and support infinite time outs here. */
|
|
|
|
|
2005-04-21 07:34:33 +02:00
|
|
|
static int
|
|
|
|
ser_base_wait_for (struct serial *scb, int timeout)
|
|
|
|
{
|
|
|
|
while (1)
|
|
|
|
{
|
|
|
|
int numfds;
|
|
|
|
struct timeval tv;
|
|
|
|
fd_set readfds, exceptfds;
|
target remote: Don't rely on immediate_quit (introduce quit handlers)
remote.c is the last user of immediate_quit. It's relied on to
immediately break the initial remote connection sync up, if the user
does Ctrl-C, assuming that was because the target isn't responding.
At that stage, since the connection isn't synced yet, disconnecting is
the only safe thing to do. This commit reworks that, to not rely on
throwing from the SIGINT signal handler.
So, this commit:
- Introduces the concept of a "quit handler". This is used to
override what does the QUIT macro do when the quit flag is set.
- Makes the "struct serial" reachar / write code call QUIT in the
partial read/write loops, so the current quit handler is invoked
whenever a serial->read_prim / serial->write_prim returns EINTR.
- Makes the "struct serial" reachar / write code call
interruptible_select instead of gdb_select, so that QUITs are
detected in a race-free manner.
- Stops remote.c from setting immediate_quit during the initial
connection.
- Instead, we install a custom quit handler whenever we're calling
into the serial code. This custom quit handler knows to immediately
throw a quit when we're in the initial connection setup, and
otherwise defer handling the quit/Ctrl-C request to later, when
we're safely out of a packet command/response sequence. This also
is what is now responsible for handling "double Ctrl-C because
target connection is stuck/wedged."
- remote.c no longer installs a specialized SIGINT handlers, and
instead re-uses the quit flag. Since we want to rely on the QUIT
macro, the SIGINT handler must also set the quit. And the easiest
is just to not install custom SIGINT handler in remote.c. Let the
standard SIGINT handler do its job of setting the quit flag.
Centralizing SIGINT handlers seems like a good thing to me, anyway.
gdb/ChangeLog:
2016-04-12 Pedro Alves <palves@redhat.com>
* defs.h (quit_handler_ftype, quit_handler)
(make_cleanup_override_quit_handler, default_quit_handler): New.
(QUIT): Adjust comments.
* event-top.c (default_quit_handler): New function.
(quit_handler): New global.
(struct quit_handler_cleanup_data): New.
(restore_quit_handler, restore_quit_handler_dtor)
(make_cleanup_override_quit_handler): New.
(async_request_quit): Call QUIT.
* remote.c (struct remote_state) <got_ctrlc_during_io>: New field.
(async_sigint_remote_twice_token, async_sigint_remote_token):
Delete.
(remote_close): Update comments.
(remote_start_remote): Don't set immediate_quit. Set starting_up
earlier.
(remote_serial_quit_handler, remote_unpush_and_throw): New
functions.
(remote_open_1): Clear got_ctrlc_during_io. Set
remote_async_terminal_ours_p unconditionally.
(async_initialize_sigint_signal_handler)
(async_handle_remote_sigint, async_handle_remote_sigint_twice)
(remote_check_pending_interrupt, async_remote_interrupt)
(async_remote_interrupt_twice)
(async_cleanup_sigint_signal_handler, ofunc)
(sync_remote_interrupt, sync_remote_interrupt_twice): Delete.
(remote_terminal_inferior, remote_terminal_ours): Remove async
checks.
(remote_wait_as): Don't install a SIGINT handler in sync mode.
(readchar, remote_serial_write): Override the quit handler with
remote_serial_quit_handler.
(getpkt_or_notif_sane_1): Don't call QUIT.
(initialize_remote_ops): Don't install
remote_check_pending_interrupt.
(_initialize_remote): Don't create async_sigint_remote_token and
async_sigint_remote_twice_token.
* ser-base.c (ser_base_wait_for): Call QUIT and use
interruptible_select.
(ser_base_write): Call QUIT.
* ser-go32.c (dos_readchar, dos_write): Call QUIT.
* ser-unix.c (wait_for): Don't use VTIME. Always take the
gdb_select path, but call QUIT and interruptible_select.
* utils.c (maybe_quit): Call the current quit handler. Don't call
target_check_pending_interrupt.
(defaulted_query, prompt_for_continue): Override the quit handler
with the default quit handler.
2016-04-12 17:49:32 +02:00
|
|
|
int nfds;
|
2005-04-21 07:34:33 +02:00
|
|
|
|
|
|
|
/* NOTE: Some OS's can scramble the READFDS when the select()
|
|
|
|
call fails (ex the kernel with Red Hat 5.2). Initialize all
|
2011-01-11 22:53:25 +01:00
|
|
|
arguments before each call. */
|
2005-04-21 07:34:33 +02:00
|
|
|
|
|
|
|
tv.tv_sec = timeout;
|
|
|
|
tv.tv_usec = 0;
|
|
|
|
|
|
|
|
FD_ZERO (&readfds);
|
|
|
|
FD_ZERO (&exceptfds);
|
|
|
|
FD_SET (scb->fd, &readfds);
|
|
|
|
FD_SET (scb->fd, &exceptfds);
|
|
|
|
|
target remote: Don't rely on immediate_quit (introduce quit handlers)
remote.c is the last user of immediate_quit. It's relied on to
immediately break the initial remote connection sync up, if the user
does Ctrl-C, assuming that was because the target isn't responding.
At that stage, since the connection isn't synced yet, disconnecting is
the only safe thing to do. This commit reworks that, to not rely on
throwing from the SIGINT signal handler.
So, this commit:
- Introduces the concept of a "quit handler". This is used to
override what does the QUIT macro do when the quit flag is set.
- Makes the "struct serial" reachar / write code call QUIT in the
partial read/write loops, so the current quit handler is invoked
whenever a serial->read_prim / serial->write_prim returns EINTR.
- Makes the "struct serial" reachar / write code call
interruptible_select instead of gdb_select, so that QUITs are
detected in a race-free manner.
- Stops remote.c from setting immediate_quit during the initial
connection.
- Instead, we install a custom quit handler whenever we're calling
into the serial code. This custom quit handler knows to immediately
throw a quit when we're in the initial connection setup, and
otherwise defer handling the quit/Ctrl-C request to later, when
we're safely out of a packet command/response sequence. This also
is what is now responsible for handling "double Ctrl-C because
target connection is stuck/wedged."
- remote.c no longer installs a specialized SIGINT handlers, and
instead re-uses the quit flag. Since we want to rely on the QUIT
macro, the SIGINT handler must also set the quit. And the easiest
is just to not install custom SIGINT handler in remote.c. Let the
standard SIGINT handler do its job of setting the quit flag.
Centralizing SIGINT handlers seems like a good thing to me, anyway.
gdb/ChangeLog:
2016-04-12 Pedro Alves <palves@redhat.com>
* defs.h (quit_handler_ftype, quit_handler)
(make_cleanup_override_quit_handler, default_quit_handler): New.
(QUIT): Adjust comments.
* event-top.c (default_quit_handler): New function.
(quit_handler): New global.
(struct quit_handler_cleanup_data): New.
(restore_quit_handler, restore_quit_handler_dtor)
(make_cleanup_override_quit_handler): New.
(async_request_quit): Call QUIT.
* remote.c (struct remote_state) <got_ctrlc_during_io>: New field.
(async_sigint_remote_twice_token, async_sigint_remote_token):
Delete.
(remote_close): Update comments.
(remote_start_remote): Don't set immediate_quit. Set starting_up
earlier.
(remote_serial_quit_handler, remote_unpush_and_throw): New
functions.
(remote_open_1): Clear got_ctrlc_during_io. Set
remote_async_terminal_ours_p unconditionally.
(async_initialize_sigint_signal_handler)
(async_handle_remote_sigint, async_handle_remote_sigint_twice)
(remote_check_pending_interrupt, async_remote_interrupt)
(async_remote_interrupt_twice)
(async_cleanup_sigint_signal_handler, ofunc)
(sync_remote_interrupt, sync_remote_interrupt_twice): Delete.
(remote_terminal_inferior, remote_terminal_ours): Remove async
checks.
(remote_wait_as): Don't install a SIGINT handler in sync mode.
(readchar, remote_serial_write): Override the quit handler with
remote_serial_quit_handler.
(getpkt_or_notif_sane_1): Don't call QUIT.
(initialize_remote_ops): Don't install
remote_check_pending_interrupt.
(_initialize_remote): Don't create async_sigint_remote_token and
async_sigint_remote_twice_token.
* ser-base.c (ser_base_wait_for): Call QUIT and use
interruptible_select.
(ser_base_write): Call QUIT.
* ser-go32.c (dos_readchar, dos_write): Call QUIT.
* ser-unix.c (wait_for): Don't use VTIME. Always take the
gdb_select path, but call QUIT and interruptible_select.
* utils.c (maybe_quit): Call the current quit handler. Don't call
target_check_pending_interrupt.
(defaulted_query, prompt_for_continue): Override the quit handler
with the default quit handler.
2016-04-12 17:49:32 +02:00
|
|
|
QUIT;
|
|
|
|
|
|
|
|
nfds = scb->fd + 1;
|
2005-04-21 07:34:33 +02:00
|
|
|
if (timeout >= 0)
|
target remote: Don't rely on immediate_quit (introduce quit handlers)
remote.c is the last user of immediate_quit. It's relied on to
immediately break the initial remote connection sync up, if the user
does Ctrl-C, assuming that was because the target isn't responding.
At that stage, since the connection isn't synced yet, disconnecting is
the only safe thing to do. This commit reworks that, to not rely on
throwing from the SIGINT signal handler.
So, this commit:
- Introduces the concept of a "quit handler". This is used to
override what does the QUIT macro do when the quit flag is set.
- Makes the "struct serial" reachar / write code call QUIT in the
partial read/write loops, so the current quit handler is invoked
whenever a serial->read_prim / serial->write_prim returns EINTR.
- Makes the "struct serial" reachar / write code call
interruptible_select instead of gdb_select, so that QUITs are
detected in a race-free manner.
- Stops remote.c from setting immediate_quit during the initial
connection.
- Instead, we install a custom quit handler whenever we're calling
into the serial code. This custom quit handler knows to immediately
throw a quit when we're in the initial connection setup, and
otherwise defer handling the quit/Ctrl-C request to later, when
we're safely out of a packet command/response sequence. This also
is what is now responsible for handling "double Ctrl-C because
target connection is stuck/wedged."
- remote.c no longer installs a specialized SIGINT handlers, and
instead re-uses the quit flag. Since we want to rely on the QUIT
macro, the SIGINT handler must also set the quit. And the easiest
is just to not install custom SIGINT handler in remote.c. Let the
standard SIGINT handler do its job of setting the quit flag.
Centralizing SIGINT handlers seems like a good thing to me, anyway.
gdb/ChangeLog:
2016-04-12 Pedro Alves <palves@redhat.com>
* defs.h (quit_handler_ftype, quit_handler)
(make_cleanup_override_quit_handler, default_quit_handler): New.
(QUIT): Adjust comments.
* event-top.c (default_quit_handler): New function.
(quit_handler): New global.
(struct quit_handler_cleanup_data): New.
(restore_quit_handler, restore_quit_handler_dtor)
(make_cleanup_override_quit_handler): New.
(async_request_quit): Call QUIT.
* remote.c (struct remote_state) <got_ctrlc_during_io>: New field.
(async_sigint_remote_twice_token, async_sigint_remote_token):
Delete.
(remote_close): Update comments.
(remote_start_remote): Don't set immediate_quit. Set starting_up
earlier.
(remote_serial_quit_handler, remote_unpush_and_throw): New
functions.
(remote_open_1): Clear got_ctrlc_during_io. Set
remote_async_terminal_ours_p unconditionally.
(async_initialize_sigint_signal_handler)
(async_handle_remote_sigint, async_handle_remote_sigint_twice)
(remote_check_pending_interrupt, async_remote_interrupt)
(async_remote_interrupt_twice)
(async_cleanup_sigint_signal_handler, ofunc)
(sync_remote_interrupt, sync_remote_interrupt_twice): Delete.
(remote_terminal_inferior, remote_terminal_ours): Remove async
checks.
(remote_wait_as): Don't install a SIGINT handler in sync mode.
(readchar, remote_serial_write): Override the quit handler with
remote_serial_quit_handler.
(getpkt_or_notif_sane_1): Don't call QUIT.
(initialize_remote_ops): Don't install
remote_check_pending_interrupt.
(_initialize_remote): Don't create async_sigint_remote_token and
async_sigint_remote_twice_token.
* ser-base.c (ser_base_wait_for): Call QUIT and use
interruptible_select.
(ser_base_write): Call QUIT.
* ser-go32.c (dos_readchar, dos_write): Call QUIT.
* ser-unix.c (wait_for): Don't use VTIME. Always take the
gdb_select path, but call QUIT and interruptible_select.
* utils.c (maybe_quit): Call the current quit handler. Don't call
target_check_pending_interrupt.
(defaulted_query, prompt_for_continue): Override the quit handler
with the default quit handler.
2016-04-12 17:49:32 +02:00
|
|
|
numfds = interruptible_select (nfds, &readfds, 0, &exceptfds, &tv);
|
2005-04-21 07:34:33 +02:00
|
|
|
else
|
target remote: Don't rely on immediate_quit (introduce quit handlers)
remote.c is the last user of immediate_quit. It's relied on to
immediately break the initial remote connection sync up, if the user
does Ctrl-C, assuming that was because the target isn't responding.
At that stage, since the connection isn't synced yet, disconnecting is
the only safe thing to do. This commit reworks that, to not rely on
throwing from the SIGINT signal handler.
So, this commit:
- Introduces the concept of a "quit handler". This is used to
override what does the QUIT macro do when the quit flag is set.
- Makes the "struct serial" reachar / write code call QUIT in the
partial read/write loops, so the current quit handler is invoked
whenever a serial->read_prim / serial->write_prim returns EINTR.
- Makes the "struct serial" reachar / write code call
interruptible_select instead of gdb_select, so that QUITs are
detected in a race-free manner.
- Stops remote.c from setting immediate_quit during the initial
connection.
- Instead, we install a custom quit handler whenever we're calling
into the serial code. This custom quit handler knows to immediately
throw a quit when we're in the initial connection setup, and
otherwise defer handling the quit/Ctrl-C request to later, when
we're safely out of a packet command/response sequence. This also
is what is now responsible for handling "double Ctrl-C because
target connection is stuck/wedged."
- remote.c no longer installs a specialized SIGINT handlers, and
instead re-uses the quit flag. Since we want to rely on the QUIT
macro, the SIGINT handler must also set the quit. And the easiest
is just to not install custom SIGINT handler in remote.c. Let the
standard SIGINT handler do its job of setting the quit flag.
Centralizing SIGINT handlers seems like a good thing to me, anyway.
gdb/ChangeLog:
2016-04-12 Pedro Alves <palves@redhat.com>
* defs.h (quit_handler_ftype, quit_handler)
(make_cleanup_override_quit_handler, default_quit_handler): New.
(QUIT): Adjust comments.
* event-top.c (default_quit_handler): New function.
(quit_handler): New global.
(struct quit_handler_cleanup_data): New.
(restore_quit_handler, restore_quit_handler_dtor)
(make_cleanup_override_quit_handler): New.
(async_request_quit): Call QUIT.
* remote.c (struct remote_state) <got_ctrlc_during_io>: New field.
(async_sigint_remote_twice_token, async_sigint_remote_token):
Delete.
(remote_close): Update comments.
(remote_start_remote): Don't set immediate_quit. Set starting_up
earlier.
(remote_serial_quit_handler, remote_unpush_and_throw): New
functions.
(remote_open_1): Clear got_ctrlc_during_io. Set
remote_async_terminal_ours_p unconditionally.
(async_initialize_sigint_signal_handler)
(async_handle_remote_sigint, async_handle_remote_sigint_twice)
(remote_check_pending_interrupt, async_remote_interrupt)
(async_remote_interrupt_twice)
(async_cleanup_sigint_signal_handler, ofunc)
(sync_remote_interrupt, sync_remote_interrupt_twice): Delete.
(remote_terminal_inferior, remote_terminal_ours): Remove async
checks.
(remote_wait_as): Don't install a SIGINT handler in sync mode.
(readchar, remote_serial_write): Override the quit handler with
remote_serial_quit_handler.
(getpkt_or_notif_sane_1): Don't call QUIT.
(initialize_remote_ops): Don't install
remote_check_pending_interrupt.
(_initialize_remote): Don't create async_sigint_remote_token and
async_sigint_remote_twice_token.
* ser-base.c (ser_base_wait_for): Call QUIT and use
interruptible_select.
(ser_base_write): Call QUIT.
* ser-go32.c (dos_readchar, dos_write): Call QUIT.
* ser-unix.c (wait_for): Don't use VTIME. Always take the
gdb_select path, but call QUIT and interruptible_select.
* utils.c (maybe_quit): Call the current quit handler. Don't call
target_check_pending_interrupt.
(defaulted_query, prompt_for_continue): Override the quit handler
with the default quit handler.
2016-04-12 17:49:32 +02:00
|
|
|
numfds = interruptible_select (nfds, &readfds, 0, &exceptfds, 0);
|
2005-04-21 07:34:33 +02:00
|
|
|
|
|
|
|
if (numfds <= 0)
|
|
|
|
{
|
|
|
|
if (numfds == 0)
|
|
|
|
return SERIAL_TIMEOUT;
|
|
|
|
else if (errno == EINTR)
|
|
|
|
continue;
|
|
|
|
else
|
2011-01-11 22:53:25 +01:00
|
|
|
return SERIAL_ERROR; /* Got an error from select or
|
|
|
|
poll. */
|
2005-04-21 07:34:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-18 06:36:24 +02:00
|
|
|
/* Read any error output we might have. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
ser_base_read_error_fd (struct serial *scb, int close_fd)
|
|
|
|
{
|
|
|
|
if (scb->error_fd != -1)
|
|
|
|
{
|
|
|
|
ssize_t s;
|
|
|
|
char buf[GDB_MI_MSG_WIDTH + 1];
|
|
|
|
|
|
|
|
for (;;)
|
|
|
|
{
|
|
|
|
char *current;
|
|
|
|
char *newline;
|
|
|
|
int to_read = GDB_MI_MSG_WIDTH;
|
|
|
|
int num_bytes = -1;
|
|
|
|
|
|
|
|
if (scb->ops->avail)
|
|
|
|
num_bytes = (scb->ops->avail)(scb, scb->error_fd);
|
|
|
|
|
|
|
|
if (num_bytes != -1)
|
|
|
|
to_read = (num_bytes < to_read) ? num_bytes : to_read;
|
|
|
|
|
|
|
|
if (to_read == 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
s = read (scb->error_fd, &buf, to_read);
|
|
|
|
if ((s == -1) || (s == 0 && !close_fd))
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (s == 0 && close_fd)
|
|
|
|
{
|
|
|
|
/* End of file. */
|
2017-10-19 17:00:21 +02:00
|
|
|
if (serial_is_async_p (scb))
|
|
|
|
delete_file_handler (scb->error_fd);
|
2012-07-18 06:36:24 +02:00
|
|
|
close (scb->error_fd);
|
|
|
|
scb->error_fd = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* In theory, embedded newlines are not a problem.
|
|
|
|
But for MI, we want each output line to have just
|
|
|
|
one newline for legibility. So output things
|
|
|
|
in newline chunks. */
|
|
|
|
gdb_assert (s > 0 && s <= GDB_MI_MSG_WIDTH);
|
|
|
|
buf[s] = '\0';
|
|
|
|
current = buf;
|
|
|
|
while ((newline = strstr (current, "\n")) != NULL)
|
|
|
|
{
|
|
|
|
*newline = '\0';
|
|
|
|
fputs_unfiltered (current, gdb_stderr);
|
|
|
|
fputs_unfiltered ("\n", gdb_stderr);
|
|
|
|
current = newline + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
fputs_unfiltered (current, gdb_stderr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-19 17:00:21 +02:00
|
|
|
/* Event-loop callback for a serial's error_fd. Flushes any error
|
|
|
|
output we might have. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
handle_error_fd (int error, gdb_client_data client_data)
|
|
|
|
{
|
|
|
|
serial *scb = (serial *) client_data;
|
|
|
|
|
|
|
|
ser_base_read_error_fd (scb, 0);
|
|
|
|
}
|
|
|
|
|
PR remote/21188: Fix remote serial timeout
As Gareth McMullin <gareth@blacksphere.co.nz> reports at
<https://sourceware.org/ml/gdb-patches/2017-02/msg00560.html>, the
timeout mechanism in ser-unix.c was broken by commit 048094acc
("target remote: Don't rely on immediate_quit (introduce quit
handlers)").
Instead of applying a local fix, and since we now finally always use
interrupt_select [1], let's get rid of hardwire_readchar entirely, and
use ser_base_readchar instead, which has similar timeout handling,
except for the bug.
Smoke tested with:
$ socat -d -d pty,raw,echo=0 pty,raw,echo=0
2017/03/14 14:08:13 socat[4994] N PTY is /dev/pts/14
2017/03/14 14:08:13 socat[4994] N PTY is /dev/pts/15
2017/03/14 14:08:13 socat[4994] N starting data transfer loop with FDs [3,3] and [5,5]
$ gdbserver /dev/pts/14 PROG
$ gdb PROG -ex "tar rem /dev/pts/15"
and then a few continues/ctrl-c's, plus killing gdbserver and socat.
[1] - See FIXME comments being removed.
gdb/ChangeLog:
2017-03-17 Pedro Alves <palves@redhat.com>
PR remote/21188
* ser-base.c (ser_base_wait_for): Add comment.
(do_ser_base_readchar): Improve comment based on the ser-unix.c's
version.
* ser-unix.c (hardwire_raw): Remove reference to
scb->current_timeout.
(wait_for, do_hardwire_readchar, hardwire_readchar): Delete.
(hardwire_ops): Install ser_base_readchar instead of
hardwire_readchar.
* serial.h (struct serial) <current_timeout, timeout_remaining>:
Remove fields.
2017-03-17 17:08:12 +01:00
|
|
|
/* Read a character with user-specified timeout. TIMEOUT is number of
|
|
|
|
seconds to wait, or -1 to wait forever. Use timeout of 0 to effect
|
|
|
|
a poll. Returns char if successful. Returns SERIAL_TIMEOUT if
|
|
|
|
timeout expired, SERIAL_EOF if line dropped dead, or SERIAL_ERROR
|
|
|
|
for any other error (see errno in that case). */
|
2005-04-21 07:34:33 +02:00
|
|
|
|
|
|
|
static int
|
|
|
|
do_ser_base_readchar (struct serial *scb, int timeout)
|
|
|
|
{
|
|
|
|
int status;
|
|
|
|
int delta;
|
|
|
|
|
|
|
|
/* We have to be able to keep the GUI alive here, so we break the
|
|
|
|
original timeout into steps of 1 second, running the "keep the
|
|
|
|
GUI alive" hook each time through the loop.
|
|
|
|
|
|
|
|
Also, timeout = 0 means to poll, so we just set the delta to 0,
|
|
|
|
so we will only go through the loop once. */
|
|
|
|
|
|
|
|
delta = (timeout == 0 ? 0 : 1);
|
|
|
|
while (1)
|
|
|
|
{
|
|
|
|
/* N.B. The UI may destroy our world (for instance by calling
|
|
|
|
remote_stop,) in which case we want to get out of here as
|
|
|
|
quickly as possible. It is not safe to touch scb, since
|
|
|
|
someone else might have freed it. The
|
|
|
|
deprecated_ui_loop_hook signals that we should exit by
|
|
|
|
returning 1. */
|
|
|
|
|
|
|
|
if (deprecated_ui_loop_hook)
|
|
|
|
{
|
|
|
|
if (deprecated_ui_loop_hook (0))
|
|
|
|
return SERIAL_TIMEOUT;
|
|
|
|
}
|
|
|
|
|
|
|
|
status = ser_base_wait_for (scb, delta);
|
|
|
|
if (timeout > 0)
|
|
|
|
timeout -= delta;
|
|
|
|
|
|
|
|
/* If we got a character or an error back from wait_for, then we can
|
2011-01-11 22:53:25 +01:00
|
|
|
break from the loop before the timeout is completed. */
|
2005-04-21 07:34:33 +02:00
|
|
|
if (status != SERIAL_TIMEOUT)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* If we have exhausted the original timeout, then generate
|
2011-01-11 22:53:25 +01:00
|
|
|
a SERIAL_TIMEOUT, and pass it out of the loop. */
|
2005-04-21 07:34:33 +02:00
|
|
|
else if (timeout == 0)
|
|
|
|
{
|
|
|
|
status = SERIAL_TIMEOUT;
|
|
|
|
break;
|
|
|
|
}
|
2012-07-18 06:36:24 +02:00
|
|
|
|
|
|
|
/* We also need to check and consume the stderr because it could
|
|
|
|
come before the stdout for some stubs. If we just sit and wait
|
|
|
|
for stdout, we would hit a deadlock for that case. */
|
|
|
|
ser_base_read_error_fd (scb, 0);
|
2005-04-21 07:34:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
|
2016-04-12 17:49:31 +02:00
|
|
|
do
|
|
|
|
{
|
|
|
|
status = scb->ops->read_prim (scb, BUFSIZ);
|
|
|
|
}
|
|
|
|
while (status < 0 && errno == EINTR);
|
2005-04-21 07:34:33 +02:00
|
|
|
|
|
|
|
if (status <= 0)
|
|
|
|
{
|
|
|
|
if (status == 0)
|
2007-10-12 22:14:57 +02:00
|
|
|
return SERIAL_EOF;
|
2005-04-21 07:34:33 +02:00
|
|
|
else
|
|
|
|
/* Got an error from read. */
|
|
|
|
return SERIAL_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
scb->bufcnt = status;
|
|
|
|
scb->bufcnt--;
|
|
|
|
scb->bufp = scb->buf;
|
|
|
|
return *scb->bufp++;
|
|
|
|
}
|
|
|
|
|
2011-01-11 22:53:25 +01:00
|
|
|
/* Perform operations common to both old and new readchar. */
|
2005-04-21 07:34:33 +02:00
|
|
|
|
|
|
|
/* Return the next character from the input FIFO. If the FIFO is
|
|
|
|
empty, call the SERIAL specific routine to try and read in more
|
|
|
|
characters.
|
|
|
|
|
|
|
|
Initially data from the input FIFO is returned (fd_event()
|
|
|
|
pre-reads the input into that FIFO. Once that has been emptied,
|
|
|
|
further data is obtained by polling the input FD using the device
|
|
|
|
specific readchar() function. Note: reschedule() is called after
|
|
|
|
every read. This is because there is no guarentee that the lower
|
|
|
|
level fd_event() poll_event() code (which also calls reschedule())
|
2011-01-11 22:53:25 +01:00
|
|
|
will be called. */
|
2005-04-21 07:34:33 +02:00
|
|
|
|
|
|
|
int
|
|
|
|
generic_readchar (struct serial *scb, int timeout,
|
|
|
|
int (do_readchar) (struct serial *scb, int timeout))
|
|
|
|
{
|
|
|
|
int ch;
|
|
|
|
if (scb->bufcnt > 0)
|
|
|
|
{
|
|
|
|
ch = *scb->bufp;
|
|
|
|
scb->bufcnt--;
|
|
|
|
scb->bufp++;
|
|
|
|
}
|
|
|
|
else if (scb->bufcnt < 0)
|
|
|
|
{
|
2011-01-11 22:53:25 +01:00
|
|
|
/* Some errors/eof are are sticky. */
|
2005-04-21 07:34:33 +02:00
|
|
|
ch = scb->bufcnt;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ch = do_readchar (scb, timeout);
|
|
|
|
if (ch < 0)
|
|
|
|
{
|
|
|
|
switch ((enum serial_rc) ch)
|
|
|
|
{
|
|
|
|
case SERIAL_EOF:
|
|
|
|
case SERIAL_ERROR:
|
2011-01-11 22:53:25 +01:00
|
|
|
/* Make the error/eof stick. */
|
2005-04-21 07:34:33 +02:00
|
|
|
scb->bufcnt = ch;
|
|
|
|
break;
|
|
|
|
case SERIAL_TIMEOUT:
|
|
|
|
scb->bufcnt = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2007-04-08 17:20:07 +02:00
|
|
|
|
2012-07-18 06:36:24 +02:00
|
|
|
/* Read any error output we might have. */
|
|
|
|
ser_base_read_error_fd (scb, 1);
|
2007-04-08 17:20:07 +02:00
|
|
|
|
2005-04-21 07:34:33 +02:00
|
|
|
reschedule (scb);
|
|
|
|
return ch;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ser_base_readchar (struct serial *scb, int timeout)
|
|
|
|
{
|
|
|
|
return generic_readchar (scb, timeout, do_ser_base_readchar);
|
|
|
|
}
|
|
|
|
|
2005-03-25 20:47:23 +01:00
|
|
|
int
|
serial_write: change prototype to take a void-pointer buffer.
While remote.c works with "char *" buffers most of the time, other
remote targets have binary-ish-er protocols, and choose to use
"unsigned char" throughout, like e.g., remote-mips.c or
remote-m32r-sdi.c. That results in -Wpointer-sign warnings in those
targets, unless we add casts in calls to serial_write. Since
serial_write is only concerned about sending raw host bytes out, and
serial_ops->write_prim already works with "void *"/"size_t", a similar
interface to the "write" or "send" system calls, I find it natural to
change serial_write's prototype accordingly, avoiding the need for
casts.
Tested on x86_64 Fedora 17, and also by building x86_64-mingw32
and DJGPP/go32 -hosted gdbs.
gdb/
2013-04-19 Pedro Alves <palves@redhat.com>
* ser-base.c (ser_base_write): Change prototype -- take 'void *'
buffer and size_t size. Adjust.
* ser-base.h (ser_base_write): Adjust.
* ser-go32.c (cnts): Change type to size_t.
(dos_write): Change prototype -- take 'void *'
buffer and size_t size. Adjust.
(dos_info): Print elements of 'cnts' as unsigned long.
* serial.c (serial_write): Likewise.
* serial.h (serial_write): Adjust.
(struct serial_ops) <write>: Change prototype -- take 'void *'
buffer and size_t size. Adjust.
2013-04-19 17:26:17 +02:00
|
|
|
ser_base_write (struct serial *scb, const void *buf, size_t count)
|
2005-03-25 20:47:23 +01:00
|
|
|
{
|
2015-09-25 20:08:07 +02:00
|
|
|
const char *str = (const char *) buf;
|
2005-03-25 20:47:23 +01:00
|
|
|
int cc;
|
|
|
|
|
serial_write: change prototype to take a void-pointer buffer.
While remote.c works with "char *" buffers most of the time, other
remote targets have binary-ish-er protocols, and choose to use
"unsigned char" throughout, like e.g., remote-mips.c or
remote-m32r-sdi.c. That results in -Wpointer-sign warnings in those
targets, unless we add casts in calls to serial_write. Since
serial_write is only concerned about sending raw host bytes out, and
serial_ops->write_prim already works with "void *"/"size_t", a similar
interface to the "write" or "send" system calls, I find it natural to
change serial_write's prototype accordingly, avoiding the need for
casts.
Tested on x86_64 Fedora 17, and also by building x86_64-mingw32
and DJGPP/go32 -hosted gdbs.
gdb/
2013-04-19 Pedro Alves <palves@redhat.com>
* ser-base.c (ser_base_write): Change prototype -- take 'void *'
buffer and size_t size. Adjust.
* ser-base.h (ser_base_write): Adjust.
* ser-go32.c (cnts): Change type to size_t.
(dos_write): Change prototype -- take 'void *'
buffer and size_t size. Adjust.
(dos_info): Print elements of 'cnts' as unsigned long.
* serial.c (serial_write): Likewise.
* serial.h (serial_write): Adjust.
(struct serial_ops) <write>: Change prototype -- take 'void *'
buffer and size_t size. Adjust.
2013-04-19 17:26:17 +02:00
|
|
|
while (count > 0)
|
2005-03-25 20:47:23 +01:00
|
|
|
{
|
target remote: Don't rely on immediate_quit (introduce quit handlers)
remote.c is the last user of immediate_quit. It's relied on to
immediately break the initial remote connection sync up, if the user
does Ctrl-C, assuming that was because the target isn't responding.
At that stage, since the connection isn't synced yet, disconnecting is
the only safe thing to do. This commit reworks that, to not rely on
throwing from the SIGINT signal handler.
So, this commit:
- Introduces the concept of a "quit handler". This is used to
override what does the QUIT macro do when the quit flag is set.
- Makes the "struct serial" reachar / write code call QUIT in the
partial read/write loops, so the current quit handler is invoked
whenever a serial->read_prim / serial->write_prim returns EINTR.
- Makes the "struct serial" reachar / write code call
interruptible_select instead of gdb_select, so that QUITs are
detected in a race-free manner.
- Stops remote.c from setting immediate_quit during the initial
connection.
- Instead, we install a custom quit handler whenever we're calling
into the serial code. This custom quit handler knows to immediately
throw a quit when we're in the initial connection setup, and
otherwise defer handling the quit/Ctrl-C request to later, when
we're safely out of a packet command/response sequence. This also
is what is now responsible for handling "double Ctrl-C because
target connection is stuck/wedged."
- remote.c no longer installs a specialized SIGINT handlers, and
instead re-uses the quit flag. Since we want to rely on the QUIT
macro, the SIGINT handler must also set the quit. And the easiest
is just to not install custom SIGINT handler in remote.c. Let the
standard SIGINT handler do its job of setting the quit flag.
Centralizing SIGINT handlers seems like a good thing to me, anyway.
gdb/ChangeLog:
2016-04-12 Pedro Alves <palves@redhat.com>
* defs.h (quit_handler_ftype, quit_handler)
(make_cleanup_override_quit_handler, default_quit_handler): New.
(QUIT): Adjust comments.
* event-top.c (default_quit_handler): New function.
(quit_handler): New global.
(struct quit_handler_cleanup_data): New.
(restore_quit_handler, restore_quit_handler_dtor)
(make_cleanup_override_quit_handler): New.
(async_request_quit): Call QUIT.
* remote.c (struct remote_state) <got_ctrlc_during_io>: New field.
(async_sigint_remote_twice_token, async_sigint_remote_token):
Delete.
(remote_close): Update comments.
(remote_start_remote): Don't set immediate_quit. Set starting_up
earlier.
(remote_serial_quit_handler, remote_unpush_and_throw): New
functions.
(remote_open_1): Clear got_ctrlc_during_io. Set
remote_async_terminal_ours_p unconditionally.
(async_initialize_sigint_signal_handler)
(async_handle_remote_sigint, async_handle_remote_sigint_twice)
(remote_check_pending_interrupt, async_remote_interrupt)
(async_remote_interrupt_twice)
(async_cleanup_sigint_signal_handler, ofunc)
(sync_remote_interrupt, sync_remote_interrupt_twice): Delete.
(remote_terminal_inferior, remote_terminal_ours): Remove async
checks.
(remote_wait_as): Don't install a SIGINT handler in sync mode.
(readchar, remote_serial_write): Override the quit handler with
remote_serial_quit_handler.
(getpkt_or_notif_sane_1): Don't call QUIT.
(initialize_remote_ops): Don't install
remote_check_pending_interrupt.
(_initialize_remote): Don't create async_sigint_remote_token and
async_sigint_remote_twice_token.
* ser-base.c (ser_base_wait_for): Call QUIT and use
interruptible_select.
(ser_base_write): Call QUIT.
* ser-go32.c (dos_readchar, dos_write): Call QUIT.
* ser-unix.c (wait_for): Don't use VTIME. Always take the
gdb_select path, but call QUIT and interruptible_select.
* utils.c (maybe_quit): Call the current quit handler. Don't call
target_check_pending_interrupt.
(defaulted_query, prompt_for_continue): Override the quit handler
with the default quit handler.
2016-04-12 17:49:32 +02:00
|
|
|
QUIT;
|
|
|
|
|
serial_write: change prototype to take a void-pointer buffer.
While remote.c works with "char *" buffers most of the time, other
remote targets have binary-ish-er protocols, and choose to use
"unsigned char" throughout, like e.g., remote-mips.c or
remote-m32r-sdi.c. That results in -Wpointer-sign warnings in those
targets, unless we add casts in calls to serial_write. Since
serial_write is only concerned about sending raw host bytes out, and
serial_ops->write_prim already works with "void *"/"size_t", a similar
interface to the "write" or "send" system calls, I find it natural to
change serial_write's prototype accordingly, avoiding the need for
casts.
Tested on x86_64 Fedora 17, and also by building x86_64-mingw32
and DJGPP/go32 -hosted gdbs.
gdb/
2013-04-19 Pedro Alves <palves@redhat.com>
* ser-base.c (ser_base_write): Change prototype -- take 'void *'
buffer and size_t size. Adjust.
* ser-base.h (ser_base_write): Adjust.
* ser-go32.c (cnts): Change type to size_t.
(dos_write): Change prototype -- take 'void *'
buffer and size_t size. Adjust.
(dos_info): Print elements of 'cnts' as unsigned long.
* serial.c (serial_write): Likewise.
* serial.h (serial_write): Adjust.
(struct serial_ops) <write>: Change prototype -- take 'void *'
buffer and size_t size. Adjust.
2013-04-19 17:26:17 +02:00
|
|
|
cc = scb->ops->write_prim (scb, str, count);
|
2005-03-25 20:47:23 +01:00
|
|
|
|
|
|
|
if (cc < 0)
|
2016-04-12 17:49:31 +02:00
|
|
|
{
|
|
|
|
if (errno == EINTR)
|
|
|
|
continue;
|
|
|
|
return 1;
|
|
|
|
}
|
serial_write: change prototype to take a void-pointer buffer.
While remote.c works with "char *" buffers most of the time, other
remote targets have binary-ish-er protocols, and choose to use
"unsigned char" throughout, like e.g., remote-mips.c or
remote-m32r-sdi.c. That results in -Wpointer-sign warnings in those
targets, unless we add casts in calls to serial_write. Since
serial_write is only concerned about sending raw host bytes out, and
serial_ops->write_prim already works with "void *"/"size_t", a similar
interface to the "write" or "send" system calls, I find it natural to
change serial_write's prototype accordingly, avoiding the need for
casts.
Tested on x86_64 Fedora 17, and also by building x86_64-mingw32
and DJGPP/go32 -hosted gdbs.
gdb/
2013-04-19 Pedro Alves <palves@redhat.com>
* ser-base.c (ser_base_write): Change prototype -- take 'void *'
buffer and size_t size. Adjust.
* ser-base.h (ser_base_write): Adjust.
* ser-go32.c (cnts): Change type to size_t.
(dos_write): Change prototype -- take 'void *'
buffer and size_t size. Adjust.
(dos_info): Print elements of 'cnts' as unsigned long.
* serial.c (serial_write): Likewise.
* serial.h (serial_write): Adjust.
(struct serial_ops) <write>: Change prototype -- take 'void *'
buffer and size_t size. Adjust.
2013-04-19 17:26:17 +02:00
|
|
|
count -= cc;
|
2005-03-25 20:47:23 +01:00
|
|
|
str += cc;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2005-03-25 21:06:36 +01:00
|
|
|
ser_base_flush_output (struct serial *scb)
|
2005-03-25 20:47:23 +01:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2005-03-25 21:06:36 +01:00
|
|
|
ser_base_flush_input (struct serial *scb)
|
2005-03-25 20:47:23 +01:00
|
|
|
{
|
|
|
|
if (scb->bufcnt >= 0)
|
|
|
|
{
|
|
|
|
scb->bufcnt = 0;
|
|
|
|
scb->bufp = scb->buf;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return SERIAL_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2005-03-25 21:06:36 +01:00
|
|
|
ser_base_send_break (struct serial *scb)
|
2005-03-25 20:47:23 +01:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2005-03-25 21:06:36 +01:00
|
|
|
ser_base_drain_output (struct serial *scb)
|
2005-03-25 20:47:23 +01:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2005-03-25 21:06:36 +01:00
|
|
|
ser_base_raw (struct serial *scb)
|
2005-03-25 20:47:23 +01:00
|
|
|
{
|
2011-01-11 22:53:25 +01:00
|
|
|
return; /* Always in raw mode. */
|
2005-03-25 20:47:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
serial_ttystate
|
2005-03-25 21:06:36 +01:00
|
|
|
ser_base_get_tty_state (struct serial *scb)
|
2005-03-25 20:47:23 +01:00
|
|
|
{
|
2011-01-11 22:53:25 +01:00
|
|
|
/* Allocate a dummy. */
|
2013-12-28 23:31:23 +01:00
|
|
|
return (serial_ttystate) XNEW (int);
|
2005-03-25 20:47:23 +01:00
|
|
|
}
|
|
|
|
|
2011-03-04 20:23:42 +01:00
|
|
|
serial_ttystate
|
|
|
|
ser_base_copy_tty_state (struct serial *scb, serial_ttystate ttystate)
|
|
|
|
{
|
|
|
|
/* Allocate another dummy. */
|
2013-12-28 23:31:23 +01:00
|
|
|
return (serial_ttystate) XNEW (int);
|
2011-03-04 20:23:42 +01:00
|
|
|
}
|
|
|
|
|
2005-03-25 20:47:23 +01:00
|
|
|
int
|
2005-03-25 21:06:36 +01:00
|
|
|
ser_base_set_tty_state (struct serial *scb, serial_ttystate ttystate)
|
2005-03-25 20:47:23 +01:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2005-03-25 21:06:36 +01:00
|
|
|
ser_base_print_tty_state (struct serial *scb,
|
|
|
|
serial_ttystate ttystate,
|
|
|
|
struct ui_file *stream)
|
2005-03-25 20:47:23 +01:00
|
|
|
{
|
|
|
|
/* Nothing to print. */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2005-03-25 21:06:36 +01:00
|
|
|
ser_base_setbaudrate (struct serial *scb, int rate)
|
2005-03-25 20:47:23 +01:00
|
|
|
{
|
2011-01-11 22:53:25 +01:00
|
|
|
return 0; /* Never fails! */
|
2005-03-25 20:47:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2005-03-25 21:06:36 +01:00
|
|
|
ser_base_setstopbits (struct serial *scb, int num)
|
2005-03-25 20:47:23 +01:00
|
|
|
{
|
2011-01-11 22:53:25 +01:00
|
|
|
return 0; /* Never fails! */
|
2005-03-25 20:47:23 +01:00
|
|
|
}
|
|
|
|
|
2015-03-23 22:15:42 +01:00
|
|
|
/* Implement the "setparity" serial_ops callback. */
|
|
|
|
|
|
|
|
int
|
|
|
|
ser_base_setparity (struct serial *scb, int parity)
|
|
|
|
{
|
|
|
|
return 0; /* Never fails! */
|
|
|
|
}
|
|
|
|
|
2005-03-25 20:47:23 +01:00
|
|
|
/* Put the SERIAL device into/out-of ASYNC mode. */
|
|
|
|
|
|
|
|
void
|
2005-03-25 21:06:36 +01:00
|
|
|
ser_base_async (struct serial *scb,
|
2005-03-25 20:47:23 +01:00
|
|
|
int async_p)
|
|
|
|
{
|
|
|
|
if (async_p)
|
|
|
|
{
|
2011-01-11 22:53:25 +01:00
|
|
|
/* Force a re-schedule. */
|
2005-03-25 20:47:23 +01:00
|
|
|
scb->async_state = NOTHING_SCHEDULED;
|
|
|
|
if (serial_debug_p (scb))
|
|
|
|
fprintf_unfiltered (gdb_stdlog, "[fd%d->asynchronous]\n",
|
|
|
|
scb->fd);
|
|
|
|
reschedule (scb);
|
2017-10-19 17:00:21 +02:00
|
|
|
|
|
|
|
if (scb->error_fd != -1)
|
|
|
|
add_file_handler (scb->error_fd, handle_error_fd, scb);
|
2005-03-25 20:47:23 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (serial_debug_p (scb))
|
|
|
|
fprintf_unfiltered (gdb_stdlog, "[fd%d->synchronous]\n",
|
|
|
|
scb->fd);
|
2011-01-11 22:53:25 +01:00
|
|
|
/* De-schedule whatever tasks are currently scheduled. */
|
2005-03-25 20:47:23 +01:00
|
|
|
switch (scb->async_state)
|
|
|
|
{
|
|
|
|
case FD_SCHEDULED:
|
|
|
|
delete_file_handler (scb->fd);
|
|
|
|
break;
|
|
|
|
case NOTHING_SCHEDULED:
|
|
|
|
break;
|
|
|
|
default: /* TIMER SCHEDULED */
|
|
|
|
delete_timer (scb->async_state);
|
|
|
|
break;
|
|
|
|
}
|
2017-10-19 17:00:21 +02:00
|
|
|
|
|
|
|
if (scb->error_fd != -1)
|
|
|
|
delete_file_handler (scb->error_fd);
|
2005-03-25 20:47:23 +01:00
|
|
|
}
|
|
|
|
}
|