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