+2017-06-07 Sergio Durigan Junior <sergiodj@redhat.com>
+ Pedro Alves <palves@redhat.com>
+
+ * Makefile.in (HFILES_NO_SRCDIR): Add "common/common-inferior.h"
+ and "nat/fork-inferior.h".
+ * common/common-inferior.h: New file, with contents from
+ "gdb/inferior.h".
+ * commom/common-utils.c: Include "common-utils.h".
+ (stringify_argv): New function.
+ * common/common-utils.h (stringify_argv): New prototype.
+ * configure.nat: Add "fork-inferior.o" as a dependency for
+ "*linux*", "fbsd*" and "nbsd*" hosts.
+ * corefile.c (get_exec_file): Update comment.
+ * darwin-nat.c (darwin_ptrace_him): Call "gdb_startup_inferior"
+ instead of "startup_inferior".
+ (darwin_create_inferior): Call "add_thread_silent" after
+ "fork_inferior".
+ * fork-child.c: Cleanup unnecessary includes.
+ (SHELL_FILE): Move to "common/common-fork-child.c".
+ (environ): Likewise.
+ (exec_wrapper): Initialize.
+ (get_exec_wrapper): New function.
+ (breakup_args): Move to "common/common-fork-child.c"; rename to
+ "breakup_args_for_exec".
+ (escape_bang_in_quoted_argument): Move to
+ "common/common-fork-child.c".
+ (saved_ui): New variable.
+ (prefork_hook): New function.
+ (postfork_hook): Likewise.
+ (postfork_child_hook): Likewise.
+ (gdb_startup_inferior): Likewise.
+ (fork_inferior): Move to "common/common-fork-child.c". Update
+ function to support gdbserver.
+ (startup_inferior): Likewise.
+ * gdbcore.h (get_exec_file): Remove declaration.
+ * gnu-nat.c (gnu_create_inferior): Call "gdb_startup_inferior"
+ instead of "startup_inferior". Call "add_thread_silent" after
+ "fork_inferior".
+ * inf-ptrace.c: Include "nat/fork-inferior.h" and "utils.h".
+ (inf_ptrace_create_inferior): Call "gdb_startup_inferior"
+ instead of "startup_inferior". Call "add_thread_silent" after
+ "fork_inferior".
+ * inferior.h: Include "common-inferior.h".
+ (trace_start_error): Move to "common/common-utils.h".
+ (trace_start_error_with_name): Likewise.
+ (fork_inferior): Move prototype to "nat/fork-inferior.h".
+ (startup_inferior): Likewise.
+ (gdb_startup_inferior): New prototype.
+ * nat/fork-inferior.c: New file, with contents from "fork-child.c".
+ * nat/fork-inferior.h: New file.
+ * procfs.c (procfs_init_inferior): Call "gdb_startup_inferior"
+ instead of "startup_inferior". Call "add_thread_silent" after
+ "fork_inferior".
+ * target.h (target_terminal_init): Move prototype to
+ "target/target.h".
+ (target_terminal_inferior): Likewise.
+ (target_terminal_ours): Likewise.
+ * target/target.h (target_terminal_init): New prototype, moved
+ from "target.h".
+ (target_terminal_inferior): Likewise.
+ (target_terminal_ours): Likewise.
+ * utils.c (gdb_flush_out_err): New function.
+
2017-06-07 Sergio Durigan Junior <sergiodj@redhat.com>
* Makefile.in (HFILES_NO_SRCDIR): Add "common/common-gdbthread.h".
common/gdb_termios.h \
common/gdb_vecs.h \
common/gdb_wait.h \
+ common/common-inferior.h \
common/host-defs.h \
common/print-utils.h \
common/ptid.h \
nat/amd64-linux-siginfo.h \
nat/gdb_ptrace.h \
nat/gdb_thread_db.h \
+ nat/fork-inferior.h \
nat/linux-btrace.h \
nat/linux-namespaces.h \
nat/linux-nat.h \
--- /dev/null
+/* Functions to deal with the inferior being executed on GDB or
+ GDBserver.
+
+ Copyright (C) 1986-2017 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/>. */
+
+#ifndef COMMON_INFERIOR_H
+#define COMMON_INFERIOR_H
+
+/* Return the exec wrapper to be used when starting the inferior, or NULL
+ otherwise. */
+extern const char *get_exec_wrapper ();
+
+/* Return the name of the executable file as a string.
+ ERR nonzero means get error if there is none specified;
+ otherwise return 0 in that case. */
+extern char *get_exec_file (int err);
+
+#endif /* ! COMMON_INFERIOR_H */
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "common-defs.h"
+#include "common-utils.h"
#include "host-defs.h"
#include <ctype.h>
v.clear ();
}
+
+/* See common/common-utils.h. */
+
+std::string
+stringify_argv (const std::vector<char *> &args)
+{
+ std::string ret;
+
+ if (!args.empty ())
+ {
+ for (auto s : args)
+ if (s != NULL)
+ {
+ ret += s;
+ ret += ' ';
+ }
+
+ /* Erase the last whitespace. */
+ ret.erase (ret.end () - 1);
+ }
+
+ return ret;
+}
freeing all the elements. */
extern void free_vector_argv (std::vector<char *> &v);
+/* Given a vector of arguments ARGV, return a string equivalent to
+ joining all the arguments with a whitespace separating them. */
+extern std::string stringify_argv (const std::vector<char *> &argv);
+
#endif
case ${gdb_host} in
*linux*)
NAT_FILE='config/nm-linux.h'
- NATDEPFILES='inf-ptrace.o fork-child.o proc-service.o \
+ NATDEPFILES='inf-ptrace.o fork-child.o fork-inferior.o proc-service.o \
linux-thread-db.o linux-nat.o linux-osdata.o linux-fork.o \
linux-procfs.o linux-ptrace.o linux-waitpid.o \
linux-personality.o linux-namespaces.o'
LOADLIBES='-ldl $(RDYNAMIC)'
;;
fbsd*)
- NATDEPFILES='fork-child.o inf-ptrace.o fbsd-nat.o'
+ NATDEPFILES='fork-child.o fork-inferior.o inf-ptrace.o fbsd-nat.o'
HAVE_NATIVE_GCORE_HOST=1
LOADLIBES='-lkvm'
;;
nbsd*)
- NATDEPFILES='fork-child.o inf-ptrace.o'
+ NATDEPFILES='fork-child.o fork-inferior.o inf-ptrace.o'
;;
obsd*)
- NATDEPFILES='fork-child.o inf-ptrace.o'
+ NATDEPFILES='fork-child.o fork-inferior.o inf-ptrace.o'
;;
cygwin*)
NATDEPFILES='x86-nat.o x86-dregs.o windows-nat.o'
}
}
-/* Return the name of the executable file as a string.
- ERR nonzero means get error if there is none specified;
- otherwise return 0 in that case. */
+/* See common/common-inferior.h. */
char *
get_exec_file (int err)
darwin_init_thread_list (inf);
- startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
+ gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
}
static void
const std::string &allargs,
char **env, int from_tty)
{
+ pid_t pid;
+ ptid_t ptid;
+
/* Do the hard work. */
- fork_inferior (exec_file, allargs, env, darwin_ptrace_me, darwin_ptrace_him,
- darwin_pre_ptrace, NULL, darwin_execvp);
+ pid = fork_inferior (exec_file, allargs, env, darwin_ptrace_me,
+ darwin_ptrace_him, darwin_pre_ptrace, NULL,
+ darwin_execvp);
+ ptid = pid_to_ptid (pid);
/* Return now in case of error. */
if (ptid_equal (inferior_ptid, null_ptid))
return;
+
+ /* We have something that executes now. We'll be running through
+ the shell at this point (if startup-with-shell is true), but the
+ pid shouldn't change. */
+ add_thread_silent (ptid);
}
\f
#include "defs.h"
#include "inferior.h"
+#include "gdbcmd.h"
#include "terminal.h"
-#include "target.h"
-#include "gdb_wait.h"
-#include "gdb_vfork.h"
-#include "gdbcore.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 "job-control.h"
-#include <signal.h>
-#include <vector>
-
-/* This just gets used as a default if we can't find SHELL. */
-#define SHELL_FILE "/bin/sh"
-
-extern char **environ;
-
-static char *exec_wrapper;
-
-/* Build the argument vector for execv(3). */
-
-class execv_argv
-{
-public:
- /* EXEC_FILE is the file to run. ALLARGS is a string containing the
- arguments to the program. If starting with a shell, SHELL_FILE
- is the shell to run. Otherwise, SHELL_FILE is NULL. */
- execv_argv (const char *exec_file, const std::string &allargs,
- const char *shell_file);
-
- /* Return a pointer to the built argv, in the type expected by
- execv. The result is (only) valid for as long as this execv_argv
- object is live. We return a "char **" because that's the type
- that the execv functions expect. Note that it is guaranteed that
- the execv functions do not modify the argv[] array nor the
- strings to which the array point. */
- char **argv ()
- {
- return const_cast<char **> (&m_argv[0]);
- }
-
-private:
- /* Disable copying. */
- execv_argv (const execv_argv &) = delete;
- void operator= (const execv_argv &) = delete;
-
- /* Helper methods for constructing the argument vector. */
-
- /* Used when building an argv for a straight execv call, without
- going via the shell. */
- void init_for_no_shell (const char *exec_file,
- const std::string &allargs);
-
- /* Used when building an argv for execing a shell that execs the
- child program. */
- void init_for_shell (const char *exec_file,
- const std::string &allargs,
- const char *shell_file);
-
- /* The argument vector built. Holds non-owning pointers. Elements
- either point to the strings passed to the execv_argv ctor, or
- inside M_STORAGE. */
- std::vector<const char *> m_argv;
-
- /* Storage. In the no-shell case, this contains a copy of the
- arguments passed to the ctor, split by '\0'. In the shell case,
- this contains the quoted shell command. I.e., SHELL_COMMAND in
- {"$SHELL" "-c", SHELL_COMMAND, NULL}. */
- std::string m_storage;
-};
-
-/* Create argument vector for straight call to execvp. Breaks up
- ALLARGS into an argument vector suitable for passing to execvp and
- stores it in M_ARGV. E.g., on "run a b c d" this routine would get
- as input the string "a b c d", and as output it would fill in
- M_ARGV with the four arguments "a", "b", "c", "d". Each argument
- in M_ARGV points to a substring of a copy of ALLARGS stored in
- M_STORAGE. */
-
-void
-execv_argv::init_for_no_shell (const char *exec_file,
- const std::string &allargs)
-{
-
- /* Save/work with a copy stored in our storage. The pointers pushed
- to M_ARGV point directly into M_STORAGE, which is modified in
- place with the necessary NULL terminators. This avoids N heap
- allocations and string dups when 1 is sufficient. */
- std::string &args_copy = m_storage = allargs;
-
- m_argv.push_back (exec_file);
-
- for (size_t cur_pos = 0; cur_pos < args_copy.size ();)
- {
- /* Skip whitespace-like chars. */
- std::size_t pos = args_copy.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 = args_copy.find_first_of (" \t\n", cur_pos);
-
- if (next_sep == std::string::npos)
- {
- /* No separator found, which means this is the last
- argument. */
- next_sep = args_copy.size ();
- }
- else
- {
- /* Replace the separator with a terminator. */
- args_copy[next_sep++] = '\0';
- }
-
- m_argv.push_back (&args_copy[cur_pos]);
-
- cur_pos = next_sep;
- }
-
- /* NULL-terminate the vector. */
- m_argv.push_back (NULL);
-}
-
-/* When executing a command under the given shell, return true if the
- '!' character should be escaped when embedded in a quoted
- command-line argument. */
-
-static bool
-escape_bang_in_quoted_argument (const char *shell_file)
-{
- size_t shell_file_len = strlen (shell_file);
-
- /* Bang should be escaped only in C Shells. For now, simply check
- that the shell name ends with 'csh', which covers at least csh
- and tcsh. This should be good enough for now. */
-
- if (shell_file_len < 3)
- return false;
+#include "filestuff.h"
+#include "nat/fork-inferior.h"
+#include "common/common-inferior.h"
- if (shell_file[shell_file_len - 3] == 'c'
- && shell_file[shell_file_len - 2] == 's'
- && shell_file[shell_file_len - 1] == 'h')
- return true;
+/* The exec-wrapper, if any, that will be used when starting the
+ inferior. */
- return false;
-}
+static char *exec_wrapper = NULL;
-/* See declaration. */
+/* See common/common-inferior.h. */
-execv_argv::execv_argv (const char *exec_file,
- const std::string &allargs,
- const char *shell_file)
+const char *
+get_exec_wrapper ()
{
- if (shell_file == NULL)
- init_for_no_shell (exec_file, allargs);
- else
- init_for_shell (exec_file, allargs, shell_file);
+ return exec_wrapper;
}
-/* See declaration. */
+/* See nat/fork-inferior.h. */
void
-execv_argv::init_for_shell (const char *exec_file,
- const std::string &allargs,
- const char *shell_file)
+gdb_flush_out_err ()
{
- /* We're going to call a shell. */
- bool escape_bang = escape_bang_in_quoted_argument (shell_file);
-
- /* We need to build a new shell command string, and make argv point
- to it. So build it in the storage. */
- std::string &shell_command = m_storage;
-
- shell_command = "exec ";
-
- /* Add any exec wrapper. That may be a program name with arguments,
- so the user must handle quoting. */
- if (exec_wrapper)
- {
- shell_command += exec_wrapper;
- shell_command += ' ';
- }
-
- /* Now add exec_file, quoting as necessary. */
-
- /* Quoting in this style is said to work with all shells. But csh
- on IRIX 4.0.1 can't deal with it. So we only quote it if we need
- to. */
- bool need_to_quote;
- const char *p = exec_file;
- while (1)
- {
- switch (*p)
- {
- case '\'':
- case '!':
- case '"':
- case '(':
- case ')':
- case '$':
- case '&':
- case ';':
- case '<':
- case '>':
- case ' ':
- case '\n':
- case '\t':
- need_to_quote = true;
- goto end_scan;
-
- case '\0':
- need_to_quote = false;
- goto end_scan;
-
- default:
- break;
- }
- ++p;
- }
- end_scan:
- if (need_to_quote)
- {
- shell_command += '\'';
- for (p = exec_file; *p != '\0'; ++p)
- {
- if (*p == '\'')
- shell_command += "'\\''";
- else if (*p == '!' && escape_bang)
- shell_command += "\\!";
- else
- shell_command += *p;
- }
- shell_command += '\'';
- }
- else
- shell_command += exec_file;
-
- shell_command += ' ' + allargs;
-
- /* 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>". */
- m_argv.reserve (4);
- m_argv.push_back (shell_file);
- m_argv.push_back ("-c");
- m_argv.push_back (shell_command.c_str ());
- m_argv.push_back (NULL);
+ gdb_flush (main_ui->m_gdb_stdout);
+ gdb_flush (main_ui->m_gdb_stderr);
}
-/* 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);
+/* The ui structure that will be saved on 'prefork_hook' and
+ restored on 'postfork_hook'. */
+static struct ui *saved_ui = NULL;
- gdb_flush (gdb_stderr);
- _exit (0177);
-}
-
-/* See inferior.h. */
+/* See nat/fork-inferior.h. */
void
-trace_start_error_with_name (const char *string)
+prefork_hook (const char *args)
{
- 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 (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;
- static char default_shell_file[] = SHELL_FILE;
- /* 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 const char *exec_file;
- char **save_our_env;
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. */
- if (exec_file_arg == NULL)
- exec_file = get_exec_file (1);
- else
- exec_file = exec_file_arg;
-
- /* '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. */
- if (startup_with_shell)
- {
- shell_file = shell_file_arg;
- /* Figure out what shell to start up the user program under. */
- if (shell_file == NULL)
- shell_file = getenv ("SHELL");
- if (shell_file == NULL)
- shell_file = default_shell_file;
- }
- else
- shell_file = NULL;
- /* Build the argument vector. */
- execv_argv child_argv (exec_file, allargs, shell_file);
-
- /* 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;
+ gdb_assert (saved_ui == NULL);
+ /* Retain a copy of our UI, since the child will replace this value
+ and if we're vforked, we have to restore it. */
+ saved_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 (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
- now... */
- if (pre_trace_fun != NULL)
- (*pre_trace_fun) ();
-
- /* Create the child process. Since the child process is going to
- exec(3) shortly afterwards, try to reduce the overhead by
- calling vfork(2). However, if PRE_TRACE_FUN is non-null, it's
- likely that this optimization won't work since there's too much
- work to do between the vfork(2) and the exec(3). This is known
- to be the case on ttrace(2)-based HP-UX, where some handshaking
- between parent and child needs to happen between fork(2) and
- exec(2). However, since the parent is suspended in the vforked
- state, this doesn't work. Also note that the vfork(2) call might
- actually be a call to fork(2) due to the fact that autoconf will
- ``#define vfork fork'' on certain platforms. */
- if (pre_trace_fun || debug_fork)
- pid = fork ();
- else
- pid = vfork ();
-
- if (pid < 0)
- perror_with_name (("vfork"));
-
- 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);
-
- /* Create a new session for the inferior process, if necessary.
- It will also place the inferior in a separate process group. */
- if (create_tty_session () <= 0)
- {
- /* No session was created, but we still want to run the inferior
- in a separate process group. */
- debug_setpgrp = gdb_setpgid ();
- if (debug_setpgrp == -1)
- perror (_("setpgrp failed in child"));
- }
-
- /* Ask the tty subsystem to switch to the one we specified
- earlier (or to share the current terminal, if none was
- specified). */
- new_tty ();
-
- /* Changing the signal handlers for the inferior after
- a vfork can also change them for the superior, so we don't mess
- with signals here. See comments in
- initialize_signals for how we get the right signal handlers
- for the inferior. */
-
- /* "Trace me, Dr. Memory!" */
- (*traceme_fun) ();
-
- /* The call above set this process (the "child") as debuggable
- by the original gdb process (the "parent"). Since processes
- (unlike people) can have only one parent, if you are debugging
- gdb itself (and your debugger is thus _already_ the
- controller/parent for this child), code from here on out is
- undebuggable. Indeed, you probably got an error message
- 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
- in the parent. By the way, yes we do need to look down the
- path to find $SHELL. Rich Pixley says so, and I agree. */
- environ = env;
-
- char **argv = child_argv.argv ();
-
- if (exec_fun != NULL)
- (*exec_fun) (argv[0], &argv[0], env);
- else
- 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);
- }
-
- /* Restore our environment in case a vforked child clob'd it. */
- environ = save_our_env;
+/* See nat/fork-inferior.h. */
- /* Likewise the current UI. */
- current_ui = save_ui;
+void
+postfork_hook (pid_t pid)
+{
+ struct inferior *inf;
if (!have_inferiors ())
init_thread_list ();
inferior_appeared (inf, pid);
- /* Needed for wait_for_inferior stuff below. */
+ /* Needed for wait_for_inferior stuff. */
inferior_ptid = pid_to_ptid (pid);
- new_tty_postfork ();
+ gdb_assert (saved_ui != NULL);
+ current_ui = saved_ui;
+ saved_ui = NULL;
- /* We have something that executes now. We'll be running through
- the shell at this point, but the pid shouldn't change. Targets
- supporting MT should fill this task's ptid with more data as soon
- as they can. */
- add_thread_silent (inferior_ptid);
-
- /* Now that we have a child process, make it our target, and
- initialize anything target-vector-specific that needs
- initializing. */
- if (init_trace_fun)
- (*init_trace_fun) (pid);
-
- /* We are now in the child process of interest, having exec'd the
- correct program, and are poised at the first instruction of the
- new program. */
- return pid;
+ new_tty_postfork ();
}
-/* Accept NTRAPS traps from the inferior. */
+/* See nat/fork-inferior.h. */
void
-startup_inferior (int ntraps)
+postfork_child_hook ()
{
- int pending_execs = ntraps;
- int terminal_initted = 0;
- ptid_t resume_ptid;
+ /* 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;
+
+ /* Make sure we switch to main_ui here in order to be able to
+ use the fprintf_unfiltered/warning/error functions. */
+ current_ui = main_ui;
- if (startup_with_shell)
+ /* Create a new session for the inferior process, if necessary.
+ It will also place the inferior in a separate process group. */
+ if (create_tty_session () <= 0)
{
- /* One trap extra for exec'ing the shell. */
- pending_execs++;
+ /* No session was created, but we still want to run the inferior
+ in a separate process group. */
+ debug_setpgrp = gdb_setpgid ();
+ if (debug_setpgrp == -1)
+ perror (_("setpgrp failed in child"));
}
- if (target_supports_multi_process ())
- resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
- else
- resume_ptid = minus_one_ptid;
-
- /* The process was started by the fork that created it, but it will
- have stopped one instruction after execing the shell. Here we
- must get it up to actual execution of the real program. */
+ /* Ask the tty subsystem to switch to the one we specified
+ earlier (or to share the current terminal, if none was
+ specified). */
+ new_tty ();
+}
- if (exec_wrapper)
- pending_execs++;
+/* See inferior.h. */
- while (1)
- {
- enum gdb_signal resume_signal = GDB_SIGNAL_0;
- ptid_t event_ptid;
-
- struct target_waitstatus ws;
- memset (&ws, 0, sizeof (ws));
- event_ptid = target_wait (resume_ptid, &ws, 0);
-
- if (ws.kind == TARGET_WAITKIND_IGNORE)
- /* The inferior didn't really stop, keep waiting. */
- continue;
-
- switch (ws.kind)
- {
- case TARGET_WAITKIND_SPURIOUS:
- case TARGET_WAITKIND_LOADED:
- case TARGET_WAITKIND_FORKED:
- case TARGET_WAITKIND_VFORKED:
- case TARGET_WAITKIND_SYSCALL_ENTRY:
- case TARGET_WAITKIND_SYSCALL_RETURN:
- /* Ignore gracefully during startup of the inferior. */
- switch_to_thread (event_ptid);
- break;
-
- case TARGET_WAITKIND_SIGNALLED:
- target_terminal_ours ();
- target_mourn_inferior (event_ptid);
- error (_("During startup program terminated with signal %s, %s."),
- 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 (event_ptid);
- if (ws.value.integer)
- error (_("During startup program exited with code %d."),
- ws.value.integer);
- else
- error (_("During startup program exited normally."));
- return;
-
- case TARGET_WAITKIND_EXECD:
- /* Handle EXEC signals as if they were SIGTRAP signals. */
- xfree (ws.value.execd_pathname);
- resume_signal = GDB_SIGNAL_TRAP;
- switch_to_thread (event_ptid);
- break;
-
- case TARGET_WAITKIND_STOPPED:
- resume_signal = ws.value.sig;
- switch_to_thread (event_ptid);
- break;
- }
-
- if (resume_signal != GDB_SIGNAL_TRAP)
- {
- /* Let shell child handle its own signals in its own way. */
- target_continue (resume_ptid, resume_signal);
- }
- else
- {
- /* We handle SIGTRAP, however; it means child did an exec. */
- if (!terminal_initted)
- {
- /* Now that the child has exec'd we know it has already
- set its process group. On POSIX systems, tcsetpgrp
- will fail with EPERM if we try it before the child's
- setpgid. */
-
- /* Set up the "saved terminal modes" of the inferior
- based on what modes we are starting it with. */
- target_terminal_init ();
-
- /* Install inferior's terminal modes. */
- target_terminal_inferior ();
-
- terminal_initted = 1;
- }
-
- if (--pending_execs == 0)
- break;
-
- /* Just make it go on. */
- target_continue_no_signal (resume_ptid);
- }
- }
+ptid_t
+gdb_startup_inferior (pid_t pid, int num_traps)
+{
+ ptid_t ptid = startup_inferior (pid, num_traps, NULL, NULL);
/* Mark all threads non-executing. */
- set_executing (resume_ptid, 0);
+ set_executing (ptid, 0);
+
+ return ptid;
}
/* Implement the "unset exec-wrapper" command. */
#include "exec.h"
#include "target.h"
-/* Return the name of the executable file as a string.
- ERR nonzero means get error if there is none specified;
- otherwise return 0 in that case. */
-
-extern char *get_exec_file (int err);
-
/* Nonzero if there is a core file. */
extern int have_core_file_p (void);
+2017-06-07 Sergio Durigan Junior <sergiodj@redhat.com>
+ Pedro Alves <palves@redhat.com>
+
+ * Makefile.in (SFILES): Add "nat/fork-inferior.o".
+ * configure: Regenerate.
+ * configure.srv (srv_linux_obj): Add "fork-child.o" and
+ "fork-inferior.o".
+ (i[34567]86-*-lynxos*): Likewise.
+ (spu*-*-*): Likewise.
+ * fork-child.c: New file.
+ * linux-low.c: Include "common-inferior.h", "nat/fork-inferior.h"
+ and "environ.h".
+ (linux_ptrace_fun): New function.
+ (linux_create_inferior): Adjust function prototype to reflect
+ change on "target.h". Adjust function code to use
+ "fork_inferior".
+ (linux_request_interrupt): Delete "signal_pid".
+ * lynx-low.c: Include "common-inferior.h" and "nat/fork-inferior.h".
+ (lynx_ptrace_fun): New function.
+ (lynx_create_inferior): Adjust function prototype to reflect
+ change on "target.h". Adjust function code to use
+ "fork_inferior".
+ * nto-low.c (nto_create_inferior): Adjust function prototype and
+ code to reflect change on "target.h". Update comments.
+ * server.c: Include "common-inferior.h", "nat/fork-inferior.h",
+ "common-terminal.h" and "environ.h".
+ (terminal_fd): Moved to fork-child.c.
+ (old_foreground_pgrp): Likewise.
+ (restore_old_foreground_pgrp): Likewise.
+ (last_status): Make it global.
+ (last_ptid): Likewise.
+ (our_environ): New variable.
+ (startup_with_shell): Likewise.
+ (program_name): Likewise.
+ (program_argv): Rename to...
+ (program_args): ...this.
+ (wrapper_argv): New variable.
+ (start_inferior): Delete function.
+ (get_exec_wrapper): New function.
+ (get_exec_file): Likewise.
+ (get_environ): Likewise.
+ (prefork_hook): Likewise.
+ (post_fork_inferior): Likewise.
+ (postfork_hook): Likewise.
+ (postfork_child_hook): Likewise.
+ (handle_v_run): Update code to deal with arguments coming from the
+ remote host. Update calls from "start_inferior" to
+ "create_inferior".
+ (captured_main): Likewise. Initialize environment variable. Call
+ "have_job_control".
+ * server.h (post_fork_inferior): New prototype.
+ (get_environ): Likewise.
+ (last_status): Declare.
+ (last_ptid): Likewise.
+ (signal_pid): Likewise.
+ * spu-low.c: Include "common-inferior.h" and "nat/fork-inferior.h".
+ (spu_ptrace_fun): New function.
+ (spu_create_inferior): Adjust function prototype to reflect change
+ on "target.h". Adjust function code to use "fork_inferior".
+ * target.c (target_terminal_init): New function.
+ (target_terminal_inferior): Likewise.
+ (target_terminal_ours): Likewise.
+ * target.h: Include <vector>.
+ (struct target_ops) <create_inferior>: Update prototype.
+ (create_inferior): Update macro.
+ * utils.c (gdb_flush_out_err): New function.
+ * win32-low.c (win32_create_inferior): Adjust function prototype
+ and code to reflect change on "target.h".
+
2017-06-07 Sergio Durigan Junior <sergiodj@redhat.com>
* inferiors.c (switch_to_thread): New function.
$(srcdir)/nat/linux-personality.c \
$(srcdir)/nat/mips-linux-watch.c \
$(srcdir)/nat/ppc-linux.c \
+ $(srcdir)/nat/fork-inferior.c \
$(srcdir)/target/waitstatus.c
DEPFILES = @GDBSERVER_DEPFILES@
# Linux object files. This is so we don't have to repeat
# these files over and over again.
-srv_linux_obj="linux-low.o linux-osdata.o linux-procfs.o linux-ptrace.o linux-waitpid.o linux-personality.o linux-namespaces.o"
+srv_linux_obj="linux-low.o linux-osdata.o linux-procfs.o linux-ptrace.o linux-waitpid.o linux-personality.o linux-namespaces.o fork-child.o fork-inferior.o"
# Input is taken from the "${target}" variable.
ipa_obj="${ipa_i386_linux_regobj} linux-i386-ipa.o"
;;
i[34567]86-*-lynxos*) srv_regobj="i386.o"
- srv_tgtobj="lynx-low.o lynx-i386-low.o"
+ srv_tgtobj="lynx-low.o lynx-i386-low.o fork-child.o fork-inferior.o"
srv_xmlfiles="i386/i386.xml"
srv_xmlfiles="${srv_xmlfiles} i386/32bit-core.xml"
srv_xmlfiles="${srv_xmlfiles} i386/32bit-sse.xml"
srv_linux_thread_db=yes
;;
spu*-*-*) srv_regobj=reg-spu.o
- srv_tgtobj="spu-low.o"
+ srv_tgtobj="spu-low.o fork-child.o fork-inferior.o"
;;
tic6x-*-uclinux) srv_regobj="tic6x-c64xp-linux.o"
srv_regobj="${srv_regobj} tic6x-c64x-linux.o"
--- /dev/null
+/* Fork a Unix child process, and set up to debug it, for GDBserver.
+ Copyright (C) 1989-2017 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/>. */
+
+#include "server.h"
+#include "job-control.h"
+#include "nat/fork-inferior.h"
+
+#ifdef SIGTTOU
+/* A file descriptor for the controlling terminal. */
+static int terminal_fd;
+
+/* TERMINAL_FD's original foreground group. */
+static pid_t old_foreground_pgrp;
+
+/* Hand back terminal ownership to the original foreground group. */
+
+static void
+restore_old_foreground_pgrp (void)
+{
+ tcsetpgrp (terminal_fd, old_foreground_pgrp);
+}
+#endif
+
+/* See nat/fork-inferior.h. */
+
+void
+prefork_hook (const char *args)
+{
+ if (debug_threads)
+ {
+ debug_printf ("args: %s\n", args);
+ debug_flush ();
+ }
+
+#ifdef SIGTTOU
+ signal (SIGTTOU, SIG_DFL);
+ signal (SIGTTIN, SIG_DFL);
+#endif
+
+ /* Clear this so the backend doesn't get confused, thinking
+ CONT_THREAD died, and it needs to resume all threads. */
+ cont_thread = null_ptid;
+}
+
+/* See nat/fork-inferior.h. */
+
+void
+postfork_hook (pid_t pid)
+{
+}
+
+/* See nat/fork-inferior.h. */
+
+void
+postfork_child_hook ()
+{
+ /* 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;
+
+ debug_setpgrp = gdb_setpgid ();
+ if (debug_setpgrp == -1)
+ perror (_("setpgrp failed in child"));
+}
+
+/* See nat/fork-inferior.h. */
+
+void
+gdb_flush_out_err ()
+{
+ fflush (stdout);
+ fflush (stderr);
+}
+
+/* See server.h. */
+
+void
+post_fork_inferior (int pid, const char *program)
+{
+#ifdef SIGTTOU
+ signal (SIGTTOU, SIG_IGN);
+ signal (SIGTTIN, SIG_IGN);
+ terminal_fd = fileno (stderr);
+ old_foreground_pgrp = tcgetpgrp (terminal_fd);
+ tcsetpgrp (terminal_fd, pid);
+ atexit (restore_old_foreground_pgrp);
+#endif
+
+ startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED,
+ &last_status, &last_ptid);
+ current_thread->last_resume_kind = resume_stop;
+ current_thread->last_status = last_status;
+ signal_pid = pid;
+ target_post_create_inferior ();
+ fprintf (stderr, "Process %s created; pid = %d\n", program, pid);
+ fflush (stderr);
+}
#include "tracepoint.h"
#include "hostio.h"
#include <inttypes.h>
+#include "common-inferior.h"
+#include "nat/fork-inferior.h"
+#include "environ.h"
#ifndef ELFMAG0
/* Don't include <linux/elf.h> here. If it got included by gdb_proc_service.h
then ELFMAG0 will have been defined. If it didn't get included by
return lwp;
}
+/* Callback to be used when calling fork_inferior, responsible for
+ actually initiating the tracing of the inferior. */
+
+static void
+linux_ptrace_fun ()
+{
+ if (ptrace (PTRACE_TRACEME, 0, (PTRACE_TYPE_ARG3) 0,
+ (PTRACE_TYPE_ARG4) 0) < 0)
+ trace_start_error_with_name ("ptrace");
+
+ if (setpgid (0, 0) < 0)
+ trace_start_error_with_name ("setpgid");
+
+ /* If GDBserver is connected to gdb via stdio, redirect the inferior's
+ stdout to stderr so that inferior i/o doesn't corrupt the connection.
+ Also, redirect stdin to /dev/null. */
+ if (remote_connection_is_stdio ())
+ {
+ if (close (0) < 0)
+ trace_start_error_with_name ("close");
+ if (open ("/dev/null", O_RDONLY) < 0)
+ trace_start_error_with_name ("open");
+ if (dup2 (2, 1) < 0)
+ trace_start_error_with_name ("dup2");
+ if (write (2, "stdin/stdout redirected\n",
+ sizeof ("stdin/stdout redirected\n") - 1) < 0)
+ {
+ /* Errors ignored. */;
+ }
+ }
+}
+
/* Start an inferior process and returns its pid.
- ALLARGS is a vector of program-name and args. */
+ PROGRAM is the name of the program to be started, and PROGRAM_ARGS
+ are its arguments. */
static int
-linux_create_inferior (char *program, char **allargs)
+linux_create_inferior (const char *program,
+ const std::vector<char *> &program_args)
{
struct lwp_info *new_lwp;
int pid;
ptid_t ptid;
struct cleanup *restore_personality
= maybe_disable_address_space_randomization (disable_randomization);
+ std::string str_program_args = stringify_argv (program_args);
-#if defined(__UCLIBC__) && defined(HAS_NOMMU)
- pid = vfork ();
-#else
- pid = fork ();
-#endif
- if (pid < 0)
- perror_with_name ("fork");
-
- if (pid == 0)
- {
- close_most_fds ();
- ptrace (PTRACE_TRACEME, 0, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) 0);
-
- setpgid (0, 0);
-
- /* If gdbserver is connected to gdb via stdio, redirect the inferior's
- stdout to stderr so that inferior i/o doesn't corrupt the connection.
- Also, redirect stdin to /dev/null. */
- if (remote_connection_is_stdio ())
- {
- close (0);
- open ("/dev/null", O_RDONLY);
- dup2 (2, 1);
- if (write (2, "stdin/stdout redirected\n",
- sizeof ("stdin/stdout redirected\n") - 1) < 0)
- {
- /* Errors ignored. */;
- }
- }
-
- restore_original_signals_state ();
-
- execv (program, allargs);
- if (errno == ENOENT)
- execvp (program, allargs);
-
- fprintf (stderr, "Cannot exec %s: %s.\n", program,
- strerror (errno));
- fflush (stderr);
- _exit (0177);
- }
+ pid = fork_inferior (program,
+ str_program_args.c_str (),
+ environ_vector (get_environ ()), linux_ptrace_fun,
+ NULL, NULL, NULL, NULL);
do_cleanups (restore_personality);
new_lwp = add_lwp (ptid);
new_lwp->must_set_ptrace_flags = 1;
+ post_fork_inferior (pid, program);
+
return pid;
}
static void
linux_request_interrupt (void)
{
- extern unsigned long signal_pid;
-
/* Send a SIGINT to the process group. This acts just like the user
typed a ^C on the controlling terminal. */
kill (-signal_pid, SIGINT);
#include "gdb_wait.h"
#include <signal.h>
#include "filestuff.h"
+#include "common-inferior.h"
+#include "nat/fork-inferior.h"
int using_threads = 1;
return proc;
}
+/* Callback used by fork_inferior to start tracing the inferior. */
+
+static void
+lynx_ptrace_fun ()
+{
+ int pgrp;
+
+ /* Switch child to its own process group so that signals won't
+ directly affect GDBserver. */
+ pgrp = getpid();
+ if (pgrp < 0)
+ trace_start_error_with_name ("pgrp");
+ if (setpgid (0, pgrp) < 0)
+ trace_start_error_with_name ("setpgid");
+ if (ioctl (0, TIOCSPGRP, &pgrp) < 0)
+ trace_start_error_with_name ("ioctl");
+ if (lynx_ptrace (PTRACE_TRACEME, null_ptid, 0, 0, 0) < 0)
+ trace_start_error_with_name ("lynx_ptrace");
+}
+
/* Implement the create_inferior method of the target_ops vector. */
static int
-lynx_create_inferior (char *program, char **allargs)
+lynx_create_inferior (const char *program,
+ const std::vector<char *> &program_args)
{
int pid;
+ std::string str_program_args = stringify_argv (program_args);
lynx_debug ("lynx_create_inferior ()");
- pid = fork ();
- if (pid < 0)
- perror_with_name ("fork");
+ pid = fork_inferior (program,
+ str_program_args.c_str (),
+ environ_vector (get_environ ()), lynx_ptrace_fun,
+ NULL, NULL, NULL, NULL);
- if (pid == 0)
- {
- int pgrp;
-
- close_most_fds ();
-
- /* Switch child to its own process group so that signals won't
- directly affect gdbserver. */
- pgrp = getpid();
- setpgid (0, pgrp);
- ioctl (0, TIOCSPGRP, &pgrp);
- lynx_ptrace (PTRACE_TRACEME, null_ptid, 0, 0, 0);
- execv (program, allargs);
- fprintf (stderr, "Cannot exec %s: %s.\n", program, strerror (errno));
- fflush (stderr);
- _exit (0177);
- }
+ post_fork_inferior (pid, program);
lynx_add_process (pid, 0);
/* Do not add the process thread just yet, as we do not know its tid.
return len_read;
}
-/* Start inferior specified by PROGRAM passing arguments ALLARGS. */
+/* Start inferior specified by PROGRAM, using PROGRAM_ARGS as its
+ arguments. */
static int
-nto_create_inferior (char *program, char **allargs)
+nto_create_inferior (const char *program,
+ const std::vector<char *> &program_args)
{
struct inheritance inherit;
pid_t pid;
sigset_t set;
+ std::string str_program_args = stringify_argv (program_args);
TRACE ("%s %s\n", __func__, program);
/* Clear any pending SIGUSR1's but keep the behavior the same. */
memset (&inherit, 0, sizeof (inherit));
inherit.flags |= SPAWN_SETGROUP | SPAWN_HOLD;
inherit.pgroup = SPAWN_NEWPGROUP;
- pid = spawnp (program, 0, NULL, &inherit, allargs, 0);
+ pid = spawnp (program, 0, NULL, &inherit,
+ (char *) str_program_args.c_str (), 0);
sigprocmask (SIG_BLOCK, &set, NULL);
if (pid == -1)
#include "dll.h"
#include "hostio.h"
#include <vector>
+#include "common-inferior.h"
+#include "job-control.h"
+#include "environ.h"
+
+/* The environment to pass to the inferior when creating it. */
+
+struct gdb_environ *our_environ = NULL;
+
+/* Start the inferior using a shell. */
+
+/* We always try to start the inferior using a shell. */
+
+int startup_with_shell = 1;
/* The thread set with an `Hc' packet. `Hc' is deprecated in favor of
`vCont'. Note the multi-process extensions made `vCont' a
space randomization feature before starting an inferior. */
int disable_randomization = 1;
-static std::vector<char *> program_argv;
-static std::vector<char *> wrapper_argv;
+static char *program_name = NULL;
+static std::vector<char *> program_args;
+static std::string wrapper_argv;
int pass_signals[GDB_SIGNAL_LAST];
int program_signals[GDB_SIGNAL_LAST];
unsigned long signal_pid;
-#ifdef SIGTTOU
-/* A file descriptor for the controlling terminal. */
-int terminal_fd;
-
-/* TERMINAL_FD's original foreground group. */
-pid_t old_foreground_pgrp;
-
-/* Hand back terminal ownership to the original foreground group. */
-
-static void
-restore_old_foreground_pgrp (void)
-{
- tcsetpgrp (terminal_fd, old_foreground_pgrp);
-}
-#endif
-
/* Set if you want to disable optional thread related packets support
in gdbserver, for the sake of testing GDB against stubs that don't
support them. */
int disable_packet_qfThreadInfo;
/* Last status reported to GDB. */
-static struct target_waitstatus last_status;
-static ptid_t last_ptid;
+struct target_waitstatus last_status;
+ptid_t last_ptid;
char *own_buf;
static unsigned char *mem_buf;
return get_first_thread () != NULL;
}
-static int
-start_inferior (char **argv)
-{
- std::vector<char *> new_argv;
-
- if (!wrapper_argv.empty ())
- new_argv.insert (new_argv.begin (),
- wrapper_argv.begin (),
- wrapper_argv.end ());
-
- for (int i = 0; argv[i] != NULL; ++i)
- new_argv.push_back (argv[i]);
-
- new_argv.push_back (NULL);
+/* See common/common-inferior.h. */
- if (debug_threads)
- {
- for (int i = 0; i < new_argv.size (); ++i)
- debug_printf ("new_argv[%d] = \"%s\"\n", i, new_argv[i]);
- debug_flush ();
- }
-
-#ifdef SIGTTOU
- signal (SIGTTOU, SIG_DFL);
- signal (SIGTTIN, SIG_DFL);
-#endif
-
- signal_pid = create_inferior (new_argv[0], &new_argv[0]);
-
- /* FIXME: we don't actually know at this point that the create
- actually succeeded. We won't know that until we wait. */
- fprintf (stderr, "Process %s created; pid = %ld\n", argv[0],
- signal_pid);
- fflush (stderr);
-
-#ifdef SIGTTOU
- signal (SIGTTOU, SIG_IGN);
- signal (SIGTTIN, SIG_IGN);
- terminal_fd = fileno (stderr);
- old_foreground_pgrp = tcgetpgrp (terminal_fd);
- tcsetpgrp (terminal_fd, signal_pid);
- atexit (restore_old_foreground_pgrp);
-#endif
-
- if (!wrapper_argv.empty ())
- {
- ptid_t ptid = pid_to_ptid (signal_pid);
-
- last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
-
- if (last_status.kind == TARGET_WAITKIND_STOPPED)
- {
- do
- {
- target_continue_no_signal (ptid);
+const char *
+get_exec_wrapper ()
+{
+ return !wrapper_argv.empty () ? wrapper_argv.c_str () : NULL;
+}
- last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
- if (last_status.kind != TARGET_WAITKIND_STOPPED)
- break;
+/* See common/common-inferior.h. */
- current_thread->last_resume_kind = resume_stop;
- current_thread->last_status = last_status;
- }
- while (last_status.value.sig != GDB_SIGNAL_TRAP);
- }
- target_post_create_inferior ();
- return signal_pid;
- }
+char *
+get_exec_file (int err)
+{
+ if (err && program_name == NULL)
+ error (_("No executable file specified."));
- /* Wait till we are at 1st instruction in program, return new pid
- (assuming success). */
- last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
+ return program_name;
+}
- /* At this point, the target process, if it exits, is stopped. Do not call
- the function target_post_create_inferior if the process has already
- exited, as the target implementation of the routine may rely on the
- process being live. */
- if (last_status.kind != TARGET_WAITKIND_EXITED
- && last_status.kind != TARGET_WAITKIND_SIGNALLED)
- {
- target_post_create_inferior ();
- current_thread->last_resume_kind = resume_stop;
- current_thread->last_status = last_status;
- }
- else
- target_mourn_inferior (last_ptid);
+/* See server.h. */
- return signal_pid;
+struct gdb_environ *
+get_environ ()
+{
+ return our_environ;
}
static int
{
char *p, *next_p;
std::vector<char *> new_argv;
+ char *new_program_name = NULL;
int i, new_argc;
new_argc = 0;
if (i == 0 && p == next_p)
{
/* No program specified. */
- new_argv.push_back (NULL);
+ new_program_name = NULL;
+ }
+ else if (p == next_p)
+ {
+ /* Empty argument. */
+ new_argv.push_back (xstrdup ("''"));
}
else
{
size_t len = (next_p - p) / 2;
+ /* ARG is the unquoted argument received via the RSP. */
char *arg = (char *) xmalloc (len + 1);
+ /* FULL_ARGS will contain the quoted version of ARG. */
+ char *full_arg = (char *) xmalloc ((len + 1) * 2);
+ /* These are pointers used to navigate the strings above. */
+ char *tmp_arg = arg;
+ char *tmp_full_arg = full_arg;
+ int need_quote = 0;
hex2bin (p, (gdb_byte *) arg, len);
arg[len] = '\0';
- new_argv.push_back (arg);
- }
+ while (*tmp_arg != '\0')
+ {
+ switch (*tmp_arg)
+ {
+ case '\n':
+ /* Quote \n. */
+ *tmp_full_arg = '\'';
+ ++tmp_full_arg;
+ need_quote = 1;
+ break;
+
+ case '\'':
+ /* Quote single quote. */
+ *tmp_full_arg = '\\';
+ ++tmp_full_arg;
+ break;
+
+ default:
+ break;
+ }
+
+ *tmp_full_arg = *tmp_arg;
+ ++tmp_full_arg;
+ ++tmp_arg;
+ }
+
+ if (need_quote)
+ *tmp_full_arg++ = '\'';
+
+ /* Finish FULL_ARG and push it into the vector containing
+ the argv. */
+ *tmp_full_arg = '\0';
+ if (i == 0)
+ new_program_name = full_arg;
+ else
+ new_argv.push_back (full_arg);
+ xfree (arg);
+ }
if (*next_p)
next_p++;
}
new_argv.push_back (NULL);
- if (new_argv[0] == NULL)
+ if (new_program_name == NULL)
{
/* GDB didn't specify a program to run. Use the program from the
last run with the new argument list. */
- if (program_argv.empty ())
+ if (program_name == NULL)
{
write_enn (own_buf);
free_vector_argv (new_argv);
return 0;
}
-
- new_argv.push_back (xstrdup (program_argv[0]));
+ }
+ else
+ {
+ xfree (program_name);
+ program_name = new_program_name;
}
/* Free the old argv and install the new one. */
- free_vector_argv (program_argv);
- program_argv = new_argv;
+ free_vector_argv (program_args);
+ program_args = new_argv;
+
+ create_inferior (program_name, program_args);
- start_inferior (&program_argv[0]);
if (last_status.kind == TARGET_WAITKIND_STOPPED)
{
prepare_resume_reply (own_buf, last_ptid, &last_status);
tmp = next_arg;
while (*next_arg != NULL && strcmp (*next_arg, "--") != 0)
{
- wrapper_argv.push_back (*next_arg);
+ wrapper_argv += *next_arg;
+ wrapper_argv += ' ';
next_arg++;
}
+ if (!wrapper_argv.empty ())
+ {
+ /* Erase the last whitespace. */
+ wrapper_argv.erase (wrapper_argv.end () - 1);
+ }
+
if (next_arg == tmp || *next_arg == NULL)
{
gdbserver_usage (stderr);
exit (1);
}
+ /* Gather information about the environment. */
+ our_environ = make_environ ();
+ init_environ (our_environ);
+
initialize_async_io ();
initialize_low ();
+ have_job_control ();
initialize_event_loop ();
if (target_supports_tracepoints ())
initialize_tracepoint ();
int i, n;
n = argc - (next_arg - argv);
- for (i = 0; i < n; i++)
- program_argv.push_back (xstrdup (next_arg[i]));
- program_argv.push_back (NULL);
+ program_name = xstrdup (next_arg[0]);
+ for (i = 1; i < n; i++)
+ program_args.push_back (xstrdup (next_arg[i]));
+ program_args.push_back (NULL);
/* Wait till we are at first instruction in program. */
- start_inferior (&program_argv[0]);
+ create_inferior (program_name, program_args);
/* We are now (hopefully) stopped at the first instruction of
the target process. This assumes that the target process was
fprintf (stderr, "GDBserver restarting\n");
/* Wait till we are at 1st instruction in prog. */
- if (!program_argv.empty ())
+ if (program_name != NULL)
{
- start_inferior (&program_argv[0]);
+ create_inferior (program_name, program_args);
+
if (last_status.kind == TARGET_WAITKIND_STOPPED)
{
/* Stopped at the first instruction of the target
/* Definition for any syscall, used for unfiltered syscall reporting. */
#define ANY_SYSCALL (-2)
+/* After fork_inferior has been called, we need to adjust a few
+ signals and call startup_inferior to start the inferior and consume
+ its first events. This is done here. PID is the pid of the new
+ inferior and PROGRAM is its name. */
+extern void post_fork_inferior (int pid, const char *program);
+
+/* Get the 'struct gdb_environ *' being used in the current
+ session. */
+extern struct gdb_environ *get_environ ();
+
+extern target_waitstatus last_status;
+extern ptid_t last_ptid;
+extern unsigned long signal_pid;
+
#endif /* SERVER_H */
#include <sys/syscall.h>
#include "filestuff.h"
#include "hostio.h"
+#include "nat/fork-inferior.h"
/* Some older glibc versions do not define this. */
#ifndef __WNOTHREAD
return ret;
}
+/* Callback to be used when calling fork_inferior, responsible for
+ actually initiating the tracing of the inferior. */
+
+static void
+spu_ptrace_fun ()
+{
+ if (ptrace (PTRACE_TRACEME, 0, 0, 0) < 0)
+ trace_start_error_with_name ("ptrace");
+ if (setpgid (0, 0) < 0)
+ trace_start_error_with_name ("setpgid");
+}
/* Start an inferior process and returns its pid.
- ALLARGS is a vector of program-name and args. */
+ PROGRAM is the name of the program to be started, and PROGRAM_ARGS
+ are its arguments. */
+
static int
-spu_create_inferior (char *program, char **allargs)
+spu_create_inferior (const char *program,
+ const std::vector<char *> &program_argv)
{
int pid;
ptid_t ptid;
struct process_info *proc;
+ std::string str_program_args = stringify_argv (program_args);
- pid = fork ();
- if (pid < 0)
- perror_with_name ("fork");
-
- if (pid == 0)
- {
- close_most_fds ();
- ptrace (PTRACE_TRACEME, 0, 0, 0);
-
- setpgid (0, 0);
-
- execv (program, allargs);
- if (errno == ENOENT)
- execvp (program, allargs);
+ pid = fork_inferior (program,
+ str_program_args.c_str (),
+ environ_vector (get_environ ()), spu_ptrace_fun,
+ NULL, NULL, NULL, NULL);
- fprintf (stderr, "Cannot exec %s: %s.\n", program,
- strerror (errno));
- fflush (stderr);
- _exit (0177);
- }
+ post_fork_inferior (pid, program);
proc = add_process (pid, 0);
proc->tdesc = tdesc_spu;
(*the_target->sw_breakpoint_from_kind) (0, &size);
return size;
}
+
+/* See target/target.h. */
+
+void
+target_terminal_init ()
+{
+ /* Placeholder needed because of fork_inferior. Not necessary on
+ GDBserver. */
+}
+
+/* See target/target.h. */
+
+void
+target_terminal_inferior ()
+{
+ /* Placeholder needed because of fork_inferior. Not necessary on
+ GDBserver. */
+}
+
+/* See target/target.h. */
+
+void
+target_terminal_ours ()
+{
+ /* Placeholder needed because of fork_inferior. Not necessary on
+ GDBserver. */
+}
#include "target/waitstatus.h"
#include "mem-break.h"
#include "btrace-common.h"
+#include <vector>
struct emit_ops;
struct buffer;
/* Start a new process.
PROGRAM is a path to the program to execute.
- ARGS is a standard NULL-terminated array of arguments,
- to be passed to the inferior as ``argv''.
+ PROGRAM_ARGS is a standard NULL-terminated array of arguments,
+ to be passed to the inferior as ``argv'' (along with PROGRAM).
Returns the new PID on success, -1 on failure. Registers the new
process with the process list. */
-
- int (*create_inferior) (char *program, char **args);
+ int (*create_inferior) (const char *program,
+ const std::vector<char *> &program_args);
/* Do additional setup after a new process is created, including
exec-wrapper completion. */
void set_target_ops (struct target_ops *);
-#define create_inferior(program, args) \
- (*the_target->create_inferior) (program, args)
+#define create_inferior(program, program_args) \
+ (*the_target->create_inferior) (program, program_args)
#define target_post_create_inferior() \
do \
}
/* Start a new process.
- PROGRAM is a path to the program to execute.
- ARGS is a standard NULL-terminated array of arguments,
- to be passed to the inferior as ``argv''.
+ PROGRAM is the program name.
+ PROGRAM_ARGS is the vector containing the inferior's args.
Returns the new PID on success, -1 on failure. Registers the new
process with the process list. */
static int
-win32_create_inferior (char *program, char **program_args)
+win32_create_inferior (const char *program,
+ const std::vector<char *> &program_args)
{
#ifndef USE_WIN32API
char real_path[PATH_MAX];
#endif
BOOL ret;
DWORD flags;
- char *args;
int argslen;
int argc;
PROCESS_INFORMATION pi;
DWORD err;
+ std::string str_program_args = stringify_argv (program_args);
+ char *args = (char *) str_program_args.c_str ();
/* win32_wait needs to know we're not attaching. */
attaching = 0;
program = real_path;
#endif
- argslen = 1;
- for (argc = 1; program_args[argc]; argc++)
- argslen += strlen (program_args[argc]) + 1;
- args = (char *) alloca (argslen);
- args[0] = '\0';
- for (argc = 1; program_args[argc]; argc++)
- {
- /* FIXME: Can we do better about quoting? How does Cygwin
- handle this? */
- strcat (args, " ");
- strcat (args, program_args[argc]);
- }
OUTMSG2 (("Command line is \"%s\"\n", args));
#ifdef CREATE_NEW_PROCESS_GROUP
pid = fork_inferior (exec_file, allargs, env, gnu_ptrace_me,
NULL, NULL, NULL, NULL);
+ /* We have something that executes now. We'll be running through
+ the shell at this point (if startup-with-shell is true), but the
+ pid shouldn't change. */
+ add_thread_silent (pid_to_ptid (pid));
+
/* Attach to the now stopped child, which is actually a shell... */
inf_debug (inf, "attaching to child: %d", pid);
thread_change_ptid (inferior_ptid,
ptid_build (inf->pid, inf_pick_first_thread (), 0));
- startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
+ gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
+
inf->pending_execs = 0;
/* Get rid of the old shell threads. */
prune_threads ();
#include "inf-ptrace.h"
#include "inf-child.h"
#include "gdbthread.h"
+#include "nat/fork-inferior.h"
+#include "utils.h"
\f
const char *exec_file, const std::string &allargs,
char **env, int from_tty)
{
- int pid;
+ pid_t pid;
+ ptid_t ptid;
/* Do not change either targets above or the same target if already present.
The reason is the target stack is shared across multiple inferiors. */
pid = fork_inferior (exec_file, allargs, env, inf_ptrace_me, NULL,
NULL, NULL, NULL);
+ ptid = pid_to_ptid (pid);
+ /* We have something that executes now. We'll be running through
+ the shell at this point (if startup-with-shell is true), but the
+ pid shouldn't change. */
+ add_thread_silent (ptid);
+
discard_cleanups (back_to);
- startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
+ gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
/* On some targets, there must be some explicit actions taken after
the inferior has been started up. */
- target_post_startup_inferior (pid_to_ptid (pid));
+ target_post_startup_inferior (ptid);
}
#ifdef PT_GET_PROCESS_STATE
#include "symfile-add-flags.h"
#include "common/refcounted-object.h"
+#include "common-inferior.h"
+
struct infcall_suspend_state;
struct infcall_control_state;
/* From fork-child.c */
-/* Report an error that happened when starting to trace the inferior
- (i.e., when the "traceme_fun" callback is called on fork_inferior)
- and bail out. This function does not return. */
-
-extern void trace_start_error (const char *fmt, ...)
- ATTRIBUTE_NORETURN;
-
-/* Like "trace_start_error", but the error message is constructed by
- combining STRING with the system error message for errno. This
- function does not return. */
-
-extern void trace_start_error_with_name (const char *string)
- ATTRIBUTE_NORETURN;
-
-extern int fork_inferior (const char *, const std::string &, char **,
- void (*)(void),
- void (*)(int), void (*)(void), char *,
- void (*)(const char *,
- char * const *, char * const *));
-
-
-extern void startup_inferior (int);
+/* Helper function to call STARTUP_INFERIOR with PID and NUM_TRAPS.
+ This function already calls set_executing. Return the ptid_t from
+ STARTUP_INFERIOR. */
+extern ptid_t gdb_startup_inferior (pid_t pid, int num_traps);
extern char *construct_inferior_arguments (int, char **);
#define ON_STACK 1
#define AT_ENTRY_POINT 4
-/* Number of traps that happen between exec'ing the shell to run an
- inferior and when we finally get to the inferior code, not counting
- the exec for the shell. This is 1 on all supported
- implementations. */
-#define START_INFERIOR_TRAPS_EXPECTED 1
-
struct private_inferior;
/* Inferior process specific part of `struct infcall_control_state'.
--- /dev/null
+/* Fork a Unix child process, and set up to debug it, for GDB and GDBserver.
+
+ Copyright (C) 1990-2017 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/>. */
+
+#include "common-defs.h"
+#include "fork-inferior.h"
+#include "target/waitstatus.h"
+#include "filestuff.h"
+#include "target/target.h"
+#include "common-inferior.h"
+#include "common-gdbthread.h"
+#include "signals-state-save-restore.h"
+#include <vector>
+
+extern char **environ;
+
+/* Default shell file to be used if 'startup-with-shell' is set but
+ $SHELL is not. */
+#define SHELL_FILE "/bin/sh"
+
+/* Build the argument vector for execv(3). */
+
+class execv_argv
+{
+public:
+ /* EXEC_FILE is the file to run. ALLARGS is a string containing the
+ arguments to the program. If starting with a shell, SHELL_FILE
+ is the shell to run. Otherwise, SHELL_FILE is NULL. */
+ execv_argv (const char *exec_file, const std::string &allargs,
+ const char *shell_file);
+
+ /* Return a pointer to the built argv, in the type expected by
+ execv. The result is (only) valid for as long as this execv_argv
+ object is live. We return a "char **" because that's the type
+ that the execv functions expect. Note that it is guaranteed that
+ the execv functions do not modify the argv[] array nor the
+ strings to which the array point. */
+ char **argv ()
+ {
+ return const_cast<char **> (&m_argv[0]);
+ }
+
+private:
+ /* Disable copying. */
+ execv_argv (const execv_argv &) = delete;
+ void operator= (const execv_argv &) = delete;
+
+ /* Helper methods for constructing the argument vector. */
+
+ /* Used when building an argv for a straight execv call, without
+ going via the shell. */
+ void init_for_no_shell (const char *exec_file,
+ const std::string &allargs);
+
+ /* Used when building an argv for execing a shell that execs the
+ child program. */
+ void init_for_shell (const char *exec_file,
+ const std::string &allargs,
+ const char *shell_file);
+
+ /* The argument vector built. Holds non-owning pointers. Elements
+ either point to the strings passed to the execv_argv ctor, or
+ inside M_STORAGE. */
+ std::vector<const char *> m_argv;
+
+ /* Storage. In the no-shell case, this contains a copy of the
+ arguments passed to the ctor, split by '\0'. In the shell case,
+ this contains the quoted shell command. I.e., SHELL_COMMAND in
+ {"$SHELL" "-c", SHELL_COMMAND, NULL}. */
+ std::string m_storage;
+};
+
+/* Create argument vector for straight call to execvp. Breaks up
+ ALLARGS into an argument vector suitable for passing to execvp and
+ stores it in M_ARGV. E.g., on "run a b c d" this routine would get
+ as input the string "a b c d", and as output it would fill in
+ M_ARGV with the four arguments "a", "b", "c", "d". Each argument
+ in M_ARGV points to a substring of a copy of ALLARGS stored in
+ M_STORAGE. */
+
+void
+execv_argv::init_for_no_shell (const char *exec_file,
+ const std::string &allargs)
+{
+
+ /* Save/work with a copy stored in our storage. The pointers pushed
+ to M_ARGV point directly into M_STORAGE, which is modified in
+ place with the necessary NULL terminators. This avoids N heap
+ allocations and string dups when 1 is sufficient. */
+ std::string &args_copy = m_storage = allargs;
+
+ m_argv.push_back (exec_file);
+
+ for (size_t cur_pos = 0; cur_pos < args_copy.size ();)
+ {
+ /* Skip whitespace-like chars. */
+ std::size_t pos = args_copy.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 = args_copy.find_first_of (" \t\n", cur_pos);
+
+ if (next_sep == std::string::npos)
+ {
+ /* No separator found, which means this is the last
+ argument. */
+ next_sep = args_copy.size ();
+ }
+ else
+ {
+ /* Replace the separator with a terminator. */
+ args_copy[next_sep++] = '\0';
+ }
+
+ m_argv.push_back (&args_copy[cur_pos]);
+
+ cur_pos = next_sep;
+ }
+
+ /* NULL-terminate the vector. */
+ m_argv.push_back (NULL);
+}
+
+/* When executing a command under the given shell, return true if the
+ '!' character should be escaped when embedded in a quoted
+ command-line argument. */
+
+static bool
+escape_bang_in_quoted_argument (const char *shell_file)
+{
+ size_t shell_file_len = strlen (shell_file);
+
+ /* Bang should be escaped only in C Shells. For now, simply check
+ that the shell name ends with 'csh', which covers at least csh
+ and tcsh. This should be good enough for now. */
+
+ if (shell_file_len < 3)
+ return false;
+
+ if (shell_file[shell_file_len - 3] == 'c'
+ && shell_file[shell_file_len - 2] == 's'
+ && shell_file[shell_file_len - 1] == 'h')
+ return true;
+
+ return false;
+}
+
+/* See declaration. */
+
+execv_argv::execv_argv (const char *exec_file,
+ const std::string &allargs,
+ const char *shell_file)
+{
+ if (shell_file == NULL)
+ init_for_no_shell (exec_file, allargs);
+ else
+ init_for_shell (exec_file, allargs, shell_file);
+}
+
+/* See declaration. */
+
+void
+execv_argv::init_for_shell (const char *exec_file,
+ const std::string &allargs,
+ const char *shell_file)
+{
+ const char *exec_wrapper = get_exec_wrapper ();
+
+ /* We're going to call a shell. */
+ bool escape_bang = escape_bang_in_quoted_argument (shell_file);
+
+ /* We need to build a new shell command string, and make argv point
+ to it. So build it in the storage. */
+ std::string &shell_command = m_storage;
+
+ shell_command = "exec ";
+
+ /* Add any exec wrapper. That may be a program name with arguments,
+ so the user must handle quoting. */
+ if (exec_wrapper != NULL)
+ {
+ shell_command += exec_wrapper;
+ shell_command += ' ';
+ }
+
+ /* Now add exec_file, quoting as necessary. */
+
+ /* Quoting in this style is said to work with all shells. But csh
+ on IRIX 4.0.1 can't deal with it. So we only quote it if we need
+ to. */
+ bool need_to_quote;
+ const char *p = exec_file;
+ while (1)
+ {
+ switch (*p)
+ {
+ case '\'':
+ case '!':
+ case '"':
+ case '(':
+ case ')':
+ case '$':
+ case '&':
+ case ';':
+ case '<':
+ case '>':
+ case ' ':
+ case '\n':
+ case '\t':
+ need_to_quote = true;
+ goto end_scan;
+
+ case '\0':
+ need_to_quote = false;
+ goto end_scan;
+
+ default:
+ break;
+ }
+ ++p;
+ }
+ end_scan:
+ if (need_to_quote)
+ {
+ shell_command += '\'';
+ for (p = exec_file; *p != '\0'; ++p)
+ {
+ if (*p == '\'')
+ shell_command += "'\\''";
+ else if (*p == '!' && escape_bang)
+ shell_command += "\\!";
+ else
+ shell_command += *p;
+ }
+ shell_command += '\'';
+ }
+ else
+ shell_command += exec_file;
+
+ shell_command += ' ' + allargs;
+
+ /* 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>". */
+ m_argv.reserve (4);
+ m_argv.push_back (shell_file);
+ m_argv.push_back ("-c");
+ m_argv.push_back (shell_command.c_str ());
+ m_argv.push_back (NULL);
+}
+
+/* Return the shell that must be used to startup the inferior. The
+ first attempt is the environment variable SHELL; if it is not set,
+ then we default to SHELL_FILE. */
+
+static const char *
+get_startup_shell ()
+{
+ static const char *ret;
+
+ ret = getenv ("SHELL");
+ if (ret == NULL)
+ ret = SHELL_FILE;
+
+ return ret;
+}
+
+/* See nat/fork-inferior.h. */
+
+pid_t
+fork_inferior (const char *exec_file_arg, const std::string &allargs,
+ char **env, void (*traceme_fun) (),
+ void (*init_trace_fun) (int), void (*pre_trace_fun) (),
+ const char *shell_file_arg,
+ void (*exec_fun)(const char *file, char * const *argv,
+ char * const *env))
+{
+ pid_t pid;
+ /* Set debug_fork then attach to the child while it sleeps, to debug. */
+ int debug_fork = 0;
+ const char *shell_file;
+ const char *exec_file;
+ char **save_our_env;
+ int i;
+ int save_errno;
+
+ /* If no exec file handed to us, get it from the exec-file command
+ -- with a good, common error message if none is specified. */
+ if (exec_file_arg == NULL)
+ exec_file = get_exec_file (1);
+ else
+ exec_file = exec_file_arg;
+
+ /* '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. */
+ if (startup_with_shell)
+ {
+ shell_file = shell_file_arg;
+
+ /* Figure out what shell to start up the user program under. */
+ if (shell_file == NULL)
+ shell_file = get_startup_shell ();
+
+ gdb_assert (shell_file != NULL);
+ }
+ else
+ shell_file = NULL;
+
+ /* Build the argument vector. */
+ execv_argv child_argv (exec_file, allargs, shell_file);
+
+ /* 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;
+
+ /* Perform any necessary actions regarding to TTY before the
+ fork/vfork call. */
+ prefork_hook (allargs.c_str ());
+
+ /* 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_out_err ();
+
+ /* If there's any initialization of the target layers that must
+ happen to prepare to handle the child we're about fork, do it
+ now... */
+ if (pre_trace_fun != NULL)
+ (*pre_trace_fun) ();
+
+ /* Create the child process. Since the child process is going to
+ exec(3) shortly afterwards, try to reduce the overhead by
+ calling vfork(2). However, if PRE_TRACE_FUN is non-null, it's
+ likely that this optimization won't work since there's too much
+ work to do between the vfork(2) and the exec(3). This is known
+ to be the case on ttrace(2)-based HP-UX, where some handshaking
+ between parent and child needs to happen between fork(2) and
+ exec(2). However, since the parent is suspended in the vforked
+ state, this doesn't work. Also note that the vfork(2) call might
+ actually be a call to fork(2) due to the fact that autoconf will
+ ``#define vfork fork'' on certain platforms. */
+#if !(defined(__UCLIBC__) && defined(HAS_NOMMU))
+ if (pre_trace_fun || debug_fork)
+ pid = fork ();
+ else
+#endif
+ pid = vfork ();
+
+ if (pid < 0)
+ perror_with_name (("vfork"));
+
+ if (pid == 0)
+ {
+ /* 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);
+
+ /* Execute any necessary post-fork actions before we exec. */
+ postfork_child_hook ();
+
+ /* Changing the signal handlers for the inferior after
+ a vfork can also change them for the superior, so we don't mess
+ with signals here. See comments in
+ initialize_signals for how we get the right signal handlers
+ for the inferior. */
+
+ /* "Trace me, Dr. Memory!" */
+ (*traceme_fun) ();
+
+ /* The call above set this process (the "child") as debuggable
+ by the original gdb process (the "parent"). Since processes
+ (unlike people) can have only one parent, if you are debugging
+ gdb itself (and your debugger is thus _already_ the
+ controller/parent for this child), code from here on out is
+ undebuggable. Indeed, you probably got an error message
+ 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
+ in the parent. By the way, yes we do need to look down the
+ path to find $SHELL. Rich Pixley says so, and I agree. */
+ environ = env;
+
+ char **argv = child_argv.argv ();
+
+ if (exec_fun != NULL)
+ (*exec_fun) (argv[0], &argv[0], env);
+ else
+ execvp (argv[0], &argv[0]);
+
+ /* If we get here, it's an error. */
+ save_errno = errno;
+ warning ("Cannot exec %s", argv[0]);
+
+ for (i = 1; argv[i] != NULL; i++)
+ warning (" %s", argv[i]);
+
+ warning ("Error: %s\n", safe_strerror (save_errno));
+
+ _exit (0177);
+ }
+
+ /* Restore our environment in case a vforked child clob'd it. */
+ environ = save_our_env;
+
+ postfork_hook (pid);
+
+ /* Now that we have a child process, make it our target, and
+ initialize anything target-vector-specific that needs
+ initializing. */
+ if (init_trace_fun)
+ (*init_trace_fun) (pid);
+
+ /* We are now in the child process of interest, having exec'd the
+ correct program, and are poised at the first instruction of the
+ new program. */
+ return pid;
+}
+
+/* See nat/fork-inferior.h. */
+
+ptid_t
+startup_inferior (pid_t pid, int ntraps,
+ struct target_waitstatus *last_waitstatus,
+ ptid_t *last_ptid)
+{
+ int pending_execs = ntraps;
+ 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 (pid);
+ else
+ resume_ptid = minus_one_ptid;
+
+ /* The process was started by the fork that created it, but it will
+ have stopped one instruction after execing the shell. Here we
+ must get it up to actual execution of the real program. */
+ if (get_exec_wrapper () != NULL)
+ pending_execs++;
+
+ while (1)
+ {
+ enum gdb_signal resume_signal = GDB_SIGNAL_0;
+ ptid_t event_ptid;
+
+ struct target_waitstatus ws;
+ memset (&ws, 0, sizeof (ws));
+ event_ptid = target_wait (resume_ptid, &ws, 0);
+
+ if (last_waitstatus != NULL)
+ *last_waitstatus = ws;
+ if (last_ptid != NULL)
+ *last_ptid = event_ptid;
+
+ if (ws.kind == TARGET_WAITKIND_IGNORE)
+ /* The inferior didn't really stop, keep waiting. */
+ continue;
+
+ switch (ws.kind)
+ {
+ case TARGET_WAITKIND_SPURIOUS:
+ case TARGET_WAITKIND_LOADED:
+ case TARGET_WAITKIND_FORKED:
+ case TARGET_WAITKIND_VFORKED:
+ case TARGET_WAITKIND_SYSCALL_ENTRY:
+ case TARGET_WAITKIND_SYSCALL_RETURN:
+ /* Ignore gracefully during startup of the inferior. */
+ switch_to_thread (event_ptid);
+ break;
+
+ case TARGET_WAITKIND_SIGNALLED:
+ target_terminal_ours ();
+ target_mourn_inferior (event_ptid);
+ error (_("During startup program terminated with signal %s, %s."),
+ gdb_signal_to_name (ws.value.sig),
+ gdb_signal_to_string (ws.value.sig));
+ return resume_ptid;
+
+ case TARGET_WAITKIND_EXITED:
+ target_terminal_ours ();
+ target_mourn_inferior (event_ptid);
+ if (ws.value.integer)
+ error (_("During startup program exited with code %d."),
+ ws.value.integer);
+ else
+ error (_("During startup program exited normally."));
+ return resume_ptid;
+
+ case TARGET_WAITKIND_EXECD:
+ /* Handle EXEC signals as if they were SIGTRAP signals. */
+ xfree (ws.value.execd_pathname);
+ resume_signal = GDB_SIGNAL_TRAP;
+ switch_to_thread (event_ptid);
+ break;
+
+ case TARGET_WAITKIND_STOPPED:
+ resume_signal = ws.value.sig;
+ switch_to_thread (event_ptid);
+ break;
+ }
+
+ if (resume_signal != GDB_SIGNAL_TRAP)
+ {
+ /* Let shell child handle its own signals in its own way. */
+ target_continue (resume_ptid, resume_signal);
+ }
+ else
+ {
+ /* We handle SIGTRAP, however; it means child did an exec. */
+ if (!terminal_initted)
+ {
+ /* Now that the child has exec'd we know it has already
+ set its process group. On POSIX systems, tcsetpgrp
+ will fail with EPERM if we try it before the child's
+ setpgid. */
+
+ /* Set up the "saved terminal modes" of the inferior
+ based on what modes we are starting it with. */
+ target_terminal_init ();
+
+ /* Install inferior's terminal modes. */
+ target_terminal_inferior ();
+
+ terminal_initted = 1;
+ }
+
+ if (--pending_execs == 0)
+ break;
+
+ /* Just make it go on. */
+ target_continue_no_signal (resume_ptid);
+ }
+ }
+
+ return resume_ptid;
+}
+
+/* See nat/fork-inferior.h. */
+
+void
+trace_start_error (const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start (ap, fmt);
+ warning ("Could not trace the inferior process.\nError: ");
+ vwarning (fmt, ap);
+ va_end (ap);
+
+ gdb_flush_out_err ();
+ _exit (0177);
+}
+
+/* See nat/fork-inferior.h. */
+
+void
+trace_start_error_with_name (const char *string)
+{
+ trace_start_error ("%s: %s", string, safe_strerror (errno));
+}
--- /dev/null
+/* Functions and data responsible for forking the inferior process.
+
+ Copyright (C) 1986-2017 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/>. */
+
+#ifndef FORK_INFERIOR_H
+#define FORK_INFERIOR_H
+
+#include <string>
+
+/* Number of traps that happen between exec'ing the shell to run an
+ inferior and when we finally get to the inferior code, not counting
+ the exec for the shell. This is 1 on all supported
+ implementations. */
+#define START_INFERIOR_TRAPS_EXPECTED 1
+
+/* 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. */
+extern pid_t fork_inferior (const char *exec_file_arg,
+ const std::string &allargs,
+ char **env, void (*traceme_fun) (),
+ void (*init_trace_fun) (int),
+ void (*pre_trace_fun) (),
+ const char *shell_file_arg,
+ void (*exec_fun) (const char *file,
+ char * const *argv,
+ char * const *env));
+
+/* Accept NTRAPS traps from the inferior.
+
+ Return the ptid of the inferior being started. */
+extern ptid_t startup_inferior (pid_t pid, int ntraps,
+ struct target_waitstatus *mystatus,
+ ptid_t *myptid);
+
+/* Whether to start up the debuggee under a shell.
+
+ If startup-with-shell is set, GDB's "run" will attempt to start up
+ the debuggee under a shell. This also happens when using GDBserver
+ under extended remote mode.
+
+ This is in order for argument-expansion to occur. E.g.,
+
+ (gdb) run *
+
+ The "*" gets expanded by the shell into a list of files.
+
+ While this is a nice feature, it may be handy to bypass the shell
+ in some cases. To disable this feature, do "set startup-with-shell
+ false".
+
+ The catch-exec traps expected during start-up will be one more if
+ the target is started up with a shell. */
+extern int startup_with_shell;
+
+/* Perform any necessary tasks before a fork/vfork takes place. ARGS
+ is a string containing all the arguments received by the inferior.
+ This function is mainly used by fork_inferior. */
+extern void prefork_hook (const char *args);
+
+/* Perform any necessary tasks after a fork/vfork takes place. This
+ function is mainly used by fork_inferior. */
+extern void postfork_hook (pid_t pid);
+
+/* Perform any necessary tasks *on the child* after a fork/vfork takes
+ place. This function is mainly used by fork_inferior. */
+extern void postfork_child_hook ();
+
+/* Flush both stdout and stderr. This function needs to be
+ implemented differently on GDB and GDBserver. */
+extern void gdb_flush_out_err ();
+
+/* Report an error that happened when starting to trace the inferior
+ (i.e., when the "traceme_fun" callback is called on fork_inferior)
+ and bail out. This function does not return. */
+extern void trace_start_error (const char *fmt, ...)
+ ATTRIBUTE_NORETURN;
+
+/* Like "trace_start_error", but the error message is constructed by
+ combining STRING with the system error message for errno. This
+ function does not return. */
+extern void trace_start_error_with_name (const char *string)
+ ATTRIBUTE_NORETURN;
+
+#endif /* ! FORK_INFERIOR_H */
thread_change_ptid (pid_to_ptid (pid),
ptid_build (pid, lwpid, 0));
- startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
+ gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
#ifdef SYS_syssgi
/* On mips-irix, we need to stop the inferior early enough during
pid = fork_inferior (exec_file, allargs, env, procfs_set_exec_trap,
NULL, NULL, shell_file, NULL);
+ /* We have something that executes now. We'll be running through
+ the shell at this point (if startup-with-shell is true), but the
+ pid shouldn't change. */
+ add_thread_silent (pid_to_ptid (pid));
+
procfs_init_inferior (ops, pid);
}
extern int target_terminal_is_ours (void);
-/* Initialize the terminal settings we record for the inferior,
- before we actually run the inferior. */
-
-extern void target_terminal_init (void);
-
-/* 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);
+/* For target_terminal_init, target_terminal_inferior and
+ target_terminal_ours, see target/target.h. */
/* 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
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. This is
- a no-op unless called with the main UI as current UI. */
-
-extern void target_terminal_ours (void);
-
/* Return true if the target stack has a non-default
"to_terminal_ours" method. */
extern int target_supports_multi_process (void);
+/* Initialize the terminal settings we record for the inferior,
+ before we actually run the inferior. */
+extern void target_terminal_init ();
+
+/* 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 ();
+
+/* 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 ();
+
#endif /* TARGET_COMMON_H */
+2017-06-07 Sergio Durigan Junior <sergiodj@redhat.com>
+
+ * gdb.server/non-existing-program.exp: Update regex in order to
+ reflect the fact that gdbserver is now using fork_inferior (with a
+ shell) to startup the inferior.
+
2017-05-30 Simon Marchi <simon.marchi@ericsson.com>
* gdb.base/watch-cond-infcall.exp: Don't run if target doesn't
set msg "gdbserver exits cleanly"
set saw_exiting 0
expect {
- # This is what we get on ptrace-based targets.
- -re "stdin/stdout redirected.*No program to debug\r\nExiting\r\n$" {
+ # This is what we get on ptrace-based targets with
+ # startup-with-shell disabled (e.g., when the SHELL variable is
+ # unset).
+ -re "stdin/stdout redirected.*gdbserver: Cannot exec non-existing-program\r\ngdbserver: Error: No such file or directory\r\n\r\nDuring startup program exited with code 127\.\r\nExiting\r\n$" {
+ set saw_exiting 1
+ exp_continue
+ }
+ # Likewise, but with startup-with-shell enabled, which is the
+ # default behaviour.
+ -re "stdin/stdout redirected.*exec: non-existing-program: not found\r\nDuring startup program exited with code 127\.\r\nExiting\r\n$" {
set saw_exiting 1
exp_continue
}
projects / binutils-gdb.git / commitdiff