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   /* We have something that executes now.  We'll be running through
 401      the shell at this point, but the pid shouldn't change.  Targets
 402      supporting MT should fill this task's ptid with more data as soon
 403      as they can.  */
 404   add_thread_silent (inferior_ptid);
 405
 406   /* Now that we have a child process, make it our target, and
 407      initialize anything target-vector-specific that needs
 408      initializing.  */
 409   (*init_trace_fun) (pid);
 410
 411   /* We are now in the child process of interest, having exec'd the
 412      correct program, and are poised at the first instruction of the
 413      new program.  */
 414 }
 415
 416 /* Accept NTRAPS traps from the inferior.  */
 417
 418 void
 419 startup_inferior (int ntraps)
 420 {
 421   int pending_execs = ntraps;
 422   int terminal_initted = 0;
 423
 424   /* The process was started by the fork that created it, but it will
 425      have stopped one instruction after execing the shell.  Here we
 426      must get it up to actual execution of the real program.  */
 427
 428   if (exec_wrapper)
 429     pending_execs++;
 430
 431   while (1)
 432     {
 433       int resume_signal = TARGET_SIGNAL_0;
 434       ptid_t resume_ptid;
 435
 436       struct target_waitstatus ws;
 437       memset (&ws, 0, sizeof (ws));
 438       resume_ptid = target_wait (pid_to_ptid (-1), &ws);
 439
 440       /* Mark all threads non-executing.  */
 441       set_executing (pid_to_ptid (-1), 0);
 442
 443       /* In all-stop mode, resume all threads.  */
 444       if (!non_stop)
 445         resume_ptid = pid_to_ptid (-1);
 446
 447       switch (ws.kind)
 448         {
 449           case TARGET_WAITKIND_IGNORE:
 450           case TARGET_WAITKIND_SPURIOUS:
 451           case TARGET_WAITKIND_LOADED:
 452           case TARGET_WAITKIND_FORKED:
 453           case TARGET_WAITKIND_VFORKED:
 454           case TARGET_WAITKIND_SYSCALL_ENTRY:
 455           case TARGET_WAITKIND_SYSCALL_RETURN:
 456             /* Ignore gracefully during startup of the inferior.  */
 457             break;
 458
 459           case TARGET_WAITKIND_SIGNALLED:
 460             target_terminal_ours ();
 461             target_mourn_inferior ();
 462             error (_("During startup program terminated with signal %s, %s."),
 463                    target_signal_to_name (ws.value.sig),
 464                    target_signal_to_string (ws.value.sig));
 465             return;
 466
 467           case TARGET_WAITKIND_EXITED:
 468             target_terminal_ours ();
 469             target_mourn_inferior ();
 470             if (ws.value.integer)
 471               error (_("During startup program exited with code %d."),
 472                      ws.value.integer);
 473             else
 474               error (_("During startup program exited normally."));
 475             return;
 476
 477           case TARGET_WAITKIND_EXECD:
 478             /* Handle EXEC signals as if they were SIGTRAP signals.  */
 479             xfree (ws.value.execd_pathname);
 480             resume_signal = TARGET_SIGNAL_TRAP;
 481             break;
 482
 483           case TARGET_WAITKIND_STOPPED:
 484             resume_signal = ws.value.sig;
 485             break;
 486         }
 487
 488       if (resume_signal != TARGET_SIGNAL_TRAP)
 489         {
 490           /* Let shell child handle its own signals in its own way.  */
 491           target_resume (resume_ptid, 0, resume_signal);
 492         }
 493       else
 494         {
 495           /* We handle SIGTRAP, however; it means child did an exec.  */
 496           if (!terminal_initted)
 497             {
 498               /* Now that the child has exec'd we know it has already
 499                  set its process group.  On POSIX systems, tcsetpgrp
 500                  will fail with EPERM if we try it before the child's
 501                  setpgid.  */
 502
 503               /* Set up the "saved terminal modes" of the inferior
 504                  based on what modes we are starting it with.  */
 505               target_terminal_init ();
 506
 507               /* Install inferior's terminal modes.  */
 508               target_terminal_inferior ();
 509
 510               terminal_initted = 1;
 511             }
 512
 513           if (--pending_execs == 0)
 514             break;
 515
 516           /* Just make it go on.  */
 517           target_resume (resume_ptid, 0, TARGET_SIGNAL_0);
 518         }
 519     }
 520 }
 521
 522 /* Implement the "unset exec-wrapper" command.  */
 523
 524 static void
 525 unset_exec_wrapper_command (char *args, int from_tty)
 526 {
 527   xfree (exec_wrapper);
 528   exec_wrapper = NULL;
 529 }
 530
 531 void
 532 _initialize_fork_child (void)
 533 {
 534   add_setshow_filename_cmd ("exec-wrapper", class_run, &exec_wrapper, _("\
 535 Set a wrapper for running programs.\n\
 536 The wrapper prepares the system and environment for the new program."),
 537                             _("\
 538 Show the wrapper for running programs."), NULL,
 539                             NULL, NULL,
 540                             &setlist, &showlist);
 541
 542   add_cmd ("exec-wrapper", class_run, unset_exec_wrapper_command,
 543            _("Disable use of an execution wrapper."),
 544            &unsetlist);
 545 }