gdb/fork-child.c

   1 /* Fork a Unix child process, and set up to debug it, for GDB.
   2
   3    Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
   4    2001, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   5    Free Software Foundation, Inc.
   6
   7    Contributed by Cygnus Support.
   8
   9    This file is part of GDB.
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  23
  24 #include "defs.h"
  25 #include "gdb_string.h"
  26 #include "inferior.h"
  27 #include "terminal.h"
  28 #include "target.h"
  29 #include "gdb_wait.h"
  30 #include "gdb_vfork.h"
  31 #include "gdbcore.h"
  32 #include "terminal.h"
  33 #include "gdbthread.h"
  34 #include "command.h" /* for dont_repeat () */
  35 #include "gdbcmd.h"
  36 #include "solib.h"
  37
  38 #include <signal.h>
  39
  40 /* This just gets used as a default if we can't find SHELL.  */
  41 #define SHELL_FILE "/bin/sh"
  42
  43 extern char **environ;
  44
  45 static char *exec_wrapper;
  46
  47 /* Break up SCRATCH into an argument vector suitable for passing to
  48    execvp and store it in ARGV.  E.g., on "run a b c d" this routine
  49    would get as input the string "a b c d", and as output it would
  50    fill in ARGV with the four arguments "a", "b", "c", "d".  */
  51
  52 static void
  53 breakup_args (char *scratch, char **argv)
  54 {
  55   char *cp = scratch, *tmp;
  56
  57   for (;;)
  58     {
  59       /* Scan past leading separators */
  60       while (*cp == ' ' || *cp == '\t' || *cp == '\n')
  61         cp++;
  62
  63       /* Break if at end of string.  */
  64       if (*cp == '\0')
  65         break;
  66
  67       /* Take an arg.  */
  68       *argv++ = cp;
  69
  70       /* Scan for next arg separator.  */
  71       tmp = strchr (cp, ' ');
  72       if (tmp == NULL)
  73         tmp = strchr (cp, '\t');
  74       if (tmp == NULL)
  75         tmp = strchr (cp, '\n');
  76
  77       /* No separators => end of string => break.  */
  78       if (tmp == NULL)
  79         break;
  80       cp = tmp;
  81
  82       /* Replace the separator with a terminator.  */
  83       *cp++ = '\0';
  84     }
  85
  86   /* Null-terminate the vector.  */
  87   *argv = NULL;
  88 }
  89
  90 /* When executing a command under the given shell, return non-zero if
  91    the '!' character should be escaped when embedded in a quoted
  92    command-line argument.  */
  93
  94 static int
  95 escape_bang_in_quoted_argument (const char *shell_file)
  96 {
  97   const int shell_file_len = strlen (shell_file);
  98
  99   /* Bang should be escaped only in C Shells.  For now, simply check
 100      that the shell name ends with 'csh', which covers at least csh
 101      and tcsh.  This should be good enough for now.  */
 102
 103   if (shell_file_len < 3)
 104     return 0;
 105
 106   if (shell_file[shell_file_len - 3] == 'c'
 107       && shell_file[shell_file_len - 2] == 's'
 108       && shell_file[shell_file_len - 1] == 'h')
 109     return 1;
 110
 111   return 0;
 112 }
 113
 114 /* Start an inferior Unix child process and sets inferior_ptid to its
 115    pid.  EXEC_FILE is the file to run.  ALLARGS is a string containing
 116    the arguments to the program.  ENV is the environment vector to
 117    pass.  SHELL_FILE is the shell file, or NULL if we should pick
 118    one.  */
 119
 120 /* This function is NOT reentrant.  Some of the variables have been
 121    made static to ensure that they survive the vfork call.  */
 122
 123 int
 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 {
 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 defined in inferior.h.  If 0,e we'll just
 152     do a fork/exec, no shell, so don't bother figuring out what
 153     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   /* On some systems an exec will fail if the executable is open.  */
 274   close_exec_file ();
 275
 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
 278      restore it.  */
 279   save_our_env = environ;
 280
 281   /* Tell the terminal handling subsystem what tty we plan to run on;
 282      it will just record the information for later.  */
 283   new_tty_prefork (inferior_io_terminal);
 284
 285   /* It is generally good practice to flush any possible pending stdio
 286      output prior to doing a fork, to avoid the possibility of both
 287      the parent and child flushing the same data after the fork.  */
 288   gdb_flush (gdb_stdout);
 289   gdb_flush (gdb_stderr);
 290
 291   /* If there's any initialization of the target layers that must
 292      happen to prepare to handle the child we're about fork, do it
 293      now...  */
 294   if (pre_trace_fun != NULL)
 295     (*pre_trace_fun) ();
 296
 297   /* Create the child process.  Since the child process is going to
 298      exec(3) shortly afterwards, try to reduce the overhead by
 299      calling vfork(2).  However, if PRE_TRACE_FUN is non-null, it's
 300      likely that this optimization won't work since there's too much
 301      work to do between the vfork(2) and the exec(3).  This is known
 302      to be the case on ttrace(2)-based HP-UX, where some handshaking
 303      between parent and child needs to happen between fork(2) and
 304      exec(2).  However, since the parent is suspended in the vforked
 305      state, this doesn't work.  Also note that the vfork(2) call might
 306      actually be a call to fork(2) due to the fact that autoconf will
 307      ``#define vfork fork'' on certain platforms.  */
 308   if (pre_trace_fun || debug_fork)
 309     pid = fork ();
 310   else
 311     pid = vfork ();
 312
 313   if (pid < 0)
 314     perror_with_name (("vfork"));
 315
 316   if (pid == 0)
 317     {
 318       if (debug_fork)
 319         sleep (debug_fork);
 320
 321       /* Create a new session for the inferior process, if necessary.
 322          It will also place the inferior in a separate process group.  */
 323       if (create_tty_session () <= 0)
 324         {
 325           /* No session was created, but we still want to run the inferior
 326              in a separate process group.  */
 327           debug_setpgrp = gdb_setpgid ();
 328           if (debug_setpgrp == -1)
 329             perror (_("setpgrp failed in child"));
 330         }
 331
 332       /* Ask the tty subsystem to switch to the one we specified
 333          earlier (or to share the current terminal, if none was
 334          specified).  */
 335       new_tty ();
 336
 337       /* Changing the signal handlers for the inferior after
 338          a vfork can also change them for the superior, so we don't mess
 339          with signals here.  See comments in
 340          initialize_signals for how we get the right signal handlers
 341          for the inferior.  */
 342
 343       /* "Trace me, Dr. Memory!"  */
 344       (*traceme_fun) ();
 345
 346       /* The call above set this process (the "child") as debuggable
 347         by the original gdb process (the "parent").  Since processes
 348         (unlike people) can have only one parent, if you are debugging
 349         gdb itself (and your debugger is thus _already_ the
 350         controller/parent for this child), code from here on out is
 351         undebuggable.  Indeed, you probably got an error message
 352         saying "not parent".  Sorry; you'll have to use print
 353         statements!  */
 354
 355       /* There is no execlpe call, so we have to set the environment
 356          for our child in the global variable.  If we've vforked, this
 357          clobbers the parent, but environ is restored a few lines down
 358          in the parent.  By the way, yes we do need to look down the
 359          path to find $SHELL.  Rich Pixley says so, and I agree.  */
 360       environ = env;
 361
 362       execvp (argv[0], argv);
 363
 364       /* If we get here, it's an error.  */
 365       save_errno = errno;
 366       fprintf_unfiltered (gdb_stderr, "Cannot exec %s", exec_file);
 367       for (i = 1; argv[i] != NULL; i++)
 368         fprintf_unfiltered (gdb_stderr, " %s", argv[i]);
 369       fprintf_unfiltered (gdb_stderr, ".\n");
 370       fprintf_unfiltered (gdb_stderr, "Error: %s\n",
 371                           safe_strerror (save_errno));
 372       gdb_flush (gdb_stderr);
 373       _exit (0177);
 374     }
 375
 376   /* Restore our environment in case a vforked child clob'd it.  */
 377   environ = save_our_env;
 378
 379   if (!have_inferiors ())
 380     init_thread_list ();
 381
 382   inf = current_inferior ();
 383
 384   inferior_appeared (inf, pid);
 385
 386   /* Needed for wait_for_inferior stuff below.  */
 387   inferior_ptid = pid_to_ptid (pid);
 388
 389   new_tty_postfork ();
 390
 391   /* We have something that executes now.  We'll be running through
 392      the shell at this point, but the pid shouldn't change.  Targets
 393      supporting MT should fill this task's ptid with more data as soon
 394      as they can.  */
 395   add_thread_silent (inferior_ptid);
 396
 397   /* Now that we have a child process, make it our target, and
 398      initialize anything target-vector-specific that needs
 399      initializing.  */
 400   if (init_trace_fun)
 401     (*init_trace_fun) (pid);
 402
 403   /* We are now in the child process of interest, having exec'd the
 404      correct program, and are poised at the first instruction of the
 405      new program.  */
 406   return pid;
 407 }
 408
 409 /* Accept NTRAPS traps from the inferior.  */
 410
 411 void
 412 startup_inferior (int ntraps)
 413 {
 414   int pending_execs = ntraps;
 415   int terminal_initted = 0;
 416   ptid_t resume_ptid;
 417
 418   if (target_supports_multi_process ())
 419     resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
 420   else
 421     resume_ptid = minus_one_ptid;
 422
 423   /* The process was started by the fork that created it, but it will
 424      have stopped one instruction after execing the shell.  Here we
 425      must get it up to actual execution of the real program.  */
 426
 427   if (exec_wrapper)
 428     pending_execs++;
 429
 430   while (1)
 431     {
 432       enum target_signal resume_signal = TARGET_SIGNAL_0;
 433       ptid_t event_ptid;
 434
 435       struct target_waitstatus ws;
 436       memset (&ws, 0, sizeof (ws));
 437       event_ptid = target_wait (resume_ptid, &ws, 0);
 438
 439       if (ws.kind == TARGET_WAITKIND_IGNORE)
 440         /* The inferior didn't really stop, keep waiting.  */
 441         continue;
 442
 443       switch (ws.kind)
 444         {
 445           case TARGET_WAITKIND_SPURIOUS:
 446           case TARGET_WAITKIND_LOADED:
 447           case TARGET_WAITKIND_FORKED:
 448           case TARGET_WAITKIND_VFORKED:
 449           case TARGET_WAITKIND_SYSCALL_ENTRY:
 450           case TARGET_WAITKIND_SYSCALL_RETURN:
 451             /* Ignore gracefully during startup of the inferior.  */
 452             switch_to_thread (event_ptid);
 453             break;
 454
 455           case TARGET_WAITKIND_SIGNALLED:
 456             target_terminal_ours ();
 457             target_mourn_inferior ();
 458             error (_("During startup program terminated with signal %s, %s."),
 459                    target_signal_to_name (ws.value.sig),
 460                    target_signal_to_string (ws.value.sig));
 461             return;
 462
 463           case TARGET_WAITKIND_EXITED:
 464             target_terminal_ours ();
 465             target_mourn_inferior ();
 466             if (ws.value.integer)
 467               error (_("During startup program exited with code %d."),
 468                      ws.value.integer);
 469             else
 470               error (_("During startup program exited normally."));
 471             return;
 472
 473           case TARGET_WAITKIND_EXECD:
 474             /* Handle EXEC signals as if they were SIGTRAP signals.  */
 475             xfree (ws.value.execd_pathname);
 476             resume_signal = TARGET_SIGNAL_TRAP;
 477             switch_to_thread (event_ptid);
 478             break;
 479
 480           case TARGET_WAITKIND_STOPPED:
 481             resume_signal = ws.value.sig;
 482             switch_to_thread (event_ptid);
 483             break;
 484         }
 485
 486       if (resume_signal != TARGET_SIGNAL_TRAP)
 487         {
 488           /* Let shell child handle its own signals in its own way.  */
 489           target_resume (resume_ptid, 0, resume_signal);
 490         }
 491       else
 492         {
 493           /* We handle SIGTRAP, however; it means child did an exec.  */
 494           if (!terminal_initted)
 495             {
 496               /* Now that the child has exec'd we know it has already
 497                  set its process group.  On POSIX systems, tcsetpgrp
 498                  will fail with EPERM if we try it before the child's
 499                  setpgid.  */
 500
 501               /* Set up the "saved terminal modes" of the inferior
 502                  based on what modes we are starting it with.  */
 503               target_terminal_init ();
 504
 505               /* Install inferior's terminal modes.  */
 506               target_terminal_inferior ();
 507
 508               terminal_initted = 1;
 509             }
 510
 511           if (--pending_execs == 0)
 512             break;
 513
 514           /* Just make it go on.  */
 515           target_resume (resume_ptid, 0, TARGET_SIGNAL_0);
 516         }
 517     }
 518
 519   /* Mark all threads non-executing.  */
 520   set_executing (resume_ptid, 0);
 521 }
 522
 523 /* Implement the "unset exec-wrapper" command.  */
 524
 525 static void
 526 unset_exec_wrapper_command (char *args, int from_tty)
 527 {
 528   xfree (exec_wrapper);
 529   exec_wrapper = NULL;
 530 }
 531
 532 /* Provide a prototype to silence -Wmissing-prototypes.  */
 533 extern initialize_file_ftype _initialize_fork_child;
 534
 535 void
 536 _initialize_fork_child (void)
 537 {
 538   add_setshow_filename_cmd ("exec-wrapper", class_run, &exec_wrapper, _("\
 539 Set a wrapper for running programs.\n\
 540 The wrapper prepares the system and environment for the new program."),
 541                             _("\
 542 Show the wrapper for running programs."), NULL,
 543                             NULL, NULL,
 544                             &setlist, &showlist);
 545
 546   add_cmd ("exec-wrapper", class_run, unset_exec_wrapper_command,
 547            _("Disable use of an execution wrapper."),
 548            &unsetlist);
 549 }