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