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"
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 (const std::string &scratch, std::vector<char *> &argv)
54 for (size_t cur_pos = 0; cur_pos < scratch.size ();)
56 /* Skip whitespace-like chars. */
57 std::size_t pos = scratch.find_first_not_of (" \t\n", cur_pos);
59 if (pos != std::string::npos)
62 /* Find the position of the next separator. */
63 std::size_t next_sep = scratch.find_first_of (" \t\n", cur_pos);
65 /* No separator found, which means this is the last
67 if (next_sep == std::string::npos)
68 next_sep = scratch.size ();
70 char *arg = savestring (scratch.c_str () + cur_pos, next_sep - cur_pos);
76 /* NULL-terminate the vector. */
77 argv.push_back (NULL);
80 /* When executing a command under the given shell, return non-zero if
81 the '!' character should be escaped when embedded in a quoted
82 command-line argument. */
85 escape_bang_in_quoted_argument (const char *shell_file)
87 const int shell_file_len = strlen (shell_file);
89 /* Bang should be escaped only in C Shells. For now, simply check
90 that the shell name ends with 'csh', which covers at least csh
91 and tcsh. This should be good enough for now. */
93 if (shell_file_len < 3)
96 if (shell_file[shell_file_len - 3] == 'c'
97 && shell_file[shell_file_len - 2] == 's'
98 && shell_file[shell_file_len - 1] == 'h')
104 /* See inferior.h. */
107 trace_start_error (const char *fmt, ...)
112 fprintf_unfiltered (gdb_stderr, "Could not trace the inferior "
113 "process.\nError: ");
114 vfprintf_unfiltered (gdb_stderr, fmt, ap);
117 gdb_flush (gdb_stderr);
121 /* See inferior.h. */
124 trace_start_error_with_name (const char *string)
126 trace_start_error ("%s: %s", string, safe_strerror (errno));
129 /* Start an inferior Unix child process and sets inferior_ptid to its
130 pid. EXEC_FILE is the file to run. ALLARGS is a string containing
131 the arguments to the program. ENV is the environment vector to
132 pass. SHELL_FILE is the shell file, or NULL if we should pick
133 one. EXEC_FUN is the exec(2) function to use, or NULL for the default
136 /* This function is NOT reentrant. Some of the variables have been
137 made static to ensure that they survive the vfork call. */
140 fork_inferior (const char *exec_file_arg, const std::string &allargs,
141 char **env, void (*traceme_fun) (void),
142 void (*init_trace_fun) (int), void (*pre_trace_fun) (void),
143 char *shell_file_arg,
144 void (*exec_fun)(const char *file, char * const *argv,
148 static char default_shell_file[] = SHELL_FILE;
149 /* Set debug_fork then attach to the child while it sleeps, to debug. */
150 static int debug_fork = 0;
151 /* This is set to the result of setpgrp, which if vforked, will be visible
152 to you in the parent process. It's only used by humans for debugging. */
153 static int debug_setpgrp = 657473;
154 static char *shell_file;
155 static const char *exec_file;
158 std::vector<char *> argv;
159 const char *inferior_io_terminal = get_inferior_io_terminal ();
160 struct inferior *inf;
165 /* If no exec file handed to us, get it from the exec-file command
166 -- with a good, common error message if none is specified. */
167 if (exec_file_arg == NULL)
168 exec_file = get_exec_file (1);
170 exec_file = exec_file_arg;
172 /* 'startup_with_shell' is declared in inferior.h and bound to the
173 "set startup-with-shell" option. If 0, we'll just do a
174 fork/exec, no shell, so don't bother figuring out what shell. */
175 shell_file = shell_file_arg;
176 if (startup_with_shell)
178 /* Figure out what shell to start up the user program under. */
179 if (shell_file == NULL)
180 shell_file = getenv ("SHELL");
181 if (shell_file == NULL)
182 shell_file = default_shell_file;
188 /* We're going to call execvp. Create argument vector. */
189 argv.push_back (xstrdup (exec_file));
190 breakup_args (allargs, argv);
194 /* We're going to call a shell. */
195 std::string shell_command;
198 const int escape_bang = escape_bang_in_quoted_argument (shell_file);
200 shell_command = std::string ("exec ");
202 /* Add any exec wrapper. That may be a program name with arguments, so
203 the user must handle quoting. */
206 shell_command += exec_wrapper;
207 shell_command += ' ';
210 /* Now add exec_file, quoting as necessary. */
212 /* Quoting in this style is said to work with all shells. But
213 csh on IRIX 4.0.1 can't deal with it. So we only quote it if
248 shell_command += '\'';
249 for (p = exec_file; *p != '\0'; ++p)
252 shell_command += "'\\''";
253 else if (*p == '!' && escape_bang)
254 shell_command += "\\!";
258 shell_command += '\'';
261 shell_command += exec_file;
263 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>
268 <args>". We xstrdup all the strings here because they will
269 be free'd later in the code. */
270 argv.push_back (xstrdup (shell_file));
271 argv.push_back (xstrdup ("-c"));
272 argv.push_back (xstrdup (shell_command.c_str ()));
273 argv.push_back (NULL);
276 /* Retain a copy of our environment variables, since the child will
277 replace the value of environ and if we're vforked, we have to
279 save_our_env = environ;
281 /* Likewise the current UI. */
282 save_ui = current_ui;
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 (main_ui->m_gdb_stdout);
292 gdb_flush (main_ui->m_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"));
321 /* Switch to the main UI, so that gdb_std{in/out/err} in the
322 child are mapped to std{in/out/err}. This makes it possible
323 to use fprintf_unfiltered/warning/error/etc. in the child
325 current_ui = main_ui;
327 /* Close all file descriptors except those that gdb inherited
328 (usually 0/1/2), so they don't leak to the inferior. Note
329 that this closes the file descriptors of all secondary
336 /* Create a new session for the inferior process, if necessary.
337 It will also place the inferior in a separate process group. */
338 if (create_tty_session () <= 0)
340 /* No session was created, but we still want to run the inferior
341 in a separate process group. */
342 debug_setpgrp = gdb_setpgid ();
343 if (debug_setpgrp == -1)
344 perror (_("setpgrp failed in child"));
347 /* Ask the tty subsystem to switch to the one we specified
348 earlier (or to share the current terminal, if none was
352 /* Changing the signal handlers for the inferior after
353 a vfork can also change them for the superior, so we don't mess
354 with signals here. See comments in
355 initialize_signals for how we get the right signal handlers
358 /* "Trace me, Dr. Memory!" */
361 /* The call above set this process (the "child") as debuggable
362 by the original gdb process (the "parent"). Since processes
363 (unlike people) can have only one parent, if you are debugging
364 gdb itself (and your debugger is thus _already_ the
365 controller/parent for this child), code from here on out is
366 undebuggable. Indeed, you probably got an error message
367 saying "not parent". Sorry; you'll have to use print
370 restore_original_signals_state ();
372 /* There is no execlpe call, so we have to set the environment
373 for our child in the global variable. If we've vforked, this
374 clobbers the parent, but environ is restored a few lines down
375 in the parent. By the way, yes we do need to look down the
376 path to find $SHELL. Rich Pixley says so, and I agree. */
379 if (exec_fun != NULL)
380 (*exec_fun) (argv[0], &argv[0], env);
382 execvp (argv[0], &argv[0]);
384 /* If we get here, it's an error. */
386 fprintf_unfiltered (gdb_stderr, "Cannot exec %s", argv[0]);
387 for (i = 1; argv[i] != NULL; i++)
388 fprintf_unfiltered (gdb_stderr, " %s", argv[i]);
389 fprintf_unfiltered (gdb_stderr, ".\n");
390 fprintf_unfiltered (gdb_stderr, "Error: %s\n",
391 safe_strerror (save_errno));
392 gdb_flush (gdb_stderr);
396 free_vector_argv (argv);
398 /* Restore our environment in case a vforked child clob'd it. */
399 environ = save_our_env;
401 /* Likewise the current UI. */
402 current_ui = save_ui;
404 if (!have_inferiors ())
407 inf = current_inferior ();
409 inferior_appeared (inf, pid);
411 /* Needed for wait_for_inferior stuff below. */
412 inferior_ptid = pid_to_ptid (pid);
416 /* We have something that executes now. We'll be running through
417 the shell at this point, but the pid shouldn't change. Targets
418 supporting MT should fill this task's ptid with more data as soon
420 add_thread_silent (inferior_ptid);
422 /* Now that we have a child process, make it our target, and
423 initialize anything target-vector-specific that needs
426 (*init_trace_fun) (pid);
428 /* We are now in the child process of interest, having exec'd the
429 correct program, and are poised at the first instruction of the
434 /* Accept NTRAPS traps from the inferior. */
437 startup_inferior (int ntraps)
439 int pending_execs = ntraps;
440 int terminal_initted = 0;
443 if (startup_with_shell)
445 /* One trap extra for exec'ing the shell. */
449 if (target_supports_multi_process ())
450 resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
452 resume_ptid = minus_one_ptid;
454 /* The process was started by the fork that created it, but it will
455 have stopped one instruction after execing the shell. Here we
456 must get it up to actual execution of the real program. */
463 enum gdb_signal resume_signal = GDB_SIGNAL_0;
466 struct target_waitstatus ws;
467 memset (&ws, 0, sizeof (ws));
468 event_ptid = target_wait (resume_ptid, &ws, 0);
470 if (ws.kind == TARGET_WAITKIND_IGNORE)
471 /* The inferior didn't really stop, keep waiting. */
476 case TARGET_WAITKIND_SPURIOUS:
477 case TARGET_WAITKIND_LOADED:
478 case TARGET_WAITKIND_FORKED:
479 case TARGET_WAITKIND_VFORKED:
480 case TARGET_WAITKIND_SYSCALL_ENTRY:
481 case TARGET_WAITKIND_SYSCALL_RETURN:
482 /* Ignore gracefully during startup of the inferior. */
483 switch_to_thread (event_ptid);
486 case TARGET_WAITKIND_SIGNALLED:
487 target_terminal_ours ();
488 target_mourn_inferior (event_ptid);
489 error (_("During startup program terminated with signal %s, %s."),
490 gdb_signal_to_name (ws.value.sig),
491 gdb_signal_to_string (ws.value.sig));
494 case TARGET_WAITKIND_EXITED:
495 target_terminal_ours ();
496 target_mourn_inferior (event_ptid);
497 if (ws.value.integer)
498 error (_("During startup program exited with code %d."),
501 error (_("During startup program exited normally."));
504 case TARGET_WAITKIND_EXECD:
505 /* Handle EXEC signals as if they were SIGTRAP signals. */
506 xfree (ws.value.execd_pathname);
507 resume_signal = GDB_SIGNAL_TRAP;
508 switch_to_thread (event_ptid);
511 case TARGET_WAITKIND_STOPPED:
512 resume_signal = ws.value.sig;
513 switch_to_thread (event_ptid);
517 if (resume_signal != GDB_SIGNAL_TRAP)
519 /* Let shell child handle its own signals in its own way. */
520 target_continue (resume_ptid, resume_signal);
524 /* We handle SIGTRAP, however; it means child did an exec. */
525 if (!terminal_initted)
527 /* Now that the child has exec'd we know it has already
528 set its process group. On POSIX systems, tcsetpgrp
529 will fail with EPERM if we try it before the child's
532 /* Set up the "saved terminal modes" of the inferior
533 based on what modes we are starting it with. */
534 target_terminal_init ();
536 /* Install inferior's terminal modes. */
537 target_terminal_inferior ();
539 terminal_initted = 1;
542 if (--pending_execs == 0)
545 /* Just make it go on. */
546 target_continue_no_signal (resume_ptid);
550 /* Mark all threads non-executing. */
551 set_executing (resume_ptid, 0);
554 /* Implement the "unset exec-wrapper" command. */
557 unset_exec_wrapper_command (char *args, int from_tty)
559 xfree (exec_wrapper);
564 show_startup_with_shell (struct ui_file *file, int from_tty,
565 struct cmd_list_element *c, const char *value)
567 fprintf_filtered (file,
568 _("Use of shell to start subprocesses is %s.\n"),
572 /* Provide a prototype to silence -Wmissing-prototypes. */
573 extern initialize_file_ftype _initialize_fork_child;
576 _initialize_fork_child (void)
578 add_setshow_filename_cmd ("exec-wrapper", class_run, &exec_wrapper, _("\
579 Set a wrapper for running programs.\n\
580 The wrapper prepares the system and environment for the new program."),
582 Show the wrapper for running programs."), NULL,
584 &setlist, &showlist);
586 add_cmd ("exec-wrapper", class_run, unset_exec_wrapper_command,
587 _("Disable use of an execution wrapper."),
590 add_setshow_boolean_cmd ("startup-with-shell", class_support,
591 &startup_with_shell, _("\
592 Set use of shell to start subprocesses. The default is on."), _("\
593 Show use of shell to start subprocesses."), NULL,
595 show_startup_with_shell,
596 &setlist, &showlist);