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