1999-04-16 01:35:26 +00:00
|
|
|
/* Fork a Unix child process, and set up to debug it, for GDB.
|
2004-09-30 20:15:39 +00:00
|
|
|
|
2005-12-17 22:34:03 +00:00
|
|
|
Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999,
|
2006-01-24 22:34:34 +00:00
|
|
|
2000, 2001, 2004, 2005, 2006 Free Software Foundation, Inc.
|
2004-09-30 20:15:39 +00:00
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
Contributed by Cygnus Support.
|
|
|
|
|
1999-07-07 20:19:36 +00:00
|
|
|
This file is part of GDB.
|
1999-04-16 01:35:26 +00:00
|
|
|
|
1999-07-07 20:19:36 +00:00
|
|
|
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 2 of the License, or
|
|
|
|
(at your option) any later version.
|
1999-04-16 01:35:26 +00:00
|
|
|
|
1999-07-07 20:19:36 +00:00
|
|
|
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.
|
1999-04-16 01:35:26 +00:00
|
|
|
|
1999-07-07 20:19:36 +00:00
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program; if not, write to the Free Software
|
2005-12-17 22:34:03 +00:00
|
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
|
|
Boston, MA 02110-1301, USA. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
#include "defs.h"
|
|
|
|
#include "gdb_string.h"
|
|
|
|
#include "frame.h" /* required by inferior.h */
|
|
|
|
#include "inferior.h"
|
|
|
|
#include "target.h"
|
2000-02-09 08:52:47 +00:00
|
|
|
#include "gdb_wait.h"
|
2001-01-31 02:08:23 +00:00
|
|
|
#include "gdb_vfork.h"
|
1999-04-16 01:35:26 +00:00
|
|
|
#include "gdbcore.h"
|
|
|
|
#include "terminal.h"
|
|
|
|
#include "gdbthread.h"
|
1999-12-07 03:56:43 +00:00
|
|
|
#include "command.h" /* for dont_repeat () */
|
* solib.h (CLEAR_SOLIB, SOLIB_ADD)
(SOLIB_CREATE_INFERIOR_HOOK, SOLIB_REMOVE_INFERIOR_HOOK)
(SOLIB_IN_DYNAMIC_LINKER, SOLIB_RESTART)
(DISABLE_UNSETTABLE_BREAK, PC_SOLIB)
(IN_SOLIB_DYNSYM_RESOLVE_CODE): Remove defines and orphaned
comments.
* breakpoint.c: Include "solib.h".
(insert_bp_location) [!DISABLE_UNSETTABLE_BREAK]: Call
solib_address.
(remove_solib_event_breakpoints, create_solib_event_breakpoint)
(disable_breakpoints_in_shlibs)
(disable_breakpoints_in_unloaded_shlib)
(re_enable_breakpoints_in_shlibs): Compile if SOLIB_ADD isn't
defined. If PC_SOLIB isn't defined, call solib_address.
(_initialize_breakpoint): Unconditionally install observer.
* corelow.c: Include "solib.h".
[SOLIB_ADD] (solib_add_stub): Remove prototype.
(core_close) [!CLEAR_SOLIB]: Call clear_solib.
(solib_add_stub) [!SOLIB_ADD] Call solib_add.
(core_open): Unconditionally call solib_add_stub.
* fork-child.c: Include "solib.h".
(fork_inferior) [!SOLIB_CREATE_INFERIOR_HOOK]: Call
solib_create_inferior_hook.
* infcmd.c: Include "solib.h".
(attach_command) [!SOLIB_ADD]: Call shlib_rescan. Unconditionally
call re_enable_breakpoints_in_shlibs.
* infrun.c: Include "solib.h".
(SOLIB_IN_SYNSYM_RESOLVE_CODE): Don't define if not already
defined.
(stop_on_solib_events, show_stop_on_solib_events): Include
unconditionally.
(follow_exec) [!SOLIB_CREATE_INFERIOR_HOOK]: Call
solib_create_inferior_hook.
(handle_inferior_event) [!SOLIB_ADD]: Call shlib_add.
[!IN_SOLIB_DYNSYM_RESOLVE_CODE]: Call in_solib_dynsym_resolve_code.
(_initialize_infrun): Unconditionally add "stop_on_solib-events"
command.
* remote.c: Include "solib.h".
(remote_open_1): Unconditionally call no_shared_libraries.
[!SOLIB_CREATE_INFERIOR_HOOK] Call solib_create_inferior_hook.
* stack.c: Include "solib.h".
(print_frame) [!PC_SOLIB] Call shlib_for_pc.
* xcoffsolib.c (no_shared_libraries): Remove function.
* Makefile.in (SFILES): Add solib.c.
(ALLDEPFILES): Remove solib.c.
(COMMON_OBS): Add solib.o.
(breakpoint.o, corelow.o, fork-chiled.o, infcmd.o, infrun.o)
(remote.o, stack.o): Update dependencies.
2005-05-12 20:21:18 +00:00
|
|
|
#include "solib.h"
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
#include <signal.h>
|
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* This just gets used as a default if we can't find SHELL. */
|
1999-04-16 01:35:26 +00:00
|
|
|
#ifndef SHELL_FILE
|
|
|
|
#define SHELL_FILE "/bin/sh"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
extern char **environ;
|
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* Break up SCRATCH into an argument vector suitable for passing to
|
|
|
|
execvp and store it in 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 ARGV with the four arguments "a", "b", "c", "d". */
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
static void
|
2000-07-30 01:48:28 +00:00
|
|
|
breakup_args (char *scratch, char **argv)
|
1999-04-16 01:35:26 +00:00
|
|
|
{
|
|
|
|
char *cp = scratch;
|
|
|
|
|
|
|
|
for (;;)
|
|
|
|
{
|
|
|
|
/* Scan past leading separators */
|
|
|
|
while (*cp == ' ' || *cp == '\t' || *cp == '\n')
|
2004-09-30 20:15:39 +00:00
|
|
|
cp++;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* Break if at end of string. */
|
1999-04-16 01:35:26 +00:00
|
|
|
if (*cp == '\0')
|
|
|
|
break;
|
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* Take an arg. */
|
1999-04-16 01:35:26 +00:00
|
|
|
*argv++ = cp;
|
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* Scan for next arg separator. */
|
1999-04-16 01:35:26 +00:00
|
|
|
cp = strchr (cp, ' ');
|
|
|
|
if (cp == NULL)
|
|
|
|
cp = strchr (cp, '\t');
|
|
|
|
if (cp == NULL)
|
|
|
|
cp = strchr (cp, '\n');
|
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* No separators => end of string => break. */
|
1999-04-16 01:35:26 +00:00
|
|
|
if (cp == NULL)
|
|
|
|
break;
|
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* Replace the separator with a terminator. */
|
1999-04-16 01:35:26 +00:00
|
|
|
*cp++ = '\0';
|
|
|
|
}
|
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* Null-terminate the vector. */
|
1999-04-16 01:35:26 +00:00
|
|
|
*argv = NULL;
|
|
|
|
}
|
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* When executing a command under the given shell, return non-zero if
|
|
|
|
the '!' character should be escaped when embedded in a quoted
|
2003-05-08 18:08:57 +00:00
|
|
|
command-line argument. */
|
|
|
|
|
|
|
|
static int
|
|
|
|
escape_bang_in_quoted_argument (const char *shell_file)
|
|
|
|
{
|
|
|
|
const int shell_file_len = strlen (shell_file);
|
2004-09-30 20:15:39 +00:00
|
|
|
|
2003-05-08 18:08:57 +00:00
|
|
|
/* 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 0;
|
|
|
|
|
|
|
|
if (shell_file[shell_file_len - 3] == 'c'
|
|
|
|
&& shell_file[shell_file_len - 2] == 's'
|
|
|
|
&& shell_file[shell_file_len - 1] == 'h')
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
1999-04-16 01:35:26 +00:00
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* 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. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* This function is NOT reentrant. Some of the variables have been
|
|
|
|
made static to ensure that they survive the vfork call. */
|
2001-03-23 22:48:44 +00:00
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
void
|
2001-03-23 22:48:44 +00:00
|
|
|
fork_inferior (char *exec_file_arg, char *allargs, char **env,
|
2000-08-23 16:37:23 +00:00
|
|
|
void (*traceme_fun) (void), void (*init_trace_fun) (int),
|
2001-03-23 22:48:44 +00:00
|
|
|
void (*pre_trace_fun) (void), char *shell_file_arg)
|
1999-04-16 01:35:26 +00:00
|
|
|
{
|
|
|
|
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. */
|
|
|
|
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;
|
2001-03-23 22:48:44 +00:00
|
|
|
static char *shell_file;
|
|
|
|
static char *exec_file;
|
1999-04-16 01:35:26 +00:00
|
|
|
char **save_our_env;
|
|
|
|
int shell = 0;
|
2001-03-23 22:48:44 +00:00
|
|
|
static char **argv;
|
2005-07-06 14:54:37 +00:00
|
|
|
const char *inferior_io_terminal = get_inferior_io_terminal ();
|
1999-04-16 01:35:26 +00:00
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* If no exec file handed to us, get it from the exec-file command
|
|
|
|
-- with a good, common error message if none is specified. */
|
2001-03-23 22:48:44 +00:00
|
|
|
exec_file = exec_file_arg;
|
1999-04-16 01:35:26 +00:00
|
|
|
if (exec_file == 0)
|
|
|
|
exec_file = get_exec_file (1);
|
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* 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. */
|
2001-03-23 22:48:44 +00:00
|
|
|
shell_file = shell_file_arg;
|
1999-04-16 01:35:26 +00:00
|
|
|
if (STARTUP_WITH_SHELL)
|
|
|
|
{
|
2004-09-30 20:15:39 +00:00
|
|
|
/* Figure out what shell to start up the user program under. */
|
1999-04-16 01:35:26 +00:00
|
|
|
if (shell_file == NULL)
|
|
|
|
shell_file = getenv ("SHELL");
|
|
|
|
if (shell_file == NULL)
|
|
|
|
shell_file = default_shell_file;
|
|
|
|
shell = 1;
|
|
|
|
}
|
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* 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 '. */
|
1999-07-07 20:19:36 +00:00
|
|
|
len = 5 + 4 * strlen (exec_file) + 1 + strlen (allargs) + 1 + /*slop */ 12;
|
1999-04-16 01:35:26 +00:00
|
|
|
/* If desired, concat something onto the front of ALLARGS.
|
|
|
|
SHELL_COMMAND is the result. */
|
|
|
|
#ifdef SHELL_COMMAND_CONCAT
|
|
|
|
shell_command = (char *) alloca (strlen (SHELL_COMMAND_CONCAT) + len);
|
|
|
|
strcpy (shell_command, SHELL_COMMAND_CONCAT);
|
|
|
|
#else
|
|
|
|
shell_command = (char *) alloca (len);
|
|
|
|
shell_command[0] = '\0';
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (!shell)
|
|
|
|
{
|
2004-09-30 20:15:39 +00:00
|
|
|
/* 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));
|
1999-04-16 01:35:26 +00:00
|
|
|
argv[0] = exec_file;
|
|
|
|
breakup_args (allargs, &argv[1]);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2004-09-30 20:15:39 +00:00
|
|
|
/* We're going to call a shell. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
/* Now add exec_file, quoting as necessary. */
|
|
|
|
|
|
|
|
char *p;
|
|
|
|
int need_to_quote;
|
2003-05-08 18:08:57 +00:00
|
|
|
const int escape_bang = escape_bang_in_quoted_argument (shell_file);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
strcat (shell_command, "exec ");
|
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* 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. */
|
1999-04-16 01:35:26 +00:00
|
|
|
p = exec_file;
|
|
|
|
while (1)
|
|
|
|
{
|
|
|
|
switch (*p)
|
|
|
|
{
|
|
|
|
case '\'':
|
2002-02-07 06:11:55 +00:00
|
|
|
case '!':
|
1999-04-16 01:35:26 +00:00
|
|
|
case '"':
|
|
|
|
case '(':
|
|
|
|
case ')':
|
|
|
|
case '$':
|
|
|
|
case '&':
|
|
|
|
case ';':
|
|
|
|
case '<':
|
|
|
|
case '>':
|
|
|
|
case ' ':
|
|
|
|
case '\n':
|
|
|
|
case '\t':
|
|
|
|
need_to_quote = 1;
|
|
|
|
goto end_scan;
|
|
|
|
|
|
|
|
case '\0':
|
|
|
|
need_to_quote = 0;
|
|
|
|
goto end_scan;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
++p;
|
|
|
|
}
|
|
|
|
end_scan:
|
|
|
|
if (need_to_quote)
|
|
|
|
{
|
|
|
|
strcat (shell_command, "'");
|
|
|
|
for (p = exec_file; *p != '\0'; ++p)
|
|
|
|
{
|
|
|
|
if (*p == '\'')
|
|
|
|
strcat (shell_command, "'\\''");
|
2003-05-08 18:08:57 +00:00
|
|
|
else if (*p == '!' && escape_bang)
|
2002-02-07 06:11:55 +00:00
|
|
|
strcat (shell_command, "\\!");
|
1999-04-16 01:35:26 +00:00
|
|
|
else
|
|
|
|
strncat (shell_command, p, 1);
|
|
|
|
}
|
|
|
|
strcat (shell_command, "'");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
strcat (shell_command, exec_file);
|
|
|
|
|
|
|
|
strcat (shell_command, " ");
|
|
|
|
strcat (shell_command, allargs);
|
|
|
|
}
|
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* On some systems an exec will fail if the executable is open. */
|
1999-04-16 01:35:26 +00:00
|
|
|
close_exec_file ();
|
|
|
|
|
|
|
|
/* Retain a copy of our environment variables, since the child will
|
2004-09-30 20:15:39 +00:00
|
|
|
replace the value of environ and if we're vforked, we have to
|
1999-04-16 01:35:26 +00:00
|
|
|
restore it. */
|
|
|
|
save_our_env = environ;
|
|
|
|
|
|
|
|
/* 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
|
2004-09-30 20:15:39 +00:00
|
|
|
output prior to doing a fork, to avoid the possibility of both
|
|
|
|
the parent and child flushing the same data after the fork. */
|
1999-04-16 01:35:26 +00:00
|
|
|
gdb_flush (gdb_stdout);
|
|
|
|
gdb_flush (gdb_stderr);
|
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* 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... */
|
1999-04-16 01:35:26 +00:00
|
|
|
if (pre_trace_fun != NULL)
|
|
|
|
(*pre_trace_fun) ();
|
|
|
|
|
2004-11-29 08:37:14 +00:00
|
|
|
/* Create the child process. Since the child process is going to
|
|
|
|
exec(3) shortlty 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)
|
1999-04-16 01:35:26 +00:00
|
|
|
pid = fork ();
|
|
|
|
else
|
|
|
|
pid = vfork ();
|
|
|
|
|
|
|
|
if (pid < 0)
|
2005-02-11 Andrew Cagney <cagney@gnu.org>
Mark up error_no_arg, query, perror_with_name, complaint, and
internal_error.
* breakpoint.c, cp-abi.c, cp-namespace.c, cp-support.c: Update.
* cris-tdep.c, dbxread.c, dictionary.c, dsrec.c: Update.
* dummy-frame.c, dve3900-rom.c, dwarf2-frame.c, dwarf2expr.c: Update.
* dwarf2read.c, dwarfread.c, elfread.c, event-loop.c: Update.
* exceptions.c, exec.c, f-lang.c, findvar.c, fork-child.c: Update.
* frame-unwind.c, frame.c, frv-linux-tdep.c, frv-tdep.c: Update.
* gdb_assert.h, gdbarch.c, gdbtypes.c, gnu-nat.c: Update.
* go32-nat.c, hppa-tdep.c, hppabsd-nat.c, hpread.c: Update.
* i386-linux-nat.c, i386-nat.c, i386-tdep.c, i386bsd-nat.c: Update.
* i386fbsd-nat.c, inf-ptrace.c, inf-ttrace.c, infcall.c: Update.
* infcmd.c, inflow.c, infptrace.c, infrun.c, inftarg.c: Update.
* interps.c, language.c, linespec.c, linux-nat.c: Update.
* m32r-linux-nat.c, m68k-tdep.c, m68kbsd-nat.c: Update.
* m68klinux-nat.c, m88kbsd-nat.c, macroexp.c, macroscope.c: Update.
* macrotab.c, maint.c, mdebugread.c, memattr.c: Update.
* mips-linux-tdep.c, mips-tdep.c, mips64obsd-nat.c: Update.
* mipsnbsd-nat.c, mn10300-tdep.c, monitor.c, nto-procfs.c: Update.
* objc-lang.c, objfiles.c, objfiles.h, ocd.c, osabi.c: Update.
* parse.c, ppc-bdm.c, ppc-linux-nat.c, ppc-sysv-tdep.c: Update.
* ppcnbsd-nat.c, ppcobsd-nat.c, printcmd.c, procfs.c: Update.
* regcache.c, reggroups.c, remote-e7000.c, remote-mips.c: Update.
* remote-rdp.c, remote-sds.c, remote-sim.c, remote-st.c: Update.
* remote-utils.c, remote.c, rs6000-nat.c, rs6000-tdep.c: Update.
* s390-nat.c, s390-tdep.c, sentinel-frame.c, serial.c: Update.
* sh-tdep.c, sh3-rom.c, sh64-tdep.c, shnbsd-nat.c: Update.
* solib-aix5.c, solib-svr4.c, solib.c, source.c: Update.
* sparc-nat.c, stabsread.c, stack.c, symfile.c, symtab.c: Update.
* symtab.h, target.c, tracepoint.c, ui-file.c, ui-out.c: Update.
* utils.c, valops.c, valprint.c, vax-nat.c, vaxbsd-nat.c: Update.
* win32-nat.c, xcoffread.c, xstormy16-tdep.c: Update.
* cli/cli-cmds.c, cli/cli-logging.c, cli/cli-script.c: Update.
* cli/cli-setshow.c, mi/mi-cmd-break.c, mi/mi-cmds.c: Update.
* mi/mi-console.c, mi/mi-getopt.c, mi/mi-out.c: Update.
* tui/tui-file.c, tui/tui-interp.c: Update.
2005-02-11 18:13:55 +00:00
|
|
|
perror_with_name (("vfork"));
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
if (pid == 0)
|
|
|
|
{
|
|
|
|
if (debug_fork)
|
|
|
|
sleep (debug_fork);
|
|
|
|
|
|
|
|
/* Run inferior in a separate process group. */
|
|
|
|
debug_setpgrp = gdb_setpgid ();
|
|
|
|
if (debug_setpgrp == -1)
|
|
|
|
perror ("setpgrp failed in child");
|
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* Ask the tty subsystem to switch to the one we specified
|
|
|
|
earlier (or to share the current terminal, if none was
|
|
|
|
specified). */
|
1999-04-16 01:35:26 +00:00
|
|
|
new_tty ();
|
|
|
|
|
|
|
|
/* Changing the signal handlers for the inferior after
|
1999-07-07 20:19:36 +00:00
|
|
|
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. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
/* "Trace me, Dr. Memory!" */
|
|
|
|
(*traceme_fun) ();
|
2004-09-30 20:15:39 +00:00
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
/* The call above set this process (the "child") as debuggable
|
2004-09-30 20:15:39 +00:00
|
|
|
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! */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
/* There is no execlpe call, so we have to set the environment
|
1999-07-07 20:19:36 +00:00
|
|
|
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. */
|
1999-04-16 01:35:26 +00:00
|
|
|
environ = env;
|
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* 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>". "-f" means "fast startup" to the c-shell, which
|
|
|
|
means don't do .cshrc file. Doing .cshrc may cause fork/exec
|
|
|
|
events which will confuse debugger start-up code. */
|
1999-04-16 01:35:26 +00:00
|
|
|
if (shell)
|
|
|
|
{
|
|
|
|
execlp (shell_file, shell_file, "-c", shell_command, (char *) 0);
|
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* If we get here, it's an error. */
|
1999-04-16 01:35:26 +00:00
|
|
|
fprintf_unfiltered (gdb_stderr, "Cannot exec %s: %s.\n", shell_file,
|
|
|
|
safe_strerror (errno));
|
|
|
|
gdb_flush (gdb_stderr);
|
|
|
|
_exit (0177);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2004-09-30 20:15:39 +00:00
|
|
|
/* Otherwise, we directly exec the target program with
|
|
|
|
execvp. */
|
1999-04-16 01:35:26 +00:00
|
|
|
int i;
|
|
|
|
char *errstring;
|
1999-06-07 19:19:32 +00:00
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
execvp (exec_file, argv);
|
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* If we get here, it's an error. */
|
1999-04-16 01:35:26 +00:00
|
|
|
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");
|
2004-09-30 20:15:39 +00:00
|
|
|
#if 0
|
|
|
|
/* This extra info seems to be useless. */
|
|
|
|
fprintf_unfiltered (gdb_stderr, "Got error %s.\n", errstring);
|
|
|
|
#endif
|
1999-04-16 01:35:26 +00:00
|
|
|
gdb_flush (gdb_stderr);
|
|
|
|
_exit (0177);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Restore our environment in case a vforked child clob'd it. */
|
|
|
|
environ = save_our_env;
|
|
|
|
|
|
|
|
init_thread_list ();
|
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* Needed for wait_for_inferior stuff below. */
|
|
|
|
inferior_ptid = pid_to_ptid (pid);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
/* Now that we have a child process, make it our target, and
|
2004-09-30 20:15:39 +00:00
|
|
|
initialize anything target-vector-specific that needs
|
|
|
|
initializing. */
|
1999-04-16 01:35:26 +00:00
|
|
|
(*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. */
|
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* Allow target dependent code to play with the new process. This
|
|
|
|
might be used to have target-specific code initialize a variable
|
|
|
|
in the new process prior to executing the first instruction. */
|
1999-04-16 01:35:26 +00:00
|
|
|
TARGET_CREATE_INFERIOR_HOOK (pid);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Accept NTRAPS traps from the inferior. */
|
|
|
|
|
|
|
|
void
|
2000-07-30 01:48:28 +00:00
|
|
|
startup_inferior (int ntraps)
|
1999-04-16 01:35:26 +00:00
|
|
|
{
|
|
|
|
int pending_execs = ntraps;
|
2004-09-30 20:15:39 +00:00
|
|
|
int terminal_initted = 0;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
/* 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. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
clear_proceed_status ();
|
|
|
|
|
|
|
|
init_wait_for_inferior ();
|
|
|
|
|
|
|
|
if (STARTUP_WITH_SHELL)
|
|
|
|
inferior_ignoring_startup_exec_events = ntraps;
|
|
|
|
else
|
|
|
|
inferior_ignoring_startup_exec_events = 0;
|
|
|
|
inferior_ignoring_leading_exec_events =
|
|
|
|
target_reported_exec_events_per_exec_call () - 1;
|
|
|
|
|
|
|
|
while (1)
|
|
|
|
{
|
2004-09-30 20:15:39 +00:00
|
|
|
/* Make wait_for_inferior be quiet. */
|
2003-04-08 19:21:15 +00:00
|
|
|
stop_soon = STOP_QUIETLY;
|
1999-04-16 01:35:26 +00:00
|
|
|
wait_for_inferior ();
|
|
|
|
if (stop_signal != TARGET_SIGNAL_TRAP)
|
|
|
|
{
|
2004-09-30 20:15:39 +00:00
|
|
|
/* Let shell child handle its own signals in its own way.
|
|
|
|
FIXME: what if child has exited? Must exit loop
|
|
|
|
somehow. */
|
1999-04-16 01:35:26 +00:00
|
|
|
resume (0, stop_signal);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* We handle SIGTRAP, however; it means child did an exec. */
|
|
|
|
if (!terminal_initted)
|
|
|
|
{
|
2004-09-30 20:15:39 +00:00
|
|
|
/* 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. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
/* Set up the "saved terminal modes" of the inferior
|
1999-07-07 20:19:36 +00:00
|
|
|
based on what modes we are starting it with. */
|
1999-04-16 01:35:26 +00:00
|
|
|
target_terminal_init ();
|
|
|
|
|
|
|
|
/* Install inferior's terminal modes. */
|
|
|
|
target_terminal_inferior ();
|
|
|
|
|
|
|
|
terminal_initted = 1;
|
|
|
|
}
|
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
if (--pending_execs == 0)
|
1999-04-16 01:35:26 +00:00
|
|
|
break;
|
|
|
|
|
2004-09-30 20:15:39 +00:00
|
|
|
resume (0, TARGET_SIGNAL_0); /* Just make it go on. */
|
1999-04-16 01:35:26 +00:00
|
|
|
}
|
|
|
|
}
|
2003-04-08 19:21:15 +00:00
|
|
|
stop_soon = NO_STOP_QUIETLY;
|
1999-04-16 01:35:26 +00:00
|
|
|
}
|