/* Fork a Unix child process, and set up to debug it, for GDB.
- Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
- 2001, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
- Free Software Foundation, Inc.
+ Copyright (C) 1990-2017 Free Software Foundation, Inc.
Contributed by Cygnus Support.
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
-#include "gdb_string.h"
#include "inferior.h"
#include "terminal.h"
#include "target.h"
#include "gdb_wait.h"
#include "gdb_vfork.h"
#include "gdbcore.h"
-#include "terminal.h"
#include "gdbthread.h"
#include "command.h" /* for dont_repeat () */
#include "gdbcmd.h"
#include "solib.h"
-
+#include "filestuff.h"
+#include "top.h"
+#include "signals-state-save-restore.h"
#include <signal.h>
+#include <vector>
/* This just gets used as a default if we can't find SHELL. */
#define SHELL_FILE "/bin/sh"
fill in ARGV with the four arguments "a", "b", "c", "d". */
static void
-breakup_args (char *scratch, char **argv)
+breakup_args (const std::string &scratch, std::vector<char *> &argv)
{
- char *cp = scratch, *tmp;
-
- for (;;)
+ for (size_t cur_pos = 0; cur_pos < scratch.size ();)
{
- /* Scan past leading separators */
- while (*cp == ' ' || *cp == '\t' || *cp == '\n')
- cp++;
-
- /* Break if at end of string. */
- if (*cp == '\0')
- break;
-
- /* Take an arg. */
- *argv++ = cp;
-
- /* Scan for next arg separator. */
- tmp = strchr (cp, ' ');
- if (tmp == NULL)
- tmp = strchr (cp, '\t');
- if (tmp == NULL)
- tmp = strchr (cp, '\n');
-
- /* No separators => end of string => break. */
- if (tmp == NULL)
- break;
- cp = tmp;
-
- /* Replace the separator with a terminator. */
- *cp++ = '\0';
+ /* Skip whitespace-like chars. */
+ std::size_t pos = scratch.find_first_not_of (" \t\n", cur_pos);
+
+ if (pos != std::string::npos)
+ cur_pos = pos;
+
+ /* Find the position of the next separator. */
+ std::size_t next_sep = scratch.find_first_of (" \t\n", cur_pos);
+
+ /* No separator found, which means this is the last
+ argument. */
+ if (next_sep == std::string::npos)
+ next_sep = scratch.size ();
+
+ char *arg = savestring (scratch.c_str () + cur_pos, next_sep - cur_pos);
+ argv.push_back (arg);
+
+ cur_pos = next_sep;
}
- /* Null-terminate the vector. */
- *argv = NULL;
+ /* NULL-terminate the vector. */
+ argv.push_back (NULL);
}
/* When executing a command under the given shell, return non-zero if
return 0;
}
+/* See inferior.h. */
+
+void
+trace_start_error (const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start (ap, fmt);
+ fprintf_unfiltered (gdb_stderr, "Could not trace the inferior "
+ "process.\nError: ");
+ vfprintf_unfiltered (gdb_stderr, fmt, ap);
+ va_end (ap);
+
+ gdb_flush (gdb_stderr);
+ _exit (0177);
+}
+
+/* See inferior.h. */
+
+void
+trace_start_error_with_name (const char *string)
+{
+ trace_start_error ("%s: %s", string, safe_strerror (errno));
+}
+
/* Start an inferior Unix child process and sets inferior_ptid to its
pid. EXEC_FILE is the file to run. ALLARGS is a string containing
the arguments to the program. ENV is the environment vector to
pass. SHELL_FILE is the shell file, or NULL if we should pick
+ one. EXEC_FUN is the exec(2) function to use, or NULL for the default
one. */
/* This function is NOT reentrant. Some of the variables have been
made static to ensure that they survive the vfork call. */
int
-fork_inferior (char *exec_file_arg, char *allargs, char **env,
- void (*traceme_fun) (void), void (*init_trace_fun) (int),
- void (*pre_trace_fun) (void), char *shell_file_arg)
+fork_inferior (const char *exec_file_arg, const std::string &allargs,
+ char **env, void (*traceme_fun) (void),
+ void (*init_trace_fun) (int), void (*pre_trace_fun) (void),
+ char *shell_file_arg,
+ void (*exec_fun)(const char *file, char * const *argv,
+ char * const *env))
{
int pid;
- char *shell_command;
static char default_shell_file[] = SHELL_FILE;
- int len;
- /* Set debug_fork then attach to the child while it sleeps, to debug. */
+ /* Set debug_fork then attach to the child while it sleeps, to debug. */
static int debug_fork = 0;
/* This is set to the result of setpgrp, which if vforked, will be visible
to you in the parent process. It's only used by humans for debugging. */
static int debug_setpgrp = 657473;
static char *shell_file;
- static char *exec_file;
+ static const char *exec_file;
char **save_our_env;
int shell = 0;
- static char **argv;
+ std::vector<char *> argv;
const char *inferior_io_terminal = get_inferior_io_terminal ();
struct inferior *inf;
+ int i;
+ int save_errno;
+ struct ui *save_ui;
/* If no exec file handed to us, get it from the exec-file command
-- with a good, common error message if none is specified. */
- exec_file = exec_file_arg;
- if (exec_file == 0)
+ if (exec_file_arg == NULL)
exec_file = get_exec_file (1);
+ else
+ exec_file = exec_file_arg;
- /* STARTUP_WITH_SHELL is defined in inferior.h. If 0,e we'll just
- do a fork/exec, no shell, so don't bother figuring out what
- shell. */
+ /* 'startup_with_shell' is declared in inferior.h and bound to the
+ "set startup-with-shell" option. If 0, we'll just do a
+ fork/exec, no shell, so don't bother figuring out what shell. */
shell_file = shell_file_arg;
- if (STARTUP_WITH_SHELL)
+ if (startup_with_shell)
{
/* Figure out what shell to start up the user program under. */
if (shell_file == NULL)
shell = 1;
}
- /* Multiplying the length of exec_file by 4 is to account for the
- fact that it may expand when quoted; it is a worst-case number
- based on every character being '. */
- len = 5 + 4 * strlen (exec_file) + 1 + strlen (allargs) + 1 + /*slop */ 12;
- if (exec_wrapper)
- len += strlen (exec_wrapper) + 1;
-
- shell_command = (char *) alloca (len);
- shell_command[0] = '\0';
-
if (!shell)
{
- /* We're going to call execvp. Create argument vector.
- Calculate an upper bound on the length of the vector by
- assuming that every other character is a separate
- argument. */
- int argc = (strlen (allargs) + 1) / 2 + 2;
-
- argv = (char **) xmalloc (argc * sizeof (*argv));
- argv[0] = exec_file;
- breakup_args (allargs, &argv[1]);
+ /* We're going to call execvp. Create argument vector. */
+ argv.push_back (xstrdup (exec_file));
+ breakup_args (allargs, argv);
}
else
{
/* We're going to call a shell. */
-
- char *p;
+ std::string shell_command;
+ const char *p;
int need_to_quote;
const int escape_bang = escape_bang_in_quoted_argument (shell_file);
- strcat (shell_command, "exec ");
+ shell_command = std::string ("exec ");
/* Add any exec wrapper. That may be a program name with arguments, so
the user must handle quoting. */
if (exec_wrapper)
{
- strcat (shell_command, exec_wrapper);
- strcat (shell_command, " ");
+ shell_command += exec_wrapper;
+ shell_command += ' ';
}
/* Now add exec_file, quoting as necessary. */
end_scan:
if (need_to_quote)
{
- strcat (shell_command, "'");
+ shell_command += '\'';
for (p = exec_file; *p != '\0'; ++p)
{
if (*p == '\'')
- strcat (shell_command, "'\\''");
+ shell_command += "'\\''";
else if (*p == '!' && escape_bang)
- strcat (shell_command, "\\!");
+ shell_command += "\\!";
else
- strncat (shell_command, p, 1);
+ shell_command += *p;
}
- strcat (shell_command, "'");
+ shell_command += '\'';
}
else
- strcat (shell_command, exec_file);
+ shell_command += exec_file;
- strcat (shell_command, " ");
- strcat (shell_command, allargs);
- }
+ shell_command += " " + allargs;
- /* On some systems an exec will fail if the executable is open. */
- close_exec_file ();
+ /* If we decided above to start up with a shell, we exec the
+ shell, "-c" says to interpret the next arg as a shell command
+ to execute, and this command is "exec <target-program>
+ <args>". We xstrdup all the strings here because they will
+ be free'd later in the code. */
+ argv.push_back (xstrdup (shell_file));
+ argv.push_back (xstrdup ("-c"));
+ argv.push_back (xstrdup (shell_command.c_str ()));
+ argv.push_back (NULL);
+ }
/* Retain a copy of our environment variables, since the child will
replace the value of environ and if we're vforked, we have to
restore it. */
save_our_env = environ;
+ /* Likewise the current UI. */
+ save_ui = current_ui;
+
/* Tell the terminal handling subsystem what tty we plan to run on;
it will just record the information for later. */
new_tty_prefork (inferior_io_terminal);
/* It is generally good practice to flush any possible pending stdio
output prior to doing a fork, to avoid the possibility of both
- the parent and child flushing the same data after the fork. */
- gdb_flush (gdb_stdout);
- gdb_flush (gdb_stderr);
+ the parent and child flushing the same data after the fork. */
+ gdb_flush (main_ui->m_gdb_stdout);
+ gdb_flush (main_ui->m_gdb_stderr);
/* If there's any initialization of the target layers that must
happen to prepare to handle the child we're about fork, do it
if (pid == 0)
{
+ /* Switch to the main UI, so that gdb_std{in/out/err} in the
+ child are mapped to std{in/out/err}. This makes it possible
+ to use fprintf_unfiltered/warning/error/etc. in the child
+ from here on. */
+ current_ui = main_ui;
+
+ /* Close all file descriptors except those that gdb inherited
+ (usually 0/1/2), so they don't leak to the inferior. Note
+ that this closes the file descriptors of all secondary
+ UIs. */
+ close_most_fds ();
+
if (debug_fork)
sleep (debug_fork);
in a separate process group. */
debug_setpgrp = gdb_setpgid ();
if (debug_setpgrp == -1)
- perror ("setpgrp failed in child");
+ perror (_("setpgrp failed in child"));
}
/* Ask the tty subsystem to switch to the one we specified
initialize_signals for how we get the right signal handlers
for the inferior. */
- /* "Trace me, Dr. Memory!" */
+ /* "Trace me, Dr. Memory!" */
(*traceme_fun) ();
/* The call above set this process (the "child") as debuggable
saying "not parent". Sorry; you'll have to use print
statements! */
+ restore_original_signals_state ();
+
/* There is no execlpe call, so we have to set the environment
for our child in the global variable. If we've vforked, this
clobbers the parent, but environ is restored a few lines down
path to find $SHELL. Rich Pixley says so, and I agree. */
environ = env;
- /* If we decided above to start up with a shell, we exec the
- shell, "-c" says to interpret the next arg as a shell command
- to execute, and this command is "exec <target-program>
- <args>". */
- if (shell)
- {
- execlp (shell_file, shell_file, "-c", shell_command, (char *) 0);
-
- /* If we get here, it's an error. */
- fprintf_unfiltered (gdb_stderr, "Cannot exec %s: %s.\n", shell_file,
- safe_strerror (errno));
- gdb_flush (gdb_stderr);
- _exit (0177);
- }
+ if (exec_fun != NULL)
+ (*exec_fun) (argv[0], &argv[0], env);
else
- {
- /* Otherwise, we directly exec the target program with
- execvp. */
- int i;
- char *errstring;
-
- execvp (exec_file, argv);
-
- /* If we get here, it's an error. */
- errstring = safe_strerror (errno);
- fprintf_unfiltered (gdb_stderr, "Cannot exec %s ", exec_file);
-
- i = 1;
- while (argv[i] != NULL)
- {
- if (i != 1)
- fprintf_unfiltered (gdb_stderr, " ");
- fprintf_unfiltered (gdb_stderr, "%s", argv[i]);
- i++;
- }
- fprintf_unfiltered (gdb_stderr, ".\n");
-#if 0
- /* This extra info seems to be useless. */
- fprintf_unfiltered (gdb_stderr, "Got error %s.\n", errstring);
-#endif
- gdb_flush (gdb_stderr);
- _exit (0177);
- }
+ execvp (argv[0], &argv[0]);
+
+ /* If we get here, it's an error. */
+ save_errno = errno;
+ fprintf_unfiltered (gdb_stderr, "Cannot exec %s", argv[0]);
+ for (i = 1; argv[i] != NULL; i++)
+ fprintf_unfiltered (gdb_stderr, " %s", argv[i]);
+ fprintf_unfiltered (gdb_stderr, ".\n");
+ fprintf_unfiltered (gdb_stderr, "Error: %s\n",
+ safe_strerror (save_errno));
+ gdb_flush (gdb_stderr);
+ _exit (0177);
}
+ free_vector_argv (argv);
+
/* Restore our environment in case a vforked child clob'd it. */
environ = save_our_env;
+ /* Likewise the current UI. */
+ current_ui = save_ui;
+
if (!have_inferiors ())
init_thread_list ();
int terminal_initted = 0;
ptid_t resume_ptid;
+ if (startup_with_shell)
+ {
+ /* One trap extra for exec'ing the shell. */
+ pending_execs++;
+ }
+
if (target_supports_multi_process ())
resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
else
while (1)
{
- enum target_signal resume_signal = TARGET_SIGNAL_0;
+ enum gdb_signal resume_signal = GDB_SIGNAL_0;
ptid_t event_ptid;
struct target_waitstatus ws;
case TARGET_WAITKIND_SIGNALLED:
target_terminal_ours ();
- target_mourn_inferior ();
+ target_mourn_inferior (event_ptid);
error (_("During startup program terminated with signal %s, %s."),
- target_signal_to_name (ws.value.sig),
- target_signal_to_string (ws.value.sig));
+ gdb_signal_to_name (ws.value.sig),
+ gdb_signal_to_string (ws.value.sig));
return;
case TARGET_WAITKIND_EXITED:
target_terminal_ours ();
- target_mourn_inferior ();
+ target_mourn_inferior (event_ptid);
if (ws.value.integer)
error (_("During startup program exited with code %d."),
ws.value.integer);
case TARGET_WAITKIND_EXECD:
/* Handle EXEC signals as if they were SIGTRAP signals. */
xfree (ws.value.execd_pathname);
- resume_signal = TARGET_SIGNAL_TRAP;
+ resume_signal = GDB_SIGNAL_TRAP;
switch_to_thread (event_ptid);
break;
break;
}
- if (resume_signal != TARGET_SIGNAL_TRAP)
+ if (resume_signal != GDB_SIGNAL_TRAP)
{
/* Let shell child handle its own signals in its own way. */
- target_resume (resume_ptid, 0, resume_signal);
+ target_continue (resume_ptid, resume_signal);
}
else
{
break;
/* Just make it go on. */
- target_resume (resume_ptid, 0, TARGET_SIGNAL_0);
+ target_continue_no_signal (resume_ptid);
}
}
exec_wrapper = NULL;
}
+static void
+show_startup_with_shell (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file,
+ _("Use of shell to start subprocesses is %s.\n"),
+ value);
+}
+
/* Provide a prototype to silence -Wmissing-prototypes. */
extern initialize_file_ftype _initialize_fork_child;
add_cmd ("exec-wrapper", class_run, unset_exec_wrapper_command,
_("Disable use of an execution wrapper."),
&unsetlist);
+
+ add_setshow_boolean_cmd ("startup-with-shell", class_support,
+ &startup_with_shell, _("\
+Set use of shell to start subprocesses. The default is on."), _("\
+Show use of shell to start subprocesses."), NULL,
+ NULL,
+ show_startup_with_shell,
+ &setlist, &showlist);
}
projects / deliverable / binutils-gdb.git / blobdiff