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