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, 2010 5 Free Software Foundation, Inc. 6 7 Contributed by Cygnus Support. 8 9 This file is part of GDB. 10 11 This program is free software; you can redistribute it and/or modify 12 it under the terms of the GNU General Public License as published by 13 the Free Software Foundation; either version 3 of the License, or 14 (at your option) any later version. 15 16 This program is distributed in the hope that it will be useful, 17 but WITHOUT ANY WARRANTY; without even the implied warranty of 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 GNU General Public License for more details. 20 21 You should have received a copy of the GNU General Public License 22 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 23 24 #include "defs.h" 25 #include "gdb_string.h" 26 #include "inferior.h" 27 #include "terminal.h" 28 #include "target.h" 29 #include "gdb_wait.h" 30 #include "gdb_vfork.h" 31 #include "gdbcore.h" 32 #include "terminal.h" 33 #include "gdbthread.h" 34 #include "command.h" /* for dont_repeat () */ 35 #include "gdbcmd.h" 36 #include "solib.h" 37 38 #include <signal.h> 39 40 /* This just gets used as a default if we can't find SHELL. */ 41 #define SHELL_FILE "/bin/sh" 42 43 extern char **environ; 44 45 static char *exec_wrapper; 46 47 /* Break up SCRATCH into an argument vector suitable for passing to 48 execvp and store it in ARGV. E.g., on "run a b c d" this routine 49 would get as input the string "a b c d", and as output it would 50 fill in ARGV with the four arguments "a", "b", "c", "d". */ 51 52 static void 53 breakup_args (char *scratch, char **argv) 54 { 55 char *cp = scratch; 56 57 for (;;) 58 { 59 /* Scan past leading separators */ 60 while (*cp == ' ' || *cp == '\t' || *cp == '\n') 61 cp++; 62 63 /* Break if at end of string. */ 64 if (*cp == '\0') 65 break; 66 67 /* Take an arg. */ 68 *argv++ = cp; 69 70 /* Scan for next arg separator. */ 71 cp = strchr (cp, ' '); 72 if (cp == NULL) 73 cp = strchr (cp, '\t'); 74 if (cp == NULL) 75 cp = strchr (cp, '\n'); 76 77 /* No separators => end of string => break. */ 78 if (cp == NULL) 79 break; 80 81 /* Replace the separator with a terminator. */ 82 *cp++ = '\0'; 83 } 84 85 /* Null-terminate the vector. */ 86 *argv = NULL; 87 } 88 89 /* When executing a command under the given shell, return non-zero if 90 the '!' character should be escaped when embedded in a quoted 91 command-line argument. */ 92 93 static int 94 escape_bang_in_quoted_argument (const char *shell_file) 95 { 96 const int shell_file_len = strlen (shell_file); 97 98 /* Bang should be escaped only in C Shells. For now, simply check 99 that the shell name ends with 'csh', which covers at least csh 100 and tcsh. This should be good enough for now. */ 101 102 if (shell_file_len < 3) 103 return 0; 104 105 if (shell_file[shell_file_len - 3] == 'c' 106 && shell_file[shell_file_len - 2] == 's' 107 && shell_file[shell_file_len - 1] == 'h') 108 return 1; 109 110 return 0; 111 } 112 113 /* Start an inferior Unix child process and sets inferior_ptid to its 114 pid. EXEC_FILE is the file to run. ALLARGS is a string containing 115 the arguments to the program. ENV is the environment vector to 116 pass. SHELL_FILE is the shell file, or NULL if we should pick 117 one. */ 118 119 /* This function is NOT reentrant. Some of the variables have been 120 made static to ensure that they survive the vfork call. */ 121 122 int 123 fork_inferior (char *exec_file_arg, char *allargs, char **env, 124 void (*traceme_fun) (void), void (*init_trace_fun) (int), 125 void (*pre_trace_fun) (void), char *shell_file_arg) 126 { 127 int pid; 128 char *shell_command; 129 static char default_shell_file[] = SHELL_FILE; 130 int len; 131 /* Set debug_fork then attach to the child while it sleeps, to debug. */ 132 static int debug_fork = 0; 133 /* This is set to the result of setpgrp, which if vforked, will be visible 134 to you in the parent process. It's only used by humans for debugging. */ 135 static int debug_setpgrp = 657473; 136 static char *shell_file; 137 static char *exec_file; 138 char **save_our_env; 139 int shell = 0; 140 static char **argv; 141 const char *inferior_io_terminal = get_inferior_io_terminal (); 142 struct inferior *inf; 143 144 /* If no exec file handed to us, get it from the exec-file command 145 -- with 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. If 0,e we'll just 151 do a fork/exec, no shell, so don't bother figuring out what 152 shell. */ 153 shell_file = shell_file_arg; 154 if (STARTUP_WITH_SHELL) 155 { 156 /* Figure out what shell to start up the user program under. */ 157 if (shell_file == NULL) 158 shell_file = getenv ("SHELL"); 159 if (shell_file == NULL) 160 shell_file = default_shell_file; 161 shell = 1; 162 } 163 164 /* Multiplying the length of exec_file by 4 is to account for the 165 fact that it may expand when quoted; it is a worst-case number 166 based on every character being '. */ 167 len = 5 + 4 * strlen (exec_file) + 1 + strlen (allargs) + 1 + /*slop */ 12; 168 if (exec_wrapper) 169 len += strlen (exec_wrapper) + 1; 170 171 shell_command = (char *) alloca (len); 172 shell_command[0] = '\0'; 173 174 if (!shell) 175 { 176 /* We're going to call execvp. Create argument vector. 177 Calculate an upper bound on the length of the vector by 178 assuming that every other character is a separate 179 argument. */ 180 int argc = (strlen (allargs) + 1) / 2 + 2; 181 182 argv = (char **) xmalloc (argc * sizeof (*argv)); 183 argv[0] = exec_file; 184 breakup_args (allargs, &argv[1]); 185 } 186 else 187 { 188 /* We're going to call a shell. */ 189 190 char *p; 191 int need_to_quote; 192 const int escape_bang = escape_bang_in_quoted_argument (shell_file); 193 194 strcat (shell_command, "exec "); 195 196 /* Add any exec wrapper. That may be a program name with arguments, so 197 the user must handle quoting. */ 198 if (exec_wrapper) 199 { 200 strcat (shell_command, exec_wrapper); 201 strcat (shell_command, " "); 202 } 203 204 /* Now add exec_file, quoting as necessary. */ 205 206 /* Quoting in this style is said to work with all shells. But 207 csh on IRIX 4.0.1 can't deal with it. So we only quote it if 208 we need to. */ 209 p = exec_file; 210 while (1) 211 { 212 switch (*p) 213 { 214 case '\'': 215 case '!': 216 case '"': 217 case '(': 218 case ')': 219 case '$': 220 case '&': 221 case ';': 222 case '<': 223 case '>': 224 case ' ': 225 case '\n': 226 case '\t': 227 need_to_quote = 1; 228 goto end_scan; 229 230 case '\0': 231 need_to_quote = 0; 232 goto end_scan; 233 234 default: 235 break; 236 } 237 ++p; 238 } 239 end_scan: 240 if (need_to_quote) 241 { 242 strcat (shell_command, "'"); 243 for (p = exec_file; *p != '\0'; ++p) 244 { 245 if (*p == '\'') 246 strcat (shell_command, "'\\''"); 247 else if (*p == '!' && escape_bang) 248 strcat (shell_command, "\\!"); 249 else 250 strncat (shell_command, p, 1); 251 } 252 strcat (shell_command, "'"); 253 } 254 else 255 strcat (shell_command, exec_file); 256 257 strcat (shell_command, " "); 258 strcat (shell_command, allargs); 259 } 260 261 /* On some systems an exec will fail if the executable is open. */ 262 close_exec_file (); 263 264 /* Retain a copy of our environment variables, since the child will 265 replace the value of environ and if we're vforked, we have to 266 restore it. */ 267 save_our_env = environ; 268 269 /* Tell the terminal handling subsystem what tty we plan to run on; 270 it will just record the information for later. */ 271 new_tty_prefork (inferior_io_terminal); 272 273 /* It is generally good practice to flush any possible pending stdio 274 output prior to doing a fork, to avoid the possibility of both 275 the parent and child flushing the same data after the fork. */ 276 gdb_flush (gdb_stdout); 277 gdb_flush (gdb_stderr); 278 279 /* If there's any initialization of the target layers that must 280 happen to prepare to handle the child we're about fork, do it 281 now... */ 282 if (pre_trace_fun != NULL) 283 (*pre_trace_fun) (); 284 285 /* Create the child process. Since the child process is going to 286 exec(3) shortly afterwards, try to reduce the overhead by 287 calling vfork(2). However, if PRE_TRACE_FUN is non-null, it's 288 likely that this optimization won't work since there's too much 289 work to do between the vfork(2) and the exec(3). This is known 290 to be the case on ttrace(2)-based HP-UX, where some handshaking 291 between parent and child needs to happen between fork(2) and 292 exec(2). However, since the parent is suspended in the vforked 293 state, this doesn't work. Also note that the vfork(2) call might 294 actually be a call to fork(2) due to the fact that autoconf will 295 ``#define vfork fork'' on certain platforms. */ 296 if (pre_trace_fun || debug_fork) 297 pid = fork (); 298 else 299 pid = vfork (); 300 301 if (pid < 0) 302 perror_with_name (("vfork")); 303 304 if (pid == 0) 305 { 306 if (debug_fork) 307 sleep (debug_fork); 308 309 /* Create a new session for the inferior process, if necessary. 310 It will also place the inferior in a separate process group. */ 311 if (create_tty_session () <= 0) 312 { 313 /* No session was created, but we still want to run the inferior 314 in a separate process group. */ 315 debug_setpgrp = gdb_setpgid (); 316 if (debug_setpgrp == -1) 317 perror ("setpgrp failed in child"); 318 } 319 320 /* Ask the tty subsystem to switch to the one we specified 321 earlier (or to share the current terminal, if none was 322 specified). */ 323 new_tty (); 324 325 /* Changing the signal handlers for the inferior after 326 a vfork can also change them for the superior, so we don't mess 327 with signals here. See comments in 328 initialize_signals for how we get the right signal handlers 329 for the inferior. */ 330 331 /* "Trace me, Dr. Memory!" */ 332 (*traceme_fun) (); 333 334 /* The call above set this process (the "child") as debuggable 335 by the original gdb process (the "parent"). Since processes 336 (unlike people) can have only one parent, if you are debugging 337 gdb itself (and your debugger is thus _already_ the 338 controller/parent for this child), code from here on out is 339 undebuggable. Indeed, you probably got an error message 340 saying "not parent". Sorry; you'll have to use print 341 statements! */ 342 343 /* There is no execlpe call, so we have to set the environment 344 for our child in the global variable. If we've vforked, this 345 clobbers the parent, but environ is restored a few lines down 346 in the parent. By the way, yes we do need to look down the 347 path to find $SHELL. Rich Pixley says so, and I agree. */ 348 environ = env; 349 350 /* If we decided above to start up with a shell, we exec the 351 shell, "-c" says to interpret the next arg as a shell command 352 to execute, and this command is "exec <target-program> 353 <args>". */ 354 if (shell) 355 { 356 execlp (shell_file, shell_file, "-c", shell_command, (char *) 0); 357 358 /* If we get here, it's an error. */ 359 fprintf_unfiltered (gdb_stderr, "Cannot exec %s: %s.\n", shell_file, 360 safe_strerror (errno)); 361 gdb_flush (gdb_stderr); 362 _exit (0177); 363 } 364 else 365 { 366 /* Otherwise, we directly exec the target program with 367 execvp. */ 368 int i; 369 char *errstring; 370 371 execvp (exec_file, argv); 372 373 /* If we get here, it's an error. */ 374 errstring = safe_strerror (errno); 375 fprintf_unfiltered (gdb_stderr, "Cannot exec %s ", exec_file); 376 377 i = 1; 378 while (argv[i] != NULL) 379 { 380 if (i != 1) 381 fprintf_unfiltered (gdb_stderr, " "); 382 fprintf_unfiltered (gdb_stderr, "%s", argv[i]); 383 i++; 384 } 385 fprintf_unfiltered (gdb_stderr, ".\n"); 386 #if 0 387 /* This extra info seems to be useless. */ 388 fprintf_unfiltered (gdb_stderr, "Got error %s.\n", errstring); 389 #endif 390 gdb_flush (gdb_stderr); 391 _exit (0177); 392 } 393 } 394 395 /* Restore our environment in case a vforked child clob'd it. */ 396 environ = save_our_env; 397 398 if (!have_inferiors ()) 399 init_thread_list (); 400 401 inf = current_inferior (); 402 403 inferior_appeared (inf, pid); 404 405 /* Needed for wait_for_inferior stuff below. */ 406 inferior_ptid = pid_to_ptid (pid); 407 408 new_tty_postfork (); 409 410 /* We have something that executes now. We'll be running through 411 the shell at this point, but the pid shouldn't change. Targets 412 supporting MT should fill this task's ptid with more data as soon 413 as they can. */ 414 add_thread_silent (inferior_ptid); 415 416 /* Now that we have a child process, make it our target, and 417 initialize anything target-vector-specific that needs 418 initializing. */ 419 if (init_trace_fun) 420 (*init_trace_fun) (pid); 421 422 /* We are now in the child process of interest, having exec'd the 423 correct program, and are poised at the first instruction of the 424 new program. */ 425 return pid; 426 } 427 428 /* Accept NTRAPS traps from the inferior. */ 429 430 void 431 startup_inferior (int ntraps) 432 { 433 int pending_execs = ntraps; 434 int terminal_initted = 0; 435 ptid_t resume_ptid; 436 437 if (target_supports_multi_process ()) 438 resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid)); 439 else 440 resume_ptid = minus_one_ptid; 441 442 /* The process was started by the fork that created it, but it will 443 have stopped one instruction after execing the shell. Here we 444 must get it up to actual execution of the real program. */ 445 446 if (exec_wrapper) 447 pending_execs++; 448 449 while (1) 450 { 451 int resume_signal = TARGET_SIGNAL_0; 452 ptid_t event_ptid; 453 454 struct target_waitstatus ws; 455 memset (&ws, 0, sizeof (ws)); 456 event_ptid = target_wait (resume_ptid, &ws, 0); 457 458 if (ws.kind == TARGET_WAITKIND_IGNORE) 459 /* The inferior didn't really stop, keep waiting. */ 460 continue; 461 462 switch (ws.kind) 463 { 464 case TARGET_WAITKIND_SPURIOUS: 465 case TARGET_WAITKIND_LOADED: 466 case TARGET_WAITKIND_FORKED: 467 case TARGET_WAITKIND_VFORKED: 468 case TARGET_WAITKIND_SYSCALL_ENTRY: 469 case TARGET_WAITKIND_SYSCALL_RETURN: 470 /* Ignore gracefully during startup of the inferior. */ 471 switch_to_thread (event_ptid); 472 break; 473 474 case TARGET_WAITKIND_SIGNALLED: 475 target_terminal_ours (); 476 target_mourn_inferior (); 477 error (_("During startup program terminated with signal %s, %s."), 478 target_signal_to_name (ws.value.sig), 479 target_signal_to_string (ws.value.sig)); 480 return; 481 482 case TARGET_WAITKIND_EXITED: 483 target_terminal_ours (); 484 target_mourn_inferior (); 485 if (ws.value.integer) 486 error (_("During startup program exited with code %d."), 487 ws.value.integer); 488 else 489 error (_("During startup program exited normally.")); 490 return; 491 492 case TARGET_WAITKIND_EXECD: 493 /* Handle EXEC signals as if they were SIGTRAP signals. */ 494 xfree (ws.value.execd_pathname); 495 resume_signal = TARGET_SIGNAL_TRAP; 496 switch_to_thread (event_ptid); 497 break; 498 499 case TARGET_WAITKIND_STOPPED: 500 resume_signal = ws.value.sig; 501 switch_to_thread (event_ptid); 502 break; 503 } 504 505 if (resume_signal != TARGET_SIGNAL_TRAP) 506 { 507 /* Let shell child handle its own signals in its own way. */ 508 target_resume (resume_ptid, 0, resume_signal); 509 } 510 else 511 { 512 /* We handle SIGTRAP, however; it means child did an exec. */ 513 if (!terminal_initted) 514 { 515 /* Now that the child has exec'd we know it has already 516 set its process group. On POSIX systems, tcsetpgrp 517 will fail with EPERM if we try it before the child's 518 setpgid. */ 519 520 /* Set up the "saved terminal modes" of the inferior 521 based on what modes we are starting it with. */ 522 target_terminal_init (); 523 524 /* Install inferior's terminal modes. */ 525 target_terminal_inferior (); 526 527 terminal_initted = 1; 528 } 529 530 if (--pending_execs == 0) 531 break; 532 533 /* Just make it go on. */ 534 target_resume (resume_ptid, 0, TARGET_SIGNAL_0); 535 } 536 } 537 538 /* Mark all threads non-executing. */ 539 set_executing (resume_ptid, 0); 540 } 541 542 /* Implement the "unset exec-wrapper" command. */ 543 544 static void 545 unset_exec_wrapper_command (char *args, int from_tty) 546 { 547 xfree (exec_wrapper); 548 exec_wrapper = NULL; 549 } 550 551 /* Provide a prototype to silence -Wmissing-prototypes. */ 552 extern initialize_file_ftype _initialize_fork_child; 553 554 void 555 _initialize_fork_child (void) 556 { 557 add_setshow_filename_cmd ("exec-wrapper", class_run, &exec_wrapper, _("\ 558 Set a wrapper for running programs.\n\ 559 The wrapper prepares the system and environment for the new program."), 560 _("\ 561 Show the wrapper for running programs."), NULL, 562 NULL, NULL, 563 &setlist, &showlist); 564 565 add_cmd ("exec-wrapper", class_run, unset_exec_wrapper_command, 566 _("Disable use of an execution wrapper."), 567 &unsetlist); 568 } 569