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