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