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