1 /* Fork a Unix child process, and set up to debug it, for GDB.
3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999,
4 2000, 2001, 2004 Free Software Foundation, Inc.
6 Contributed by Cygnus Support.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
26 #include "gdb_string.h"
27 #include "frame.h" /* required by inferior.h */
31 #include "gdb_vfork.h"
34 #include "gdbthread.h"
35 #include "command.h" /* for dont_repeat () */
40 /* This just gets used as a default if we can't find SHELL. */
42 #define SHELL_FILE "/bin/sh"
45 extern char **environ
;
47 /* Break up SCRATCH into an argument vector suitable for passing to
48 execvp and store it in ARGV. E.g., on "run a b c d" this routine
49 would get as input the string "a b c d", and as output it would
50 fill in ARGV with the four arguments "a", "b", "c", "d". */
53 breakup_args (char *scratch
, char **argv
)
59 /* Scan past leading separators */
60 while (*cp
== ' ' || *cp
== '\t' || *cp
== '\n')
63 /* Break if at end of string. */
70 /* Scan for next arg separator. */
71 cp
= strchr (cp
, ' ');
73 cp
= strchr (cp
, '\t');
75 cp
= strchr (cp
, '\n');
77 /* No separators => end of string => break. */
81 /* Replace the separator with a terminator. */
85 /* Null-terminate the vector. */
89 /* When executing a command under the given shell, return non-zero if
90 the '!' character should be escaped when embedded in a quoted
91 command-line argument. */
94 escape_bang_in_quoted_argument (const char *shell_file
)
96 const int shell_file_len
= strlen (shell_file
);
98 /* Bang should be escaped only in C Shells. For now, simply check
99 that the shell name ends with 'csh', which covers at least csh
100 and tcsh. This should be good enough for now. */
102 if (shell_file_len
< 3)
105 if (shell_file
[shell_file_len
- 3] == 'c'
106 && shell_file
[shell_file_len
- 2] == 's'
107 && shell_file
[shell_file_len
- 1] == 'h')
113 /* Start an inferior Unix child process and sets inferior_ptid to its
114 pid. EXEC_FILE is the file to run. ALLARGS is a string containing
115 the arguments to the program. ENV is the environment vector to
116 pass. SHELL_FILE is the shell file, or NULL if we should pick
119 /* This function is NOT reentrant. Some of the variables have been
120 made static to ensure that they survive the vfork call. */
123 fork_inferior (char *exec_file_arg
, char *allargs
, char **env
,
124 void (*traceme_fun
) (void), void (*init_trace_fun
) (int),
125 void (*pre_trace_fun
) (void), char *shell_file_arg
)
129 static char default_shell_file
[] = SHELL_FILE
;
131 /* Set debug_fork then attach to the child while it sleeps, to debug. */
132 static int debug_fork
= 0;
133 /* This is set to the result of setpgrp, which if vforked, will be visible
134 to you in the parent process. It's only used by humans for debugging. */
135 static int debug_setpgrp
= 657473;
136 static char *shell_file
;
137 static char *exec_file
;
142 /* If no exec file handed to us, get it from the exec-file command
143 -- with a good, common error message if none is specified. */
144 exec_file
= exec_file_arg
;
146 exec_file
= get_exec_file (1);
148 /* STARTUP_WITH_SHELL is defined in inferior.h. If 0,e we'll just
149 do a fork/exec, no shell, so don't bother figuring out what
151 shell_file
= shell_file_arg
;
152 if (STARTUP_WITH_SHELL
)
154 /* Figure out what shell to start up the user program under. */
155 if (shell_file
== NULL
)
156 shell_file
= getenv ("SHELL");
157 if (shell_file
== NULL
)
158 shell_file
= default_shell_file
;
162 /* Multiplying the length of exec_file by 4 is to account for the
163 fact that it may expand when quoted; it is a worst-case number
164 based on every character being '. */
165 len
= 5 + 4 * strlen (exec_file
) + 1 + strlen (allargs
) + 1 + /*slop */ 12;
166 /* If desired, concat something onto the front of ALLARGS.
167 SHELL_COMMAND is the result. */
168 #ifdef SHELL_COMMAND_CONCAT
169 shell_command
= (char *) alloca (strlen (SHELL_COMMAND_CONCAT
) + len
);
170 strcpy (shell_command
, SHELL_COMMAND_CONCAT
);
172 shell_command
= (char *) alloca (len
);
173 shell_command
[0] = '\0';
178 /* We're going to call execvp. Create argument vector.
179 Calculate an upper bound on the length of the vector by
180 assuming that every other character is a separate
182 int argc
= (strlen (allargs
) + 1) / 2 + 2;
183 argv
= (char **) xmalloc (argc
* sizeof (*argv
));
185 breakup_args (allargs
, &argv
[1]);
189 /* We're going to call a shell. */
191 /* Now add exec_file, quoting as necessary. */
195 const int escape_bang
= escape_bang_in_quoted_argument (shell_file
);
197 strcat (shell_command
, "exec ");
199 /* Quoting in this style is said to work with all shells. But
200 csh on IRIX 4.0.1 can't deal with it. So we only quote it if
235 strcat (shell_command
, "'");
236 for (p
= exec_file
; *p
!= '\0'; ++p
)
239 strcat (shell_command
, "'\\''");
240 else if (*p
== '!' && escape_bang
)
241 strcat (shell_command
, "\\!");
243 strncat (shell_command
, p
, 1);
245 strcat (shell_command
, "'");
248 strcat (shell_command
, exec_file
);
250 strcat (shell_command
, " ");
251 strcat (shell_command
, allargs
);
254 /* On some systems an exec will fail if the executable is open. */
257 /* Retain a copy of our environment variables, since the child will
258 replace the value of environ and if we're vforked, we have to
260 save_our_env
= environ
;
262 /* Tell the terminal handling subsystem what tty we plan to run on;
263 it will just record the information for later. */
264 new_tty_prefork (inferior_io_terminal
);
266 /* It is generally good practice to flush any possible pending stdio
267 output prior to doing a fork, to avoid the possibility of both
268 the parent and child flushing the same data after the fork. */
269 gdb_flush (gdb_stdout
);
270 gdb_flush (gdb_stderr
);
272 /* If there's any initialization of the target layers that must
273 happen to prepare to handle the child we're about fork, do it
275 if (pre_trace_fun
!= NULL
)
278 /* Create the child process. Since the child process is going to
279 exec(3) shortlty afterwards, try to reduce the overhead by
280 calling vfork(2). However, if PRE_TRACE_FUN is non-null, it's
281 likely that this optimization won't work since there's too much
282 work to do between the vfork(2) and the exec(3). This is known
283 to be the case on ttrace(2)-based HP-UX, where some handshaking
284 between parent and child needs to happen between fork(2) and
285 exec(2). However, since the parent is suspended in the vforked
286 state, this doesn't work. Also note that the vfork(2) call might
287 actually be a call to fork(2) due to the fact that autoconf will
288 ``#define vfork fork'' on certain platforms. */
289 if (pre_trace_fun
|| debug_fork
)
295 perror_with_name (("vfork"));
302 /* Run inferior in a separate process group. */
303 debug_setpgrp
= gdb_setpgid ();
304 if (debug_setpgrp
== -1)
305 perror ("setpgrp failed in child");
307 /* Ask the tty subsystem to switch to the one we specified
308 earlier (or to share the current terminal, if none was
312 /* Changing the signal handlers for the inferior after
313 a vfork can also change them for the superior, so we don't mess
314 with signals here. See comments in
315 initialize_signals for how we get the right signal handlers
318 /* "Trace me, Dr. Memory!" */
321 /* The call above set this process (the "child") as debuggable
322 by the original gdb process (the "parent"). Since processes
323 (unlike people) can have only one parent, if you are debugging
324 gdb itself (and your debugger is thus _already_ the
325 controller/parent for this child), code from here on out is
326 undebuggable. Indeed, you probably got an error message
327 saying "not parent". Sorry; you'll have to use print
330 /* There is no execlpe call, so we have to set the environment
331 for our child in the global variable. If we've vforked, this
332 clobbers the parent, but environ is restored a few lines down
333 in the parent. By the way, yes we do need to look down the
334 path to find $SHELL. Rich Pixley says so, and I agree. */
337 /* If we decided above to start up with a shell, we exec the
338 shell, "-c" says to interpret the next arg as a shell command
339 to execute, and this command is "exec <target-program>
340 <args>". "-f" means "fast startup" to the c-shell, which
341 means don't do .cshrc file. Doing .cshrc may cause fork/exec
342 events which will confuse debugger start-up code. */
345 execlp (shell_file
, shell_file
, "-c", shell_command
, (char *) 0);
347 /* If we get here, it's an error. */
348 fprintf_unfiltered (gdb_stderr
, "Cannot exec %s: %s.\n", shell_file
,
349 safe_strerror (errno
));
350 gdb_flush (gdb_stderr
);
355 /* Otherwise, we directly exec the target program with
360 execvp (exec_file
, argv
);
362 /* If we get here, it's an error. */
363 errstring
= safe_strerror (errno
);
364 fprintf_unfiltered (gdb_stderr
, "Cannot exec %s ", exec_file
);
367 while (argv
[i
] != NULL
)
370 fprintf_unfiltered (gdb_stderr
, " ");
371 fprintf_unfiltered (gdb_stderr
, "%s", argv
[i
]);
374 fprintf_unfiltered (gdb_stderr
, ".\n");
376 /* This extra info seems to be useless. */
377 fprintf_unfiltered (gdb_stderr
, "Got error %s.\n", errstring
);
379 gdb_flush (gdb_stderr
);
384 /* Restore our environment in case a vforked child clob'd it. */
385 environ
= save_our_env
;
389 /* Needed for wait_for_inferior stuff below. */
390 inferior_ptid
= pid_to_ptid (pid
);
392 /* Now that we have a child process, make it our target, and
393 initialize anything target-vector-specific that needs
395 (*init_trace_fun
) (pid
);
397 /* We are now in the child process of interest, having exec'd the
398 correct program, and are poised at the first instruction of the
401 /* Allow target dependent code to play with the new process. This
402 might be used to have target-specific code initialize a variable
403 in the new process prior to executing the first instruction. */
404 TARGET_CREATE_INFERIOR_HOOK (pid
);
406 #ifdef SOLIB_CREATE_INFERIOR_HOOK
407 SOLIB_CREATE_INFERIOR_HOOK (pid
);
409 solib_create_inferior_hook ();
413 /* Accept NTRAPS traps from the inferior. */
416 startup_inferior (int ntraps
)
418 int pending_execs
= ntraps
;
419 int terminal_initted
= 0;
421 /* The process was started by the fork that created it, but it will
422 have stopped one instruction after execing the shell. Here we
423 must get it up to actual execution of the real program. */
425 clear_proceed_status ();
427 init_wait_for_inferior ();
429 if (STARTUP_WITH_SHELL
)
430 inferior_ignoring_startup_exec_events
= ntraps
;
432 inferior_ignoring_startup_exec_events
= 0;
433 inferior_ignoring_leading_exec_events
=
434 target_reported_exec_events_per_exec_call () - 1;
438 /* Make wait_for_inferior be quiet. */
439 stop_soon
= STOP_QUIETLY
;
440 wait_for_inferior ();
441 if (stop_signal
!= TARGET_SIGNAL_TRAP
)
443 /* Let shell child handle its own signals in its own way.
444 FIXME: what if child has exited? Must exit loop
446 resume (0, stop_signal
);
450 /* We handle SIGTRAP, however; it means child did an exec. */
451 if (!terminal_initted
)
453 /* Now that the child has exec'd we know it has already
454 set its process group. On POSIX systems, tcsetpgrp
455 will fail with EPERM if we try it before the child's
458 /* Set up the "saved terminal modes" of the inferior
459 based on what modes we are starting it with. */
460 target_terminal_init ();
462 /* Install inferior's terminal modes. */
463 target_terminal_inferior ();
465 terminal_initted
= 1;
468 if (--pending_execs
== 0)
471 resume (0, TARGET_SIGNAL_0
); /* Just make it go on. */
474 stop_soon
= NO_STOP_QUIETLY
;