From patchwork Sat Sep 13 23:57:48 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Doug Evans X-Patchwork-Id: 2834 Received: (qmail 27795 invoked by alias); 13 Sep 2014 23:58:41 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 27784 invoked by uid 89); 13 Sep 2014 23:58:40 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.9 required=5.0 tests=AWL, BAYES_00, FREEMAIL_ENVFROM_END_DIGIT, FREEMAIL_FROM, RCVD_IN_DNSWL_LOW, SPF_PASS autolearn=no version=3.3.2 X-HELO: mail-pa0-f52.google.com Received: from mail-pa0-f52.google.com (HELO mail-pa0-f52.google.com) (209.85.220.52) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-SHA encrypted) ESMTPS; Sat, 13 Sep 2014 23:58:38 +0000 Received: by mail-pa0-f52.google.com with SMTP id kq14so3861320pab.25 for ; Sat, 13 Sep 2014 16:58:36 -0700 (PDT) X-Received: by 10.68.217.106 with SMTP id ox10mr26218018pbc.27.1410652716139; Sat, 13 Sep 2014 16:58:36 -0700 (PDT) Received: from seba.sebabeach.org.gmail.com (173-13-178-50-sfba.hfc.comcastbusiness.net. [173.13.178.50]) by mx.google.com with ESMTPSA id nl2sm7458545pdb.83.2014.09.13.16.58.34 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Sat, 13 Sep 2014 16:58:35 -0700 (PDT) From: Doug Evans To: Eli Zaretskii Cc: gdb-patches@sourceware.org Subject: Re: [PATCH] New command: queue-signal References: <834mwgc163.fsf@gnu.org> Date: Sat, 13 Sep 2014 16:57:48 -0700 In-Reply-To: <834mwgc163.fsf@gnu.org> (Eli Zaretskii's message of "Tue, 09 Sep 2014 17:35:00 +0300") Message-ID: User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/24.3 (gnu/linux) MIME-Version: 1.0 X-IsSubscribed: yes Eli Zaretskii writes: >> From: Doug Evans >> Date: Sun, 07 Sep 2014 16:36:00 -0700 >> >> --- a/gdb/NEWS >> +++ b/gdb/NEWS >> @@ -3,6 +3,11 @@ >> >> *** Changes since GDB 7.8 >> >> +* New commands >> + >> +queue-signal signal-name-or-number >> + Queue a signal to be delivered to the thread when it is resumed. >> + > > This part is OK. > >> +@kindex queue-signal >> +@item queue-signal @var{signal} >> +Queue signal @var{signal} to be delivered immediately to the current thread > > You don't need the first "signal"; the second alone is enough. > >> +The handling of the signal must be set to pass the signal to the program, >> +otherwise gdb will discard it when resuming the thread. The handling of > ^^^ > @value{GDBN} > >> +signals from @value{GDBN} is done with the @code{handle} command > ^^^^^^^ > "is controlled" is better. For bonus points, make this sentence use > active tense ("you can control ..."). > >> +Alternatively, if @var{signal} is zero, any currently queued signal is >> +discarded and when execution resumes no signal will be delivered. > > Only to/for the current thread, right? The text sounds much more > general than that, so I wonder. > >> + c = add_com ("queue-signal", class_run, queue_signal_command, _("\ >> +Queue a signal to be delivered to the program when it is resumed.\n\ > ^^^^^^^^^^^ > I suggest to say "the current thread" here. > > The documentation parts are OK with these fixed. > > Thanks. Hi. Thanks. I made a few more changes to the online help text. Look ok? 2014-09-13 Doug Evans gdb/ChangeLog: * NEWS: Mention new "queue-signal" command. * infcmd.c (queue_signal_command): New function. (_initialize_infcmd): Add new queue-signal command. gdb/doc/ChangeLog: * gdb.texinfo (Signaling): Document new queue-signal command. gdb/testsuite/ChangeLog: * gdb.threads/queue-signal.c: New file. * gdb.threads/queue-signal.exp: New file. diff --git a/gdb/NEWS b/gdb/NEWS index 3bb1c74..d0a6ea5 100644 --- a/gdb/NEWS +++ b/gdb/NEWS @@ -13,6 +13,11 @@ ** $_any_caller_is(name [, number_of_frames]) ** $_any_caller_matches(regexp [, number_of_frames]) +* New commands + +queue-signal signal-name-or-number + Queue a signal to be delivered to the thread when it is resumed. + * On resume, GDB now always passes the signal the program had stopped for to the thread the signal was sent to, even if the user changed threads before resuming. Previously GDB would often (but not diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo index facbd16..037806f 100644 --- a/gdb/doc/gdb.texinfo +++ b/gdb/doc/gdb.texinfo @@ -16630,17 +16630,38 @@ same thread before issuing the @samp{signal 0} command. If you issue the @samp{signal 0} command with another thread as the selected one, @value{GDBN} detects that and asks for confirmation. -@code{signal} does not repeat when you press @key{RET} a second time -after executing the command. -@end table -@c @end group - Invoking the @code{signal} command is not the same as invoking the @code{kill} utility from the shell. Sending a signal with @code{kill} causes @value{GDBN} to decide what to do with the signal depending on the signal handling tables (@pxref{Signals}). The @code{signal} command passes the signal directly to your program. +@code{signal} does not repeat when you press @key{RET} a second time +after executing the command. + +@kindex queue-signal +@item queue-signal @var{signal} +Queue @var{signal} to be delivered immediately to the current thread +when execution of the thread resumes. The @var{signal} can be the name or +the number of a signal. For example, on many systems @code{signal 2} and +@code{signal SIGINT} are both ways of sending an interrupt signal. +The handling of the signal must be set to pass the signal to the program, +otherwise @value{GDBN} will report an error. +You can control the handling of signals from @value{GDBN} with the +@code{handle} command (@pxref{Signals}). + +Alternatively, if @var{signal} is zero, any currently queued signal +for the current thread is discarded and when execution resumes no signal +will be delivered. This is useful when your program stopped on account +of a signal and would ordinarily see the signal when resumed with the +@code{continue} command. + +This command differs from the @code{signal} command in that the signal +is just queued, execution is not resumed. And @code{queue-signal} cannot +be used to pass a signal whose handling state has been set to @code{nopass} +(@pxref{Signals}). +@end table +@c @end group @node Returning @section Returning from a Function diff --git a/gdb/infcmd.c b/gdb/infcmd.c index 46a2b0e..178bd73 100644 --- a/gdb/infcmd.c +++ b/gdb/infcmd.c @@ -1300,6 +1300,46 @@ signal_command (char *signum_exp, int from_tty) proceed ((CORE_ADDR) -1, oursig, 0); } +/* Queue a signal to be delivered to the current thread. */ + +static void +queue_signal_command (char *signum_exp, int from_tty) +{ + enum gdb_signal oursig; + struct thread_info *tp; + + ERROR_NO_INFERIOR; + ensure_not_tfind_mode (); + ensure_valid_thread (); + ensure_not_running (); + + if (signum_exp == NULL) + error_no_arg (_("signal number")); + + /* It would be even slicker to make signal names be valid expressions, + (the type could be "enum $signal" or some such), then the user could + assign them to convenience variables. */ + oursig = gdb_signal_from_name (signum_exp); + + if (oursig == GDB_SIGNAL_UNKNOWN) + { + /* No, try numeric. */ + int num = parse_and_eval_long (signum_exp); + + if (num == 0) + oursig = GDB_SIGNAL_0; + else + oursig = gdb_signal_from_command (num); + } + + if (oursig != GDB_SIGNAL_0 + && !signal_pass_state (oursig)) + error (_("Signal handling set to not pass this signal to the program.")); + + tp = inferior_thread (); + tp->suspend.stop_signal = oursig; +} + /* Continuation args to be passed to the "until" command continuation. */ struct until_next_continuation_args @@ -3008,7 +3048,24 @@ The SIGNAL argument is processed the same as the handle command.\n\ \n\ An argument of \"0\" means continue the program without sending it a signal.\n\ This is useful in cases where the program stopped because of a signal,\n\ -and you want to resume the program while discarding the signal.")); +and you want to resume the program while discarding the signal.\n\ +\n\ +In a multi-threaded program the signal is delivered to, or discarded from,\n\ +the current thread only.")); + set_cmd_completer (c, signal_completer); + + c = add_com ("queue-signal", class_run, queue_signal_command, _("\ +Queue a signal to be delivered to the current thread when it is resumed.\n\ +Usage: queue-signal SIGNAL\n\ +The SIGNAL argument is processed the same as the handle command.\n\ +It is an error if the handling state of SIGNAL is \"nopass\".\n\ +\n\ +An argument of \"0\" means remove any currently queued signal from\n\ +the current thread. This is useful in cases where the program stopped\n\ +because of a signal, and you want to resume it while discarding the signal.\n\ +\n\ +In a multi-threaded program the signal is queued with, or discarded from,\n\ +the current thread only.")); set_cmd_completer (c, signal_completer); add_com ("stepi", class_run, stepi_command, _("\ diff --git a/gdb/testsuite/gdb.threads/queue-signal.c b/gdb/testsuite/gdb.threads/queue-signal.c new file mode 100644 index 0000000..147f2f7 --- /dev/null +++ b/gdb/testsuite/gdb.threads/queue-signal.c @@ -0,0 +1,102 @@ +/* This testcase is part of GDB, the GNU debugger. + + Copyright 2014 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 . */ + +#include +#include +#include +#include + +/* Used to individually advance each thread to the desired stopping point. */ +int ready; + +sig_atomic_t sigusr1_received; +sig_atomic_t sigusr2_received; +sig_atomic_t sigabrt_received; + +static void +sigusr1_handler (int sig) +{ + sigusr1_received = 1; +} + +static void +sigusr2_handler (int sig) +{ + sigusr2_received = 1; +} + +static void +sigabrt_handler (int sig) +{ + sigabrt_received = 1; +} + +static void * +sigusr1_thread_function (void *unused) +{ + while (!ready) + usleep (100); + pthread_kill (pthread_self (), SIGUSR1); +} + +static void * +sigusr2_thread_function (void *unused) +{ + while (!ready) + usleep (100); + /* pthread_kill (pthread_self (), SIGUSR2); - manually injected by gdb */ +} + +static void +all_threads_running (void) +{ + while (!ready) + usleep (100); +} + +static void +all_threads_done (void) +{ +} + +int +main () +{ + pthread_t sigusr1_thread, sigusr2_thread; + + /* Protect against running forever. */ + alarm (60); + + signal (SIGUSR1, sigusr1_handler); + signal (SIGUSR2, sigusr2_handler); + signal (SIGABRT, sigabrt_handler); + + /* Don't let any thread advance past initialization. */ + ready = 0; + + pthread_create (&sigusr1_thread, NULL, sigusr1_thread_function, NULL); + pthread_create (&sigusr2_thread, NULL, sigusr2_thread_function, NULL); + all_threads_running (); + + pthread_kill (pthread_self (), SIGABRT); + + pthread_join (sigusr1_thread, NULL); + pthread_join (sigusr2_thread, NULL); + all_threads_done (); + + return 0; +} diff --git a/gdb/testsuite/gdb.threads/queue-signal.exp b/gdb/testsuite/gdb.threads/queue-signal.exp new file mode 100644 index 0000000..207073d --- /dev/null +++ b/gdb/testsuite/gdb.threads/queue-signal.exp @@ -0,0 +1,91 @@ +# Copyright (C) 2014 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 . + +standard_testfile + +if {[gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" \ + executable { debug }] != "" } { + return -1 +} + +clean_restart ${binfile} + +if ![runto_main] { + fail "Can't run to main" + return 0 +} + +gdb_test "handle SIGUSR1 stop print pass" +gdb_test "handle SIGUSR2 stop print pass" +gdb_test "handle SIGABRT stop print pass" + +gdb_breakpoint "all_threads_running" +gdb_continue_to_breakpoint "all_threads_running" + +# Find out which of threads 2,3 are for sigusr1,2. +set sigusr1_thread 0 +set sigusr2_thread 0 +gdb_test "thread 2" +gdb_test_multiple "bt" "determine thread functions" { + -re "sigusr1.*$gdb_prompt $" { + set sigusr1_thread 2 + set sigusr2_thread 3 + } + -re "sigusr2.*$gdb_prompt $" { + set sigusr1_thread 3 + set sigusr2_thread 2 + } +} + +# No point in continuing if we couldn't figure out which thread is which. +if { $sigusr1_thread == 0 } { + # FAIL already recorded. + return 0 +} + +# Advance each thread to where we want them one at a time. +gdb_test_no_output "set scheduler-locking on" +gdb_test_no_output "set var ready = 1" + +# Thread sigusr1_thread gets a SIGUSR1 which we leave alone. +gdb_test "thread $sigusr1_thread" "" +gdb_test "continue" "SIGUSR1.*" + +# Inject SIGUSR2 into thread sigusr2_thread. +gdb_test "thread $sigusr2_thread" "" +gdb_test_no_output "queue-signal SIGUSR2" + +# The main thread gets SIGABRT which we then throw away. +gdb_test "thread 1" "" +gdb_test "continue" "SIGABRT.*" +gdb_test_no_output "queue-signal 0" + +# Now let every thread run. +gdb_test_no_output "set scheduler-locking off" + +gdb_breakpoint "all_threads_done" +gdb_continue_to_breakpoint "all_threads_done" + +# Verify SIGUSR1, SIGUSR2 were received, and SIGABRT was discarded. +gdb_test "p sigusr1_received" "= 1" +gdb_test "p sigusr2_received" "= 1" +gdb_test "p sigabrt_received" "= 0" + +# Before we finish up verify the queueing of nopass signals flags an error. +gdb_test "queue-signal SIGINT" \ + "Signal handling set to not pass this signal to the program." + +# Verify program is able to finish. +gdb_continue_to_end