When executing commands on a secondary UI running the MI interpreter,
some commands that should be synchronous are not. MI incorrectly
continues processing input right after the synchronous command is
sent, before the target stops.
The problem happens when we emit MI async events (=library-loaded,
etc.), and we go about restoring the previous terminal state, we end
up calling target_terminal_ours, which incorrectly always installs the
current UI's input_fd in the event loop... That is, code like this:
old_chain = make_cleanup_restore_target_terminal ();
target_terminal_ours_for_output ();
fprintf_unfiltered (mi->event_channel, "library-loaded");
...
do_cleanups (old_chain);
The fix is to move the add_file_handler/delete_file_handler calls out
of target_terminal_$foo, making these completely no-ops unless called
with the main UI as current UI.
gdb/ChangeLog:
2016-08-09 Pedro Alves <palves@redhat.com>
PR gdb/20418
* event-top.c (ui_register_input_event_handler)
(ui_unregister_input_event_handler): New functions.
(async_enable_stdin): Register input in the event loop.
(async_disable_stdin): Unregister input from the event loop.
(gdb_setup_readline): Register input in the event loop.
* infrun.c (check_curr_ui_sync_execution_done): Register input in
the event loop.
* target.c (target_terminal_inferior): Don't unregister input from
the event loop.
(target_terminal_ours): Don't register input in the event loop.
* target.h (target_terminal_inferior)
(target_terminal_ours_for_output, target_terminal_ours): Update
comments.
* top.h (ui_register_input_event_handler)
(ui_unregister_input_event_handler): New declarations.
* utils.c (ui_unregister_input_event_handler_cleanup)
(prepare_to_handle_input): New functions.
(defaulted_query, prompt_for_continue): Use
prepare_to_handle_input.
gdb/testsuite/ChangeLog:
2016-08-09 Pedro Alves <palves@redhat.com>
Simon Marchi <simon.marchi@ericsson.com>
PR gdb/20418
* gdb.mi/new-ui-mi-sync.c, gdb.mi/new-ui-mi-sync.exp: New files.
* lib/mi-support.exp (mi_expect_interrupt): Remove anchors.
+2016-08-09 Pedro Alves <palves@redhat.com>
+
+ PR gdb/20418
+ * event-top.c (ui_register_input_event_handler)
+ (ui_unregister_input_event_handler): New functions.
+ (async_enable_stdin): Register input in the event loop.
+ (async_disable_stdin): Unregister input from the event loop.
+ (gdb_setup_readline): Register input in the event loop.
+ * infrun.c (check_curr_ui_sync_execution_done): Register input in
+ the event loop.
+ * target.c (target_terminal_inferior): Don't unregister input from
+ the event loop.
+ (target_terminal_ours): Don't register input in the event loop.
+ * target.h (target_terminal_inferior)
+ (target_terminal_ours_for_output, target_terminal_ours): Update
+ comments.
+ * top.h (ui_register_input_event_handler)
+ (ui_unregister_input_event_handler): New declarations.
+ * utils.c (ui_unregister_input_event_handler_cleanup)
+ (prepare_to_handle_input): New functions.
+ (defaulted_query, prompt_for_continue): Use
+ prepare_to_handle_input.
+
2016-08-09 Pedro Alves <palves@redhat.com>
PR mi/20431
}
}
+/* See top.h. */
+
+void
+ui_register_input_event_handler (struct ui *ui)
+{
+ add_file_handler (ui->input_fd, stdin_event_handler, ui);
+}
+
+/* See top.h. */
+
+void
+ui_unregister_input_event_handler (struct ui *ui)
+{
+ delete_file_handler (ui->input_fd);
+}
+
/* Re-enable stdin after the end of an execution command in
synchronous mode, or after an error from the target, and we aborted
the exec operation. */
if (ui->prompt_state == PROMPT_BLOCKED)
{
target_terminal_ours ();
+ ui_register_input_event_handler (ui);
ui->prompt_state = PROMPT_NEEDED;
}
}
struct ui *ui = current_ui;
ui->prompt_state = PROMPT_BLOCKED;
+ delete_file_handler (ui->input_fd);
}
\f
Another source is going to be the target program (inferior), but
that must be registered only when it actually exists (I.e. after
we say 'run' or after we connect to a remote target. */
- add_file_handler (ui->input_fd, stdin_event_handler, ui);
+ ui_register_input_event_handler (ui);
}
/* Disable command input through the standard CLI channels. Used in
{
target_terminal_ours ();
observer_notify_sync_execution_done ();
+ ui_register_input_event_handler (ui);
}
}
if (ui->prompt_state != PROMPT_BLOCKED)
return;
- /* Always delete the current UI's input file handler, regardless of
- terminal_state, because terminal_state is only valid for the main
- UI. */
- delete_file_handler (ui->input_fd);
-
/* Since we always run the inferior in the main console (unless "set
inferior-tty" is in effect), when some UI other than the main one
calls target_terminal_inferior/target_terminal_inferior, then we
- only register/unregister the UI's input from the event loop, but
leave the main UI's terminal settings as is. */
if (ui != main_ui)
return;
{
struct ui *ui = current_ui;
- /* Always add the current UI's input file handler, regardless of
- terminal_state, because terminal_state is only valid for the main
- UI. */
- add_file_handler (ui->input_fd, stdin_event_handler, ui);
-
/* See target_terminal_inferior. */
if (ui != main_ui)
return;
extern void target_terminal_init (void);
-/* Put the inferior's terminal settings into effect.
- This is preparation for starting or resuming the inferior. */
+/* Put the inferior's terminal settings into effect. This is
+ preparation for starting or resuming the inferior. This is a no-op
+ unless called with the main UI as current UI. */
extern void target_terminal_inferior (void);
/* Put some of our terminal settings into effect, enough to get proper
results from our output, but do not change into or out of RAW mode
so that no input is discarded. This is a no-op if terminal_ours
- was most recently called. */
+ was most recently called. This is a no-op unless called with the main
+ UI as current UI. */
extern void target_terminal_ours_for_output (void);
-/* Put our terminal settings into effect.
- First record the inferior's terminal settings
- so they can be restored properly later. */
+/* Put our terminal settings into effect. First record the inferior's
+ terminal settings so they can be restored properly later. This is
+ a no-op unless called with the main UI as current UI. */
extern void target_terminal_ours (void);
+2016-08-09 Pedro Alves <palves@redhat.com>
+ Simon Marchi <simon.marchi@ericsson.com>
+
+ PR gdb/20418
+ * gdb.mi/new-ui-mi-sync.c, gdb.mi/new-ui-mi-sync.exp: New files.
+ * lib/mi-support.exp (mi_expect_interrupt): Remove anchors.
+
2016-08-09 Pedro Alves <palves@redhat.com>
PR mi/20431
--- /dev/null
+/* This testcase is part of GDB, the GNU debugger.
+
+ Copyright 2016 Free Software Foundation, Inc.
+
+ 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 <unistd.h>
+
+int
+main (void)
+{
+ sleep (180);
+ return 0;
+}
--- /dev/null
+# Copyright 2016 Free Software Foundation, Inc.
+
+# 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/>.
+
+# Test that on a separate MI UI (new-ui mi <tty>), the printing of an
+# asynchronous event (e.g. =library-loaded) during the synchronous
+# execution of a command (e.g. -exec-run or -exec-continue) does not
+# prematurely re-enable MI input. After executing synchronous
+# commands, MI should not process further commands until the inferior
+# stops again. See PR gdb/20418.
+
+load_lib mi-support.exp
+
+standard_testfile
+
+if {[build_executable $testfile.exp $testfile ${srcfile} "debug"] == -1} {
+ untested "failed to compile $testfile"
+ return -1
+}
+
+# The test driver. SYNC_COMMAND specifies which command is used to
+# synchronously start the program running.
+
+proc do_test {sync_command} {
+ global srcdir subdir binfile srcfile
+ global gdb_spawn_id gdb_main_spawn_id mi_spawn_id inferior_spawn_id
+ global gdb_prompt mi_gdb_prompt
+
+ mi_gdb_exit
+
+ if {[mi_gdb_start "separate-mi-tty"] != 0} {
+ fail "Could not start gdb"
+ return
+ }
+
+ mi_delete_breakpoints
+ mi_gdb_reinitialize_dir $srcdir/$subdir
+ mi_gdb_load $binfile
+
+ # Start a synchronous run/continue on the MI UI.
+ set test "send synchronous execution command"
+ if {$sync_command == "run"} {
+ if {[mi_run_cmd] >= 0} {
+ pass $test
+ } else {
+ return
+ }
+ } else {
+ if {[mi_runto main] < 0} {
+ return
+ }
+ if {[mi_send_resuming_command_raw "123-exec-continue" $test] >= 0} {
+ pass $test
+ } else {
+ return
+ }
+ }
+
+ # Send -thread-info immediately after. If everything works
+ # correctly, this is only serviced by GDB when the execution
+ # stops.
+ send_gdb "456-thread-info\n"
+ pass "send -thread-info"
+
+ # Make sure we trigger an asynchronous event (=thread-group-added)
+ # in the separate MI UI. Note the "run" variant usually triggers
+ # =thread-group-started/=thread-created/=library-loaded as well.
+ with_spawn_id $gdb_main_spawn_id {
+ gdb_test "add-inferior" "Added inferior 2"
+ }
+
+ # Interrupt the program.
+ with_spawn_id $gdb_main_spawn_id {
+ set message "interrupt on the CLI"
+ gdb_test_multiple "interrupt" "$message" {
+ -re "$gdb_prompt " {
+ gdb_test_multiple "" "$message" {
+ -re "received signal SIGINT" {
+ pass $message
+ }
+ }
+ }
+ }
+ }
+
+ # On the MI channel, we should see the interrupt output _before_
+ # the -thread-info output.
+ with_spawn_id $mi_spawn_id {
+ mi_expect_interrupt "got MI interrupt output"
+ }
+
+ # Look for the result of our -thread-info. If input were
+ # re-enabled too soon, the thread would incorrectly show up with
+ # state="running".
+ with_spawn_id $mi_spawn_id {
+ mi_gdb_test "" "456\\^.*state=\"stopped\".*" \
+ "got -thread-info output and thread is stopped"
+ }
+}
+
+foreach_with_prefix sync-command {"run" "continue"} {
+ do_test ${sync-command}
+}
if {$async} {
set prompt_re ""
} else {
- set prompt_re "$mi_gdb_prompt$"
+ set prompt_re "$mi_gdb_prompt"
}
set r_nonstop "reason=\"signal-received\",signal-name=\"0\",signal-meaning=\"Signal 0\""
pass "$test"
return 0
}
- -re ".*\r\n$mi_gdb_prompt$" {
+ -re ".*\r\n$mi_gdb_prompt" {
verbose -log "got $expect_out(buffer)"
fail "$test (unknown output after running)"
return -1
/* Cleanup that restores the current UI. */
extern void restore_ui_cleanup (void *data);
+/* Register the UI's input file descriptor in the event loop. */
+extern void ui_register_input_event_handler (struct ui *ui);
+
+/* Unregister the UI's input file descriptor from the event loop. */
+extern void ui_unregister_input_event_handler (struct ui *ui);
+
/* From top.c. */
extern char *saved_command_line;
extern int in_user_command;
return make_regfree_cleanup (pattern);
}
+/* A cleanup that simply calls ui_unregister_input_event_handler. */
+
+static void
+ui_unregister_input_event_handler_cleanup (void *ui)
+{
+ ui_unregister_input_event_handler ((struct ui *) ui);
+}
+
+/* Set up to handle input. */
+
+static struct cleanup *
+prepare_to_handle_input (void)
+{
+ struct cleanup *old_chain;
+
+ old_chain = make_cleanup_restore_target_terminal ();
+ target_terminal_ours ();
+
+ ui_register_input_event_handler (current_ui);
+ if (current_ui->prompt_state == PROMPT_BLOCKED)
+ make_cleanup (ui_unregister_input_event_handler_cleanup, current_ui);
+
+ make_cleanup_override_quit_handler (default_quit_handler);
+
+ return old_chain;
+}
+
\f
/* This function supports the query, nquery, and yquery functions.
if (!confirm || server_command)
return def_value;
- old_chain = make_cleanup_restore_target_terminal ();
-
/* If input isn't coming from the user directly, just say what
question we're asking, and then answer the default automatically. This
way, important error messages don't get lost when talking to GDB
if (current_ui->instream != current_ui->stdin_stream
|| !input_interactive_p (current_ui))
{
+ old_chain = make_cleanup_restore_target_terminal ();
+
target_terminal_ours_for_output ();
wrap_here ("");
vfprintf_filtered (gdb_stdout, ctlstr, args);
{
int res;
+ old_chain = make_cleanup_restore_target_terminal ();
res = deprecated_query_hook (ctlstr, args);
do_cleanups (old_chain);
return res;
/* Format the question outside of the loop, to avoid reusing args. */
question = xstrvprintf (ctlstr, args);
- make_cleanup (xfree, question);
+ old_chain = make_cleanup (xfree, question);
prompt = xstrprintf (_("%s%s(%s or %s) %s"),
annotation_level > 1 ? "\n\032\032pre-query\n" : "",
question, y_string, n_string,
/* Used for calculating time spend waiting for user. */
gettimeofday (&prompt_started, NULL);
- /* We'll need to handle input. */
- target_terminal_ours ();
- make_cleanup_override_quit_handler (default_quit_handler);
+ prepare_to_handle_input ();
while (1)
{
beyond the end of the screen. */
reinitialize_more_filter ();
- /* We'll need to handle input. */
- make_cleanup_restore_target_terminal ();
- target_terminal_ours ();
- make_cleanup_override_quit_handler (default_quit_handler);
+ prepare_to_handle_input ();
/* Call gdb_readline_wrapper, not readline, in order to keep an
event loop running. */
projects / deliverable / binutils-gdb.git / commitdiff
