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