gdb/fork-child.c

   1 /* Fork a Unix child process, and set up to debug it, for GDB.
   2
   3    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999,
   4    2000, 2001, 2004 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 2 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, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330,
  23    Boston, MA 02111-1307, USA.  */
  24
  25 #include "defs.h"
  26 #include "gdb_string.h"
  27 #include "frame.h"              /* required by inferior.h */
  28 #include "inferior.h"
  29 #include "target.h"
  30 #include "gdb_wait.h"
  31 #include "gdb_vfork.h"
  32 #include "gdbcore.h"
  33 #include "terminal.h"
  34 #include "gdbthread.h"
  35 #include "command.h" /* for dont_repeat () */
  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 #ifndef SHELL_FILE
  42 #define SHELL_FILE "/bin/sh"
  43 #endif
  44
  45 extern char **environ;
  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;
  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       cp = strchr (cp, ' ');
  72       if (cp == NULL)
  73         cp = strchr (cp, '\t');
  74       if (cp == NULL)
  75         cp = strchr (cp, '\n');
  76
  77       /* No separators => end of string => break.  */
  78       if (cp == NULL)
  79         break;
  80
  81       /* Replace the separator with a terminator.  */
  82       *cp++ = '\0';
  83     }
  84
  85   /* Null-terminate the vector.  */
  86   *argv = NULL;
  87 }
  88
  89 /* When executing a command under the given shell, return non-zero if
  90    the '!' character should be escaped when embedded in a quoted
  91    command-line argument.  */
  92
  93 static int
  94 escape_bang_in_quoted_argument (const char *shell_file)
  95 {
  96   const int shell_file_len = strlen (shell_file);
  97
  98   /* Bang should be escaped only in C Shells.  For now, simply check
  99      that the shell name ends with 'csh', which covers at least csh
 100      and tcsh.  This should be good enough for now.  */
 101
 102   if (shell_file_len < 3)
 103     return 0;
 104
 105   if (shell_file[shell_file_len - 3] == 'c'
 106       && shell_file[shell_file_len - 2] == 's'
 107       && shell_file[shell_file_len - 1] == 'h')
 108     return 1;
 109
 110   return 0;
 111 }
 112
 113 /* Start an inferior Unix child process and sets inferior_ptid to its
 114    pid.  EXEC_FILE is the file to run.  ALLARGS is a string containing
 115    the arguments to the program.  ENV is the environment vector to
 116    pass.  SHELL_FILE is the shell file, or NULL if we should pick
 117    one.  */
 118
 119 /* This function is NOT reentrant.  Some of the variables have been
 120    made static to ensure that they survive the vfork call.  */
 121
 122 void
 123 fork_inferior (char *exec_file_arg, char *allargs, char **env,
 124                void (*traceme_fun) (void), void (*init_trace_fun) (int),
 125                void (*pre_trace_fun) (void), char *shell_file_arg)
 126 {
 127   int pid;
 128   char *shell_command;
 129   static char default_shell_file[] = SHELL_FILE;
 130   int len;
 131   /* Set debug_fork then attach to the child while it sleeps, to debug. */
 132   static int debug_fork = 0;
 133   /* This is set to the result of setpgrp, which if vforked, will be visible
 134      to you in the parent process.  It's only used by humans for debugging.  */
 135   static int debug_setpgrp = 657473;
 136   static char *shell_file;
 137   static char *exec_file;
 138   char **save_our_env;
 139   int shell = 0;
 140   static char **argv;
 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 desired, concat something onto the front of ALLARGS.
 167      SHELL_COMMAND is the result.  */
 168 #ifdef SHELL_COMMAND_CONCAT
 169   shell_command = (char *) alloca (strlen (SHELL_COMMAND_CONCAT) + len);
 170   strcpy (shell_command, SHELL_COMMAND_CONCAT);
 171 #else
 172   shell_command = (char *) alloca (len);
 173   shell_command[0] = '\0';
 174 #endif
 175
 176   if (!shell)
 177     {
 178       /* We're going to call execvp.  Create argument vector.
 179          Calculate an upper bound on the length of the vector by
 180          assuming that every other character is a separate
 181          argument.  */
 182       int argc = (strlen (allargs) + 1) / 2 + 2;
 183       argv = (char **) xmalloc (argc * sizeof (*argv));
 184       argv[0] = exec_file;
 185       breakup_args (allargs, &argv[1]);
 186     }
 187   else
 188     {
 189       /* We're going to call a shell.  */
 190
 191       /* Now add exec_file, quoting as necessary.  */
 192
 193       char *p;
 194       int need_to_quote;
 195       const int escape_bang = escape_bang_in_quoted_argument (shell_file);
 196
 197       strcat (shell_command, "exec ");
 198
 199       /* Quoting in this style is said to work with all shells.  But
 200          csh on IRIX 4.0.1 can't deal with it.  So we only quote it if
 201          we need to.  */
 202       p = exec_file;
 203       while (1)
 204         {
 205           switch (*p)
 206             {
 207             case '\'':
 208             case '!':
 209             case '"':
 210             case '(':
 211             case ')':
 212             case '$':
 213             case '&':
 214             case ';':
 215             case '<':
 216             case '>':
 217             case ' ':
 218             case '\n':
 219             case '\t':
 220               need_to_quote = 1;
 221               goto end_scan;
 222
 223             case '\0':
 224               need_to_quote = 0;
 225               goto end_scan;
 226
 227             default:
 228               break;
 229             }
 230           ++p;
 231         }
 232     end_scan:
 233       if (need_to_quote)
 234         {
 235           strcat (shell_command, "'");
 236           for (p = exec_file; *p != '\0'; ++p)
 237             {
 238               if (*p == '\'')
 239                 strcat (shell_command, "'\\''");
 240               else if (*p == '!' && escape_bang)
 241                 strcat (shell_command, "\\!");
 242               else
 243                 strncat (shell_command, p, 1);
 244             }
 245           strcat (shell_command, "'");
 246         }
 247       else
 248         strcat (shell_command, exec_file);
 249
 250       strcat (shell_command, " ");
 251       strcat (shell_command, allargs);
 252     }
 253
 254   /* On some systems an exec will fail if the executable is open.  */
 255   close_exec_file ();
 256
 257   /* Retain a copy of our environment variables, since the child will
 258      replace the value of environ and if we're vforked, we have to
 259      restore it.  */
 260   save_our_env = environ;
 261
 262   /* Tell the terminal handling subsystem what tty we plan to run on;
 263      it will just record the information for later.  */
 264   new_tty_prefork (inferior_io_terminal);
 265
 266   /* It is generally good practice to flush any possible pending stdio
 267      output prior to doing a fork, to avoid the possibility of both
 268      the parent and child flushing the same data after the fork. */
 269   gdb_flush (gdb_stdout);
 270   gdb_flush (gdb_stderr);
 271
 272   /* If there's any initialization of the target layers that must
 273      happen to prepare to handle the child we're about fork, do it
 274      now...  */
 275   if (pre_trace_fun != NULL)
 276     (*pre_trace_fun) ();
 277
 278   /* Create the child process.  Since the child process is going to
 279      exec(3) shortlty afterwards, try to reduce the overhead by
 280      calling vfork(2).  However, if PRE_TRACE_FUN is non-null, it's
 281      likely that this optimization won't work since there's too much
 282      work to do between the vfork(2) and the exec(3).  This is known
 283      to be the case on ttrace(2)-based HP-UX, where some handshaking
 284      between parent and child needs to happen between fork(2) and
 285      exec(2).  However, since the parent is suspended in the vforked
 286      state, this doesn't work.  Also note that the vfork(2) call might
 287      actually be a call to fork(2) due to the fact that autoconf will
 288      ``#define vfork fork'' on certain platforms.  */
 289   if (pre_trace_fun || debug_fork)
 290     pid = fork ();
 291   else
 292     pid = vfork ();
 293
 294   if (pid < 0)
 295     perror_with_name (("vfork"));
 296
 297   if (pid == 0)
 298     {
 299       if (debug_fork)
 300         sleep (debug_fork);
 301
 302       /* Run inferior in a separate process group.  */
 303       debug_setpgrp = gdb_setpgid ();
 304       if (debug_setpgrp == -1)
 305         perror ("setpgrp failed in child");
 306
 307       /* Ask the tty subsystem to switch to the one we specified
 308          earlier (or to share the current terminal, if none was
 309          specified).  */
 310       new_tty ();
 311
 312       /* Changing the signal handlers for the inferior after
 313          a vfork can also change them for the superior, so we don't mess
 314          with signals here.  See comments in
 315          initialize_signals for how we get the right signal handlers
 316          for the inferior.  */
 317
 318       /* "Trace me, Dr. Memory!" */
 319       (*traceme_fun) ();
 320
 321       /* The call above set this process (the "child") as debuggable
 322         by the original gdb process (the "parent").  Since processes
 323         (unlike people) can have only one parent, if you are debugging
 324         gdb itself (and your debugger is thus _already_ the
 325         controller/parent for this child), code from here on out is
 326         undebuggable.  Indeed, you probably got an error message
 327         saying "not parent".  Sorry; you'll have to use print
 328         statements!  */
 329
 330       /* There is no execlpe call, so we have to set the environment
 331          for our child in the global variable.  If we've vforked, this
 332          clobbers the parent, but environ is restored a few lines down
 333          in the parent.  By the way, yes we do need to look down the
 334          path to find $SHELL.  Rich Pixley says so, and I agree.  */
 335       environ = env;
 336
 337       /* If we decided above to start up with a shell, we exec the
 338         shell, "-c" says to interpret the next arg as a shell command
 339         to execute, and this command is "exec <target-program>
 340         <args>".  "-f" means "fast startup" to the c-shell, which
 341         means don't do .cshrc file. Doing .cshrc may cause fork/exec
 342         events which will confuse debugger start-up code.  */
 343       if (shell)
 344         {
 345           execlp (shell_file, shell_file, "-c", shell_command, (char *) 0);
 346
 347           /* If we get here, it's an error.  */
 348           fprintf_unfiltered (gdb_stderr, "Cannot exec %s: %s.\n", shell_file,
 349                               safe_strerror (errno));
 350           gdb_flush (gdb_stderr);
 351           _exit (0177);
 352         }
 353       else
 354         {
 355           /* Otherwise, we directly exec the target program with
 356              execvp.  */
 357           int i;
 358           char *errstring;
 359
 360           execvp (exec_file, argv);
 361
 362           /* If we get here, it's an error.  */
 363           errstring = safe_strerror (errno);
 364           fprintf_unfiltered (gdb_stderr, "Cannot exec %s ", exec_file);
 365
 366           i = 1;
 367           while (argv[i] != NULL)
 368             {
 369               if (i != 1)
 370                 fprintf_unfiltered (gdb_stderr, " ");
 371               fprintf_unfiltered (gdb_stderr, "%s", argv[i]);
 372               i++;
 373             }
 374           fprintf_unfiltered (gdb_stderr, ".\n");
 375 #if 0
 376           /* This extra info seems to be useless.  */
 377           fprintf_unfiltered (gdb_stderr, "Got error %s.\n", errstring);
 378 #endif
 379           gdb_flush (gdb_stderr);
 380           _exit (0177);
 381         }
 382     }
 383
 384   /* Restore our environment in case a vforked child clob'd it.  */
 385   environ = save_our_env;
 386
 387   init_thread_list ();
 388
 389   /* Needed for wait_for_inferior stuff below.  */
 390   inferior_ptid = pid_to_ptid (pid);
 391
 392   /* Now that we have a child process, make it our target, and
 393      initialize anything target-vector-specific that needs
 394      initializing.  */
 395   (*init_trace_fun) (pid);
 396
 397   /* We are now in the child process of interest, having exec'd the
 398      correct program, and are poised at the first instruction of the
 399      new program.  */
 400
 401   /* Allow target dependent code to play with the new process.  This
 402      might be used to have target-specific code initialize a variable
 403      in the new process prior to executing the first instruction.  */
 404   TARGET_CREATE_INFERIOR_HOOK (pid);
 405
 406 #ifdef SOLIB_CREATE_INFERIOR_HOOK
 407   SOLIB_CREATE_INFERIOR_HOOK (pid);
 408 #else
 409   solib_create_inferior_hook ();
 410 #endif
 411 }
 412
 413 /* Accept NTRAPS traps from the inferior.  */
 414
 415 void
 416 startup_inferior (int ntraps)
 417 {
 418   int pending_execs = ntraps;
 419   int terminal_initted = 0;
 420
 421   /* The process was started by the fork that created it, but it will
 422      have stopped one instruction after execing the shell.  Here we
 423      must get it up to actual execution of the real program.  */
 424
 425   clear_proceed_status ();
 426
 427   init_wait_for_inferior ();
 428
 429   if (STARTUP_WITH_SHELL)
 430     inferior_ignoring_startup_exec_events = ntraps;
 431   else
 432     inferior_ignoring_startup_exec_events = 0;
 433   inferior_ignoring_leading_exec_events =
 434     target_reported_exec_events_per_exec_call () - 1;
 435
 436   while (1)
 437     {
 438       /* Make wait_for_inferior be quiet. */
 439       stop_soon = STOP_QUIETLY;
 440       wait_for_inferior ();
 441       if (stop_signal != TARGET_SIGNAL_TRAP)
 442         {
 443           /* Let shell child handle its own signals in its own way.
 444              FIXME: what if child has exited?  Must exit loop
 445              somehow.  */
 446           resume (0, stop_signal);
 447         }
 448       else
 449         {
 450           /* We handle SIGTRAP, however; it means child did an exec.  */
 451           if (!terminal_initted)
 452             {
 453               /* Now that the child has exec'd we know it has already
 454                  set its process group.  On POSIX systems, tcsetpgrp
 455                  will fail with EPERM if we try it before the child's
 456                  setpgid.  */
 457
 458               /* Set up the "saved terminal modes" of the inferior
 459                  based on what modes we are starting it with.  */
 460               target_terminal_init ();
 461
 462               /* Install inferior's terminal modes.  */
 463               target_terminal_inferior ();
 464
 465               terminal_initted = 1;
 466             }
 467
 468           if (--pending_execs == 0)
 469             break;
 470
 471           resume (0, TARGET_SIGNAL_0);  /* Just make it go on.  */
 472         }
 473     }
 474   stop_soon = NO_STOP_QUIETLY;
 475 }