GDB (xrefs)
/tmp/gdb-7.10/gdb/fork-child.c
Go to the documentation of this file.
1 /* Fork a Unix child process, and set up to debug it, for GDB.
2 
3  Copyright (C) 1990-2015 Free Software Foundation, Inc.
4 
5  Contributed by Cygnus Support.
6 
7  This file is part of GDB.
8 
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.
13 
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.
18 
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/>. */
21 
22 #include "defs.h"
23 #include "inferior.h"
24 #include "terminal.h"
25 #include "target.h"
26 #include "gdb_wait.h"
27 #include "gdb_vfork.h"
28 #include "gdbcore.h"
29 #include "gdbthread.h"
30 #include "command.h" /* for dont_repeat () */
31 #include "gdbcmd.h"
32 #include "solib.h"
33 #include "filestuff.h"
34 
35 #include <signal.h>
36 
37 /* This just gets used as a default if we can't find SHELL. */
38 #define SHELL_FILE "/bin/sh"
39 
40 extern char **environ;
41 
42 static char *exec_wrapper;
43 
44 /* Break up SCRATCH into an argument vector suitable for passing to
45  execvp and store it in ARGV. E.g., on "run a b c d" this routine
46  would get as input the string "a b c d", and as output it would
47  fill in ARGV with the four arguments "a", "b", "c", "d". */
48 
49 static void
50 breakup_args (char *scratch, char **argv)
51 {
52  char *cp = scratch, *tmp;
53 
54  for (;;)
55  {
56  /* Scan past leading separators */
57  while (*cp == ' ' || *cp == '\t' || *cp == '\n')
58  cp++;
59 
60  /* Break if at end of string. */
61  if (*cp == '\0')
62  break;
63 
64  /* Take an arg. */
65  *argv++ = cp;
66 
67  /* Scan for next arg separator. */
68  tmp = strchr (cp, ' ');
69  if (tmp == NULL)
70  tmp = strchr (cp, '\t');
71  if (tmp == NULL)
72  tmp = strchr (cp, '\n');
73 
74  /* No separators => end of string => break. */
75  if (tmp == NULL)
76  break;
77  cp = tmp;
78 
79  /* Replace the separator with a terminator. */
80  *cp++ = '\0';
81  }
82 
83  /* Null-terminate the vector. */
84  *argv = NULL;
85 }
86 
87 /* When executing a command under the given shell, return non-zero if
88  the '!' character should be escaped when embedded in a quoted
89  command-line argument. */
90 
91 static int
92 escape_bang_in_quoted_argument (const char *shell_file)
93 {
94  const int shell_file_len = strlen (shell_file);
95 
96  /* Bang should be escaped only in C Shells. For now, simply check
97  that the shell name ends with 'csh', which covers at least csh
98  and tcsh. This should be good enough for now. */
99 
100  if (shell_file_len < 3)
101  return 0;
102 
103  if (shell_file[shell_file_len - 3] == 'c'
104  && shell_file[shell_file_len - 2] == 's'
105  && shell_file[shell_file_len - 1] == 'h')
106  return 1;
107 
108  return 0;
109 }
110 
111 /* Start an inferior Unix child process and sets inferior_ptid to its
112  pid. EXEC_FILE is the file to run. ALLARGS is a string containing
113  the arguments to the program. ENV is the environment vector to
114  pass. SHELL_FILE is the shell file, or NULL if we should pick
115  one. EXEC_FUN is the exec(2) function to use, or NULL for the default
116  one. */
117 
118 /* This function is NOT reentrant. Some of the variables have been
119  made static to ensure that they survive the vfork call. */
120 
121 int
122 fork_inferior (char *exec_file_arg, char *allargs, char **env,
123  void (*traceme_fun) (void), void (*init_trace_fun) (int),
124  void (*pre_trace_fun) (void), char *shell_file_arg,
125  void (*exec_fun)(const char *file, char * const *argv,
126  char * const *env))
127 {
128  int pid;
129  static char default_shell_file[] = SHELL_FILE;
130  /* Set debug_fork then attach to the child while it sleeps, to debug. */
131  static int debug_fork = 0;
132  /* This is set to the result of setpgrp, which if vforked, will be visible
133  to you in the parent process. It's only used by humans for debugging. */
134  static int debug_setpgrp = 657473;
135  static char *shell_file;
136  static char *exec_file;
137  char **save_our_env;
138  int shell = 0;
139  static char **argv;
140  const char *inferior_io_terminal = get_inferior_io_terminal ();
141  struct inferior *inf;
142  int i;
143  int save_errno;
144 
145  /* If no exec file handed to us, get it from the exec-file command
146  -- with a good, common error message if none is specified. */
147  exec_file = exec_file_arg;
148  if (exec_file == 0)
149  exec_file = get_exec_file (1);
150 
151  /* 'startup_with_shell' is declared in inferior.h and bound to the
152  "set startup-with-shell" option. If 0, we'll just do a
153  fork/exec, no shell, so don't bother figuring out what shell. */
154  shell_file = shell_file_arg;
155  if (startup_with_shell)
156  {
157  /* Figure out what shell to start up the user program under. */
158  if (shell_file == NULL)
159  shell_file = getenv ("SHELL");
160  if (shell_file == NULL)
161  shell_file = default_shell_file;
162  shell = 1;
163  }
164 
165  if (!shell)
166  {
167  /* We're going to call execvp. Create argument vector.
168  Calculate an upper bound on the length of the vector by
169  assuming that every other character is a separate
170  argument. */
171  int argc = (strlen (allargs) + 1) / 2 + 2;
172 
173  argv = (char **) alloca (argc * sizeof (*argv));
174  argv[0] = exec_file;
175  breakup_args (allargs, &argv[1]);
176  }
177  else
178  {
179  /* We're going to call a shell. */
180  char *shell_command;
181  int len;
182  char *p;
183  int need_to_quote;
184  const int escape_bang = escape_bang_in_quoted_argument (shell_file);
185 
186  /* Multiplying the length of exec_file by 4 is to account for the
187  fact that it may expand when quoted; it is a worst-case number
188  based on every character being '. */
189  len = 5 + 4 * strlen (exec_file) + 1 + strlen (allargs) + 1 + /*slop */ 12;
190  if (exec_wrapper)
191  len += strlen (exec_wrapper) + 1;
192 
193  shell_command = (char *) alloca (len);
194  shell_command[0] = '\0';
195 
196  strcat (shell_command, "exec ");
197 
198  /* Add any exec wrapper. That may be a program name with arguments, so
199  the user must handle quoting. */
200  if (exec_wrapper)
201  {
202  strcat (shell_command, exec_wrapper);
203  strcat (shell_command, " ");
204  }
205 
206  /* Now add exec_file, quoting as necessary. */
207 
208  /* Quoting in this style is said to work with all shells. But
209  csh on IRIX 4.0.1 can't deal with it. So we only quote it if
210  we need to. */
211  p = exec_file;
212  while (1)
213  {
214  switch (*p)
215  {
216  case '\'':
217  case '!':
218  case '"':
219  case '(':
220  case ')':
221  case '$':
222  case '&':
223  case ';':
224  case '<':
225  case '>':
226  case ' ':
227  case '\n':
228  case '\t':
229  need_to_quote = 1;
230  goto end_scan;
231 
232  case '\0':
233  need_to_quote = 0;
234  goto end_scan;
235 
236  default:
237  break;
238  }
239  ++p;
240  }
241  end_scan:
242  if (need_to_quote)
243  {
244  strcat (shell_command, "'");
245  for (p = exec_file; *p != '\0'; ++p)
246  {
247  if (*p == '\'')
248  strcat (shell_command, "'\\''");
249  else if (*p == '!' && escape_bang)
250  strcat (shell_command, "\\!");
251  else
252  strncat (shell_command, p, 1);
253  }
254  strcat (shell_command, "'");
255  }
256  else
257  strcat (shell_command, exec_file);
258 
259  strcat (shell_command, " ");
260  strcat (shell_command, allargs);
261 
262  /* If we decided above to start up with a shell, we exec the
263  shell, "-c" says to interpret the next arg as a shell command
264  to execute, and this command is "exec <target-program>
265  <args>". */
266  argv = (char **) alloca (4 * sizeof (char *));
267  argv[0] = shell_file;
268  argv[1] = "-c";
269  argv[2] = shell_command;
270  argv[3] = (char *) 0;
271  }
272 
273  /* Retain a copy of our environment variables, since the child will
274  replace the value of environ and if we're vforked, we have to
275  restore it. */
276  save_our_env = environ;
277 
278  /* Tell the terminal handling subsystem what tty we plan to run on;
279  it will just record the information for later. */
280  new_tty_prefork (inferior_io_terminal);
281 
282  /* It is generally good practice to flush any possible pending stdio
283  output prior to doing a fork, to avoid the possibility of both
284  the parent and child flushing the same data after the fork. */
287 
288  /* If there's any initialization of the target layers that must
289  happen to prepare to handle the child we're about fork, do it
290  now... */
291  if (pre_trace_fun != NULL)
292  (*pre_trace_fun) ();
293 
294  /* Create the child process. Since the child process is going to
295  exec(3) shortly afterwards, try to reduce the overhead by
296  calling vfork(2). However, if PRE_TRACE_FUN is non-null, it's
297  likely that this optimization won't work since there's too much
298  work to do between the vfork(2) and the exec(3). This is known
299  to be the case on ttrace(2)-based HP-UX, where some handshaking
300  between parent and child needs to happen between fork(2) and
301  exec(2). However, since the parent is suspended in the vforked
302  state, this doesn't work. Also note that the vfork(2) call might
303  actually be a call to fork(2) due to the fact that autoconf will
304  ``#define vfork fork'' on certain platforms. */
305  if (pre_trace_fun || debug_fork)
306  pid = fork ();
307  else
308  pid = vfork ();
309 
310  if (pid < 0)
311  perror_with_name (("vfork"));
312 
313  if (pid == 0)
314  {
315  close_most_fds ();
316 
317  if (debug_fork)
318  sleep (debug_fork);
319 
320  /* Create a new session for the inferior process, if necessary.
321  It will also place the inferior in a separate process group. */
322  if (create_tty_session () <= 0)
323  {
324  /* No session was created, but we still want to run the inferior
325  in a separate process group. */
326  debug_setpgrp = gdb_setpgid ();
327  if (debug_setpgrp == -1)
328  perror (_("setpgrp failed in child"));
329  }
330 
331  /* Ask the tty subsystem to switch to the one we specified
332  earlier (or to share the current terminal, if none was
333  specified). */
334  new_tty ();
335 
336  /* Changing the signal handlers for the inferior after
337  a vfork can also change them for the superior, so we don't mess
338  with signals here. See comments in
339  initialize_signals for how we get the right signal handlers
340  for the inferior. */
341 
342  /* "Trace me, Dr. Memory!" */
343  (*traceme_fun) ();
344 
345  /* The call above set this process (the "child") as debuggable
346  by the original gdb process (the "parent"). Since processes
347  (unlike people) can have only one parent, if you are debugging
348  gdb itself (and your debugger is thus _already_ the
349  controller/parent for this child), code from here on out is
350  undebuggable. Indeed, you probably got an error message
351  saying "not parent". Sorry; you'll have to use print
352  statements! */
353 
354  /* There is no execlpe call, so we have to set the environment
355  for our child in the global variable. If we've vforked, this
356  clobbers the parent, but environ is restored a few lines down
357  in the parent. By the way, yes we do need to look down the
358  path to find $SHELL. Rich Pixley says so, and I agree. */
359  environ = env;
360 
361  if (exec_fun != NULL)
362  (*exec_fun) (argv[0], argv, env);
363  else
364  execvp (argv[0], argv);
365 
366  /* If we get here, it's an error. */
367  save_errno = errno;
368  fprintf_unfiltered (gdb_stderr, "Cannot exec %s", exec_file);
369  for (i = 1; argv[i] != NULL; i++)
370  fprintf_unfiltered (gdb_stderr, " %s", argv[i]);
372  fprintf_unfiltered (gdb_stderr, "Error: %s\n",
373  safe_strerror (save_errno));
375  _exit (0177);
376  }
377 
378  /* Restore our environment in case a vforked child clob'd it. */
379  environ = save_our_env;
380 
381  if (!have_inferiors ())
382  init_thread_list ();
383 
384  inf = current_inferior ();
385 
386  inferior_appeared (inf, pid);
387 
388  /* Needed for wait_for_inferior stuff below. */
389  inferior_ptid = pid_to_ptid (pid);
390 
391  new_tty_postfork ();
392 
393  /* We have something that executes now. We'll be running through
394  the shell at this point, but the pid shouldn't change. Targets
395  supporting MT should fill this task's ptid with more data as soon
396  as they can. */
398 
399  /* Now that we have a child process, make it our target, and
400  initialize anything target-vector-specific that needs
401  initializing. */
402  if (init_trace_fun)
403  (*init_trace_fun) (pid);
404 
405  /* We are now in the child process of interest, having exec'd the
406  correct program, and are poised at the first instruction of the
407  new program. */
408  return pid;
409 }
410 
411 /* Accept NTRAPS traps from the inferior. */
412 
413 void
414 startup_inferior (int ntraps)
415 {
416  int pending_execs = ntraps;
417  int terminal_initted = 0;
418  ptid_t resume_ptid;
419 
420  if (startup_with_shell)
421  {
422  /* One trap extra for exec'ing the shell. */
423  pending_execs++;
424  }
425 
427  resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
428  else
429  resume_ptid = minus_one_ptid;
430 
431  /* The process was started by the fork that created it, but it will
432  have stopped one instruction after execing the shell. Here we
433  must get it up to actual execution of the real program. */
434 
435  if (exec_wrapper)
436  pending_execs++;
437 
438  while (1)
439  {
440  enum gdb_signal resume_signal = GDB_SIGNAL_0;
441  ptid_t event_ptid;
442 
443  struct target_waitstatus ws;
444  memset (&ws, 0, sizeof (ws));
445  event_ptid = target_wait (resume_ptid, &ws, 0);
446 
447  if (ws.kind == TARGET_WAITKIND_IGNORE)
448  /* The inferior didn't really stop, keep waiting. */
449  continue;
450 
451  switch (ws.kind)
452  {
459  /* Ignore gracefully during startup of the inferior. */
460  switch_to_thread (event_ptid);
461  break;
462 
466  error (_("During startup program terminated with signal %s, %s."),
469  return;
470 
474  if (ws.value.integer)
475  error (_("During startup program exited with code %d."),
476  ws.value.integer);
477  else
478  error (_("During startup program exited normally."));
479  return;
480 
482  /* Handle EXEC signals as if they were SIGTRAP signals. */
484  resume_signal = GDB_SIGNAL_TRAP;
485  switch_to_thread (event_ptid);
486  break;
487 
489  resume_signal = ws.value.sig;
490  switch_to_thread (event_ptid);
491  break;
492  }
493 
494  if (resume_signal != GDB_SIGNAL_TRAP)
495  {
496  /* Let shell child handle its own signals in its own way. */
497  target_resume (resume_ptid, 0, resume_signal);
498  }
499  else
500  {
501  /* We handle SIGTRAP, however; it means child did an exec. */
502  if (!terminal_initted)
503  {
504  /* Now that the child has exec'd we know it has already
505  set its process group. On POSIX systems, tcsetpgrp
506  will fail with EPERM if we try it before the child's
507  setpgid. */
508 
509  /* Set up the "saved terminal modes" of the inferior
510  based on what modes we are starting it with. */
512 
513  /* Install inferior's terminal modes. */
515 
516  terminal_initted = 1;
517  }
518 
519  if (--pending_execs == 0)
520  break;
521 
522  /* Just make it go on. */
523  target_resume (resume_ptid, 0, GDB_SIGNAL_0);
524  }
525  }
526 
527  /* Mark all threads non-executing. */
528  set_executing (resume_ptid, 0);
529 }
530 
531 /* Implement the "unset exec-wrapper" command. */
532 
533 static void
534 unset_exec_wrapper_command (char *args, int from_tty)
535 {
536  xfree (exec_wrapper);
537  exec_wrapper = NULL;
538 }
539 
540 static void
541 show_startup_with_shell (struct ui_file *file, int from_tty,
542  struct cmd_list_element *c, const char *value)
543 {
544  fprintf_filtered (file,
545  _("Use of shell to start subprocesses is %s.\n"),
546  value);
547 }
548 
549 /* Provide a prototype to silence -Wmissing-prototypes. */
551 
552 void
554 {
555  add_setshow_filename_cmd ("exec-wrapper", class_run, &exec_wrapper, _("\
556 Set a wrapper for running programs.\n\
557 The wrapper prepares the system and environment for the new program."),
558  _("\
559 Show the wrapper for running programs."), NULL,
560  NULL, NULL,
561  &setlist, &showlist);
562 
563  add_cmd ("exec-wrapper", class_run, unset_exec_wrapper_command,
564  _("Disable use of an execution wrapper."),
565  &unsetlist);
566 
567  add_setshow_boolean_cmd ("startup-with-shell", class_support,
568  &startup_with_shell, _("\
569 Set use of shell to start subprocesses. The default is on."), _("\
570 Show use of shell to start subprocesses."), NULL,
571  NULL,
573  &setlist, &showlist);
574 }
void target_terminal_ours(void)
Definition: target.c:491
static void unset_exec_wrapper_command(char *args, int from_tty)
Definition: fork-child.c:534
int have_inferiors(void)
Definition: inferior.c:460
static char * exec_wrapper
Definition: fork-child.c:42
void xfree(void *)
Definition: common-utils.c:97
void new_tty_prefork(const char *ttyname)
Definition: inflow.c:677
void new_tty_postfork(void)
Definition: inflow.c:763
void new_tty(void)
Definition: inflow.c:700
tuple inf
Definition: arm-linux.py:13
struct ui_file * gdb_stdout
Definition: main.c:71
void switch_to_thread(ptid_t ptid)
Definition: thread.c:1185
#define _(String)
Definition: gdb_locale.h:40
static void show_startup_with_shell(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: fork-child.c:541
Definition: ptid.h:35
static void breakup_args(char *scratch, char **argv)
Definition: fork-child.c:50
struct cmd_list_element * setlist
Definition: cli-cmds.c:135
const char * get_inferior_io_terminal(void)
Definition: infcmd.c:157
void initialize_file_ftype(void)
Definition: defs.h:281
void startup_inferior(int ntraps)
Definition: fork-child.c:414
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
static int resume_signal
Definition: go32-nat.c:347
enum gdb_signal sig
Definition: waitstatus.h:108
void target_terminal_inferior(void)
Definition: target.c:470
void target_resume(ptid_t ptid, int step, enum gdb_signal signal)
Definition: target.c:2245
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
struct cmd_list_element * showlist
Definition: cli-cmds.c:143
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:192
ptid_t pid_to_ptid(int pid)
Definition: ptid.c:44
struct cmd_list_element * unsetlist
Definition: cli-cmds.c:139
initialize_file_ftype _initialize_fork_child
union target_waitstatus::@161 value
char ** argv
Definition: inferior.h:329
void target_mourn_inferior(void)
Definition: target.c:2300
int fork_inferior(char *exec_file_arg, char *allargs, char **env, void(*traceme_fun)(void), void(*init_trace_fun)(int), void(*pre_trace_fun)(void), char *shell_file_arg, void(*exec_fun)(const char *file, char *const *argv, char *const *env))
Definition: fork-child.c:122
struct thread_info * add_thread_silent(ptid_t ptid)
Definition: thread.c:240
const char * gdb_signal_to_name(enum gdb_signal)
Definition: signals.c:78
ptid_t target_wait(ptid_t ptid, struct target_waitstatus *status, int options)
Definition: target.c:2227
void close_most_fds(void)
Definition: filestuff.c:224
Definition: value.c:172
char ** environ
int ptid_get_pid(ptid_t ptid)
Definition: ptid.c:52
void target_terminal_init(void)
Definition: target.c:452
char * execd_pathname
Definition: waitstatus.h:112
void void void void void void void void void perror_with_name(const char *string) ATTRIBUTE_NORETURN
Definition: utils.c:979
int gdb_setpgid(void)
Definition: inflow.c:857
enum target_waitkind kind
Definition: waitstatus.h:100
struct ui_file * gdb_stderr
Definition: main.c:72
ptid_t inferior_ptid
Definition: infcmd.c:124
char * safe_strerror(int)
static int escape_bang_in_quoted_argument(const char *shell_file)
Definition: fork-child.c:92
int argc
Definition: inferior.h:323
void add_setshow_filename_cmd(const char *name, enum command_class theclass, char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:563
struct inferior * current_inferior(void)
Definition: inferior.c:57
char * get_exec_file(int err)
Definition: corefile.c:179
#define SHELL_FILE
Definition: fork-child.c:38
#define target_supports_multi_process()
Definition: target.h:1353
const char * gdb_signal_to_string(enum gdb_signal)
Definition: signals.c:68
int startup_with_shell
Definition: infcmd.c:141
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:192
pid_t create_tty_session(void)
Definition: inflow.c:828
void set_executing(ptid_t ptid, int executing)
Definition: thread.c:850
void error(const char *fmt,...)
Definition: errors.c:38
ptid_t minus_one_ptid
Definition: ptid.c:26
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int int rusage_t pid_t pid
Definition: gnu-nat.c:1818
void inferior_appeared(struct inferior *inf, int pid)
Definition: inferior.c:320
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:541
void init_thread_list(void)
Definition: thread.c:198
const ULONGEST const LONGEST len
Definition: target.h:309