1 /* Fork a Unix child process, and set up to debug it, for GDB. 2 3 Copyright (C) 1990-2016 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 "inferior.h" 24 #include "terminal.h" 25 #include "target.h" 26 #include "gdb_wait.h" 27 #include "gdb_vfork.h" 28 #include "gdbcore.h" 29 #include "gdbthread.h" 30 #include "command.h" /* for dont_repeat () */ 31 #include "gdbcmd.h" 32 #include "solib.h" 33 #include "filestuff.h" 34 #include "top.h" 35 #include "signals-state-save-restore.h" 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 struct ui *save_ui; 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 declared in inferior.h and bound to the 154 "set startup-with-shell" option. If 0, we'll just do a 155 fork/exec, no shell, so don't bother figuring out what 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 = XALLOCAVEC (char *, argc); 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 /* Retain a copy of our environment variables, since the child will 276 replace the value of environ and if we're vforked, we have to 277 restore it. */ 278 save_our_env = environ; 279 280 /* Likewise the current UI. */ 281 save_ui = current_ui; 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 (main_ui->m_gdb_stdout); 291 gdb_flush (main_ui->m_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 /* Switch to the main UI, so that gdb_std{in/out/err} in the 321 child are mapped to std{in/out/err}. This makes it possible 322 to use fprintf_unfiltered/warning/error/etc. in the child 323 from here on. */ 324 current_ui = main_ui; 325 326 /* Close all file descriptors except those that gdb inherited 327 (usually 0/1/2), so they don't leak to the inferior. Note 328 that this closes the file descriptors of all secondary 329 UIs. */ 330 close_most_fds (); 331 332 if (debug_fork) 333 sleep (debug_fork); 334 335 /* Create a new session for the inferior process, if necessary. 336 It will also place the inferior in a separate process group. */ 337 if (create_tty_session () <= 0) 338 { 339 /* No session was created, but we still want to run the inferior 340 in a separate process group. */ 341 debug_setpgrp = gdb_setpgid (); 342 if (debug_setpgrp == -1) 343 perror (_("setpgrp failed in child")); 344 } 345 346 /* Ask the tty subsystem to switch to the one we specified 347 earlier (or to share the current terminal, if none was 348 specified). */ 349 new_tty (); 350 351 /* Changing the signal handlers for the inferior after 352 a vfork can also change them for the superior, so we don't mess 353 with signals here. See comments in 354 initialize_signals for how we get the right signal handlers 355 for the inferior. */ 356 357 /* "Trace me, Dr. Memory!" */ 358 (*traceme_fun) (); 359 360 /* The call above set this process (the "child") as debuggable 361 by the original gdb process (the "parent"). Since processes 362 (unlike people) can have only one parent, if you are debugging 363 gdb itself (and your debugger is thus _already_ the 364 controller/parent for this child), code from here on out is 365 undebuggable. Indeed, you probably got an error message 366 saying "not parent". Sorry; you'll have to use print 367 statements! */ 368 369 restore_original_signals_state (); 370 371 /* There is no execlpe call, so we have to set the environment 372 for our child in the global variable. If we've vforked, this 373 clobbers the parent, but environ is restored a few lines down 374 in the parent. By the way, yes we do need to look down the 375 path to find $SHELL. Rich Pixley says so, and I agree. */ 376 environ = env; 377 378 if (exec_fun != NULL) 379 (*exec_fun) (argv[0], argv, env); 380 else 381 execvp (argv[0], argv); 382 383 /* If we get here, it's an error. */ 384 save_errno = errno; 385 fprintf_unfiltered (gdb_stderr, "Cannot exec %s", argv[0]); 386 for (i = 1; argv[i] != NULL; i++) 387 fprintf_unfiltered (gdb_stderr, " %s", argv[i]); 388 fprintf_unfiltered (gdb_stderr, ".\n"); 389 fprintf_unfiltered (gdb_stderr, "Error: %s\n", 390 safe_strerror (save_errno)); 391 gdb_flush (gdb_stderr); 392 _exit (0177); 393 } 394 395 /* Restore our environment in case a vforked child clob'd it. */ 396 environ = save_our_env; 397 398 /* Likewise the current UI. */ 399 current_ui = save_ui; 400 401 if (!have_inferiors ()) 402 init_thread_list (); 403 404 inf = current_inferior (); 405 406 inferior_appeared (inf, pid); 407 408 /* Needed for wait_for_inferior stuff below. */ 409 inferior_ptid = pid_to_ptid (pid); 410 411 new_tty_postfork (); 412 413 /* We have something that executes now. We'll be running through 414 the shell at this point, but the pid shouldn't change. Targets 415 supporting MT should fill this task's ptid with more data as soon 416 as they can. */ 417 add_thread_silent (inferior_ptid); 418 419 /* Now that we have a child process, make it our target, and 420 initialize anything target-vector-specific that needs 421 initializing. */ 422 if (init_trace_fun) 423 (*init_trace_fun) (pid); 424 425 /* We are now in the child process of interest, having exec'd the 426 correct program, and are poised at the first instruction of the 427 new program. */ 428 return pid; 429 } 430 431 /* Accept NTRAPS traps from the inferior. */ 432 433 void 434 startup_inferior (int ntraps) 435 { 436 int pending_execs = ntraps; 437 int terminal_initted = 0; 438 ptid_t resume_ptid; 439 440 if (startup_with_shell) 441 { 442 /* One trap extra for exec'ing the shell. */ 443 pending_execs++; 444 } 445 446 if (target_supports_multi_process ()) 447 resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid)); 448 else 449 resume_ptid = minus_one_ptid; 450 451 /* The process was started by the fork that created it, but it will 452 have stopped one instruction after execing the shell. Here we 453 must get it up to actual execution of the real program. */ 454 455 if (exec_wrapper) 456 pending_execs++; 457 458 while (1) 459 { 460 enum gdb_signal resume_signal = GDB_SIGNAL_0; 461 ptid_t event_ptid; 462 463 struct target_waitstatus ws; 464 memset (&ws, 0, sizeof (ws)); 465 event_ptid = target_wait (resume_ptid, &ws, 0); 466 467 if (ws.kind == TARGET_WAITKIND_IGNORE) 468 /* The inferior didn't really stop, keep waiting. */ 469 continue; 470 471 switch (ws.kind) 472 { 473 case TARGET_WAITKIND_SPURIOUS: 474 case TARGET_WAITKIND_LOADED: 475 case TARGET_WAITKIND_FORKED: 476 case TARGET_WAITKIND_VFORKED: 477 case TARGET_WAITKIND_SYSCALL_ENTRY: 478 case TARGET_WAITKIND_SYSCALL_RETURN: 479 /* Ignore gracefully during startup of the inferior. */ 480 switch_to_thread (event_ptid); 481 break; 482 483 case TARGET_WAITKIND_SIGNALLED: 484 target_terminal_ours (); 485 target_mourn_inferior (); 486 error (_("During startup program terminated with signal %s, %s."), 487 gdb_signal_to_name (ws.value.sig), 488 gdb_signal_to_string (ws.value.sig)); 489 return; 490 491 case TARGET_WAITKIND_EXITED: 492 target_terminal_ours (); 493 target_mourn_inferior (); 494 if (ws.value.integer) 495 error (_("During startup program exited with code %d."), 496 ws.value.integer); 497 else 498 error (_("During startup program exited normally.")); 499 return; 500 501 case TARGET_WAITKIND_EXECD: 502 /* Handle EXEC signals as if they were SIGTRAP signals. */ 503 xfree (ws.value.execd_pathname); 504 resume_signal = GDB_SIGNAL_TRAP; 505 switch_to_thread (event_ptid); 506 break; 507 508 case TARGET_WAITKIND_STOPPED: 509 resume_signal = ws.value.sig; 510 switch_to_thread (event_ptid); 511 break; 512 } 513 514 if (resume_signal != GDB_SIGNAL_TRAP) 515 { 516 /* Let shell child handle its own signals in its own way. */ 517 target_resume (resume_ptid, 0, resume_signal); 518 } 519 else 520 { 521 /* We handle SIGTRAP, however; it means child did an exec. */ 522 if (!terminal_initted) 523 { 524 /* Now that the child has exec'd we know it has already 525 set its process group. On POSIX systems, tcsetpgrp 526 will fail with EPERM if we try it before the child's 527 setpgid. */ 528 529 /* Set up the "saved terminal modes" of the inferior 530 based on what modes we are starting it with. */ 531 target_terminal_init (); 532 533 /* Install inferior's terminal modes. */ 534 target_terminal_inferior (); 535 536 terminal_initted = 1; 537 } 538 539 if (--pending_execs == 0) 540 break; 541 542 /* Just make it go on. */ 543 target_resume (resume_ptid, 0, GDB_SIGNAL_0); 544 } 545 } 546 547 /* Mark all threads non-executing. */ 548 set_executing (resume_ptid, 0); 549 } 550 551 /* Implement the "unset exec-wrapper" command. */ 552 553 static void 554 unset_exec_wrapper_command (char *args, int from_tty) 555 { 556 xfree (exec_wrapper); 557 exec_wrapper = NULL; 558 } 559 560 static void 561 show_startup_with_shell (struct ui_file *file, int from_tty, 562 struct cmd_list_element *c, const char *value) 563 { 564 fprintf_filtered (file, 565 _("Use of shell to start subprocesses is %s.\n"), 566 value); 567 } 568 569 /* Provide a prototype to silence -Wmissing-prototypes. */ 570 extern initialize_file_ftype _initialize_fork_child; 571 572 void 573 _initialize_fork_child (void) 574 { 575 add_setshow_filename_cmd ("exec-wrapper", class_run, &exec_wrapper, _("\ 576 Set a wrapper for running programs.\n\ 577 The wrapper prepares the system and environment for the new program."), 578 _("\ 579 Show the wrapper for running programs."), NULL, 580 NULL, NULL, 581 &setlist, &showlist); 582 583 add_cmd ("exec-wrapper", class_run, unset_exec_wrapper_command, 584 _("Disable use of an execution wrapper."), 585 &unsetlist); 586 587 add_setshow_boolean_cmd ("startup-with-shell", class_support, 588 &startup_with_shell, _("\ 589 Set use of shell to start subprocesses. The default is on."), _("\ 590 Show use of shell to start subprocesses."), NULL, 591 NULL, 592 show_startup_with_shell, 593 &setlist, &showlist); 594 } 595