From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1551) id 5803B385B520; Wed, 15 Feb 2023 21:01:43 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 5803B385B520 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1676494903; bh=jFpE3kLMr8FYOrSne2dX8kzuYYkTbqlNdfLjsf37A4s=; h=From:To:Subject:Date:From; b=wVbjN1xgyyvP291BOO6BE93blJKijbfMuOz3zUZZK8TtHJjgSuTyKKmW4L3wIHZkn W4XnBgwTzkU6oRgHb6zhkIs8khnIGtc/GIsntFmFwGEhrxDkbT2Y4/j+Qd3NmMEbwo 8FIgPzVSNCLZ47IUgdWKmhyGr0AGh3bZtyz+AzLs= Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable From: Pedro Alves To: gdb-cvs@sourceware.org Subject: [binutils-gdb] Add new "$_shell(CMD)" internal function X-Act-Checkin: binutils-gdb X-Git-Author: Pedro Alves X-Git-Refname: refs/heads/master X-Git-Oldrev: 751495be92b2b319fb66ce4e12b562a0e27c15fe X-Git-Newrev: 91265a7d7cddc10314335ffcfbfae7159c7cecb1 Message-Id: <20230215210143.5803B385B520@sourceware.org> Date: Wed, 15 Feb 2023 21:01:43 +0000 (GMT) List-Id: https://sourceware.org/git/gitweb.cgi?p=3Dbinutils-gdb.git;h=3D91265a7d7cdd= c10314335ffcfbfae7159c7cecb1 commit 91265a7d7cddc10314335ffcfbfae7159c7cecb1 Author: Pedro Alves Date: Wed Feb 8 16:06:23 2023 +0000 Add new "$_shell(CMD)" internal function =20 For testing a following patch, I wanted a way to send a SIGINT to GDB from a breakpoint condition. And I didn't want to do it from a Python breakpoint or Python function, as I wanted to exercise non-Python code paths. So I thought I'd add a new $_shell internal function, that runs a command under the shell, and returns the exit code. With this, I could write: =20 (gdb) b foo if $_shell("kill -SIGINT $gdb_pid") !=3D 0 || =20 I think this is generally useful, hence I'm proposing it here. =20 Here's the new function in action: =20 (gdb) p $_shell("true") $1 =3D 0 (gdb) p $_shell("false") $2 =3D 1 (gdb) p $_shell("echo hello") hello $3 =3D 0 (gdb) p $_shell("foobar") bash: line 1: foobar: command not found $4 =3D 127 (gdb) help function _shell $_shell - execute a shell command and returns the result. Usage: $_shell (command) Returns the command's exit code: zero on success, non-zero otherwise. (gdb) =20 NEWS and manual changes included. =20 Approved-By: Andrew Burgess Approved-By: Tom Tromey Approved-By: Eli Zaretskii Change-Id: I7e36d451ee6b428cbf41fded415ae2d6b4efaa4e Diff: --- gdb/NEWS | 10 ++++ gdb/cli/cli-cmds.c | 96 ++++++++++++++++++++++++++++++++++= ++-- gdb/doc/gdb.texinfo | 60 +++++++++++++++++++++++- gdb/testsuite/gdb.base/default.exp | 1 + gdb/testsuite/gdb.base/shell.exp | 36 ++++++++++++++ 5 files changed, 198 insertions(+), 5 deletions(-) diff --git a/gdb/NEWS b/gdb/NEWS index 8ac82925fee..75cd11b204e 100644 --- a/gdb/NEWS +++ b/gdb/NEWS @@ -68,6 +68,16 @@ maintenance info frame-unwinders List the frame unwinders currently in effect, starting with the highest priority. =20 +* New convenience function "$_shell", to execute a shell command and + return the result. This lets you run shell commands in expressions. + Some examples: + + (gdb) p $_shell("true") + $1 =3D 0 + (gdb) p $_shell("false") + $2 =3D 1 + (gdb) break func if $_shell("some command") =3D=3D 0 + * MI changes =20 ** mi now reports 'no-history' as a stop reason when hitting the end of the diff --git a/gdb/cli/cli-cmds.c b/gdb/cli/cli-cmds.c index 871785d8886..0c680896c91 100644 --- a/gdb/cli/cli-cmds.c +++ b/gdb/cli/cli-cmds.c @@ -39,6 +39,7 @@ #include "gdbsupport/filestuff.h" #include "location.h" #include "block.h" +#include "valprint.h" =20 #include "ui-out.h" #include "interps.h" @@ -873,6 +874,9 @@ exit_status_set_internal_vars (int exit_status) =20 clear_internalvar (var_code); clear_internalvar (var_signal); + + /* Keep the logic here in sync with shell_internal_fn. */ + if (WIFEXITED (exit_status)) set_internalvar_integer (var_code, WEXITSTATUS (exit_status)); #ifdef __MINGW32__ @@ -893,8 +897,11 @@ exit_status_set_internal_vars (int exit_status) warning (_("unexpected shell command exit status %d"), exit_status); } =20 -static void -shell_escape (const char *arg, int from_tty) +/* Run ARG under the shell, and return the exit status. If ARG is + NULL, run an interactive shell. */ + +static int +run_under_shell (const char *arg, int from_tty) { #if defined(CANT_FORK) || \ (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK)) @@ -915,7 +922,7 @@ shell_escape (const char *arg, int from_tty) the shell command we just ran changed it. */ chdir (current_directory); #endif - exit_status_set_internal_vars (rc); + return rc; #else /* Can fork. */ int status, pid; =20 @@ -942,10 +949,21 @@ shell_escape (const char *arg, int from_tty) waitpid (pid, &status, 0); else error (_("Fork failed")); - exit_status_set_internal_vars (status); + return status; #endif /* Can fork. */ } =20 +/* Escape out to the shell to run ARG. If ARG is NULL, launch and + interactive shell. Sets $_shell_exitcode and $_shell_exitsignal + convenience variables based on the exits status. */ + +static void +shell_escape (const char *arg, int from_tty) +{ + int status =3D run_under_shell (arg, from_tty); + exit_status_set_internal_vars (status); +} + /* Implementation of the "shell" command. */ =20 static void @@ -2417,6 +2435,63 @@ gdb_maint_setting_str_internal_fn (struct gdbarch *g= dbarch, return str_value_from_setting (*show_cmd->var, gdbarch); } =20 +/* Implementation of the convenience function $_shell. */ + +static struct value * +shell_internal_fn (struct gdbarch *gdbarch, + const struct language_defn *language, + void *cookie, int argc, struct value **argv) +{ + if (argc !=3D 1) + error (_("You must provide one argument for $_shell.")); + + value *val =3D argv[0]; + struct type *type =3D check_typedef (val->type ()); + + if (!language->is_string_type_p (type)) + error (_("Argument must be a string.")); + + value_print_options opts; + get_no_prettyformat_print_options (&opts); + + string_file stream; + value_print (val, &stream, &opts); + + /* We should always have two quote chars, which we'll strip. */ + gdb_assert (stream.size () >=3D 2); + + /* Now strip them. We don't need the original string, so it's + cheaper to do it in place, avoiding a string allocation. */ + std::string str =3D stream.release (); + str[str.size () - 1] =3D 0; + const char *command =3D str.c_str () + 1; + + int exit_status =3D run_under_shell (command, 0); + + struct type *int_type =3D builtin_type (gdbarch)->builtin_int; + + /* Keep the logic here in sync with + exit_status_set_internal_vars. */ + + if (WIFEXITED (exit_status)) + return value_from_longest (int_type, WEXITSTATUS (exit_status)); +#ifdef __MINGW32__ + else if (WIFSIGNALED (exit_status) && WTERMSIG (exit_status) =3D=3D -1) + { + /* See exit_status_set_internal_vars. */ + return value_from_longest (int_type, exit_status); + } +#endif + else if (WIFSIGNALED (exit_status)) + { + /* (0x80 | SIGNO) is what most (all?) POSIX-like shells set as + exit code on fatal signal termination. */ + return value_from_longest (int_type, 0x80 | WTERMSIG (exit_status)); + } + else + return value::allocate_optimized_out (int_type); +} + void _initialize_cli_cmds (); void _initialize_cli_cmds () @@ -2606,6 +2681,19 @@ Some integer settings accept an unlimited value, ret= urned\n\ as 0 or -1 depending on the setting."), gdb_maint_setting_internal_fn, NULL); =20 + add_internal_function ("_shell", _("\ +$_shell - execute a shell command and return the result.\n\ +\n\ + Usage: $_shell (COMMAND)\n\ +\n\ + Arguments:\n\ +\n\ + COMMAND: The command to execute. Must be a string.\n\ +\n\ + Returns:\n\ + The command's exit code: zero on success, non-zero otherwise."), + shell_internal_fn, NULL); + add_cmd ("commands", no_set_class, show_commands, _("\ Show the history of commands you typed.\n\ You can supply a command number to start with, or a `+' to start after\n\ diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo index 38e6925e7d6..bbb39e73c02 100644 --- a/gdb/doc/gdb.texinfo +++ b/gdb/doc/gdb.texinfo @@ -1621,7 +1621,7 @@ just use the @code{shell} command. @cindex shell escape @item shell @var{command-string} @itemx !@var{command-string} -Invoke a standard shell to execute @var{command-string}. +Invoke a shell to execute @var{command-string}. Note that no space is needed between @code{!} and @var{command-string}. On GNU and Unix systems, the environment variable @env{SHELL}, if it exists, determines which shell to run. Otherwise @value{GDBN} uses @@ -1629,6 +1629,10 @@ the default shell (@file{/bin/sh} on GNU and Unix sy= stems, @file{cmd.exe} on MS-Windows, @file{COMMAND.COM} on MS-DOS, etc.). @end table =20 +You may also invoke shell commands from expressions, using the +@code{$_shell} convenience function. @xref{$_shell convenience +function}. + The utility @code{make} is often needed in development environments. You do not have to use the @code{shell} command for this purpose in @value{GDBN}: @@ -12977,6 +12981,60 @@ Like the @code{$_gdb_setting_str} function, but wo= rks with Like the @code{$_gdb_setting} function, but works with @code{maintenance set} variables. =20 +@anchor{$_shell convenience function} +@findex $_shell@r{, convenience function} +@item $_shell (@var{command-string}) + +Invoke a shell to execute @var{command-string}. @var{command-string} +must be a string. The shell runs on the host machine, the machine +@value{GDBN} is running on. Returns the command's exit status. On +Unix systems, a command which exits with a zero exit status has +succeeded, and non-zero exit status indicates failure. When a command +terminates on a fatal signal whose number is @var{N}, @value{GDBN} +uses the value 128+@var{N} as the exit status, as is standard in Unix +shells. Note that @var{N} is a host signal number, not a target +signal number. If you're native debugging, they will be the same, but +if cross debugging, the host vs target signal numbers may be +completely unrelated. Please consult your host operating system's +documentation for the mapping between host signal numbers and signal +names. The shell to run is determined in the same way as for the +@code{shell} command. @xref{Shell Commands, ,Shell Commands}. + +@smallexample +(@value{GDBP}) print $_shell("true") +$1 =3D 0 +(@value{GDBP}) print $_shell("false") +$2 =3D 1 +(@value{GDBP}) p $_shell("echo hello") +hello +$3 =3D 0 +(@value{GDBP}) p $_shell("foobar") +bash: line 1: foobar: command not found +$4 =3D 127 +@end smallexample + +This may also be useful in breakpoint conditions. For example: + +@smallexample +(@value{GDBP}) break function if $_shell("some command") =3D=3D 0 +@end smallexample + +In this scenario, you'll want to make sure that the shell command you +run in the breakpoint condition takes the least amount of time +possible. For example, avoid running a command that may block +indefinitely, or that sleeps for a while before exiting. Prefer a +command or script which analyzes some state and exits immediately. +This is important because the debugged program stops for the +breakpoint every time, and then @value{GDBN} evaluates the breakpoint +condition. If the condition is false, the program is re-resumed +transparently, without informing you of the stop. A quick shell +command thus avoids significantly slowing down the debugged program +unnecessarily. + +Note: unlike the @code{shell} command, the @code{$_shell} convenience +function does not affect the @code{$_shell_exitcode} and +@code{$_shell_exitsignal} convenience variables. + @end table =20 The following functions require @value{GDBN} to be configured with diff --git a/gdb/testsuite/gdb.base/default.exp b/gdb/testsuite/gdb.base/de= fault.exp index d0789a64401..7e73db0576a 100644 --- a/gdb/testsuite/gdb.base/default.exp +++ b/gdb/testsuite/gdb.base/default.exp @@ -606,6 +606,7 @@ set show_conv_list \ {$_cimag =3D } \ {$_creal =3D } \ {$_isvoid =3D } \ + {$_shell =3D } \ {$_gdb_maint_setting_str =3D } \ {$_gdb_maint_setting =3D } \ {$_gdb_setting_str =3D } \ diff --git a/gdb/testsuite/gdb.base/shell.exp b/gdb/testsuite/gdb.base/shel= l.exp index 31cdcb41af5..ba1691ea2b0 100644 --- a/gdb/testsuite/gdb.base/shell.exp +++ b/gdb/testsuite/gdb.base/shell.exp @@ -41,6 +41,42 @@ if { ! [ishost *-*-mingw*] } { gdb_test "p \$_shell_exitsignal" " =3D 2" "shell interrupt exitsignal" } =20 +# Test the $_shell convenience function. + +with_test_prefix "\$_shell convenience function" { + # Simple commands, check the result code. + gdb_test "p \$_shell(\"true\")" " =3D 0" + gdb_test "p \$_shell(\"false\")" " =3D 1" + + # Test command with arguments. + gdb_test "p \$_shell(\"echo foo\")" "foo\r\n\\$${decimal} =3D 0" + + # Check the type of the result. + gdb_test "ptype \$_shell(\"true\")" "type =3D int" + + # Test passing a non-literal string as command name. + gdb_test "p \$cmd =3D \"echo bar\"" " =3D \"echo bar\"" + gdb_test "p \$_shell(\$cmd)" "bar\r\n\\$${decimal} =3D 0" + + # Test executing a non-existing command. The result is + # shell-dependent, but most (all?) POSIX-like shells return 127 in + # this case. + gdb_test "p \$_shell(\"non-existing-command-foo-bar-qux\")" " =3D 127" + + gdb_test "p \$_shell" \ + " =3D " + gdb_test "ptype \$_shell" \ + "type =3D " + + # Test error scenarios. + gdb_test "p \$_shell()" \ + "You must provide one argument for \\\$_shell\\\." + gdb_test "p \$_shell(\"a\", \"b\")" \ + "You must provide one argument for \\\$_shell\\\." + gdb_test "p \$_shell(1)" \ + "Argument must be a string\\\." +} + # Define the user command "foo", used to test "pipe" command. gdb_test_multiple "define foo" "define foo" { -re "End with" {