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