gdb/fork-child.c

   1 /* Fork a Unix child process, and set up to debug it, for GDB.
   2
   3    Copyright (C) 1990-2017 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 #include "top.h"
  35 #include "signals-state-save-restore.h"
  36 #include <signal.h>
  37
  38 /* This just gets used as a default if we can't find SHELL.  */
  39 #define SHELL_FILE "/bin/sh"
  40
  41 extern char **environ;
  42
  43 static char *exec_wrapper;
  44
  45 /* Break up SCRATCH into an argument vector suitable for passing to
  46    execvp and store it in ARGV.  E.g., on "run a b c d" this routine
  47    would get as input the string "a b c d", and as output it would
  48    fill in ARGV with the four arguments "a", "b", "c", "d".  */
  49
  50 static void
  51 breakup_args (char *scratch, char **argv)
  52 {
  53   char *cp = scratch, *tmp;
  54
  55   for (;;)
  56     {
  57       /* Scan past leading separators */
  58       while (*cp == ' ' || *cp == '\t' || *cp == '\n')
  59         cp++;
  60
  61       /* Break if at end of string.  */
  62       if (*cp == '\0')
  63         break;
  64
  65       /* Take an arg.  */
  66       *argv++ = cp;
  67
  68       /* Scan for next arg separator.  */
  69       tmp = strchr (cp, ' ');
  70       if (tmp == NULL)
  71         tmp = strchr (cp, '\t');
  72       if (tmp == NULL)
  73         tmp = strchr (cp, '\n');
  74
  75       /* No separators => end of string => break.  */
  76       if (tmp == NULL)
  77         break;
  78       cp = tmp;
  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 /* See inferior.h.  */
 113
 114 void
 115 trace_start_error (const char *fmt, ...)
 116 {
 117   va_list ap;
 118
 119   va_start (ap, fmt);
 120   fprintf_unfiltered (gdb_stderr, "Could not trace the inferior "
 121                                   "process.\nError: ");
 122   vfprintf_unfiltered (gdb_stderr, fmt, ap);
 123   va_end (args);
 124
 125   gdb_flush (gdb_stderr);
 126   _exit (0177);
 127 }
 128
 129 /* See inferior.h.  */
 130
 131 void
 132 trace_start_error_with_name (const char *string)
 133 {
 134   trace_start_error ("%s: %s", string, safe_strerror (errno));
 135 }
 136
 137 /* Start an inferior Unix child process and sets inferior_ptid to its
 138    pid.  EXEC_FILE is the file to run.  ALLARGS is a string containing
 139    the arguments to the program.  ENV is the environment vector to
 140    pass.  SHELL_FILE is the shell file, or NULL if we should pick
 141    one.  EXEC_FUN is the exec(2) function to use, or NULL for the default
 142    one.  */
 143
 144 /* This function is NOT reentrant.  Some of the variables have been
 145    made static to ensure that they survive the vfork call.  */
 146
 147 int
 148 fork_inferior (char *exec_file_arg, char *allargs, char **env,
 149                void (*traceme_fun) (void), void (*init_trace_fun) (int),
 150                void (*pre_trace_fun) (void), char *shell_file_arg,
 151                void (*exec_fun)(const char *file, char * const *argv,
 152                                 char * const *env))
 153 {
 154   int pid;
 155   static char default_shell_file[] = SHELL_FILE;
 156   /* Set debug_fork then attach to the child while it sleeps, to debug.  */
 157   static int debug_fork = 0;
 158   /* This is set to the result of setpgrp, which if vforked, will be visible
 159      to you in the parent process.  It's only used by humans for debugging.  */
 160   static int debug_setpgrp = 657473;
 161   static char *shell_file;
 162   static char *exec_file;
 163   char **save_our_env;
 164   int shell = 0;
 165   static char **argv;
 166   const char *inferior_io_terminal = get_inferior_io_terminal ();
 167   struct inferior *inf;
 168   int i;
 169   int save_errno;
 170   struct ui *save_ui;
 171
 172   /* If no exec file handed to us, get it from the exec-file command
 173      -- with a good, common error message if none is specified.  */
 174   exec_file = exec_file_arg;
 175   if (exec_file == 0)
 176     exec_file = get_exec_file (1);
 177
 178   /* 'startup_with_shell' is declared in inferior.h and bound to the
 179      "set startup-with-shell" option.  If 0, we'll just do a
 180      fork/exec, no shell, so don't bother figuring out what shell.  */
 181   shell_file = shell_file_arg;
 182   if (startup_with_shell)
 183     {
 184       /* Figure out what shell to start up the user program under.  */
 185       if (shell_file == NULL)
 186         shell_file = getenv ("SHELL");
 187       if (shell_file == NULL)
 188         shell_file = default_shell_file;
 189       shell = 1;
 190     }
 191
 192   if (!shell)
 193     {
 194       /* We're going to call execvp.  Create argument vector.
 195          Calculate an upper bound on the length of the vector by
 196          assuming that every other character is a separate
 197          argument.  */
 198       int argc = (strlen (allargs) + 1) / 2 + 2;
 199
 200       argv = XALLOCAVEC (char *, argc);
 201       argv[0] = exec_file;
 202       breakup_args (allargs, &argv[1]);
 203     }
 204   else
 205     {
 206       /* We're going to call a shell.  */
 207       char *shell_command;
 208       int len;
 209       char *p;
 210       int need_to_quote;
 211       const int escape_bang = escape_bang_in_quoted_argument (shell_file);
 212
 213       /* Multiplying the length of exec_file by 4 is to account for the
 214          fact that it may expand when quoted; it is a worst-case number
 215          based on every character being '.  */
 216       len = 5 + 4 * strlen (exec_file) + 1 + strlen (allargs) + 1 + /*slop */ 12;
 217       if (exec_wrapper)
 218         len += strlen (exec_wrapper) + 1;
 219
 220       shell_command = (char *) alloca (len);
 221       shell_command[0] = '\0';
 222
 223       strcat (shell_command, "exec ");
 224
 225       /* Add any exec wrapper.  That may be a program name with arguments, so
 226          the user must handle quoting.  */
 227       if (exec_wrapper)
 228         {
 229           strcat (shell_command, exec_wrapper);
 230           strcat (shell_command, " ");
 231         }
 232
 233       /* Now add exec_file, quoting as necessary.  */
 234
 235       /* Quoting in this style is said to work with all shells.  But
 236          csh on IRIX 4.0.1 can't deal with it.  So we only quote it if
 237          we need to.  */
 238       p = exec_file;
 239       while (1)
 240         {
 241           switch (*p)
 242             {
 243             case '\'':
 244             case '!':
 245             case '"':
 246             case '(':
 247             case ')':
 248             case '$':
 249             case '&':
 250             case ';':
 251             case '<':
 252             case '>':
 253             case ' ':
 254             case '\n':
 255             case '\t':
 256               need_to_quote = 1;
 257               goto end_scan;
 258
 259             case '\0':
 260               need_to_quote = 0;
 261               goto end_scan;
 262
 263             default:
 264               break;
 265             }
 266           ++p;
 267         }
 268     end_scan:
 269       if (need_to_quote)
 270         {
 271           strcat (shell_command, "'");
 272           for (p = exec_file; *p != '\0'; ++p)
 273             {
 274               if (*p == '\'')
 275                 strcat (shell_command, "'\\''");
 276               else if (*p == '!' && escape_bang)
 277                 strcat (shell_command, "\\!");
 278               else
 279                 strncat (shell_command, p, 1);
 280             }
 281           strcat (shell_command, "'");
 282         }
 283       else
 284         strcat (shell_command, exec_file);
 285
 286       strcat (shell_command, " ");
 287       strcat (shell_command, allargs);
 288
 289       /* If we decided above to start up with a shell, we exec the
 290          shell, "-c" says to interpret the next arg as a shell command
 291          to execute, and this command is "exec <target-program>
 292          <args>".  */
 293       argv = (char **) alloca (4 * sizeof (char *));
 294       argv[0] = shell_file;
 295       argv[1] = "-c";
 296       argv[2] = shell_command;
 297       argv[3] = (char *) 0;
 298     }
 299
 300   /* Retain a copy of our environment variables, since the child will
 301      replace the value of environ and if we're vforked, we have to
 302      restore it.  */
 303   save_our_env = environ;
 304
 305   /* Likewise the current UI.  */
 306   save_ui = current_ui;
 307
 308   /* Tell the terminal handling subsystem what tty we plan to run on;
 309      it will just record the information for later.  */
 310   new_tty_prefork (inferior_io_terminal);
 311
 312   /* It is generally good practice to flush any possible pending stdio
 313      output prior to doing a fork, to avoid the possibility of both
 314      the parent and child flushing the same data after the fork.  */
 315   gdb_flush (main_ui->m_gdb_stdout);
 316   gdb_flush (main_ui->m_gdb_stderr);
 317
 318   /* If there's any initialization of the target layers that must
 319      happen to prepare to handle the child we're about fork, do it
 320      now...  */
 321   if (pre_trace_fun != NULL)
 322     (*pre_trace_fun) ();
 323
 324   /* Create the child process.  Since the child process is going to
 325      exec(3) shortly afterwards, try to reduce the overhead by
 326      calling vfork(2).  However, if PRE_TRACE_FUN is non-null, it's
 327      likely that this optimization won't work since there's too much
 328      work to do between the vfork(2) and the exec(3).  This is known
 329      to be the case on ttrace(2)-based HP-UX, where some handshaking
 330      between parent and child needs to happen between fork(2) and
 331      exec(2).  However, since the parent is suspended in the vforked
 332      state, this doesn't work.  Also note that the vfork(2) call might
 333      actually be a call to fork(2) due to the fact that autoconf will
 334      ``#define vfork fork'' on certain platforms.  */
 335   if (pre_trace_fun || debug_fork)
 336     pid = fork ();
 337   else
 338     pid = vfork ();
 339
 340   if (pid < 0)
 341     perror_with_name (("vfork"));
 342
 343   if (pid == 0)
 344     {
 345       /* Switch to the main UI, so that gdb_std{in/out/err} in the
 346          child are mapped to std{in/out/err}.  This makes it possible
 347          to use fprintf_unfiltered/warning/error/etc. in the child
 348          from here on.  */
 349       current_ui = main_ui;
 350
 351       /* Close all file descriptors except those that gdb inherited
 352          (usually 0/1/2), so they don't leak to the inferior.  Note
 353          that this closes the file descriptors of all secondary
 354          UIs.  */
 355       close_most_fds ();
 356
 357       if (debug_fork)
 358         sleep (debug_fork);
 359
 360       /* Create a new session for the inferior process, if necessary.
 361          It will also place the inferior in a separate process group.  */
 362       if (create_tty_session () <= 0)
 363         {
 364           /* No session was created, but we still want to run the inferior
 365              in a separate process group.  */
 366           debug_setpgrp = gdb_setpgid ();
 367           if (debug_setpgrp == -1)
 368             perror (_("setpgrp failed in child"));
 369         }
 370
 371       /* Ask the tty subsystem to switch to the one we specified
 372          earlier (or to share the current terminal, if none was
 373          specified).  */
 374       new_tty ();
 375
 376       /* Changing the signal handlers for the inferior after
 377          a vfork can also change them for the superior, so we don't mess
 378          with signals here.  See comments in
 379          initialize_signals for how we get the right signal handlers
 380          for the inferior.  */
 381
 382       /* "Trace me, Dr. Memory!"  */
 383       (*traceme_fun) ();
 384
 385       /* The call above set this process (the "child") as debuggable
 386         by the original gdb process (the "parent").  Since processes
 387         (unlike people) can have only one parent, if you are debugging
 388         gdb itself (and your debugger is thus _already_ the
 389         controller/parent for this child), code from here on out is
 390         undebuggable.  Indeed, you probably got an error message
 391         saying "not parent".  Sorry; you'll have to use print
 392         statements!  */
 393
 394       restore_original_signals_state ();
 395
 396       /* There is no execlpe call, so we have to set the environment
 397          for our child in the global variable.  If we've vforked, this
 398          clobbers the parent, but environ is restored a few lines down
 399          in the parent.  By the way, yes we do need to look down the
 400          path to find $SHELL.  Rich Pixley says so, and I agree.  */
 401       environ = env;
 402
 403       if (exec_fun != NULL)
 404         (*exec_fun) (argv[0], argv, env);
 405       else
 406         execvp (argv[0], argv);
 407
 408       /* If we get here, it's an error.  */
 409       save_errno = errno;
 410       fprintf_unfiltered (gdb_stderr, "Cannot exec %s", argv[0]);
 411       for (i = 1; argv[i] != NULL; i++)
 412         fprintf_unfiltered (gdb_stderr, " %s", argv[i]);
 413       fprintf_unfiltered (gdb_stderr, ".\n");
 414       fprintf_unfiltered (gdb_stderr, "Error: %s\n",
 415                           safe_strerror (save_errno));
 416       gdb_flush (gdb_stderr);
 417       _exit (0177);
 418     }
 419
 420   /* Restore our environment in case a vforked child clob'd it.  */
 421   environ = save_our_env;
 422
 423   /* Likewise the current UI.  */
 424   current_ui = save_ui;
 425
 426   if (!have_inferiors ())
 427     init_thread_list ();
 428
 429   inf = current_inferior ();
 430
 431   inferior_appeared (inf, pid);
 432
 433   /* Needed for wait_for_inferior stuff below.  */
 434   inferior_ptid = pid_to_ptid (pid);
 435
 436   new_tty_postfork ();
 437
 438   /* We have something that executes now.  We'll be running through
 439      the shell at this point, but the pid shouldn't change.  Targets
 440      supporting MT should fill this task's ptid with more data as soon
 441      as they can.  */
 442   add_thread_silent (inferior_ptid);
 443
 444   /* Now that we have a child process, make it our target, and
 445      initialize anything target-vector-specific that needs
 446      initializing.  */
 447   if (init_trace_fun)
 448     (*init_trace_fun) (pid);
 449
 450   /* We are now in the child process of interest, having exec'd the
 451      correct program, and are poised at the first instruction of the
 452      new program.  */
 453   return pid;
 454 }
 455
 456 /* Accept NTRAPS traps from the inferior.  */
 457
 458 void
 459 startup_inferior (int ntraps)
 460 {
 461   int pending_execs = ntraps;
 462   int terminal_initted = 0;
 463   ptid_t resume_ptid;
 464
 465   if (startup_with_shell)
 466     {
 467       /* One trap extra for exec'ing the shell.  */
 468       pending_execs++;
 469     }
 470
 471   if (target_supports_multi_process ())
 472     resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
 473   else
 474     resume_ptid = minus_one_ptid;
 475
 476   /* The process was started by the fork that created it, but it will
 477      have stopped one instruction after execing the shell.  Here we
 478      must get it up to actual execution of the real program.  */
 479
 480   if (exec_wrapper)
 481     pending_execs++;
 482
 483   while (1)
 484     {
 485       enum gdb_signal resume_signal = GDB_SIGNAL_0;
 486       ptid_t event_ptid;
 487
 488       struct target_waitstatus ws;
 489       memset (&ws, 0, sizeof (ws));
 490       event_ptid = target_wait (resume_ptid, &ws, 0);
 491
 492       if (ws.kind == TARGET_WAITKIND_IGNORE)
 493         /* The inferior didn't really stop, keep waiting.  */
 494         continue;
 495
 496       switch (ws.kind)
 497         {
 498           case TARGET_WAITKIND_SPURIOUS:
 499           case TARGET_WAITKIND_LOADED:
 500           case TARGET_WAITKIND_FORKED:
 501           case TARGET_WAITKIND_VFORKED:
 502           case TARGET_WAITKIND_SYSCALL_ENTRY:
 503           case TARGET_WAITKIND_SYSCALL_RETURN:
 504             /* Ignore gracefully during startup of the inferior.  */
 505             switch_to_thread (event_ptid);
 506             break;
 507
 508           case TARGET_WAITKIND_SIGNALLED:
 509             target_terminal_ours ();
 510             target_mourn_inferior (event_ptid);
 511             error (_("During startup program terminated with signal %s, %s."),
 512                    gdb_signal_to_name (ws.value.sig),
 513                    gdb_signal_to_string (ws.value.sig));
 514             return;
 515
 516           case TARGET_WAITKIND_EXITED:
 517             target_terminal_ours ();
 518             target_mourn_inferior (event_ptid);
 519             if (ws.value.integer)
 520               error (_("During startup program exited with code %d."),
 521                      ws.value.integer);
 522             else
 523               error (_("During startup program exited normally."));
 524             return;
 525
 526           case TARGET_WAITKIND_EXECD:
 527             /* Handle EXEC signals as if they were SIGTRAP signals.  */
 528             xfree (ws.value.execd_pathname);
 529             resume_signal = GDB_SIGNAL_TRAP;
 530             switch_to_thread (event_ptid);
 531             break;
 532
 533           case TARGET_WAITKIND_STOPPED:
 534             resume_signal = ws.value.sig;
 535             switch_to_thread (event_ptid);
 536             break;
 537         }
 538
 539       if (resume_signal != GDB_SIGNAL_TRAP)
 540         {
 541           /* Let shell child handle its own signals in its own way.  */
 542           target_continue (resume_ptid, resume_signal);
 543         }
 544       else
 545         {
 546           /* We handle SIGTRAP, however; it means child did an exec.  */
 547           if (!terminal_initted)
 548             {
 549               /* Now that the child has exec'd we know it has already
 550                  set its process group.  On POSIX systems, tcsetpgrp
 551                  will fail with EPERM if we try it before the child's
 552                  setpgid.  */
 553
 554               /* Set up the "saved terminal modes" of the inferior
 555                  based on what modes we are starting it with.  */
 556               target_terminal_init ();
 557
 558               /* Install inferior's terminal modes.  */
 559               target_terminal_inferior ();
 560
 561               terminal_initted = 1;
 562             }
 563
 564           if (--pending_execs == 0)
 565             break;
 566
 567           /* Just make it go on.  */
 568           target_continue_no_signal (resume_ptid);
 569         }
 570     }
 571
 572   /* Mark all threads non-executing.  */
 573   set_executing (resume_ptid, 0);
 574 }
 575
 576 /* Implement the "unset exec-wrapper" command.  */
 577
 578 static void
 579 unset_exec_wrapper_command (char *args, int from_tty)
 580 {
 581   xfree (exec_wrapper);
 582   exec_wrapper = NULL;
 583 }
 584
 585 static void
 586 show_startup_with_shell (struct ui_file *file, int from_tty,
 587                          struct cmd_list_element *c, const char *value)
 588 {
 589   fprintf_filtered (file,
 590                     _("Use of shell to start subprocesses is %s.\n"),
 591                     value);
 592 }
 593
 594 /* Provide a prototype to silence -Wmissing-prototypes.  */
 595 extern initialize_file_ftype _initialize_fork_child;
 596
 597 void
 598 _initialize_fork_child (void)
 599 {
 600   add_setshow_filename_cmd ("exec-wrapper", class_run, &exec_wrapper, _("\
 601 Set a wrapper for running programs.\n\
 602 The wrapper prepares the system and environment for the new program."),
 603                             _("\
 604 Show the wrapper for running programs."), NULL,
 605                             NULL, NULL,
 606                             &setlist, &showlist);
 607
 608   add_cmd ("exec-wrapper", class_run, unset_exec_wrapper_command,
 609            _("Disable use of an execution wrapper."),
 610            &unsetlist);
 611
 612   add_setshow_boolean_cmd ("startup-with-shell", class_support,
 613                            &startup_with_shell, _("\
 614 Set use of shell to start subprocesses.  The default is on."), _("\
 615 Show use of shell to start subprocesses."), NULL,
 616                            NULL,
 617                            show_startup_with_shell,
 618                            &setlist, &showlist);
 619 }