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 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 "inferior.h"
  26 #include "terminal.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 int
 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   struct inferior *inf;
 142
 143   /* If no exec file handed to us, get it from the exec-file command
 144      -- with a good, common error message if none is specified.  */
 145   exec_file = exec_file_arg;
 146   if (exec_file == 0)
 147     exec_file = get_exec_file (1);
 148
 149   /* STARTUP_WITH_SHELL is defined in inferior.h.  If 0,e we'll just
 150     do a fork/exec, no shell, so don't bother figuring out what
 151     shell.  */
 152   shell_file = shell_file_arg;
 153   if (STARTUP_WITH_SHELL)
 154     {
 155       /* Figure out what shell to start up the user program under.  */
 156       if (shell_file == NULL)
 157         shell_file = getenv ("SHELL");
 158       if (shell_file == NULL)
 159         shell_file = default_shell_file;
 160       shell = 1;
 161     }
 162
 163   /* Multiplying the length of exec_file by 4 is to account for the
 164      fact that it may expand when quoted; it is a worst-case number
 165      based on every character being '.  */
 166   len = 5 + 4 * strlen (exec_file) + 1 + strlen (allargs) + 1 + /*slop */ 12;
 167   if (exec_wrapper)
 168     len += strlen (exec_wrapper) + 1;
 169
 170   shell_command = (char *) alloca (len);
 171   shell_command[0] = '\0';
 172
 173   if (!shell)
 174     {
 175       /* We're going to call execvp.  Create argument vector.
 176          Calculate an upper bound on the length of the vector by
 177          assuming that every other character is a separate
 178          argument.  */
 179       int argc = (strlen (allargs) + 1) / 2 + 2;
 180       argv = (char **) xmalloc (argc * sizeof (*argv));
 181       argv[0] = exec_file;
 182       breakup_args (allargs, &argv[1]);
 183     }
 184   else
 185     {
 186       /* We're going to call a shell.  */
 187
 188       char *p;
 189       int need_to_quote;
 190       const int escape_bang = escape_bang_in_quoted_argument (shell_file);
 191
 192       strcat (shell_command, "exec ");
 193
 194       /* Add any exec wrapper.  That may be a program name with arguments, so
 195          the user must handle quoting.  */
 196       if (exec_wrapper)
 197         {
 198           strcat (shell_command, exec_wrapper);
 199           strcat (shell_command, " ");
 200         }
 201
 202       /* Now add exec_file, quoting as necessary.  */
 203
 204       /* Quoting in this style is said to work with all shells.  But
 205          csh on IRIX 4.0.1 can't deal with it.  So we only quote it if
 206          we need to.  */
 207       p = exec_file;
 208       while (1)
 209         {
 210           switch (*p)
 211             {
 212             case '\'':
 213             case '!':
 214             case '"':
 215             case '(':
 216             case ')':
 217             case '$':
 218             case '&':
 219             case ';':
 220             case '<':
 221             case '>':
 222             case ' ':
 223             case '\n':
 224             case '\t':
 225               need_to_quote = 1;
 226               goto end_scan;
 227
 228             case '\0':
 229               need_to_quote = 0;
 230               goto end_scan;
 231
 232             default:
 233               break;
 234             }
 235           ++p;
 236         }
 237     end_scan:
 238       if (need_to_quote)
 239         {
 240           strcat (shell_command, "'");
 241           for (p = exec_file; *p != '\0'; ++p)
 242             {
 243               if (*p == '\'')
 244                 strcat (shell_command, "'\\''");
 245               else if (*p == '!' && escape_bang)
 246                 strcat (shell_command, "\\!");
 247               else
 248                 strncat (shell_command, p, 1);
 249             }
 250           strcat (shell_command, "'");
 251         }
 252       else
 253         strcat (shell_command, exec_file);
 254
 255       strcat (shell_command, " ");
 256       strcat (shell_command, allargs);
 257     }
 258
 259   /* On some systems an exec will fail if the executable is open.  */
 260   close_exec_file ();
 261
 262   /* Retain a copy of our environment variables, since the child will
 263      replace the value of environ and if we're vforked, we have to
 264      restore it.  */
 265   save_our_env = environ;
 266
 267   /* Tell the terminal handling subsystem what tty we plan to run on;
 268      it will just record the information for later.  */
 269   new_tty_prefork (inferior_io_terminal);
 270
 271   /* It is generally good practice to flush any possible pending stdio
 272      output prior to doing a fork, to avoid the possibility of both
 273      the parent and child flushing the same data after the fork. */
 274   gdb_flush (gdb_stdout);
 275   gdb_flush (gdb_stderr);
 276
 277   /* If there's any initialization of the target layers that must
 278      happen to prepare to handle the child we're about fork, do it
 279      now...  */
 280   if (pre_trace_fun != NULL)
 281     (*pre_trace_fun) ();
 282
 283   /* Create the child process.  Since the child process is going to
 284      exec(3) shortly afterwards, try to reduce the overhead by
 285      calling vfork(2).  However, if PRE_TRACE_FUN is non-null, it's
 286      likely that this optimization won't work since there's too much
 287      work to do between the vfork(2) and the exec(3).  This is known
 288      to be the case on ttrace(2)-based HP-UX, where some handshaking
 289      between parent and child needs to happen between fork(2) and
 290      exec(2).  However, since the parent is suspended in the vforked
 291      state, this doesn't work.  Also note that the vfork(2) call might
 292      actually be a call to fork(2) due to the fact that autoconf will
 293      ``#define vfork fork'' on certain platforms.  */
 294   if (pre_trace_fun || debug_fork)
 295     pid = fork ();
 296   else
 297     pid = vfork ();
 298
 299   if (pid < 0)
 300     perror_with_name (("vfork"));
 301
 302   if (pid == 0)
 303     {
 304       if (debug_fork)
 305         sleep (debug_fork);
 306
 307       /* Create a new session for the inferior process, if necessary.
 308          It will also place the inferior in a separate process group.  */
 309       if (create_tty_session () <= 0)
 310         {
 311           /* No session was created, but we still want to run the inferior
 312              in a separate process group.  */
 313           debug_setpgrp = gdb_setpgid ();
 314           if (debug_setpgrp == -1)
 315             perror ("setpgrp failed in child");
 316         }
 317
 318       /* Ask the tty subsystem to switch to the one we specified
 319          earlier (or to share the current terminal, if none was
 320          specified).  */
 321       new_tty ();
 322
 323       /* Changing the signal handlers for the inferior after
 324          a vfork can also change them for the superior, so we don't mess
 325          with signals here.  See comments in
 326          initialize_signals for how we get the right signal handlers
 327          for the inferior.  */
 328
 329       /* "Trace me, Dr. Memory!" */
 330       (*traceme_fun) ();
 331
 332       /* The call above set this process (the "child") as debuggable
 333         by the original gdb process (the "parent").  Since processes
 334         (unlike people) can have only one parent, if you are debugging
 335         gdb itself (and your debugger is thus _already_ the
 336         controller/parent for this child), code from here on out is
 337         undebuggable.  Indeed, you probably got an error message
 338         saying "not parent".  Sorry; you'll have to use print
 339         statements!  */
 340
 341       /* There is no execlpe call, so we have to set the environment
 342          for our child in the global variable.  If we've vforked, this
 343          clobbers the parent, but environ is restored a few lines down
 344          in the parent.  By the way, yes we do need to look down the
 345          path to find $SHELL.  Rich Pixley says so, and I agree.  */
 346       environ = env;
 347
 348       /* If we decided above to start up with a shell, we exec the
 349          shell, "-c" says to interpret the next arg as a shell command
 350          to execute, and this command is "exec <target-program>
 351          <args>".  */
 352       if (shell)
 353         {
 354           execlp (shell_file, shell_file, "-c", shell_command, (char *) 0);
 355
 356           /* If we get here, it's an error.  */
 357           fprintf_unfiltered (gdb_stderr, "Cannot exec %s: %s.\n", shell_file,
 358                               safe_strerror (errno));
 359           gdb_flush (gdb_stderr);
 360           _exit (0177);
 361         }
 362       else
 363         {
 364           /* Otherwise, we directly exec the target program with
 365              execvp.  */
 366           int i;
 367           char *errstring;
 368
 369           execvp (exec_file, argv);
 370
 371           /* If we get here, it's an error.  */
 372           errstring = safe_strerror (errno);
 373           fprintf_unfiltered (gdb_stderr, "Cannot exec %s ", exec_file);
 374
 375           i = 1;
 376           while (argv[i] != NULL)
 377             {
 378               if (i != 1)
 379                 fprintf_unfiltered (gdb_stderr, " ");
 380               fprintf_unfiltered (gdb_stderr, "%s", argv[i]);
 381               i++;
 382             }
 383           fprintf_unfiltered (gdb_stderr, ".\n");
 384 #if 0
 385           /* This extra info seems to be useless.  */
 386           fprintf_unfiltered (gdb_stderr, "Got error %s.\n", errstring);
 387 #endif
 388           gdb_flush (gdb_stderr);
 389           _exit (0177);
 390         }
 391     }
 392
 393   /* Restore our environment in case a vforked child clob'd it.  */
 394   environ = save_our_env;
 395
 396   if (!have_inferiors ())
 397     init_thread_list ();
 398
 399   inf = current_inferior ();
 400
 401   inferior_appeared (inf, pid);
 402
 403   /* Needed for wait_for_inferior stuff below.  */
 404   inferior_ptid = pid_to_ptid (pid);
 405
 406   new_tty_postfork ();
 407
 408   /* We have something that executes now.  We'll be running through
 409      the shell at this point, but the pid shouldn't change.  Targets
 410      supporting MT should fill this task's ptid with more data as soon
 411      as they can.  */
 412   add_thread_silent (inferior_ptid);
 413
 414   /* Now that we have a child process, make it our target, and
 415      initialize anything target-vector-specific that needs
 416      initializing.  */
 417   if (init_trace_fun)
 418     (*init_trace_fun) (pid);
 419
 420   /* We are now in the child process of interest, having exec'd the
 421      correct program, and are poised at the first instruction of the
 422      new program.  */
 423   return pid;
 424 }
 425
 426 /* Accept NTRAPS traps from the inferior.  */
 427
 428 void
 429 startup_inferior (int ntraps)
 430 {
 431   int pending_execs = ntraps;
 432   int terminal_initted = 0;
 433   ptid_t resume_ptid;
 434
 435   if (target_supports_multi_process ())
 436     resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
 437   else
 438     resume_ptid = minus_one_ptid;
 439
 440   /* The process was started by the fork that created it, but it will
 441      have stopped one instruction after execing the shell.  Here we
 442      must get it up to actual execution of the real program.  */
 443
 444   if (exec_wrapper)
 445     pending_execs++;
 446
 447   while (1)
 448     {
 449       int resume_signal = TARGET_SIGNAL_0;
 450       ptid_t event_ptid;
 451
 452       struct target_waitstatus ws;
 453       memset (&ws, 0, sizeof (ws));
 454       event_ptid = target_wait (resume_ptid, &ws, 0);
 455
 456       if (ws.kind == TARGET_WAITKIND_IGNORE)
 457         /* The inferior didn't really stop, keep waiting.  */
 458         continue;
 459
 460       switch (ws.kind)
 461         {
 462           case TARGET_WAITKIND_SPURIOUS:
 463           case TARGET_WAITKIND_LOADED:
 464           case TARGET_WAITKIND_FORKED:
 465           case TARGET_WAITKIND_VFORKED:
 466           case TARGET_WAITKIND_SYSCALL_ENTRY:
 467           case TARGET_WAITKIND_SYSCALL_RETURN:
 468             /* Ignore gracefully during startup of the inferior.  */
 469             switch_to_thread (event_ptid);
 470             break;
 471
 472           case TARGET_WAITKIND_SIGNALLED:
 473             target_terminal_ours ();
 474             target_mourn_inferior ();
 475             error (_("During startup program terminated with signal %s, %s."),
 476                    target_signal_to_name (ws.value.sig),
 477                    target_signal_to_string (ws.value.sig));
 478             return;
 479
 480           case TARGET_WAITKIND_EXITED:
 481             target_terminal_ours ();
 482             target_mourn_inferior ();
 483             if (ws.value.integer)
 484               error (_("During startup program exited with code %d."),
 485                      ws.value.integer);
 486             else
 487               error (_("During startup program exited normally."));
 488             return;
 489
 490           case TARGET_WAITKIND_EXECD:
 491             /* Handle EXEC signals as if they were SIGTRAP signals.  */
 492             xfree (ws.value.execd_pathname);
 493             resume_signal = TARGET_SIGNAL_TRAP;
 494             switch_to_thread (event_ptid);
 495             break;
 496
 497           case TARGET_WAITKIND_STOPPED:
 498             resume_signal = ws.value.sig;
 499             switch_to_thread (event_ptid);
 500             break;
 501         }
 502
 503       if (resume_signal != TARGET_SIGNAL_TRAP)
 504         {
 505           /* Let shell child handle its own signals in its own way.  */
 506           target_resume (resume_ptid, 0, resume_signal);
 507         }
 508       else
 509         {
 510           /* We handle SIGTRAP, however; it means child did an exec.  */
 511           if (!terminal_initted)
 512             {
 513               /* Now that the child has exec'd we know it has already
 514                  set its process group.  On POSIX systems, tcsetpgrp
 515                  will fail with EPERM if we try it before the child's
 516                  setpgid.  */
 517
 518               /* Set up the "saved terminal modes" of the inferior
 519                  based on what modes we are starting it with.  */
 520               target_terminal_init ();
 521
 522               /* Install inferior's terminal modes.  */
 523               target_terminal_inferior ();
 524
 525               terminal_initted = 1;
 526             }
 527
 528           if (--pending_execs == 0)
 529             break;
 530
 531           /* Just make it go on.  */
 532           target_resume (resume_ptid, 0, TARGET_SIGNAL_0);
 533         }
 534     }
 535
 536   /* Mark all threads non-executing.  */
 537   set_executing (resume_ptid, 0);
 538 }
 539
 540 /* Implement the "unset exec-wrapper" command.  */
 541
 542 static void
 543 unset_exec_wrapper_command (char *args, int from_tty)
 544 {
 545   xfree (exec_wrapper);
 546   exec_wrapper = NULL;
 547 }
 548
 549 /* Provide a prototype to silence -Wmissing-prototypes.  */
 550 extern initialize_file_ftype _initialize_fork_child;
 551
 552 void
 553 _initialize_fork_child (void)
 554 {
 555   add_setshow_filename_cmd ("exec-wrapper", class_run, &exec_wrapper, _("\
 556 Set a wrapper for running programs.\n\
 557 The wrapper prepares the system and environment for the new program."),
 558                             _("\
 559 Show the wrapper for running programs."), NULL,
 560                             NULL, NULL,
 561                             &setlist, &showlist);
 562
 563   add_cmd ("exec-wrapper", class_run, unset_exec_wrapper_command,
 564            _("Disable use of an execution wrapper."),
 565            &unsetlist);
 566 }