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