1 /* Fork a Unix child process, and set up to debug it, for GDB.
3 Copyright (C) 1990-2013 Free Software Foundation, Inc.
5 Contributed by Cygnus Support.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_string.h"
28 #include "gdb_vfork.h"
31 #include "gdbthread.h"
32 #include "command.h" /* for dont_repeat () */
38 /* This just gets used as a default if we can't find SHELL. */
39 #define SHELL_FILE "/bin/sh"
41 extern char **environ
;
43 static char *exec_wrapper
;
45 /* Break up SCRATCH into an argument vector suitable for passing to
46 execvp and store it in ARGV. E.g., on "run a b c d" this routine
47 would get as input the string "a b c d", and as output it would
48 fill in ARGV with the four arguments "a", "b", "c", "d". */
51 breakup_args (char *scratch
, char **argv
)
53 char *cp
= scratch
, *tmp
;
57 /* Scan past leading separators */
58 while (*cp
== ' ' || *cp
== '\t' || *cp
== '\n')
61 /* Break if at end of string. */
68 /* Scan for next arg separator. */
69 tmp
= strchr (cp
, ' ');
71 tmp
= strchr (cp
, '\t');
73 tmp
= strchr (cp
, '\n');
75 /* No separators => end of string => break. */
80 /* Replace the separator with a terminator. */
84 /* Null-terminate the vector. */
88 /* When executing a command under the given shell, return non-zero if
89 the '!' character should be escaped when embedded in a quoted
90 command-line argument. */
93 escape_bang_in_quoted_argument (const char *shell_file
)
95 const int shell_file_len
= strlen (shell_file
);
97 /* Bang should be escaped only in C Shells. For now, simply check
98 that the shell name ends with 'csh', which covers at least csh
99 and tcsh. This should be good enough for now. */
101 if (shell_file_len
< 3)
104 if (shell_file
[shell_file_len
- 3] == 'c'
105 && shell_file
[shell_file_len
- 2] == 's'
106 && shell_file
[shell_file_len
- 1] == 'h')
112 /* Start an inferior Unix child process and sets inferior_ptid to its
113 pid. EXEC_FILE is the file to run. ALLARGS is a string containing
114 the arguments to the program. ENV is the environment vector to
115 pass. SHELL_FILE is the shell file, or NULL if we should pick
116 one. EXEC_FUN is the exec(2) function to use, or NULL for the default
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
,
126 void (*exec_fun
)(const char *file
, char * const *argv
,
130 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
;
141 const char *inferior_io_terminal
= get_inferior_io_terminal ();
142 struct inferior
*inf
;
146 /* If no exec file handed to us, get it from the exec-file command
147 -- with a good, common error message if none is specified. */
148 exec_file
= exec_file_arg
;
150 exec_file
= get_exec_file (1);
152 /* STARTUP_WITH_SHELL is defined in inferior.h. If 0,e we'll just
153 do a fork/exec, no shell, so don't bother figuring out what
155 shell_file
= shell_file_arg
;
156 if (STARTUP_WITH_SHELL
)
158 /* Figure out what shell to start up the user program under. */
159 if (shell_file
== NULL
)
160 shell_file
= getenv ("SHELL");
161 if (shell_file
== NULL
)
162 shell_file
= default_shell_file
;
168 /* We're going to call execvp. Create argument vector.
169 Calculate an upper bound on the length of the vector by
170 assuming that every other character is a separate
172 int argc
= (strlen (allargs
) + 1) / 2 + 2;
174 argv
= (char **) alloca (argc
* sizeof (*argv
));
176 breakup_args (allargs
, &argv
[1]);
180 /* We're going to call a shell. */
185 const int escape_bang
= escape_bang_in_quoted_argument (shell_file
);
187 /* Multiplying the length of exec_file by 4 is to account for the
188 fact that it may expand when quoted; it is a worst-case number
189 based on every character being '. */
190 len
= 5 + 4 * strlen (exec_file
) + 1 + strlen (allargs
) + 1 + /*slop */ 12;
192 len
+= strlen (exec_wrapper
) + 1;
194 shell_command
= (char *) alloca (len
);
195 shell_command
[0] = '\0';
197 strcat (shell_command
, "exec ");
199 /* Add any exec wrapper. That may be a program name with arguments, so
200 the user must handle quoting. */
203 strcat (shell_command
, exec_wrapper
);
204 strcat (shell_command
, " ");
207 /* Now add exec_file, quoting as necessary. */
209 /* Quoting in this style is said to work with all shells. But
210 csh on IRIX 4.0.1 can't deal with it. So we only quote it if
245 strcat (shell_command
, "'");
246 for (p
= exec_file
; *p
!= '\0'; ++p
)
249 strcat (shell_command
, "'\\''");
250 else if (*p
== '!' && escape_bang
)
251 strcat (shell_command
, "\\!");
253 strncat (shell_command
, p
, 1);
255 strcat (shell_command
, "'");
258 strcat (shell_command
, exec_file
);
260 strcat (shell_command
, " ");
261 strcat (shell_command
, allargs
);
263 /* If we decided above to start up with a shell, we exec the
264 shell, "-c" says to interpret the next arg as a shell command
265 to execute, and this command is "exec <target-program>
267 argv
= (char **) alloca (4 * sizeof (char *));
268 argv
[0] = shell_file
;
270 argv
[2] = shell_command
;
271 argv
[3] = (char *) 0;
274 /* Retain a copy of our environment variables, since the child will
275 replace the value of environ and if we're vforked, we have to
277 save_our_env
= environ
;
279 /* Tell the terminal handling subsystem what tty we plan to run on;
280 it will just record the information for later. */
281 new_tty_prefork (inferior_io_terminal
);
283 /* It is generally good practice to flush any possible pending stdio
284 output prior to doing a fork, to avoid the possibility of both
285 the parent and child flushing the same data after the fork. */
286 gdb_flush (gdb_stdout
);
287 gdb_flush (gdb_stderr
);
289 /* If there's any initialization of the target layers that must
290 happen to prepare to handle the child we're about fork, do it
292 if (pre_trace_fun
!= NULL
)
295 /* Create the child process. Since the child process is going to
296 exec(3) shortly afterwards, try to reduce the overhead by
297 calling vfork(2). However, if PRE_TRACE_FUN is non-null, it's
298 likely that this optimization won't work since there's too much
299 work to do between the vfork(2) and the exec(3). This is known
300 to be the case on ttrace(2)-based HP-UX, where some handshaking
301 between parent and child needs to happen between fork(2) and
302 exec(2). However, since the parent is suspended in the vforked
303 state, this doesn't work. Also note that the vfork(2) call might
304 actually be a call to fork(2) due to the fact that autoconf will
305 ``#define vfork fork'' on certain platforms. */
306 if (pre_trace_fun
|| debug_fork
)
312 perror_with_name (("vfork"));
319 /* Create a new session for the inferior process, if necessary.
320 It will also place the inferior in a separate process group. */
321 if (create_tty_session () <= 0)
323 /* No session was created, but we still want to run the inferior
324 in a separate process group. */
325 debug_setpgrp
= gdb_setpgid ();
326 if (debug_setpgrp
== -1)
327 perror (_("setpgrp failed in child"));
330 /* Ask the tty subsystem to switch to the one we specified
331 earlier (or to share the current terminal, if none was
335 /* Changing the signal handlers for the inferior after
336 a vfork can also change them for the superior, so we don't mess
337 with signals here. See comments in
338 initialize_signals for how we get the right signal handlers
341 /* "Trace me, Dr. Memory!" */
344 /* The call above set this process (the "child") as debuggable
345 by the original gdb process (the "parent"). Since processes
346 (unlike people) can have only one parent, if you are debugging
347 gdb itself (and your debugger is thus _already_ the
348 controller/parent for this child), code from here on out is
349 undebuggable. Indeed, you probably got an error message
350 saying "not parent". Sorry; you'll have to use print
353 /* There is no execlpe call, so we have to set the environment
354 for our child in the global variable. If we've vforked, this
355 clobbers the parent, but environ is restored a few lines down
356 in the parent. By the way, yes we do need to look down the
357 path to find $SHELL. Rich Pixley says so, and I agree. */
360 if (exec_fun
!= NULL
)
361 (*exec_fun
) (argv
[0], argv
, env
);
363 execvp (argv
[0], argv
);
365 /* If we get here, it's an error. */
367 fprintf_unfiltered (gdb_stderr
, "Cannot exec %s", exec_file
);
368 for (i
= 1; argv
[i
] != NULL
; i
++)
369 fprintf_unfiltered (gdb_stderr
, " %s", argv
[i
]);
370 fprintf_unfiltered (gdb_stderr
, ".\n");
371 fprintf_unfiltered (gdb_stderr
, "Error: %s\n",
372 safe_strerror (save_errno
));
373 gdb_flush (gdb_stderr
);
377 /* Restore our environment in case a vforked child clob'd it. */
378 environ
= save_our_env
;
380 if (!have_inferiors ())
383 inf
= current_inferior ();
385 inferior_appeared (inf
, pid
);
387 /* Needed for wait_for_inferior stuff below. */
388 inferior_ptid
= pid_to_ptid (pid
);
392 /* We have something that executes now. We'll be running through
393 the shell at this point, but the pid shouldn't change. Targets
394 supporting MT should fill this task's ptid with more data as soon
396 add_thread_silent (inferior_ptid
);
398 /* Now that we have a child process, make it our target, and
399 initialize anything target-vector-specific that needs
402 (*init_trace_fun
) (pid
);
404 /* We are now in the child process of interest, having exec'd the
405 correct program, and are poised at the first instruction of the
410 /* Accept NTRAPS traps from the inferior. */
413 startup_inferior (int ntraps
)
415 int pending_execs
= ntraps
;
416 int terminal_initted
= 0;
419 if (target_supports_multi_process ())
420 resume_ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
422 resume_ptid
= minus_one_ptid
;
424 /* The process was started by the fork that created it, but it will
425 have stopped one instruction after execing the shell. Here we
426 must get it up to actual execution of the real program. */
433 enum gdb_signal resume_signal
= GDB_SIGNAL_0
;
436 struct target_waitstatus ws
;
437 memset (&ws
, 0, sizeof (ws
));
438 event_ptid
= target_wait (resume_ptid
, &ws
, 0);
440 if (ws
.kind
== TARGET_WAITKIND_IGNORE
)
441 /* The inferior didn't really stop, keep waiting. */
446 case TARGET_WAITKIND_SPURIOUS
:
447 case TARGET_WAITKIND_LOADED
:
448 case TARGET_WAITKIND_FORKED
:
449 case TARGET_WAITKIND_VFORKED
:
450 case TARGET_WAITKIND_SYSCALL_ENTRY
:
451 case TARGET_WAITKIND_SYSCALL_RETURN
:
452 /* Ignore gracefully during startup of the inferior. */
453 switch_to_thread (event_ptid
);
456 case TARGET_WAITKIND_SIGNALLED
:
457 target_terminal_ours ();
458 target_mourn_inferior ();
459 error (_("During startup program terminated with signal %s, %s."),
460 gdb_signal_to_name (ws
.value
.sig
),
461 gdb_signal_to_string (ws
.value
.sig
));
464 case TARGET_WAITKIND_EXITED
:
465 target_terminal_ours ();
466 target_mourn_inferior ();
467 if (ws
.value
.integer
)
468 error (_("During startup program exited with code %d."),
471 error (_("During startup program exited normally."));
474 case TARGET_WAITKIND_EXECD
:
475 /* Handle EXEC signals as if they were SIGTRAP signals. */
476 xfree (ws
.value
.execd_pathname
);
477 resume_signal
= GDB_SIGNAL_TRAP
;
478 switch_to_thread (event_ptid
);
481 case TARGET_WAITKIND_STOPPED
:
482 resume_signal
= ws
.value
.sig
;
483 switch_to_thread (event_ptid
);
487 if (resume_signal
!= GDB_SIGNAL_TRAP
)
489 /* Let shell child handle its own signals in its own way. */
490 target_resume (resume_ptid
, 0, resume_signal
);
494 /* We handle SIGTRAP, however; it means child did an exec. */
495 if (!terminal_initted
)
497 /* Now that the child has exec'd we know it has already
498 set its process group. On POSIX systems, tcsetpgrp
499 will fail with EPERM if we try it before the child's
502 /* Set up the "saved terminal modes" of the inferior
503 based on what modes we are starting it with. */
504 target_terminal_init ();
506 /* Install inferior's terminal modes. */
507 target_terminal_inferior ();
509 terminal_initted
= 1;
512 if (--pending_execs
== 0)
515 /* Just make it go on. */
516 target_resume (resume_ptid
, 0, GDB_SIGNAL_0
);
520 /* Mark all threads non-executing. */
521 set_executing (resume_ptid
, 0);
524 /* Implement the "unset exec-wrapper" command. */
527 unset_exec_wrapper_command (char *args
, int from_tty
)
529 xfree (exec_wrapper
);
533 /* Provide a prototype to silence -Wmissing-prototypes. */
534 extern initialize_file_ftype _initialize_fork_child
;
537 _initialize_fork_child (void)
539 add_setshow_filename_cmd ("exec-wrapper", class_run
, &exec_wrapper
, _("\
540 Set a wrapper for running programs.\n\
541 The wrapper prepares the system and environment for the new program."),
543 Show the wrapper for running programs."), NULL
,
545 &setlist
, &showlist
);
547 add_cmd ("exec-wrapper", class_run
, unset_exec_wrapper_command
,
548 _("Disable use of an execution wrapper."),