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 42extern 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 */ 50static void 51breakup_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 95static int 96escape_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 124void 125fork_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 408void 409startup_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