1 /* Fork a Unix child process, and set up to debug it, for GDB.
3 Copyright (C) 1990-2017 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/>. */
27 #include "gdb_vfork.h"
29 #include "gdbthread.h"
30 #include "command.h" /* for dont_repeat () */
33 #include "filestuff.h"
35 #include "signals-state-save-restore.h"
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 /* See inferior.h. */
115 trace_start_error (const char *fmt
, ...)
120 fprintf_unfiltered (gdb_stderr
, "Could not trace the inferior "
121 "process.\nError: ");
122 vfprintf_unfiltered (gdb_stderr
, fmt
, ap
);
125 gdb_flush (gdb_stderr
);
129 /* See inferior.h. */
132 trace_start_error_with_name (const char *string
)
134 trace_start_error ("%s: %s", string
, safe_strerror (errno
));
137 /* Start an inferior Unix child process and sets inferior_ptid to its
138 pid. EXEC_FILE is the file to run. ALLARGS is a string containing
139 the arguments to the program. ENV is the environment vector to
140 pass. SHELL_FILE is the shell file, or NULL if we should pick
141 one. EXEC_FUN is the exec(2) function to use, or NULL for the default
144 /* This function is NOT reentrant. Some of the variables have been
145 made static to ensure that they survive the vfork call. */
148 fork_inferior (char *exec_file_arg
, char *allargs
, char **env
,
149 void (*traceme_fun
) (void), void (*init_trace_fun
) (int),
150 void (*pre_trace_fun
) (void), char *shell_file_arg
,
151 void (*exec_fun
)(const char *file
, char * const *argv
,
155 static char default_shell_file
[] = SHELL_FILE
;
156 /* Set debug_fork then attach to the child while it sleeps, to debug. */
157 static int debug_fork
= 0;
158 /* This is set to the result of setpgrp, which if vforked, will be visible
159 to you in the parent process. It's only used by humans for debugging. */
160 static int debug_setpgrp
= 657473;
161 static char *shell_file
;
162 static char *exec_file
;
166 const char *inferior_io_terminal
= get_inferior_io_terminal ();
167 struct inferior
*inf
;
172 /* If no exec file handed to us, get it from the exec-file command
173 -- with a good, common error message if none is specified. */
174 exec_file
= exec_file_arg
;
176 exec_file
= get_exec_file (1);
178 /* 'startup_with_shell' is declared in inferior.h and bound to the
179 "set startup-with-shell" option. If 0, we'll just do a
180 fork/exec, no shell, so don't bother figuring out what shell. */
181 shell_file
= shell_file_arg
;
182 if (startup_with_shell
)
184 /* Figure out what shell to start up the user program under. */
185 if (shell_file
== NULL
)
186 shell_file
= getenv ("SHELL");
187 if (shell_file
== NULL
)
188 shell_file
= default_shell_file
;
194 /* We're going to call execvp. Create argument vector.
195 Calculate an upper bound on the length of the vector by
196 assuming that every other character is a separate
198 int argc
= (strlen (allargs
) + 1) / 2 + 2;
200 argv
= XALLOCAVEC (char *, argc
);
202 breakup_args (allargs
, &argv
[1]);
206 /* We're going to call a shell. */
211 const int escape_bang
= escape_bang_in_quoted_argument (shell_file
);
213 /* Multiplying the length of exec_file by 4 is to account for the
214 fact that it may expand when quoted; it is a worst-case number
215 based on every character being '. */
216 len
= 5 + 4 * strlen (exec_file
) + 1 + strlen (allargs
) + 1 + /*slop */ 12;
218 len
+= strlen (exec_wrapper
) + 1;
220 shell_command
= (char *) alloca (len
);
221 shell_command
[0] = '\0';
223 strcat (shell_command
, "exec ");
225 /* Add any exec wrapper. That may be a program name with arguments, so
226 the user must handle quoting. */
229 strcat (shell_command
, exec_wrapper
);
230 strcat (shell_command
, " ");
233 /* Now add exec_file, quoting as necessary. */
235 /* Quoting in this style is said to work with all shells. But
236 csh on IRIX 4.0.1 can't deal with it. So we only quote it if
271 strcat (shell_command
, "'");
272 for (p
= exec_file
; *p
!= '\0'; ++p
)
275 strcat (shell_command
, "'\\''");
276 else if (*p
== '!' && escape_bang
)
277 strcat (shell_command
, "\\!");
279 strncat (shell_command
, p
, 1);
281 strcat (shell_command
, "'");
284 strcat (shell_command
, exec_file
);
286 strcat (shell_command
, " ");
287 strcat (shell_command
, allargs
);
289 /* If we decided above to start up with a shell, we exec the
290 shell, "-c" says to interpret the next arg as a shell command
291 to execute, and this command is "exec <target-program>
293 argv
= (char **) alloca (4 * sizeof (char *));
294 argv
[0] = shell_file
;
296 argv
[2] = shell_command
;
297 argv
[3] = (char *) 0;
300 /* Retain a copy of our environment variables, since the child will
301 replace the value of environ and if we're vforked, we have to
303 save_our_env
= environ
;
305 /* Likewise the current UI. */
306 save_ui
= current_ui
;
308 /* Tell the terminal handling subsystem what tty we plan to run on;
309 it will just record the information for later. */
310 new_tty_prefork (inferior_io_terminal
);
312 /* It is generally good practice to flush any possible pending stdio
313 output prior to doing a fork, to avoid the possibility of both
314 the parent and child flushing the same data after the fork. */
315 gdb_flush (main_ui
->m_gdb_stdout
);
316 gdb_flush (main_ui
->m_gdb_stderr
);
318 /* If there's any initialization of the target layers that must
319 happen to prepare to handle the child we're about fork, do it
321 if (pre_trace_fun
!= NULL
)
324 /* Create the child process. Since the child process is going to
325 exec(3) shortly afterwards, try to reduce the overhead by
326 calling vfork(2). However, if PRE_TRACE_FUN is non-null, it's
327 likely that this optimization won't work since there's too much
328 work to do between the vfork(2) and the exec(3). This is known
329 to be the case on ttrace(2)-based HP-UX, where some handshaking
330 between parent and child needs to happen between fork(2) and
331 exec(2). However, since the parent is suspended in the vforked
332 state, this doesn't work. Also note that the vfork(2) call might
333 actually be a call to fork(2) due to the fact that autoconf will
334 ``#define vfork fork'' on certain platforms. */
335 if (pre_trace_fun
|| debug_fork
)
341 perror_with_name (("vfork"));
345 /* Switch to the main UI, so that gdb_std{in/out/err} in the
346 child are mapped to std{in/out/err}. This makes it possible
347 to use fprintf_unfiltered/warning/error/etc. in the child
349 current_ui
= main_ui
;
351 /* Close all file descriptors except those that gdb inherited
352 (usually 0/1/2), so they don't leak to the inferior. Note
353 that this closes the file descriptors of all secondary
360 /* Create a new session for the inferior process, if necessary.
361 It will also place the inferior in a separate process group. */
362 if (create_tty_session () <= 0)
364 /* No session was created, but we still want to run the inferior
365 in a separate process group. */
366 debug_setpgrp
= gdb_setpgid ();
367 if (debug_setpgrp
== -1)
368 perror (_("setpgrp failed in child"));
371 /* Ask the tty subsystem to switch to the one we specified
372 earlier (or to share the current terminal, if none was
376 /* Changing the signal handlers for the inferior after
377 a vfork can also change them for the superior, so we don't mess
378 with signals here. See comments in
379 initialize_signals for how we get the right signal handlers
382 /* "Trace me, Dr. Memory!" */
385 /* The call above set this process (the "child") as debuggable
386 by the original gdb process (the "parent"). Since processes
387 (unlike people) can have only one parent, if you are debugging
388 gdb itself (and your debugger is thus _already_ the
389 controller/parent for this child), code from here on out is
390 undebuggable. Indeed, you probably got an error message
391 saying "not parent". Sorry; you'll have to use print
394 restore_original_signals_state ();
396 /* There is no execlpe call, so we have to set the environment
397 for our child in the global variable. If we've vforked, this
398 clobbers the parent, but environ is restored a few lines down
399 in the parent. By the way, yes we do need to look down the
400 path to find $SHELL. Rich Pixley says so, and I agree. */
403 if (exec_fun
!= NULL
)
404 (*exec_fun
) (argv
[0], argv
, env
);
406 execvp (argv
[0], argv
);
408 /* If we get here, it's an error. */
410 fprintf_unfiltered (gdb_stderr
, "Cannot exec %s", argv
[0]);
411 for (i
= 1; argv
[i
] != NULL
; i
++)
412 fprintf_unfiltered (gdb_stderr
, " %s", argv
[i
]);
413 fprintf_unfiltered (gdb_stderr
, ".\n");
414 fprintf_unfiltered (gdb_stderr
, "Error: %s\n",
415 safe_strerror (save_errno
));
416 gdb_flush (gdb_stderr
);
420 /* Restore our environment in case a vforked child clob'd it. */
421 environ
= save_our_env
;
423 /* Likewise the current UI. */
424 current_ui
= save_ui
;
426 if (!have_inferiors ())
429 inf
= current_inferior ();
431 inferior_appeared (inf
, pid
);
433 /* Needed for wait_for_inferior stuff below. */
434 inferior_ptid
= pid_to_ptid (pid
);
438 /* We have something that executes now. We'll be running through
439 the shell at this point, but the pid shouldn't change. Targets
440 supporting MT should fill this task's ptid with more data as soon
442 add_thread_silent (inferior_ptid
);
444 /* Now that we have a child process, make it our target, and
445 initialize anything target-vector-specific that needs
448 (*init_trace_fun
) (pid
);
450 /* We are now in the child process of interest, having exec'd the
451 correct program, and are poised at the first instruction of the
456 /* Accept NTRAPS traps from the inferior. */
459 startup_inferior (int ntraps
)
461 int pending_execs
= ntraps
;
462 int terminal_initted
= 0;
465 if (startup_with_shell
)
467 /* One trap extra for exec'ing the shell. */
471 if (target_supports_multi_process ())
472 resume_ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
474 resume_ptid
= minus_one_ptid
;
476 /* The process was started by the fork that created it, but it will
477 have stopped one instruction after execing the shell. Here we
478 must get it up to actual execution of the real program. */
485 enum gdb_signal resume_signal
= GDB_SIGNAL_0
;
488 struct target_waitstatus ws
;
489 memset (&ws
, 0, sizeof (ws
));
490 event_ptid
= target_wait (resume_ptid
, &ws
, 0);
492 if (ws
.kind
== TARGET_WAITKIND_IGNORE
)
493 /* The inferior didn't really stop, keep waiting. */
498 case TARGET_WAITKIND_SPURIOUS
:
499 case TARGET_WAITKIND_LOADED
:
500 case TARGET_WAITKIND_FORKED
:
501 case TARGET_WAITKIND_VFORKED
:
502 case TARGET_WAITKIND_SYSCALL_ENTRY
:
503 case TARGET_WAITKIND_SYSCALL_RETURN
:
504 /* Ignore gracefully during startup of the inferior. */
505 switch_to_thread (event_ptid
);
508 case TARGET_WAITKIND_SIGNALLED
:
509 target_terminal_ours ();
510 target_mourn_inferior (event_ptid
);
511 error (_("During startup program terminated with signal %s, %s."),
512 gdb_signal_to_name (ws
.value
.sig
),
513 gdb_signal_to_string (ws
.value
.sig
));
516 case TARGET_WAITKIND_EXITED
:
517 target_terminal_ours ();
518 target_mourn_inferior (event_ptid
);
519 if (ws
.value
.integer
)
520 error (_("During startup program exited with code %d."),
523 error (_("During startup program exited normally."));
526 case TARGET_WAITKIND_EXECD
:
527 /* Handle EXEC signals as if they were SIGTRAP signals. */
528 xfree (ws
.value
.execd_pathname
);
529 resume_signal
= GDB_SIGNAL_TRAP
;
530 switch_to_thread (event_ptid
);
533 case TARGET_WAITKIND_STOPPED
:
534 resume_signal
= ws
.value
.sig
;
535 switch_to_thread (event_ptid
);
539 if (resume_signal
!= GDB_SIGNAL_TRAP
)
541 /* Let shell child handle its own signals in its own way. */
542 target_continue (resume_ptid
, resume_signal
);
546 /* We handle SIGTRAP, however; it means child did an exec. */
547 if (!terminal_initted
)
549 /* Now that the child has exec'd we know it has already
550 set its process group. On POSIX systems, tcsetpgrp
551 will fail with EPERM if we try it before the child's
554 /* Set up the "saved terminal modes" of the inferior
555 based on what modes we are starting it with. */
556 target_terminal_init ();
558 /* Install inferior's terminal modes. */
559 target_terminal_inferior ();
561 terminal_initted
= 1;
564 if (--pending_execs
== 0)
567 /* Just make it go on. */
568 target_continue_no_signal (resume_ptid
);
572 /* Mark all threads non-executing. */
573 set_executing (resume_ptid
, 0);
576 /* Implement the "unset exec-wrapper" command. */
579 unset_exec_wrapper_command (char *args
, int from_tty
)
581 xfree (exec_wrapper
);
586 show_startup_with_shell (struct ui_file
*file
, int from_tty
,
587 struct cmd_list_element
*c
, const char *value
)
589 fprintf_filtered (file
,
590 _("Use of shell to start subprocesses is %s.\n"),
594 /* Provide a prototype to silence -Wmissing-prototypes. */
595 extern initialize_file_ftype _initialize_fork_child
;
598 _initialize_fork_child (void)
600 add_setshow_filename_cmd ("exec-wrapper", class_run
, &exec_wrapper
, _("\
601 Set a wrapper for running programs.\n\
602 The wrapper prepares the system and environment for the new program."),
604 Show the wrapper for running programs."), NULL
,
606 &setlist
, &showlist
);
608 add_cmd ("exec-wrapper", class_run
, unset_exec_wrapper_command
,
609 _("Disable use of an execution wrapper."),
612 add_setshow_boolean_cmd ("startup-with-shell", class_support
,
613 &startup_with_shell
, _("\
614 Set use of shell to start subprocesses. The default is on."), _("\
615 Show use of shell to start subprocesses."), NULL
,
617 show_startup_with_shell
,
618 &setlist
, &showlist
);