gdb/fork-child.c

   1 /* Fork a Unix child process, and set up to debug it, for GDB.
   2    Copyright 1990, 91, 92, 93, 94, 1996, 1999 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "gdb_string.h"
  24 #include "frame.h"              /* required by inferior.h */
  25 #include "inferior.h"
  26 #include "target.h"
  27 #include "gdb_wait.h"
  28 #include "gdbcore.h"
  29 #include "terminal.h"
  30 #include "gdbthread.h"
  31 #include "command.h" /* for dont_repeat () */
  32
  33 #include <signal.h>
  34
  35 /* This just gets used as a default if we can't find SHELL */
  36 #ifndef SHELL_FILE
  37 #define SHELL_FILE "/bin/sh"
  38 #endif
  39
  40 extern char **environ;
  41
  42 /* This function breaks up an argument string into an argument
  43  * vector suitable for passing to execvp().
  44  * E.g., on "run a b c d" this routine would get as input
  45  * the string "a b c d", and as output it would fill in argv with
  46  * the four arguments "a", "b", "c", "d".
  47  */
  48 static void
  49 breakup_args (char *scratch, char **argv)
  50 {
  51   char *cp = scratch;
  52
  53   for (;;)
  54     {
  55
  56       /* Scan past leading separators */
  57       while (*cp == ' ' || *cp == '\t' || *cp == '\n')
  58         {
  59           cp++;
  60         }
  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   /* execv requires a null-terminated arg vector */
  85   *argv = NULL;
  86
  87 }
  88
  89
  90 /* Start an inferior Unix child process and sets inferior_pid to its pid.
  91    EXEC_FILE is the file to run.
  92    ALLARGS is a string containing the arguments to the program.
  93    ENV is the environment vector to pass.  SHELL_FILE is the shell file,
  94    or NULL if we should pick one.  Errors reported with error().  */
  95
  96 void
  97 fork_inferior (char *exec_file, char *allargs, char **env,
  98                void (*traceme_fun) (void), void (*init_trace_fun) (int),
  99                void (*pre_trace_fun) (void), char *shell_file)
 100 {
 101   int pid;
 102   char *shell_command;
 103   static char default_shell_file[] = SHELL_FILE;
 104   int len;
 105   /* Set debug_fork then attach to the child while it sleeps, to debug. */
 106   static int debug_fork = 0;
 107   /* This is set to the result of setpgrp, which if vforked, will be visible
 108      to you in the parent process.  It's only used by humans for debugging.  */
 109   static int debug_setpgrp = 657473;
 110   char **save_our_env;
 111   int shell = 0;
 112   char **argv;
 113
 114   /* If no exec file handed to us, get it from the exec-file command -- with
 115      a good, common error message if none is specified.  */
 116   if (exec_file == 0)
 117     exec_file = get_exec_file (1);
 118
 119   /* STARTUP_WITH_SHELL is defined in inferior.h.
 120    * If 0, we'll just do a fork/exec, no shell, so don't
 121    * bother figuring out what shell.
 122    */
 123   if (STARTUP_WITH_SHELL)
 124     {
 125       /* Figure out what shell to start up the user program under. */
 126       if (shell_file == NULL)
 127         shell_file = getenv ("SHELL");
 128       if (shell_file == NULL)
 129         shell_file = default_shell_file;
 130       shell = 1;
 131     }
 132
 133   /* Multiplying the length of exec_file by 4 is to account for the fact
 134      that it may expand when quoted; it is a worst-case number based on
 135      every character being '.  */
 136   len = 5 + 4 * strlen (exec_file) + 1 + strlen (allargs) + 1 + /*slop */ 12;
 137   /* If desired, concat something onto the front of ALLARGS.
 138      SHELL_COMMAND is the result.  */
 139 #ifdef SHELL_COMMAND_CONCAT
 140   shell_command = (char *) alloca (strlen (SHELL_COMMAND_CONCAT) + len);
 141   strcpy (shell_command, SHELL_COMMAND_CONCAT);
 142 #else
 143   shell_command = (char *) alloca (len);
 144   shell_command[0] = '\0';
 145 #endif
 146
 147   if (!shell)
 148     {
 149       /* We're going to call execvp. Create argv */
 150       /* Largest case: every other character is a separate arg */
 151       argv = (char **) xmalloc (((strlen (allargs) + 1) / (unsigned) 2 + 2) * sizeof (*argv));
 152       argv[0] = exec_file;
 153       breakup_args (allargs, &argv[1]);
 154
 155     }
 156   else
 157     {
 158
 159       /* We're going to call a shell */
 160
 161       /* Now add exec_file, quoting as necessary.  */
 162
 163       char *p;
 164       int need_to_quote;
 165
 166       strcat (shell_command, "exec ");
 167
 168       /* Quoting in this style is said to work with all shells.  But csh
 169          on IRIX 4.0.1 can't deal with it.  So we only quote it if we need
 170          to.  */
 171       p = exec_file;
 172       while (1)
 173         {
 174           switch (*p)
 175             {
 176             case '\'':
 177             case '"':
 178             case '(':
 179             case ')':
 180             case '$':
 181             case '&':
 182             case ';':
 183             case '<':
 184             case '>':
 185             case ' ':
 186             case '\n':
 187             case '\t':
 188               need_to_quote = 1;
 189               goto end_scan;
 190
 191             case '\0':
 192               need_to_quote = 0;
 193               goto end_scan;
 194
 195             default:
 196               break;
 197             }
 198           ++p;
 199         }
 200     end_scan:
 201       if (need_to_quote)
 202         {
 203           strcat (shell_command, "'");
 204           for (p = exec_file; *p != '\0'; ++p)
 205             {
 206               if (*p == '\'')
 207                 strcat (shell_command, "'\\''");
 208               else
 209                 strncat (shell_command, p, 1);
 210             }
 211           strcat (shell_command, "'");
 212         }
 213       else
 214         strcat (shell_command, exec_file);
 215
 216       strcat (shell_command, " ");
 217       strcat (shell_command, allargs);
 218
 219     }
 220
 221   /* exec is said to fail if the executable is open.  */
 222   close_exec_file ();
 223
 224   /* Retain a copy of our environment variables, since the child will
 225      replace the value of  environ  and if we're vforked, we have to
 226      restore it.  */
 227   save_our_env = environ;
 228
 229   /* Tell the terminal handling subsystem what tty we plan to run on;
 230      it will just record the information for later.  */
 231
 232   new_tty_prefork (inferior_io_terminal);
 233
 234   /* It is generally good practice to flush any possible pending stdio
 235      output prior to doing a fork, to avoid the possibility of both the
 236      parent and child flushing the same data after the fork. */
 237
 238   gdb_flush (gdb_stdout);
 239   gdb_flush (gdb_stderr);
 240
 241   /* If there's any initialization of the target layers that must happen
 242      to prepare to handle the child we're about fork, do it now...
 243    */
 244   if (pre_trace_fun != NULL)
 245     (*pre_trace_fun) ();
 246
 247 #if defined(USG) && !defined(HAVE_VFORK)
 248   pid = fork ();
 249 #else
 250   if (debug_fork)
 251     pid = fork ();
 252   else
 253     pid = vfork ();
 254 #endif
 255
 256   if (pid < 0)
 257     perror_with_name ("vfork");
 258
 259   if (pid == 0)
 260     {
 261       if (debug_fork)
 262         sleep (debug_fork);
 263
 264       /* Run inferior in a separate process group.  */
 265       debug_setpgrp = gdb_setpgid ();
 266       if (debug_setpgrp == -1)
 267         perror ("setpgrp failed in child");
 268
 269       /* Ask the tty subsystem to switch to the one we specified earlier
 270          (or to share the current terminal, if none was specified).  */
 271
 272       new_tty ();
 273
 274       /* Changing the signal handlers for the inferior after
 275          a vfork can also change them for the superior, so we don't mess
 276          with signals here.  See comments in
 277          initialize_signals for how we get the right signal handlers
 278          for the inferior.  */
 279
 280       /* "Trace me, Dr. Memory!" */
 281       (*traceme_fun) ();
 282       /* The call above set this process (the "child") as debuggable
 283        * by the original gdb process (the "parent").  Since processes
 284        * (unlike people) can have only one parent, if you are
 285        * debugging gdb itself (and your debugger is thus _already_ the
 286        * controller/parent for this child),  code from here on out
 287        * is undebuggable.  Indeed, you probably got an error message
 288        * saying "not parent".  Sorry--you'll have to use print statements!
 289        */
 290
 291       /* There is no execlpe call, so we have to set the environment
 292          for our child in the global variable.  If we've vforked, this
 293          clobbers the parent, but environ is restored a few lines down
 294          in the parent.  By the way, yes we do need to look down the
 295          path to find $SHELL.  Rich Pixley says so, and I agree.  */
 296       environ = env;
 297
 298       /* If we decided above to start up with a shell,
 299        * we exec the shell,
 300        * "-c" says to interpret the next arg as a shell command
 301        * to execute, and this command is "exec <target-program> <args>".
 302        * "-f" means "fast startup" to the c-shell, which means
 303        * don't do .cshrc file. Doing .cshrc may cause fork/exec
 304        * events which will confuse debugger start-up code.
 305        */
 306       if (shell)
 307         {
 308           execlp (shell_file, shell_file, "-c", shell_command, (char *) 0);
 309
 310           /* If we get here, it's an error */
 311           fprintf_unfiltered (gdb_stderr, "Cannot exec %s: %s.\n", shell_file,
 312                               safe_strerror (errno));
 313           gdb_flush (gdb_stderr);
 314           _exit (0177);
 315         }
 316       else
 317         {
 318           /* Otherwise, we directly exec the target program with execvp. */
 319           int i;
 320           char *errstring;
 321
 322           execvp (exec_file, argv);
 323
 324           /* If we get here, it's an error */
 325           errstring = safe_strerror (errno);
 326           fprintf_unfiltered (gdb_stderr, "Cannot exec %s ", exec_file);
 327
 328           i = 1;
 329           while (argv[i] != NULL)
 330             {
 331               if (i != 1)
 332                 fprintf_unfiltered (gdb_stderr, " ");
 333               fprintf_unfiltered (gdb_stderr, "%s", argv[i]);
 334               i++;
 335             }
 336           fprintf_unfiltered (gdb_stderr, ".\n");
 337           /* This extra info seems to be useless
 338              fprintf_unfiltered (gdb_stderr, "Got error %s.\n", errstring);
 339            */
 340           gdb_flush (gdb_stderr);
 341           _exit (0177);
 342         }
 343     }
 344
 345   /* Restore our environment in case a vforked child clob'd it.  */
 346   environ = save_our_env;
 347
 348   init_thread_list ();
 349
 350   inferior_pid = pid;           /* Needed for wait_for_inferior stuff below */
 351
 352   /* Now that we have a child process, make it our target, and
 353      initialize anything target-vector-specific that needs initializing.  */
 354
 355   (*init_trace_fun) (pid);
 356
 357   /* We are now in the child process of interest, having exec'd the
 358      correct program, and are poised at the first instruction of the
 359      new program.  */
 360
 361   /* Allow target dependant code to play with the new process.  This might be
 362      used to have target-specific code initialize a variable in the new process
 363      prior to executing the first instruction.  */
 364   TARGET_CREATE_INFERIOR_HOOK (pid);
 365
 366 #ifdef SOLIB_CREATE_INFERIOR_HOOK
 367   SOLIB_CREATE_INFERIOR_HOOK (pid);
 368 #endif
 369 }
 370
 371 /* An inferior Unix process CHILD_PID has been created by a call to
 372    fork() (or variants like vfork).  It is presently stopped, and waiting
 373    to be resumed.  clone_and_follow_inferior will fork the debugger,
 374    and that clone will "follow" (attach to) CHILD_PID.  The original copy
 375    of the debugger will not touch CHILD_PID again.
 376
 377    Also, the original debugger will set FOLLOWED_CHILD FALSE, while the
 378    clone will set it TRUE.
 379  */
 380 void
 381 clone_and_follow_inferior (int child_pid, int *followed_child)
 382 {
 383   extern int auto_solib_add;
 384
 385   int debugger_pid;
 386   int status;
 387   char pid_spelling[100];       /* Arbitrary but sufficient length. */
 388
 389   /* This semaphore is used to coordinate the two debuggers' handoff
 390      of CHILD_PID.  The original debugger will detach from CHILD_PID,
 391      and then the clone debugger will attach to it.  (It must be done
 392      this way because on some targets, only one process at a time can
 393      trace another.  Thus, the original debugger must relinquish its
 394      tracing rights before the clone can pick them up.)
 395    */
 396 #define SEM_TALK (1)
 397 #define SEM_LISTEN (0)
 398   int handoff_semaphore[2];     /* Original "talks" to [1], clone "listens" to [0] */
 399   int talk_value = 99;
 400   int listen_value;
 401
 402   /* Set debug_fork then attach to the child while it sleeps, to debug. */
 403   static int debug_fork = 0;
 404
 405   /* It is generally good practice to flush any possible pending stdio
 406      output prior to doing a fork, to avoid the possibility of both the
 407      parent and child flushing the same data after the fork. */
 408
 409   gdb_flush (gdb_stdout);
 410   gdb_flush (gdb_stderr);
 411
 412   /* Open the semaphore pipes.
 413    */
 414   status = pipe (handoff_semaphore);
 415   if (status < 0)
 416     error ("error getting pipe for handoff semaphore");
 417
 418   /* Clone the debugger. */
 419 #if defined(USG) && !defined(HAVE_VFORK)
 420   debugger_pid = fork ();
 421 #else
 422   if (debug_fork)
 423     debugger_pid = fork ();
 424   else
 425     debugger_pid = vfork ();
 426 #endif
 427
 428   if (debugger_pid < 0)
 429     perror_with_name ("fork");
 430
 431   /* Are we the original debugger?  If so, we must relinquish all claims
 432      to CHILD_PID. */
 433   if (debugger_pid != 0)
 434     {
 435       char signal_spelling[100];        /* Arbitrary but sufficient length */
 436
 437       /* Detach from CHILD_PID.  Deliver a "stop" signal when we do, though,
 438          so that it remains stopped until the clone debugger can attach
 439          to it.
 440        */
 441       detach_breakpoints (child_pid);
 442
 443       sprintf (signal_spelling, "%d", target_signal_to_host (TARGET_SIGNAL_STOP));
 444       target_require_detach (child_pid, signal_spelling, 1);
 445
 446       /* Notify the clone debugger that it should attach to CHILD_PID. */
 447       write (handoff_semaphore[SEM_TALK], &talk_value, sizeof (talk_value));
 448
 449       *followed_child = 0;
 450     }
 451
 452   /* We're the child. */
 453   else
 454     {
 455       if (debug_fork)
 456         sleep (debug_fork);
 457
 458       /* The child (i.e., the cloned debugger) must now attach to
 459          CHILD_PID.  inferior_pid is presently set to the parent process
 460          of the fork, while CHILD_PID should be the child process of the
 461          fork.
 462
 463          Wait until the original debugger relinquishes control of CHILD_PID,
 464          though.
 465        */
 466       read (handoff_semaphore[SEM_LISTEN], &listen_value, sizeof (listen_value));
 467
 468       /* Note that we DON'T want to actually detach from inferior_pid,
 469          because that would allow it to run free.  The original
 470          debugger wants to retain control of the process.  So, we
 471          just reset inferior_pid to CHILD_PID, and then ensure that all
 472          breakpoints are really set in CHILD_PID.
 473        */
 474       target_mourn_inferior ();
 475
 476       /* Ask the tty subsystem to switch to the one we specified earlier
 477          (or to share the current terminal, if none was specified).  */
 478
 479       new_tty ();
 480
 481       dont_repeat ();
 482       sprintf (pid_spelling, "%d", child_pid);
 483       target_require_attach (pid_spelling, 1);
 484
 485       /* Perform any necessary cleanup, after attachment.  (This form
 486          of attaching can behave differently on some targets than the
 487          standard method, where a process formerly not under debugger
 488          control was suddenly attached to..)
 489        */
 490       target_post_follow_inferior_by_clone ();
 491
 492       *followed_child = 1;
 493     }
 494
 495   /* Discard the handoff sempahore. */
 496   (void) close (handoff_semaphore[SEM_LISTEN]);
 497   (void) close (handoff_semaphore[SEM_TALK]);
 498 }
 499
 500 /* Accept NTRAPS traps from the inferior.  */
 501
 502 void
 503 startup_inferior (int ntraps)
 504 {
 505   int pending_execs = ntraps;
 506   int terminal_initted;
 507
 508   /* The process was started by the fork that created it,
 509      but it will have stopped one instruction after execing the shell.
 510      Here we must get it up to actual execution of the real program.  */
 511
 512   clear_proceed_status ();
 513
 514   init_wait_for_inferior ();
 515
 516   terminal_initted = 0;
 517
 518   if (STARTUP_WITH_SHELL)
 519     inferior_ignoring_startup_exec_events = ntraps;
 520   else
 521     inferior_ignoring_startup_exec_events = 0;
 522   inferior_ignoring_leading_exec_events =
 523     target_reported_exec_events_per_exec_call () - 1;
 524
 525 #ifdef STARTUP_INFERIOR
 526   STARTUP_INFERIOR (pending_execs);
 527 #else
 528   while (1)
 529     {
 530       stop_soon_quietly = 1;    /* Make wait_for_inferior be quiet */
 531       wait_for_inferior ();
 532       if (stop_signal != TARGET_SIGNAL_TRAP)
 533         {
 534           /* Let shell child handle its own signals in its own way */
 535           /* FIXME, what if child has exit()ed?  Must exit loop somehow */
 536           resume (0, stop_signal);
 537         }
 538       else
 539         {
 540           /* We handle SIGTRAP, however; it means child did an exec.  */
 541           if (!terminal_initted)
 542             {
 543               /* Now that the child has exec'd we know it has already set its
 544                  process group.  On POSIX systems, tcsetpgrp will fail with
 545                  EPERM if we try it before the child's setpgid.  */
 546
 547               /* Set up the "saved terminal modes" of the inferior
 548                  based on what modes we are starting it with.  */
 549               target_terminal_init ();
 550
 551               /* Install inferior's terminal modes.  */
 552               target_terminal_inferior ();
 553
 554               terminal_initted = 1;
 555             }
 556
 557           pending_execs = pending_execs - 1;
 558           if (0 == pending_execs)
 559             break;
 560
 561           resume (0, TARGET_SIGNAL_0);  /* Just make it go on */
 562         }
 563     }
 564 #endif /* STARTUP_INFERIOR */
 565   stop_soon_quietly = 0;
 566 }