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