mirror of
https://github.com/bminor/binutils-gdb.git
synced 2025-12-05 15:15:42 +00:00
d9bda17252
Currently, on GNU/Linux, it is not possible to interrupt with Ctrl-C
programs that block or ignore SIGINT, with e.g., sigprocmask or
signal(SIGINT, SIG_IGN). You type Ctrl-C, but nothing happens.
Similarly, if a program uses sigwait to wait for SIGINT, and the
program receives a SIGINT, the SIGINT is _not_ intercepted by ptrace,
it goes straight to the inferior. These problems have been known for
years, and recorded in gdb/9425, gdb/14559.
This is a consequence of how GDB implements interrupting programs with
Ctrl-C -- when GDB spawns a new process, it makes the process use the
same terminal as GDB, and then makes the process's process group be
the foreground process group in GDB's terminal. This means that when
the process is running in the foreground, after e.g. "continue", when
the user types Ctrl-C, the kernel sends a SIGINT to the foreground
process group, which is the inferior. GDB then intercepts the SIGINT
via ptrace, the same way it intercepts any other signal, stops all the
other threads of the inferior if in all-stop, and presents the
"Program received SIGINT" stop to the user.
This patch paves the way to address gdb/9425, gdb/14559, by turning
Ctrl-C handling around such that the SIGINT always reaches GDB first,
not the inferior. That is done by making GDB put inferiors in their
own terminal/session created by GDB. I.e., GDB creates a
pseudo-terminal master/slave pair, makes the inferior run with the
slave as its terminal, and pumps output/input on the master end.
Because the inferior is run with its own session/terminal, GDB is free
to remain as the foreground process in its own terminal, which means
that the Ctrl-C SIGINT always reaches GDB first, instead of reaching
the inferior first, and then GDB reacting to the ptrace-intercepted
SIGINT. Because GDB gets the SIGINT first, GDB is then free to
handle it by interrupting the program any way it sees fit. A
following patch will then make GDB interrupt the program with SIGSTOP
instead of SIGINT, which always works even if the inferior
blocks/ignores SIGINT -- SIGSTOP can't be ignored. (In the future GDB
may even switch to PTRACE_INTERRUPT, though that's a project of its
own.)
Having the inferior in its own terminal also means that GDB is in
control of when inferior output is flushed to the screen. When
debugging with the CLI, this means that inferior output is now never
interpersed with GDB's output in an unreadable fashion. This will
also allow fixing the problem of inferior output really messing up the
screen in the TUI, forcing users to Ctrl-L to refresh the screen.
This patch does not address the TUI part, but it shouldn't be too hard
-- I wrote a quick&dirty prototype patch doing that a few years back,
so I know it works.
Implementation wise, here's what is happening:
- when GDB spawns an inferior, unless the user asked otherwise with
"tty /dev/tty", GDB creates a pty pair, and makes the slave end the
inferior's terminal. Note that starting an inferior on a given
terminal already exists, given the "tty" command. GDB records the
master and slave ends of the pty.
- GDB registers that new terminal's master end on the event loop.
When the master is written to, it means the inferior has written
some output on its terminal. The event loop wakes up and GDB
flushes the inferior output to its own terminal / to the screen.
- When target_terminal state is switched to "inferior", with
target_tarminal::inferiors(), GDB registers the stdin file
descriptor on the event loop with a callback that forwards input
typed on GDB's terminal to the inferior's tty.
- Similarly, when GDB receives a SIGWINCH signal, meaning GDB's
terminal was resized, GDB resizes the inferior's terminal too.
- GDB puts the inferior in its own session, and there's a "session
leader" process between GDB and the inferior. The latter is
because session leaders have special properties, one of which is,
if they exit, all progresses in the foreground process group in the
session get a SIGHUP. If the spawned inferior was the session
leader itself, if you were debugging an inferior that forks and
follow to the child, if the parent (the session leader) exits, then
the child would get a SIGHUP. Forking twice when launching an
inferior, and making the first child be the session leader, and the
second child the inferior avoids that problem.
- When the inferior exits or is killed, GDB sends a SIGHUP to the
session leader, waits for the leader to exit and then destroys the
terminal. The session leader's SIGHUP handler makes the session
leader pgrp be the foreground process group and then exits. This
sequence is important comparing to just closing the terminal and
letting the session leader terminate due to the SIGHUP the kernel
sends, because when the session leader exits, all processes in the
foreground process group get a SIGHUP, meaning that if the detached
process was still in the foreground, it would get a SIGHUP, and
likely die.
- The gdb.multi/multi-term-settings.exp was adjusted to test for
shared and not-shared terminal/session. Without the change, we get
failures:
FAIL: gdb.multi/multi-term-settings.exp: inf1_how=run: inf2_how=run: continue (expected SIGTTOU)
FAIL: gdb.multi/multi-term-settings.exp: inf1_how=run: inf2_how=run: stop with control-c (Quit)
Tested on GNU/Linux native, gdbserver and gdbserver + "maint target
set-non-stop on". Also build-tested tested on mingw32-w64, Solaris
11, and OpenBSD.
gdb/ChangeLog:
yyyy-mm-dd Pedro Alves <pedro@palves.net>
PR gdb/9425
PR gdb/14559
* fork-child.c (child_has_managed_tty_hook): New.
* inf-ptrace.c (inf_ptrace_me): If we created a managed tty, raise
SIGSTOP.
(inf_ptrace_handle_session_leader_fork): New.
(inf_ptrace_target::create_inferior): Pass it down as
handle_session_leader_fork callback.
* inf-ptrace.h (inf_ptrace_target) <handle_session_leader_fork>:
New virtual method.
* inferior.h (child_terminal_on_sigwinch): Declare.
* inflow.c: Include "gdbsupport/event-loop.h",
"gdbsupport/refcounted-object.h", "gdbsupport/gdb_wait.h",
"gdbsupport/managed-tty.h".
(USES_FORK_CHILD): Define, and wrap fork-child.c-related code with
it.
(struct run_terminal_info): New.
(struct terminal_info) <run_terminal>: Now a run_terminal_info.
<process_group>: Default to -1.
<save_from_tty>: New method.
(sigint_ours): Update comments.
(inferior_thisrun_terminal_pty_fd): New.
(input_fd_redirected): New.
(sharing_input_terminal): Adjust.
(gdb_tcgetattr, gdb_tcsetattr, make_raw, class scoped_raw_termios)
(child_terminal_flush_from_to, child_terminal_flush_stdout)
(inferior_stdout_event_handler, inferior_stdin_event_handler): New.
(child_terminal_inferior): Handle inferiors with gdb-managed ttys.
(child_terminal_save_inferior): Handle inferiors with gdb-managed
ttys. Use save_from_tty.
(child_terminal_ours_1): Handle inferiors with gdb-managed ttys.
(terminal_info::~terminal_info): Use delete instead of xfree.
(child_terminal_on_sigwinc): New.
(inflow_inferior_exit): Release terminal created by GDB.
(copy_terminal_info): Assert there's no run_terminal yet in TO
yet. Incref run_terminal after copying.
(child_terminal_info): Handle inferiors with gdb-managed ttys.
(new_tty_prefork): Allocate pseudo-terminal.
(created_managed_tty): New.
(new_tty): Remove __GO32__ and _WIN32 #ifdefs, not needed given
USES_FORK_CHILD.
(new_tty_postfork): Handle inferiors with gdb-managed ttys.
(show_debug_managed_tty): New.
(_initialize_inflow): Register "set/show debug managed-tty".
* linux-nat.c (waitpid_sigstop, waitpid_fork)
(linux_nat_target::handle_session_leader_fork): New.
* linux-nat.h (linux_nat_target) <handle_session_leader_fork>:
Declare override.
* nat/fork-inferior.c: Include
"gdbsupport/scoped_ignore_sigttou.h", "gdbsupport/managed-tty.h",
<sys/types.h> and <sys/wait.h>.
(session_leader_hup): New.
(fork_inferior): Add handle_session_leader_fork parameter. If the
inferior has a gdb-managed tty, don't use vfork, and fork twice,
with the first fork becoming the session leader. Call
handle_session_leader_fork.
* nat/fork-inferior.h (fork_inferior): Add
handle_session_leader_fork parameter and update comment.
(child_has_managed_tty_hook): Declare.
* terminal.h (created_managed_tty, child_gdb_owns_session):
Declare.
* tui/tui-win.c: Include "inferior.h".
(tui_async_resize_screen): Call child_terminal_on_sigwinch.
gdbsupport/ChangeLog:
yyyy-mm-dd Pedro Alves <pedro@palves.net>
PR gdb/9425
PR gdb/14559
* Makefile.am (libgdbsupport_a_SOURCES): Add managed-tty.cc.
* Makefile.in: Regenerate.
* managed-tty.cc: New.
* managed-tty.h: New.
gdbserver/ChangeLog:
yyyy-mm-dd Pedro Alves <pedro@palves.net>
PR gdb/9425
PR gdb/14559
* fork-child.cc (child_has_managed_tty_hook): New.
gdb/testsuite/ChangeLog:
yyyy-mm-dd Pedro Alves <pedro@palves.net>
PR gdb/9425
PR gdb/14559
* gdb.multi/multi-term-settings.exp (create_inferior): Document
"run-session", "run-share" and "run-tty" instead of "run" and
"tty". Adjust to handle "run-session" vs "run-share".
(coretest): Adjust to handle "run-session" vs "run-share".
(how_modes): Use "run-session", "run-share" and "run-tty" instead
of "run" and "tty".
Change-Id: I2569e189294044891e68a66401b381e4b999b19c
50 lines
1.6 KiB
C
50 lines
1.6 KiB
C
/* Terminal interface definitions for GDB, the GNU Debugger.
|
|
Copyright (C) 1986-2021 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/>. */
|
|
|
|
#if !defined (TERMINAL_H)
|
|
#define TERMINAL_H 1
|
|
|
|
struct inferior;
|
|
|
|
extern void new_tty_prefork (const char *);
|
|
|
|
extern void new_tty (void);
|
|
|
|
extern void new_tty_postfork (void);
|
|
|
|
/* Returns true if new_tty_prefork created a GDB-managed terminal. */
|
|
extern bool created_managed_tty ();
|
|
|
|
extern void copy_terminal_info (struct inferior *to, struct inferior *from);
|
|
|
|
/* Exchange the terminal info and state between inferiors A and B. */
|
|
extern void swap_terminal_info (inferior *a, inferior *b);
|
|
|
|
extern pid_t create_tty_session (void);
|
|
|
|
/* Set up a serial structure describing standard input. In inflow.c. */
|
|
extern void initialize_stdin_serial (void);
|
|
|
|
extern void gdb_save_tty_state (void);
|
|
|
|
/* Take a snapshot of our initial tty state before readline/ncurses
|
|
have had a chance to alter it. */
|
|
extern void set_initial_gdb_ttystate (void);
|
|
|
|
#endif /* !defined (TERMINAL_H) */
|