1 /* Fork a Unix child process, and set up to debug it, for GDB.
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
4 2001, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
5 Free Software Foundation, Inc.
7 Contributed by Cygnus Support.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "gdb_string.h"
30 #include "gdb_vfork.h"
33 #include "gdbthread.h"
34 #include "command.h" /* for dont_repeat () */
40 /* This just gets used as a default if we can't find SHELL. */
41 #define SHELL_FILE "/bin/sh"
43 extern char **environ;
45 static char *exec_wrapper;
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)
55 char *cp = scratch, *tmp;
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 tmp = strchr (cp, ' ');
73 tmp = strchr (cp, '\t');
75 tmp = strchr (cp, '\n');
77 /* No separators => end of string => break. */
82 /* Replace the separator with a terminator. */
86 /* Null-terminate the vector. */
90 /* When executing a command under the given shell, return non-zero if
91 the '!' character should be escaped when embedded in a quoted
92 command-line argument. */
95 escape_bang_in_quoted_argument (const char *shell_file)
97 const int shell_file_len = strlen (shell_file);
99 /* Bang should be escaped only in C Shells. For now, simply check
100 that the shell name ends with 'csh', which covers at least csh
101 and tcsh. This should be good enough for now. */
103 if (shell_file_len < 3)
106 if (shell_file[shell_file_len - 3] == 'c'
107 && shell_file[shell_file_len - 2] == 's'
108 && shell_file[shell_file_len - 1] == 'h')
114 /* Start an inferior Unix child process and sets inferior_ptid to its
115 pid. EXEC_FILE is the file to run. ALLARGS is a string containing
116 the arguments to the program. ENV is the environment vector to
117 pass. SHELL_FILE is the shell file, or NULL if we should pick
118 one. EXEC_FUN is the exec(2) function to use, or NULL for the default
121 /* This function is NOT reentrant. Some of the variables have been
122 made static to ensure that they survive the vfork call. */
125 fork_inferior (char *exec_file_arg, char *allargs, char **env,
126 void (*traceme_fun) (void), void (*init_trace_fun) (int),
127 void (*pre_trace_fun) (void), char *shell_file_arg,
128 void (*exec_fun)(const char *file, char * const *argv,
132 static char default_shell_file[] = SHELL_FILE;
133 /* Set debug_fork then attach to the child while it sleeps, to debug. */
134 static int debug_fork = 0;
135 /* This is set to the result of setpgrp, which if vforked, will be visible
136 to you in the parent process. It's only used by humans for debugging. */
137 static int debug_setpgrp = 657473;
138 static char *shell_file;
139 static char *exec_file;
143 const char *inferior_io_terminal = get_inferior_io_terminal ();
144 struct inferior *inf;
148 /* If no exec file handed to us, get it from the exec-file command
149 -- with a good, common error message if none is specified. */
150 exec_file = exec_file_arg;
152 exec_file = get_exec_file (1);
154 /* STARTUP_WITH_SHELL is defined in inferior.h. If 0,e we'll just
155 do a fork/exec, no shell, so don't bother figuring out what
157 shell_file = shell_file_arg;
158 if (STARTUP_WITH_SHELL)
160 /* Figure out what shell to start up the user program under. */
161 if (shell_file == NULL)
162 shell_file = getenv ("SHELL");
163 if (shell_file == NULL)
164 shell_file = default_shell_file;
170 /* We're going to call execvp. Create argument vector.
171 Calculate an upper bound on the length of the vector by
172 assuming that every other character is a separate
174 int argc = (strlen (allargs) + 1) / 2 + 2;
176 argv = (char **) alloca (argc * sizeof (*argv));
178 breakup_args (allargs, &argv[1]);
182 /* We're going to call a shell. */
187 const int escape_bang = escape_bang_in_quoted_argument (shell_file);
189 /* Multiplying the length of exec_file by 4 is to account for the
190 fact that it may expand when quoted; it is a worst-case number
191 based on every character being '. */
192 len = 5 + 4 * strlen (exec_file) + 1 + strlen (allargs) + 1 + /*slop */ 12;
194 len += strlen (exec_wrapper) + 1;
196 shell_command = (char *) alloca (len);
197 shell_command[0] = '\0';
199 strcat (shell_command, "exec ");
201 /* Add any exec wrapper. That may be a program name with arguments, so
202 the user must handle quoting. */
205 strcat (shell_command, exec_wrapper);
206 strcat (shell_command, " ");
209 /* Now add exec_file, quoting as necessary. */
211 /* Quoting in this style is said to work with all shells. But
212 csh on IRIX 4.0.1 can't deal with it. So we only quote it if
247 strcat (shell_command, "'");
248 for (p = exec_file; *p != '\0'; ++p)
251 strcat (shell_command, "'\\''");
252 else if (*p == '!' && escape_bang)
253 strcat (shell_command, "\\!");
255 strncat (shell_command, p, 1);
257 strcat (shell_command, "'");
260 strcat (shell_command, exec_file);
262 strcat (shell_command, " ");
263 strcat (shell_command, allargs);
265 /* If we decided above to start up with a shell, we exec the
266 shell, "-c" says to interpret the next arg as a shell command
267 to execute, and this command is "exec <target-program>
269 argv = (char **) alloca (4 * sizeof (char *));
270 argv[0] = shell_file;
272 argv[2] = shell_command;
273 argv[3] = (char *) 0;
276 /* On some systems an exec will fail if the executable is open. */
279 /* Retain a copy of our environment variables, since the child will
280 replace the value of environ and if we're vforked, we have to
282 save_our_env = environ;
284 /* Tell the terminal handling subsystem what tty we plan to run on;
285 it will just record the information for later. */
286 new_tty_prefork (inferior_io_terminal);
288 /* It is generally good practice to flush any possible pending stdio
289 output prior to doing a fork, to avoid the possibility of both
290 the parent and child flushing the same data after the fork. */
291 gdb_flush (gdb_stdout);
292 gdb_flush (gdb_stderr);
294 /* If there's any initialization of the target layers that must
295 happen to prepare to handle the child we're about fork, do it
297 if (pre_trace_fun != NULL)
300 /* Create the child process. Since the child process is going to
301 exec(3) shortly afterwards, try to reduce the overhead by
302 calling vfork(2). However, if PRE_TRACE_FUN is non-null, it's
303 likely that this optimization won't work since there's too much
304 work to do between the vfork(2) and the exec(3). This is known
305 to be the case on ttrace(2)-based HP-UX, where some handshaking
306 between parent and child needs to happen between fork(2) and
307 exec(2). However, since the parent is suspended in the vforked
308 state, this doesn't work. Also note that the vfork(2) call might
309 actually be a call to fork(2) due to the fact that autoconf will
310 ``#define vfork fork'' on certain platforms. */
311 if (pre_trace_fun || debug_fork)
317 perror_with_name (("vfork"));
324 /* Create a new session for the inferior process, if necessary.
325 It will also place the inferior in a separate process group. */
326 if (create_tty_session () <= 0)
328 /* No session was created, but we still want to run the inferior
329 in a separate process group. */
330 debug_setpgrp = gdb_setpgid ();
331 if (debug_setpgrp == -1)
332 perror (_("setpgrp failed in child"));
335 /* Ask the tty subsystem to switch to the one we specified
336 earlier (or to share the current terminal, if none was
340 /* Changing the signal handlers for the inferior after
341 a vfork can also change them for the superior, so we don't mess
342 with signals here. See comments in
343 initialize_signals for how we get the right signal handlers
346 /* "Trace me, Dr. Memory!" */
349 /* The call above set this process (the "child") as debuggable
350 by the original gdb process (the "parent"). Since processes
351 (unlike people) can have only one parent, if you are debugging
352 gdb itself (and your debugger is thus _already_ the
353 controller/parent for this child), code from here on out is
354 undebuggable. Indeed, you probably got an error message
355 saying "not parent". Sorry; you'll have to use print
358 /* There is no execlpe call, so we have to set the environment
359 for our child in the global variable. If we've vforked, this
360 clobbers the parent, but environ is restored a few lines down
361 in the parent. By the way, yes we do need to look down the
362 path to find $SHELL. Rich Pixley says so, and I agree. */
365 if (exec_fun != NULL)
366 (*exec_fun) (argv[0], argv, env);
368 execvp (argv[0], argv);
370 /* If we get here, it's an error. */
372 fprintf_unfiltered (gdb_stderr, "Cannot exec %s", exec_file);
373 for (i = 1; argv[i] != NULL; i++)
374 fprintf_unfiltered (gdb_stderr, " %s", argv[i]);
375 fprintf_unfiltered (gdb_stderr, ".\n");
376 fprintf_unfiltered (gdb_stderr, "Error: %s\n",
377 safe_strerror (save_errno));
378 gdb_flush (gdb_stderr);
382 /* Restore our environment in case a vforked child clob'd it. */
383 environ = save_our_env;
385 if (!have_inferiors ())
388 inf = current_inferior ();
390 inferior_appeared (inf, pid);
392 /* Needed for wait_for_inferior stuff below. */
393 inferior_ptid = pid_to_ptid (pid);
397 /* We have something that executes now. We'll be running through
398 the shell at this point, but the pid shouldn't change. Targets
399 supporting MT should fill this task's ptid with more data as soon
401 add_thread_silent (inferior_ptid);
403 /* Now that we have a child process, make it our target, and
404 initialize anything target-vector-specific that needs
407 (*init_trace_fun) (pid);
409 /* We are now in the child process of interest, having exec'd the
410 correct program, and are poised at the first instruction of the
415 /* Accept NTRAPS traps from the inferior. */
418 startup_inferior (int ntraps)
420 int pending_execs = ntraps;
421 int terminal_initted = 0;
424 if (target_supports_multi_process ())
425 resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
427 resume_ptid = minus_one_ptid;
429 /* The process was started by the fork that created it, but it will
430 have stopped one instruction after execing the shell. Here we
431 must get it up to actual execution of the real program. */
438 enum target_signal resume_signal = TARGET_SIGNAL_0;
441 struct target_waitstatus ws;
442 memset (&ws, 0, sizeof (ws));
443 event_ptid = target_wait (resume_ptid, &ws, 0);
445 if (ws.kind == TARGET_WAITKIND_IGNORE)
446 /* The inferior didn't really stop, keep waiting. */
451 case TARGET_WAITKIND_SPURIOUS:
452 case TARGET_WAITKIND_LOADED:
453 case TARGET_WAITKIND_FORKED:
454 case TARGET_WAITKIND_VFORKED:
455 case TARGET_WAITKIND_SYSCALL_ENTRY:
456 case TARGET_WAITKIND_SYSCALL_RETURN:
457 /* Ignore gracefully during startup of the inferior. */
458 switch_to_thread (event_ptid);
461 case TARGET_WAITKIND_SIGNALLED:
462 target_terminal_ours ();
463 target_mourn_inferior ();
464 error (_("During startup program terminated with signal %s, %s."),
465 target_signal_to_name (ws.value.sig),
466 target_signal_to_string (ws.value.sig));
469 case TARGET_WAITKIND_EXITED:
470 target_terminal_ours ();
471 target_mourn_inferior ();
472 if (ws.value.integer)
473 error (_("During startup program exited with code %d."),
476 error (_("During startup program exited normally."));
479 case TARGET_WAITKIND_EXECD:
480 /* Handle EXEC signals as if they were SIGTRAP signals. */
481 xfree (ws.value.execd_pathname);
482 resume_signal = TARGET_SIGNAL_TRAP;
483 switch_to_thread (event_ptid);
486 case TARGET_WAITKIND_STOPPED:
487 resume_signal = ws.value.sig;
488 switch_to_thread (event_ptid);
492 if (resume_signal != TARGET_SIGNAL_TRAP)
494 /* Let shell child handle its own signals in its own way. */
495 target_resume (resume_ptid, 0, resume_signal);
499 /* We handle SIGTRAP, however; it means child did an exec. */
500 if (!terminal_initted)
502 /* Now that the child has exec'd we know it has already
503 set its process group. On POSIX systems, tcsetpgrp
504 will fail with EPERM if we try it before the child's
507 /* Set up the "saved terminal modes" of the inferior
508 based on what modes we are starting it with. */
509 target_terminal_init ();
511 /* Install inferior's terminal modes. */
512 target_terminal_inferior ();
514 terminal_initted = 1;
517 if (--pending_execs == 0)
520 /* Just make it go on. */
521 target_resume (resume_ptid, 0, TARGET_SIGNAL_0);
525 /* Mark all threads non-executing. */
526 set_executing (resume_ptid, 0);
529 /* Implement the "unset exec-wrapper" command. */
532 unset_exec_wrapper_command (char *args, int from_tty)
534 xfree (exec_wrapper);
538 /* Provide a prototype to silence -Wmissing-prototypes. */
539 extern initialize_file_ftype _initialize_fork_child;
542 _initialize_fork_child (void)
544 add_setshow_filename_cmd ("exec-wrapper", class_run, &exec_wrapper, _("\
545 Set a wrapper for running programs.\n\
546 The wrapper prepares the system and environment for the new program."),
548 Show the wrapper for running programs."), NULL,
550 &setlist, &showlist);
552 add_cmd ("exec-wrapper", class_run, unset_exec_wrapper_command,
553 _("Disable use of an execution wrapper."),