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