1 /* Fork a Unix child process, and set up to debug it, for GDB.
3 Copyright (C) 1990-1996, 1998-2001, 2004-2012 Free Software
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 3 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, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_string.h"
29 #include "gdb_vfork.h"
32 #include "gdbthread.h"
33 #include "command.h" /* for dont_repeat () */
39 /* This just gets used as a default if we can't find SHELL. */
40 #define SHELL_FILE "/bin/sh"
42 extern char **environ
;
44 static char *exec_wrapper
;
46 /* Break up SCRATCH into an argument vector suitable for passing to
47 execvp and store it in ARGV. E.g., on "run a b c d" this routine
48 would get as input the string "a b c d", and as output it would
49 fill in ARGV with the four arguments "a", "b", "c", "d". */
52 breakup_args (char *scratch
, char **argv
)
54 char *cp
= scratch
, *tmp
;
58 /* Scan past leading separators */
59 while (*cp
== ' ' || *cp
== '\t' || *cp
== '\n')
62 /* Break if at end of string. */
69 /* Scan for next arg separator. */
70 tmp
= strchr (cp
, ' ');
72 tmp
= strchr (cp
, '\t');
74 tmp
= strchr (cp
, '\n');
76 /* 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
117 one. EXEC_FUN is the exec(2) function to use, or NULL for the default
120 /* This function is NOT reentrant. Some of the variables have been
121 made static to ensure that they survive the vfork call. */
124 fork_inferior (char *exec_file_arg
, char *allargs
, char **env
,
125 void (*traceme_fun
) (void), void (*init_trace_fun
) (int),
126 void (*pre_trace_fun
) (void), char *shell_file_arg
,
127 void (*exec_fun
)(const char *file
, char * const *argv
,
131 static char default_shell_file
[] = SHELL_FILE
;
132 /* Set debug_fork then attach to the child while it sleeps, to debug. */
133 static int debug_fork
= 0;
134 /* This is set to the result of setpgrp, which if vforked, will be visible
135 to you in the parent process. It's only used by humans for debugging. */
136 static int debug_setpgrp
= 657473;
137 static char *shell_file
;
138 static char *exec_file
;
142 const char *inferior_io_terminal
= get_inferior_io_terminal ();
143 struct inferior
*inf
;
147 /* If no exec file handed to us, get it from the exec-file command
148 -- with a good, common error message if none is specified. */
149 exec_file
= exec_file_arg
;
151 exec_file
= get_exec_file (1);
153 /* STARTUP_WITH_SHELL is defined in inferior.h. If 0,e we'll just
154 do a fork/exec, no shell, so don't bother figuring out what
156 shell_file
= shell_file_arg
;
157 if (STARTUP_WITH_SHELL
)
159 /* Figure out what shell to start up the user program under. */
160 if (shell_file
== NULL
)
161 shell_file
= getenv ("SHELL");
162 if (shell_file
== NULL
)
163 shell_file
= default_shell_file
;
169 /* We're going to call execvp. Create argument vector.
170 Calculate an upper bound on the length of the vector by
171 assuming that every other character is a separate
173 int argc
= (strlen (allargs
) + 1) / 2 + 2;
175 argv
= (char **) alloca (argc
* sizeof (*argv
));
177 breakup_args (allargs
, &argv
[1]);
181 /* We're going to call a shell. */
186 const int escape_bang
= escape_bang_in_quoted_argument (shell_file
);
188 /* Multiplying the length of exec_file by 4 is to account for the
189 fact that it may expand when quoted; it is a worst-case number
190 based on every character being '. */
191 len
= 5 + 4 * strlen (exec_file
) + 1 + strlen (allargs
) + 1 + /*slop */ 12;
193 len
+= strlen (exec_wrapper
) + 1;
195 shell_command
= (char *) alloca (len
);
196 shell_command
[0] = '\0';
198 strcat (shell_command
, "exec ");
200 /* Add any exec wrapper. That may be a program name with arguments, so
201 the user must handle quoting. */
204 strcat (shell_command
, exec_wrapper
);
205 strcat (shell_command
, " ");
208 /* Now add exec_file, quoting as necessary. */
210 /* Quoting in this style is said to work with all shells. But
211 csh on IRIX 4.0.1 can't deal with it. So we only quote it if
246 strcat (shell_command
, "'");
247 for (p
= exec_file
; *p
!= '\0'; ++p
)
250 strcat (shell_command
, "'\\''");
251 else if (*p
== '!' && escape_bang
)
252 strcat (shell_command
, "\\!");
254 strncat (shell_command
, p
, 1);
256 strcat (shell_command
, "'");
259 strcat (shell_command
, exec_file
);
261 strcat (shell_command
, " ");
262 strcat (shell_command
, allargs
);
264 /* If we decided above to start up with a shell, we exec the
265 shell, "-c" says to interpret the next arg as a shell command
266 to execute, and this command is "exec <target-program>
268 argv
= (char **) alloca (4 * sizeof (char *));
269 argv
[0] = shell_file
;
271 argv
[2] = shell_command
;
272 argv
[3] = (char *) 0;
275 /* On some systems an exec will fail if the executable is open. */
278 /* Retain a copy of our environment variables, since the child will
279 replace the value of environ and if we're vforked, we have to
281 save_our_env
= environ
;
283 /* Tell the terminal handling subsystem what tty we plan to run on;
284 it will just record the information for later. */
285 new_tty_prefork (inferior_io_terminal
);
287 /* It is generally good practice to flush any possible pending stdio
288 output prior to doing a fork, to avoid the possibility of both
289 the parent and child flushing the same data after the fork. */
290 gdb_flush (gdb_stdout
);
291 gdb_flush (gdb_stderr
);
293 /* If there's any initialization of the target layers that must
294 happen to prepare to handle the child we're about fork, do it
296 if (pre_trace_fun
!= NULL
)
299 /* Create the child process. Since the child process is going to
300 exec(3) shortly afterwards, try to reduce the overhead by
301 calling vfork(2). However, if PRE_TRACE_FUN is non-null, it's
302 likely that this optimization won't work since there's too much
303 work to do between the vfork(2) and the exec(3). This is known
304 to be the case on ttrace(2)-based HP-UX, where some handshaking
305 between parent and child needs to happen between fork(2) and
306 exec(2). However, since the parent is suspended in the vforked
307 state, this doesn't work. Also note that the vfork(2) call might
308 actually be a call to fork(2) due to the fact that autoconf will
309 ``#define vfork fork'' on certain platforms. */
310 if (pre_trace_fun
|| debug_fork
)
316 perror_with_name (("vfork"));
323 /* Create a new session for the inferior process, if necessary.
324 It will also place the inferior in a separate process group. */
325 if (create_tty_session () <= 0)
327 /* No session was created, but we still want to run the inferior
328 in a separate process group. */
329 debug_setpgrp
= gdb_setpgid ();
330 if (debug_setpgrp
== -1)
331 perror (_("setpgrp failed in child"));
334 /* Ask the tty subsystem to switch to the one we specified
335 earlier (or to share the current terminal, if none was
339 /* Changing the signal handlers for the inferior after
340 a vfork can also change them for the superior, so we don't mess
341 with signals here. See comments in
342 initialize_signals for how we get the right signal handlers
345 /* "Trace me, Dr. Memory!" */
348 /* The call above set this process (the "child") as debuggable
349 by the original gdb process (the "parent"). Since processes
350 (unlike people) can have only one parent, if you are debugging
351 gdb itself (and your debugger is thus _already_ the
352 controller/parent for this child), code from here on out is
353 undebuggable. Indeed, you probably got an error message
354 saying "not parent". Sorry; you'll have to use print
357 /* There is no execlpe call, so we have to set the environment
358 for our child in the global variable. If we've vforked, this
359 clobbers the parent, but environ is restored a few lines down
360 in the parent. By the way, yes we do need to look down the
361 path to find $SHELL. Rich Pixley says so, and I agree. */
364 if (exec_fun
!= NULL
)
365 (*exec_fun
) (argv
[0], argv
, env
);
367 execvp (argv
[0], argv
);
369 /* If we get here, it's an error. */
371 fprintf_unfiltered (gdb_stderr
, "Cannot exec %s", exec_file
);
372 for (i
= 1; argv
[i
] != NULL
; i
++)
373 fprintf_unfiltered (gdb_stderr
, " %s", argv
[i
]);
374 fprintf_unfiltered (gdb_stderr
, ".\n");
375 fprintf_unfiltered (gdb_stderr
, "Error: %s\n",
376 safe_strerror (save_errno
));
377 gdb_flush (gdb_stderr
);
381 /* Restore our environment in case a vforked child clob'd it. */
382 environ
= save_our_env
;
384 if (!have_inferiors ())
387 inf
= current_inferior ();
389 inferior_appeared (inf
, pid
);
391 /* Needed for wait_for_inferior stuff below. */
392 inferior_ptid
= pid_to_ptid (pid
);
396 /* We have something that executes now. We'll be running through
397 the shell at this point, but the pid shouldn't change. Targets
398 supporting MT should fill this task's ptid with more data as soon
400 add_thread_silent (inferior_ptid
);
402 /* Now that we have a child process, make it our target, and
403 initialize anything target-vector-specific that needs
406 (*init_trace_fun
) (pid
);
408 /* We are now in the child process of interest, having exec'd the
409 correct program, and are poised at the first instruction of the
414 /* Accept NTRAPS traps from the inferior. */
417 startup_inferior (int ntraps
)
419 int pending_execs
= ntraps
;
420 int terminal_initted
= 0;
423 if (target_supports_multi_process ())
424 resume_ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
426 resume_ptid
= minus_one_ptid
;
428 /* The process was started by the fork that created it, but it will
429 have stopped one instruction after execing the shell. Here we
430 must get it up to actual execution of the real program. */
437 enum target_signal resume_signal
= TARGET_SIGNAL_0
;
440 struct target_waitstatus ws
;
441 memset (&ws
, 0, sizeof (ws
));
442 event_ptid
= target_wait (resume_ptid
, &ws
, 0);
444 if (ws
.kind
== TARGET_WAITKIND_IGNORE
)
445 /* The inferior didn't really stop, keep waiting. */
450 case TARGET_WAITKIND_SPURIOUS
:
451 case TARGET_WAITKIND_LOADED
:
452 case TARGET_WAITKIND_FORKED
:
453 case TARGET_WAITKIND_VFORKED
:
454 case TARGET_WAITKIND_SYSCALL_ENTRY
:
455 case TARGET_WAITKIND_SYSCALL_RETURN
:
456 /* Ignore gracefully during startup of the inferior. */
457 switch_to_thread (event_ptid
);
460 case TARGET_WAITKIND_SIGNALLED
:
461 target_terminal_ours ();
462 target_mourn_inferior ();
463 error (_("During startup program terminated with signal %s, %s."),
464 target_signal_to_name (ws
.value
.sig
),
465 target_signal_to_string (ws
.value
.sig
));
468 case TARGET_WAITKIND_EXITED
:
469 target_terminal_ours ();
470 target_mourn_inferior ();
471 if (ws
.value
.integer
)
472 error (_("During startup program exited with code %d."),
475 error (_("During startup program exited normally."));
478 case TARGET_WAITKIND_EXECD
:
479 /* Handle EXEC signals as if they were SIGTRAP signals. */
480 xfree (ws
.value
.execd_pathname
);
481 resume_signal
= TARGET_SIGNAL_TRAP
;
482 switch_to_thread (event_ptid
);
485 case TARGET_WAITKIND_STOPPED
:
486 resume_signal
= ws
.value
.sig
;
487 switch_to_thread (event_ptid
);
491 if (resume_signal
!= TARGET_SIGNAL_TRAP
)
493 /* Let shell child handle its own signals in its own way. */
494 target_resume (resume_ptid
, 0, resume_signal
);
498 /* We handle SIGTRAP, however; it means child did an exec. */
499 if (!terminal_initted
)
501 /* Now that the child has exec'd we know it has already
502 set its process group. On POSIX systems, tcsetpgrp
503 will fail with EPERM if we try it before the child's
506 /* Set up the "saved terminal modes" of the inferior
507 based on what modes we are starting it with. */
508 target_terminal_init ();
510 /* Install inferior's terminal modes. */
511 target_terminal_inferior ();
513 terminal_initted
= 1;
516 if (--pending_execs
== 0)
519 /* Just make it go on. */
520 target_resume (resume_ptid
, 0, TARGET_SIGNAL_0
);
524 /* Mark all threads non-executing. */
525 set_executing (resume_ptid
, 0);
528 /* Implement the "unset exec-wrapper" command. */
531 unset_exec_wrapper_command (char *args
, int from_tty
)
533 xfree (exec_wrapper
);
537 /* Provide a prototype to silence -Wmissing-prototypes. */
538 extern initialize_file_ftype _initialize_fork_child
;
541 _initialize_fork_child (void)
543 add_setshow_filename_cmd ("exec-wrapper", class_run
, &exec_wrapper
, _("\
544 Set a wrapper for running programs.\n\
545 The wrapper prepares the system and environment for the new program."),
547 Show the wrapper for running programs."), NULL
,
549 &setlist
, &showlist
);
551 add_cmd ("exec-wrapper", class_run
, unset_exec_wrapper_command
,
552 _("Disable use of an execution wrapper."),