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 Free Software Foundation, Inc.
   5
   6    Contributed by Cygnus Support.
   7
   8    This file is part of GDB.
   9
  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.
  14
  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.
  19
  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/>.  */
  22
  23 #include "defs.h"
  24 #include "gdb_string.h"
  25 #include "frame.h"              /* required by inferior.h */
  26 #include "inferior.h"
  27 #include "target.h"
  28 #include "gdb_wait.h"
  29 #include "gdb_vfork.h"
  30 #include "gdbcore.h"
  31 #include "terminal.h"
  32 #include "gdbthread.h"
  33 #include "command.h" /* for dont_repeat () */
  34 #include "gdbcmd.h"
  35 #include "solib.h"
  36
  37 #include <signal.h>
  38
  39 /* This just gets used as a default if we can't find SHELL.  */
  40 #define SHELL_FILE "/bin/sh"
  41
  42 extern char **environ;
  43
  44 static char *exec_wrapper;
  45
  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".  */
  50
  51 static void
  52 breakup_args (char *scratch, char **argv)
  53 {
  54   char *cp = scratch;
  55
  56   for (;;)
  57     {
  58       /* Scan past leading separators */
  59       while (*cp == ' ' || *cp == '\t' || *cp == '\n')
  60         cp++;
  61
  62       /* Break if at end of string.  */
  63       if (*cp == '\0')
  64         break;
  65
  66       /* Take an arg.  */
  67       *argv++ = cp;
  68
  69       /* Scan for next arg separator.  */
  70       cp = strchr (cp, ' ');
  71       if (cp == NULL)
  72         cp = strchr (cp, '\t');
  73       if (cp == NULL)
  74         cp = strchr (cp, '\n');
  75
  76       /* No separators => end of string => break.  */
  77       if (cp == NULL)
  78         break;
  79
  80       /* Replace the separator with a terminator.  */
  81       *cp++ = '\0';
  82     }
  83
  84   /* Null-terminate the vector.  */
  85   *argv = NULL;
  86 }
  87
  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.  */
  91
  92 static int
  93 escape_bang_in_quoted_argument (const char *shell_file)
  94 {
  95   const int shell_file_len = strlen (shell_file);
  96
  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.  */
 100
 101   if (shell_file_len < 3)
 102     return 0;
 103
 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')
 107     return 1;
 108
 109   return 0;
 110 }
 111
 112 /* Start an inferior Unix child process and sets inferior_ptid to its
 113    pid.  EXEC_FILE is the file to run.  ALLARGS is a string containing
 114    the arguments to the program.  ENV is the environment vector to
 115    pass.  SHELL_FILE is the shell file, or NULL if we should pick
 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 void
 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 {
 126   int pid;
 127   char *shell_command;
 128   static char default_shell_file[] = SHELL_FILE;
 129   int len;
 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
 142   /* If no exec file handed to us, get it from the exec-file command
 143      -- with a good, common error message if none is specified.  */
 144   exec_file = exec_file_arg;
 145   if (exec_file == 0)
 146     exec_file = get_exec_file (1);
 147
 148   /* STARTUP_WITH_SHELL is defined in inferior.h.  If 0,e we'll just
 149     do a fork/exec, no shell, so don't bother figuring out what
 150     shell.  */
 151   shell_file = shell_file_arg;
 152   if (STARTUP_WITH_SHELL)
 153     {
 154       /* Figure out what shell to start up the user program under.  */
 155       if (shell_file == NULL)
 156         shell_file = getenv ("SHELL");
 157       if (shell_file == NULL)
 158         shell_file = default_shell_file;
 159       shell = 1;
 160     }
 161
 162   /* Multiplying the length of exec_file by 4 is to account for the
 163      fact that it may expand when quoted; it is a worst-case number
 164      based on every character being '.  */
 165   len = 5 + 4 * strlen (exec_file) + 1 + strlen (allargs) + 1 + /*slop */ 12;
 166   if (exec_wrapper)
 167     len += strlen (exec_wrapper) + 1;
 168
 169   shell_command = (char *) alloca (len);
 170   shell_command[0] = '\0';
 171
 172   if (!shell)
 173     {
 174       /* We're going to call execvp.  Create argument vector.
 175          Calculate an upper bound on the length of the vector by
 176          assuming that every other character is a separate
 177          argument.  */
 178       int argc = (strlen (allargs) + 1) / 2 + 2;
 179       argv = (char **) xmalloc (argc * sizeof (*argv));
 180       argv[0] = exec_file;
 181       breakup_args (allargs, &argv[1]);
 182     }
 183   else
 184     {
 185       /* We're going to call a shell.  */
 186
 187       char *p;
 188       int need_to_quote;
 189       const int escape_bang = escape_bang_in_quoted_argument (shell_file);
 190
 191       strcat (shell_command, "exec ");
 192
 193       /* Add any exec wrapper.  That may be a program name with arguments, so
 194          the user must handle quoting.  */
 195       if (exec_wrapper)
 196         {
 197           strcat (shell_command, exec_wrapper);
 198           strcat (shell_command, " ");
 199         }
 200
 201       /* Now add exec_file, quoting as necessary.  */
 202
 203       /* Quoting in this style is said to work with all shells.  But
 204          csh on IRIX 4.0.1 can't deal with it.  So we only quote it if
 205          we need to.  */
 206       p = exec_file;
 207       while (1)
 208         {
 209           switch (*p)
 210             {
 211             case '\'':
 212             case '!':
 213             case '"':
 214             case '(':
 215             case ')':
 216             case '$':
 217             case '&':
 218             case ';':
 219             case '<':
 220             case '>':
 221             case ' ':
 222             case '\n':
 223             case '\t':
 224               need_to_quote = 1;
 225               goto end_scan;
 226
 227             case '\0':
 228               need_to_quote = 0;
 229               goto end_scan;
 230
 231             default:
 232               break;
 233             }
 234           ++p;
 235         }
 236     end_scan:
 237       if (need_to_quote)
 238         {
 239           strcat (shell_command, "'");
 240           for (p = exec_file; *p != '\0'; ++p)
 241             {
 242               if (*p == '\'')
 243                 strcat (shell_command, "'\\''");
 244               else if (*p == '!' && escape_bang)
 245                 strcat (shell_command, "\\!");
 246               else
 247                 strncat (shell_command, p, 1);
 248             }
 249           strcat (shell_command, "'");
 250         }
 251       else
 252         strcat (shell_command, exec_file);
 253
 254       strcat (shell_command, " ");
 255       strcat (shell_command, allargs);
 256     }
 257
 258   /* On some systems an exec will fail if the executable is open.  */
 259   close_exec_file ();
 260
 261   /* Retain a copy of our environment variables, since the child will
 262      replace the value of environ and if we're vforked, we have to
 263      restore it.  */
 264   save_our_env = environ;
 265
 266   /* Tell the terminal handling subsystem what tty we plan to run on;
 267      it will just record the information for later.  */
 268   new_tty_prefork (inferior_io_terminal);
 269
 270   /* It is generally good practice to flush any possible pending stdio
 271      output prior to doing a fork, to avoid the possibility of both
 272      the parent and child flushing the same data after the fork. */
 273   gdb_flush (gdb_stdout);
 274   gdb_flush (gdb_stderr);
 275
 276   /* If there's any initialization of the target layers that must
 277      happen to prepare to handle the child we're about fork, do it
 278      now...  */
 279   if (pre_trace_fun != NULL)
 280     (*pre_trace_fun) ();
 281
 282   /* Create the child process.  Since the child process is going to
 283      exec(3) shortly afterwards, try to reduce the overhead by
 284      calling vfork(2).  However, if PRE_TRACE_FUN is non-null, it's
 285      likely that this optimization won't work since there's too much
 286      work to do between the vfork(2) and the exec(3).  This is known
 287      to be the case on ttrace(2)-based HP-UX, where some handshaking
 288      between parent and child needs to happen between fork(2) and
 289      exec(2).  However, since the parent is suspended in the vforked
 290      state, this doesn't work.  Also note that the vfork(2) call might
 291      actually be a call to fork(2) due to the fact that autoconf will
 292      ``#define vfork fork'' on certain platforms.  */
 293   if (pre_trace_fun || debug_fork)
 294     pid = fork ();
 295   else
 296     pid = vfork ();
 297
 298   if (pid < 0)
 299     perror_with_name (("vfork"));
 300
 301   if (pid == 0)
 302     {
 303       if (debug_fork)
 304         sleep (debug_fork);
 305
 306       /* Create a new session for the inferior process, if necessary.
 307          It will also place the inferior in a separate process group.  */
 308       if (create_tty_session () <= 0)
 309         {
 310           /* No session was created, but we still want to run the inferior
 311              in a separate process group.  */
 312           debug_setpgrp = gdb_setpgid ();
 313           if (debug_setpgrp == -1)
 314             perror ("setpgrp failed in child");
 315         }
 316
 317       /* Ask the tty subsystem to switch to the one we specified
 318          earlier (or to share the current terminal, if none was
 319          specified).  */
 320       new_tty ();
 321
 322       /* Changing the signal handlers for the inferior after
 323          a vfork can also change them for the superior, so we don't mess
 324          with signals here.  See comments in
 325          initialize_signals for how we get the right signal handlers
 326          for the inferior.  */
 327
 328       /* "Trace me, Dr. Memory!" */
 329       (*traceme_fun) ();
 330
 331       /* The call above set this process (the "child") as debuggable
 332         by the original gdb process (the "parent").  Since processes
 333         (unlike people) can have only one parent, if you are debugging
 334         gdb itself (and your debugger is thus _already_ the
 335         controller/parent for this child), code from here on out is
 336         undebuggable.  Indeed, you probably got an error message
 337         saying "not parent".  Sorry; you'll have to use print
 338         statements!  */
 339
 340       /* There is no execlpe call, so we have to set the environment
 341          for our child in the global variable.  If we've vforked, this
 342          clobbers the parent, but environ is restored a few lines down
 343          in the parent.  By the way, yes we do need to look down the
 344          path to find $SHELL.  Rich Pixley says so, and I agree.  */
 345       environ = env;
 346
 347       /* If we decided above to start up with a shell, we exec the
 348          shell, "-c" says to interpret the next arg as a shell command
 349          to execute, and this command is "exec <target-program>
 350          <args>".  */
 351       if (shell)
 352         {
 353           execlp (shell_file, shell_file, "-c", shell_command, (char *) 0);
 354
 355           /* If we get here, it's an error.  */
 356           fprintf_unfiltered (gdb_stderr, "Cannot exec %s: %s.\n", shell_file,
 357                               safe_strerror (errno));
 358           gdb_flush (gdb_stderr);
 359           _exit (0177);
 360         }
 361       else
 362         {
 363           /* Otherwise, we directly exec the target program with
 364              execvp.  */
 365           int i;
 366           char *errstring;
 367
 368           execvp (exec_file, argv);
 369
 370           /* If we get here, it's an error.  */
 371           errstring = safe_strerror (errno);
 372           fprintf_unfiltered (gdb_stderr, "Cannot exec %s ", exec_file);
 373
 374           i = 1;
 375           while (argv[i] != NULL)
 376             {
 377               if (i != 1)
 378                 fprintf_unfiltered (gdb_stderr, " ");
 379               fprintf_unfiltered (gdb_stderr, "%s", argv[i]);
 380               i++;
 381             }
 382           fprintf_unfiltered (gdb_stderr, ".\n");
 383 #if 0
 384           /* This extra info seems to be useless.  */
 385           fprintf_unfiltered (gdb_stderr, "Got error %s.\n", errstring);
 386 #endif
 387           gdb_flush (gdb_stderr);
 388           _exit (0177);
 389         }
 390     }
 391
 392   /* Restore our environment in case a vforked child clob'd it.  */
 393   environ = save_our_env;
 394
 395   init_thread_list ();
 396
 397   /* Needed for wait_for_inferior stuff below.  */
 398   inferior_ptid = pid_to_ptid (pid);
 399
 400   /* Now that we have a child process, make it our target, and
 401      initialize anything target-vector-specific that needs
 402      initializing.  */
 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 }
 409
 410 /* Accept NTRAPS traps from the inferior.  */
 411
 412 void
 413 startup_inferior (int ntraps)
 414 {
 415   int pending_execs = ntraps;
 416   int terminal_initted = 0;
 417
 418   /* The process was started by the fork that created it, but it will
 419      have stopped one instruction after execing the shell.  Here we
 420      must get it up to actual execution of the real program.  */
 421
 422   if (exec_wrapper)
 423     pending_execs++;
 424
 425   clear_proceed_status ();
 426
 427   init_wait_for_inferior ();
 428
 429   inferior_ignoring_leading_exec_events =
 430     target_reported_exec_events_per_exec_call () - 1;
 431
 432   while (1)
 433     {
 434       /* Make wait_for_inferior be quiet. */
 435       stop_soon = STOP_QUIETLY;
 436       wait_for_inferior (1);
 437       if (stop_signal != TARGET_SIGNAL_TRAP)
 438         {
 439           /* Let shell child handle its own signals in its own way.
 440              FIXME: what if child has exited?  Must exit loop
 441              somehow.  */
 442           resume (0, stop_signal);
 443         }
 444       else
 445         {
 446           /* We handle SIGTRAP, however; it means child did an exec.  */
 447           if (!terminal_initted)
 448             {
 449               /* Now that the child has exec'd we know it has already
 450                  set its process group.  On POSIX systems, tcsetpgrp
 451                  will fail with EPERM if we try it before the child's
 452                  setpgid.  */
 453
 454               /* Set up the "saved terminal modes" of the inferior
 455                  based on what modes we are starting it with.  */
 456               target_terminal_init ();
 457
 458               /* Install inferior's terminal modes.  */
 459               target_terminal_inferior ();
 460
 461               terminal_initted = 1;
 462             }
 463
 464           if (--pending_execs == 0)
 465             break;
 466
 467           resume (0, TARGET_SIGNAL_0);  /* Just make it go on.  */
 468         }
 469     }
 470   stop_soon = NO_STOP_QUIETLY;
 471 }
 472
 473 /* Implement the "unset exec-wrapper" command.  */
 474
 475 static void
 476 unset_exec_wrapper_command (char *args, int from_tty)
 477 {
 478   xfree (exec_wrapper);
 479   exec_wrapper = NULL;
 480 }
 481
 482 void
 483 _initialize_fork_child (void)
 484 {
 485   add_setshow_filename_cmd ("exec-wrapper", class_run, &exec_wrapper, _("\
 486 Set a wrapper for running programs.\n\
 487 The wrapper prepares the system and environment for the new program."),
 488                             _("\
 489 Show the wrapper for running programs."), NULL,
 490                             NULL, NULL,
 491                             &setlist, &showlist);
 492
 493   add_cmd ("exec-wrapper", class_run, unset_exec_wrapper_command,
 494            _("Disable use of an execution wrapper."),
 495            &unsetlist);
 496 }