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