1 /* Fork a Unix child process, and set up to debug it, for GDB.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
3 2001 Free Software Foundation, Inc.
4 Contributed by Cygnus Support.
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
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
35 #include <signal.h>
36
37 /* This just gets used as a default if we can't find SHELL */
38 #ifndef SHELL_FILE
39 #define SHELL_FILE "/bin/sh"
40 #endif
41
42 extern char **environ;
43
44 /* This function breaks up an argument string into an argument
45 * vector suitable for passing to execvp().
46 * E.g., on "run a b c d" this routine would get as input
47 * the string "a b c d", and as output it would fill in argv with
48 * the four arguments "a", "b", "c", "d".
49 */
50 static void
breakup_args(char * scratch,char ** argv)51 breakup_args (char *scratch, char **argv)
52 {
53 char *cp = scratch;
54
55 for (;;)
56 {
57
58 /* Scan past leading separators */
59 while (*cp == ' ' || *cp == '\t' || *cp == '\n')
60 {
61 cp++;
62 }
63
64 /* Break if at end of string */
65 if (*cp == '\0')
66 break;
67
68 /* Take an arg */
69 *argv++ = cp;
70
71 /* Scan for next arg separator */
72 cp = strchr (cp, ' ');
73 if (cp == NULL)
74 cp = strchr (cp, '\t');
75 if (cp == NULL)
76 cp = strchr (cp, '\n');
77
78 /* No separators => end of string => break */
79 if (cp == NULL)
80 break;
81
82 /* Replace the separator with a terminator */
83 *cp++ = '\0';
84 }
85
86 /* execv requires a null-terminated arg vector */
87 *argv = NULL;
88
89 }
90
91 /* When executing a command under the given shell, return non-zero
92 if the '!' character should be escaped when embedded in a quoted
93 command-line argument. */
94
95 static int
escape_bang_in_quoted_argument(const char * shell_file)96 escape_bang_in_quoted_argument (const char *shell_file)
97 {
98 const int shell_file_len = strlen (shell_file);
99
100 /* Bang should be escaped only in C Shells. For now, simply check
101 that the shell name ends with 'csh', which covers at least csh
102 and tcsh. This should be good enough for now. */
103
104 if (shell_file_len < 3)
105 return 0;
106
107 if (shell_file[shell_file_len - 3] == 'c'
108 && shell_file[shell_file_len - 2] == 's'
109 && shell_file[shell_file_len - 1] == 'h')
110 return 1;
111
112 return 0;
113 }
114
115 /* Start an inferior Unix child process and sets inferior_ptid to its pid.
116 EXEC_FILE is the file to run.
117 ALLARGS is a string containing the arguments to the program.
118 ENV is the environment vector to pass. SHELL_FILE is the shell file,
119 or NULL if we should pick one. Errors reported with error(). */
120
121 /* This function is NOT-REENTRANT. Some of the variables have been
122 made static to ensure that they survive the vfork() call. */
123
124 void
fork_inferior(char * exec_file_arg,char * allargs,char ** env,void (* traceme_fun)(void),void (* init_trace_fun)(int),void (* pre_trace_fun)(void),char * shell_file_arg)125 fork_inferior (char *exec_file_arg, char *allargs, char **env,
126 void (*traceme_fun) (void), void (*init_trace_fun) (int),
127 void (*pre_trace_fun) (void), char *shell_file_arg)
128 {
129 int pid;
130 char *shell_command;
131 static char default_shell_file[] = SHELL_FILE;
132 int len;
133 /* Set debug_fork then attach to the child while it sleeps, to debug. */
134 static int debug_fork = 0;
135 /* This is set to the result of setpgrp, which if vforked, will be visible
136 to you in the parent process. It's only used by humans for debugging. */
137 static int debug_setpgrp = 657473;
138 static char *shell_file;
139 static char *exec_file;
140 char **save_our_env;
141 int shell = 0;
142 static char **argv;
143
144 /* If no exec file handed to us, get it from the exec-file command -- with
145 a good, common error message if none is specified. */
146 exec_file = exec_file_arg;
147 if (exec_file == 0)
148 exec_file = get_exec_file (1);
149
150 /* STARTUP_WITH_SHELL is defined in inferior.h.
151 * If 0, we'll just do a fork/exec, no shell, so don't
152 * bother figuring out what shell.
153 */
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 /* Multiplying the length of exec_file by 4 is to account for the fact
166 that it may expand when quoted; it is a worst-case number based on
167 every character being '. */
168 len = 5 + 4 * strlen (exec_file) + 1 + strlen (allargs) + 1 + /*slop */ 12;
169 /* If desired, concat something onto the front of ALLARGS.
170 SHELL_COMMAND is the result. */
171 #ifdef SHELL_COMMAND_CONCAT
172 shell_command = (char *) alloca (strlen (SHELL_COMMAND_CONCAT) + len);
173 strcpy (shell_command, SHELL_COMMAND_CONCAT);
174 #else
175 shell_command = (char *) alloca (len);
176 shell_command[0] = '\0';
177 #endif
178
179 if (!shell)
180 {
181 /* We're going to call execvp. Create argv */
182 /* Largest case: every other character is a separate arg */
183 argv = (char **) xmalloc (((strlen (allargs) + 1) / (unsigned) 2 + 2) * sizeof (*argv));
184 argv[0] = exec_file;
185 breakup_args (allargs, &argv[1]);
186
187 }
188 else
189 {
190
191 /* We're going to call a shell */
192
193 /* Now add exec_file, quoting as necessary. */
194
195 char *p;
196 int need_to_quote;
197 const int escape_bang = escape_bang_in_quoted_argument (shell_file);
198
199 strcat (shell_command, "exec ");
200
201 /* Quoting in this style is said to work with all shells. But csh
202 on IRIX 4.0.1 can't deal with it. So we only quote it if we need
203 to. */
204 p = exec_file;
205 while (1)
206 {
207 switch (*p)
208 {
209 case '\'':
210 case '!':
211 case '"':
212 case '(':
213 case ')':
214 case '$':
215 case '&':
216 case ';':
217 case '<':
218 case '>':
219 case ' ':
220 case '\n':
221 case '\t':
222 need_to_quote = 1;
223 goto end_scan;
224
225 case '\0':
226 need_to_quote = 0;
227 goto end_scan;
228
229 default:
230 break;
231 }
232 ++p;
233 }
234 end_scan:
235 if (need_to_quote)
236 {
237 strcat (shell_command, "'");
238 for (p = exec_file; *p != '\0'; ++p)
239 {
240 if (*p == '\'')
241 strcat (shell_command, "'\\''");
242 else if (*p == '!' && escape_bang)
243 strcat (shell_command, "\\!");
244 else
245 strncat (shell_command, p, 1);
246 }
247 strcat (shell_command, "'");
248 }
249 else
250 strcat (shell_command, exec_file);
251
252 strcat (shell_command, " ");
253 strcat (shell_command, allargs);
254
255 }
256
257 /* exec is said to fail if the executable is open. */
258 close_exec_file ();
259
260 /* Retain a copy of our environment variables, since the child will
261 replace the value of environ and if we're vforked, we have to
262 restore it. */
263 save_our_env = environ;
264
265 /* Tell the terminal handling subsystem what tty we plan to run on;
266 it will just record the information for later. */
267
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 the
272 parent and child flushing the same data after the fork. */
273
274 gdb_flush (gdb_stdout);
275 gdb_flush (gdb_stderr);
276
277 /* If there's any initialization of the target layers that must happen
278 to prepare to handle the child we're about fork, do it now...
279 */
280 if (pre_trace_fun != NULL)
281 (*pre_trace_fun) ();
282
283 /* Create the child process. Note that the apparent call to vfork()
284 below *might* actually be a call to fork() due to the fact that
285 autoconf will ``#define vfork fork'' on certain platforms. */
286 if (debug_fork)
287 pid = fork ();
288 else
289 pid = vfork ();
290
291 if (pid < 0)
292 perror_with_name ("vfork");
293
294 if (pid == 0)
295 {
296 if (debug_fork)
297 sleep (debug_fork);
298
299 /* Run inferior in a separate process group. */
300 debug_setpgrp = gdb_setpgid ();
301 if (debug_setpgrp == -1)
302 perror ("setpgrp failed in child");
303
304 /* Ask the tty subsystem to switch to the one we specified earlier
305 (or to share the current terminal, if none was specified). */
306
307 new_tty ();
308
309 /* Changing the signal handlers for the inferior after
310 a vfork can also change them for the superior, so we don't mess
311 with signals here. See comments in
312 initialize_signals for how we get the right signal handlers
313 for the inferior. */
314
315 /* "Trace me, Dr. Memory!" */
316 (*traceme_fun) ();
317 /* The call above set this process (the "child") as debuggable
318 * by the original gdb process (the "parent"). Since processes
319 * (unlike people) can have only one parent, if you are
320 * debugging gdb itself (and your debugger is thus _already_ the
321 * controller/parent for this child), code from here on out
322 * is undebuggable. Indeed, you probably got an error message
323 * saying "not parent". Sorry--you'll have to use print statements!
324 */
325
326 /* There is no execlpe call, so we have to set the environment
327 for our child in the global variable. If we've vforked, this
328 clobbers the parent, but environ is restored a few lines down
329 in the parent. By the way, yes we do need to look down the
330 path to find $SHELL. Rich Pixley says so, and I agree. */
331 environ = env;
332
333 /* If we decided above to start up with a shell,
334 * we exec the shell,
335 * "-c" says to interpret the next arg as a shell command
336 * to execute, and this command is "exec <target-program> <args>".
337 * "-f" means "fast startup" to the c-shell, which means
338 * don't do .cshrc file. Doing .cshrc may cause fork/exec
339 * events which will confuse debugger start-up code.
340 */
341 if (shell)
342 {
343 execlp (shell_file, shell_file, "-c", shell_command, (char *) 0);
344
345 /* If we get here, it's an error */
346 fprintf_unfiltered (gdb_stderr, "Cannot exec %s: %s.\n", shell_file,
347 safe_strerror (errno));
348 gdb_flush (gdb_stderr);
349 _exit (0177);
350 }
351 else
352 {
353 /* Otherwise, we directly exec the target program with execvp. */
354 int i;
355 char *errstring;
356
357 execvp (exec_file, argv);
358
359 /* If we get here, it's an error */
360 errstring = safe_strerror (errno);
361 fprintf_unfiltered (gdb_stderr, "Cannot exec %s ", exec_file);
362
363 i = 1;
364 while (argv[i] != NULL)
365 {
366 if (i != 1)
367 fprintf_unfiltered (gdb_stderr, " ");
368 fprintf_unfiltered (gdb_stderr, "%s", argv[i]);
369 i++;
370 }
371 fprintf_unfiltered (gdb_stderr, ".\n");
372 /* This extra info seems to be useless
373 fprintf_unfiltered (gdb_stderr, "Got error %s.\n", errstring);
374 */
375 gdb_flush (gdb_stderr);
376 _exit (0177);
377 }
378 }
379
380 /* Restore our environment in case a vforked child clob'd it. */
381 environ = save_our_env;
382
383 init_thread_list ();
384
385 inferior_ptid = pid_to_ptid (pid); /* Needed for wait_for_inferior stuff below */
386
387 /* Now that we have a child process, make it our target, and
388 initialize anything target-vector-specific that needs initializing. */
389
390 (*init_trace_fun) (pid);
391
392 /* We are now in the child process of interest, having exec'd the
393 correct program, and are poised at the first instruction of the
394 new program. */
395
396 /* Allow target dependent code to play with the new process. This might be
397 used to have target-specific code initialize a variable in the new process
398 prior to executing the first instruction. */
399 TARGET_CREATE_INFERIOR_HOOK (pid);
400
401 #ifdef SOLIB_CREATE_INFERIOR_HOOK
402 SOLIB_CREATE_INFERIOR_HOOK (pid);
403 #endif
404 }
405
406 /* Accept NTRAPS traps from the inferior. */
407
408 void
startup_inferior(int ntraps)409 startup_inferior (int ntraps)
410 {
411 int pending_execs = ntraps;
412 int terminal_initted;
413
414 /* The process was started by the fork that created it,
415 but it will have stopped one instruction after execing the shell.
416 Here we must get it up to actual execution of the real program. */
417
418 clear_proceed_status ();
419
420 init_wait_for_inferior ();
421
422 terminal_initted = 0;
423
424 if (STARTUP_WITH_SHELL)
425 inferior_ignoring_startup_exec_events = ntraps;
426 else
427 inferior_ignoring_startup_exec_events = 0;
428 inferior_ignoring_leading_exec_events =
429 target_reported_exec_events_per_exec_call () - 1;
430
431 while (1)
432 {
433 /* Make wait_for_inferior be quiet */
434 stop_soon = STOP_QUIETLY;
435 wait_for_inferior ();
436 if (stop_signal != TARGET_SIGNAL_TRAP)
437 {
438 /* Let shell child handle its own signals in its own way */
439 /* FIXME, what if child has exit()ed? Must exit loop somehow */
440 resume (0, stop_signal);
441 }
442 else
443 {
444 /* We handle SIGTRAP, however; it means child did an exec. */
445 if (!terminal_initted)
446 {
447 /* Now that the child has exec'd we know it has already set its
448 process group. On POSIX systems, tcsetpgrp will fail with
449 EPERM if we try it before the child's setpgid. */
450
451 /* Set up the "saved terminal modes" of the inferior
452 based on what modes we are starting it with. */
453 target_terminal_init ();
454
455 /* Install inferior's terminal modes. */
456 target_terminal_inferior ();
457
458 terminal_initted = 1;
459 }
460
461 pending_execs = pending_execs - 1;
462 if (0 == pending_execs)
463 break;
464
465 resume (0, TARGET_SIGNAL_0); /* Just make it go on */
466 }
467 }
468 stop_soon = NO_STOP_QUIETLY;
469 }
470