1 /* Low level interface to ptrace, for GDB when running under Unix. 2 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 3 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 4 2009, 2010 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 #include "defs.h" 22 #include "frame.h" 23 #include "inferior.h" 24 #include "command.h" 25 #include "serial.h" 26 #include "terminal.h" 27 #include "target.h" 28 #include "gdbthread.h" 29 #include "observer.h" 30 31 #include "gdb_string.h" 32 #include <signal.h> 33 #include <fcntl.h> 34 #include "gdb_select.h" 35 36 #include "inflow.h" 37 38 #ifdef HAVE_SYS_IOCTL_H 39 #include <sys/ioctl.h> 40 #endif 41 42 #ifndef O_NOCTTY 43 #define O_NOCTTY 0 44 #endif 45 46 extern void _initialize_inflow (void); 47 48 static void pass_signal (int); 49 50 static void terminal_ours_1 (int); 51 52 /* Record terminal status separately for debugger and inferior. */ 53 54 static struct serial *stdin_serial; 55 56 /* Terminal related info we need to keep track of. Each inferior 57 holds an instance of this structure --- we save it whenever the 58 corresponding inferior stops, and restore it to the foreground 59 inferior when it resumes. */ 60 struct terminal_info 61 { 62 /* The name of the tty (from the `tty' command) that we gave to the 63 inferior when it was started. */ 64 char *run_terminal; 65 66 /* TTY state. We save it whenever the inferior stops, and restore 67 it when it resumes. */ 68 serial_ttystate ttystate; 69 70 #ifdef PROCESS_GROUP_TYPE 71 /* Process group. Saved and restored just like ttystate. */ 72 PROCESS_GROUP_TYPE process_group; 73 #endif 74 75 /* fcntl flags. Saved and restored just like ttystate. */ 76 int tflags; 77 }; 78 79 /* Our own tty state, which we restore every time we need to deal with 80 the terminal. This is only set once, when GDB first starts. The 81 settings of flags which readline saves and restores and 82 unimportant. */ 83 static struct terminal_info our_terminal_info; 84 85 static struct terminal_info *get_inflow_inferior_data (struct inferior *); 86 87 #ifdef PROCESS_GROUP_TYPE 88 89 /* Return the process group of the current inferior. */ 90 91 PROCESS_GROUP_TYPE 92 inferior_process_group (void) 93 { 94 return get_inflow_inferior_data (current_inferior ())->process_group; 95 } 96 #endif 97 98 /* While the inferior is running, we want SIGINT and SIGQUIT to go to the 99 inferior only. If we have job control, that takes care of it. If not, 100 we save our handlers in these two variables and set SIGINT and SIGQUIT 101 to SIG_IGN. */ 102 103 static void (*sigint_ours) (); 104 static void (*sigquit_ours) (); 105 106 /* The name of the tty (from the `tty' command) that we're giving to 107 the inferior when starting it up. This is only (and should only 108 be) used as a transient global by new_tty_prefork, 109 create_tty_session, new_tty and new_tty_postfork, all called from 110 fork_inferior, while forking a new child. */ 111 static const char *inferior_thisrun_terminal; 112 113 /* Nonzero if our terminal settings are in effect. Zero if the 114 inferior's settings are in effect. Ignored if !gdb_has_a_terminal 115 (). */ 116 117 int terminal_is_ours; 118 119 #ifdef PROCESS_GROUP_TYPE 120 static PROCESS_GROUP_TYPE 121 gdb_getpgrp (void) 122 { 123 int process_group = -1; 124 125 #ifdef HAVE_TERMIOS 126 process_group = tcgetpgrp (0); 127 #endif 128 #ifdef HAVE_TERMIO 129 process_group = getpgrp (); 130 #endif 131 #ifdef HAVE_SGTTY 132 ioctl (0, TIOCGPGRP, &process_group); 133 #endif 134 return process_group; 135 } 136 #endif 137 138 enum 139 { 140 yes, no, have_not_checked 141 } 142 gdb_has_a_terminal_flag = have_not_checked; 143 144 /* Does GDB have a terminal (on stdin)? */ 145 int 146 gdb_has_a_terminal (void) 147 { 148 switch (gdb_has_a_terminal_flag) 149 { 150 case yes: 151 return 1; 152 case no: 153 return 0; 154 case have_not_checked: 155 /* Get all the current tty settings (including whether we have a 156 tty at all!). Can't do this in _initialize_inflow because 157 serial_fdopen() won't work until the serial_ops_list is 158 initialized. */ 159 160 #ifdef F_GETFL 161 our_terminal_info.tflags = fcntl (0, F_GETFL, 0); 162 #endif 163 164 gdb_has_a_terminal_flag = no; 165 if (stdin_serial != NULL) 166 { 167 our_terminal_info.ttystate = serial_get_tty_state (stdin_serial); 168 169 if (our_terminal_info.ttystate != NULL) 170 { 171 gdb_has_a_terminal_flag = yes; 172 #ifdef PROCESS_GROUP_TYPE 173 our_terminal_info.process_group = gdb_getpgrp (); 174 #endif 175 } 176 } 177 178 return gdb_has_a_terminal_flag == yes; 179 default: 180 /* "Can't happen". */ 181 return 0; 182 } 183 } 184 185 /* Macro for printing errors from ioctl operations */ 186 187 #define OOPSY(what) \ 188 if (result == -1) \ 189 fprintf_unfiltered(gdb_stderr, "[%s failed in terminal_inferior: %s]\n", \ 190 what, safe_strerror (errno)) 191 192 static void terminal_ours_1 (int); 193 194 /* Initialize the terminal settings we record for the inferior, 195 before we actually run the inferior. */ 196 197 void 198 terminal_init_inferior_with_pgrp (int pgrp) 199 { 200 if (gdb_has_a_terminal ()) 201 { 202 struct inferior *inf = current_inferior (); 203 struct terminal_info *tinfo = get_inflow_inferior_data (inf); 204 205 /* We could just as well copy our_ttystate (if we felt like 206 adding a new function serial_copy_tty_state()). */ 207 xfree (tinfo->ttystate); 208 tinfo->ttystate = serial_get_tty_state (stdin_serial); 209 210 #ifdef PROCESS_GROUP_TYPE 211 tinfo->process_group = pgrp; 212 #endif 213 214 /* Make sure that next time we call terminal_inferior (which will be 215 before the program runs, as it needs to be), we install the new 216 process group. */ 217 terminal_is_ours = 1; 218 } 219 } 220 221 /* Save the terminal settings again. This is necessary for the TUI 222 when it switches to TUI or non-TUI mode; curses changes the terminal 223 and gdb must be able to restore it correctly. */ 224 225 void 226 terminal_save_ours (void) 227 { 228 if (gdb_has_a_terminal ()) 229 { 230 /* We could just as well copy our_ttystate (if we felt like adding 231 a new function serial_copy_tty_state). */ 232 xfree (our_terminal_info.ttystate); 233 our_terminal_info.ttystate = serial_get_tty_state (stdin_serial); 234 } 235 } 236 237 void 238 terminal_init_inferior (void) 239 { 240 #ifdef PROCESS_GROUP_TYPE 241 /* This is for Lynx, and should be cleaned up by having Lynx be a separate 242 debugging target with a version of target_terminal_init_inferior which 243 passes in the process group to a generic routine which does all the work 244 (and the non-threaded child_terminal_init_inferior can just pass in 245 inferior_ptid to the same routine). */ 246 /* We assume INFERIOR_PID is also the child's process group. */ 247 terminal_init_inferior_with_pgrp (PIDGET (inferior_ptid)); 248 #endif /* PROCESS_GROUP_TYPE */ 249 } 250 251 /* Put the inferior's terminal settings into effect. 252 This is preparation for starting or resuming the inferior. */ 253 254 void 255 terminal_inferior (void) 256 { 257 struct inferior *inf; 258 struct terminal_info *tinfo; 259 260 if (!terminal_is_ours) 261 return; 262 263 inf = current_inferior (); 264 tinfo = get_inflow_inferior_data (inf); 265 266 if (gdb_has_a_terminal () 267 && tinfo->ttystate != NULL 268 && tinfo->run_terminal == NULL) 269 { 270 int result; 271 272 #ifdef F_GETFL 273 /* Is there a reason this is being done twice? It happens both 274 places we use F_SETFL, so I'm inclined to think perhaps there 275 is some reason, however perverse. Perhaps not though... */ 276 result = fcntl (0, F_SETFL, tinfo->tflags); 277 result = fcntl (0, F_SETFL, tinfo->tflags); 278 OOPSY ("fcntl F_SETFL"); 279 #endif 280 281 /* Because we were careful to not change in or out of raw mode in 282 terminal_ours, we will not change in our out of raw mode with 283 this call, so we don't flush any input. */ 284 result = serial_set_tty_state (stdin_serial, 285 tinfo->ttystate); 286 OOPSY ("setting tty state"); 287 288 if (!job_control) 289 { 290 sigint_ours = (void (*)()) signal (SIGINT, SIG_IGN); 291 #ifdef SIGQUIT 292 sigquit_ours = (void (*)()) signal (SIGQUIT, SIG_IGN); 293 #endif 294 } 295 296 /* If attach_flag is set, we don't know whether we are sharing a 297 terminal with the inferior or not. (attaching a process 298 without a terminal is one case where we do not; attaching a 299 process which we ran from the same shell as GDB via `&' is 300 one case where we do, I think (but perhaps this is not 301 `sharing' in the sense that we need to save and restore tty 302 state)). I don't know if there is any way to tell whether we 303 are sharing a terminal. So what we do is to go through all 304 the saving and restoring of the tty state, but ignore errors 305 setting the process group, which will happen if we are not 306 sharing a terminal). */ 307 308 if (job_control) 309 { 310 #ifdef HAVE_TERMIOS 311 result = tcsetpgrp (0, tinfo->process_group); 312 if (!inf->attach_flag) 313 OOPSY ("tcsetpgrp"); 314 #endif 315 316 #ifdef HAVE_SGTTY 317 result = ioctl (0, TIOCSPGRP, &tinfo->process_group); 318 if (!inf->attach_flag) 319 OOPSY ("TIOCSPGRP"); 320 #endif 321 } 322 323 } 324 terminal_is_ours = 0; 325 } 326 327 /* Put some of our terminal settings into effect, 328 enough to get proper results from our output, 329 but do not change into or out of RAW mode 330 so that no input is discarded. 331 332 After doing this, either terminal_ours or terminal_inferior 333 should be called to get back to a normal state of affairs. */ 334 335 void 336 terminal_ours_for_output (void) 337 { 338 terminal_ours_1 (1); 339 } 340 341 /* Put our terminal settings into effect. 342 First record the inferior's terminal settings 343 so they can be restored properly later. */ 344 345 void 346 terminal_ours (void) 347 { 348 terminal_ours_1 (0); 349 } 350 351 /* output_only is not used, and should not be used unless we introduce 352 separate terminal_is_ours and terminal_is_ours_for_output 353 flags. */ 354 355 static void 356 terminal_ours_1 (int output_only) 357 { 358 struct inferior *inf; 359 struct terminal_info *tinfo; 360 361 if (terminal_is_ours) 362 return; 363 364 terminal_is_ours = 1; 365 366 /* Checking inferior->run_terminal is necessary so that 367 if GDB is running in the background, it won't block trying 368 to do the ioctl()'s below. Checking gdb_has_a_terminal 369 avoids attempting all the ioctl's when running in batch. */ 370 371 inf = current_inferior (); 372 tinfo = get_inflow_inferior_data (inf); 373 374 if (tinfo->run_terminal != NULL || gdb_has_a_terminal () == 0) 375 return; 376 377 { 378 #ifdef SIGTTOU 379 /* Ignore this signal since it will happen when we try to set the 380 pgrp. */ 381 void (*osigttou) () = NULL; 382 #endif 383 int result; 384 385 #ifdef SIGTTOU 386 if (job_control) 387 osigttou = (void (*)()) signal (SIGTTOU, SIG_IGN); 388 #endif 389 390 xfree (tinfo->ttystate); 391 tinfo->ttystate = serial_get_tty_state (stdin_serial); 392 393 #ifdef PROCESS_GROUP_TYPE 394 if (!inf->attach_flag) 395 /* If setpgrp failed in terminal_inferior, this would give us 396 our process group instead of the inferior's. See 397 terminal_inferior for details. */ 398 tinfo->process_group = gdb_getpgrp (); 399 #endif 400 401 /* Here we used to set ICANON in our ttystate, but I believe this 402 was an artifact from before when we used readline. Readline sets 403 the tty state when it needs to. 404 FIXME-maybe: However, query() expects non-raw mode and doesn't 405 use readline. Maybe query should use readline (on the other hand, 406 this only matters for HAVE_SGTTY, not termio or termios, I think). */ 407 408 /* Set tty state to our_ttystate. We don't change in our out of raw 409 mode, to avoid flushing input. We need to do the same thing 410 regardless of output_only, because we don't have separate 411 terminal_is_ours and terminal_is_ours_for_output flags. It's OK, 412 though, since readline will deal with raw mode when/if it needs to. 413 */ 414 415 serial_noflush_set_tty_state (stdin_serial, our_terminal_info.ttystate, 416 tinfo->ttystate); 417 418 if (job_control) 419 { 420 #ifdef HAVE_TERMIOS 421 result = tcsetpgrp (0, our_terminal_info.process_group); 422 #if 0 423 /* This fails on Ultrix with EINVAL if you run the testsuite 424 in the background with nohup, and then log out. GDB never 425 used to check for an error here, so perhaps there are other 426 such situations as well. */ 427 if (result == -1) 428 fprintf_unfiltered (gdb_stderr, "[tcsetpgrp failed in terminal_ours: %s]\n", 429 safe_strerror (errno)); 430 #endif 431 #endif /* termios */ 432 433 #ifdef HAVE_SGTTY 434 result = ioctl (0, TIOCSPGRP, &our_terminal_info.process_group); 435 #endif 436 } 437 438 #ifdef SIGTTOU 439 if (job_control) 440 signal (SIGTTOU, osigttou); 441 #endif 442 443 if (!job_control) 444 { 445 signal (SIGINT, sigint_ours); 446 #ifdef SIGQUIT 447 signal (SIGQUIT, sigquit_ours); 448 #endif 449 } 450 451 #ifdef F_GETFL 452 tinfo->tflags = fcntl (0, F_GETFL, 0); 453 454 /* Is there a reason this is being done twice? It happens both 455 places we use F_SETFL, so I'm inclined to think perhaps there 456 is some reason, however perverse. Perhaps not though... */ 457 result = fcntl (0, F_SETFL, our_terminal_info.tflags); 458 result = fcntl (0, F_SETFL, our_terminal_info.tflags); 459 #endif 460 } 461 } 462 463 /* Per-inferior data key. */ 464 static const struct inferior_data *inflow_inferior_data; 465 466 static void 467 inflow_inferior_data_cleanup (struct inferior *inf, void *arg) 468 { 469 struct terminal_info *info; 470 471 info = inferior_data (inf, inflow_inferior_data); 472 if (info != NULL) 473 { 474 xfree (info->run_terminal); 475 xfree (info); 476 } 477 } 478 479 /* Get the current svr4 data. If none is found yet, add it now. This 480 function always returns a valid object. */ 481 482 static struct terminal_info * 483 get_inflow_inferior_data (struct inferior *inf) 484 { 485 struct terminal_info *info; 486 487 info = inferior_data (inf, inflow_inferior_data); 488 if (info == NULL) 489 { 490 info = XZALLOC (struct terminal_info); 491 set_inferior_data (inf, inflow_inferior_data, info); 492 } 493 494 return info; 495 } 496 497 /* This is a "inferior_exit" observer. Releases the TERMINAL_INFO member 498 of the inferior structure. This field is private to inflow.c, and 499 its type is opaque to the rest of GDB. PID is the target pid of 500 the inferior that is about to be removed from the inferior 501 list. */ 502 503 static void 504 inflow_inferior_exit (struct inferior *inf) 505 { 506 struct terminal_info *info; 507 508 info = inferior_data (inf, inflow_inferior_data); 509 if (info != NULL) 510 { 511 xfree (info->run_terminal); 512 xfree (info); 513 set_inferior_data (inf, inflow_inferior_data, NULL); 514 } 515 } 516 517 void 518 copy_terminal_info (struct inferior *to, struct inferior *from) 519 { 520 struct terminal_info *tinfo_to, *tinfo_from; 521 522 tinfo_to = get_inflow_inferior_data (to); 523 tinfo_from = get_inflow_inferior_data (from); 524 *tinfo_to = *tinfo_from; 525 if (tinfo_from->run_terminal) 526 tinfo_to->run_terminal 527 = xstrdup (tinfo_from->run_terminal); 528 } 529 530 void 531 term_info (char *arg, int from_tty) 532 { 533 target_terminal_info (arg, from_tty); 534 } 535 536 void 537 child_terminal_info (char *args, int from_tty) 538 { 539 struct inferior *inf; 540 struct terminal_info *tinfo; 541 542 if (!gdb_has_a_terminal ()) 543 { 544 printf_filtered (_("This GDB does not control a terminal.\n")); 545 return; 546 } 547 548 if (ptid_equal (inferior_ptid, null_ptid)) 549 return; 550 551 inf = current_inferior (); 552 tinfo = get_inflow_inferior_data (inf); 553 554 printf_filtered (_("Inferior's terminal status (currently saved by GDB):\n")); 555 556 /* First the fcntl flags. */ 557 { 558 int flags; 559 560 flags = tinfo->tflags; 561 562 printf_filtered ("File descriptor flags = "); 563 564 #ifndef O_ACCMODE 565 #define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR) 566 #endif 567 /* (O_ACCMODE) parens are to avoid Ultrix header file bug */ 568 switch (flags & (O_ACCMODE)) 569 { 570 case O_RDONLY: 571 printf_filtered ("O_RDONLY"); 572 break; 573 case O_WRONLY: 574 printf_filtered ("O_WRONLY"); 575 break; 576 case O_RDWR: 577 printf_filtered ("O_RDWR"); 578 break; 579 } 580 flags &= ~(O_ACCMODE); 581 582 #ifdef O_NONBLOCK 583 if (flags & O_NONBLOCK) 584 printf_filtered (" | O_NONBLOCK"); 585 flags &= ~O_NONBLOCK; 586 #endif 587 588 #if defined (O_NDELAY) 589 /* If O_NDELAY and O_NONBLOCK are defined to the same thing, we will 590 print it as O_NONBLOCK, which is good cause that is what POSIX 591 has, and the flag will already be cleared by the time we get here. */ 592 if (flags & O_NDELAY) 593 printf_filtered (" | O_NDELAY"); 594 flags &= ~O_NDELAY; 595 #endif 596 597 if (flags & O_APPEND) 598 printf_filtered (" | O_APPEND"); 599 flags &= ~O_APPEND; 600 601 #if defined (O_BINARY) 602 if (flags & O_BINARY) 603 printf_filtered (" | O_BINARY"); 604 flags &= ~O_BINARY; 605 #endif 606 607 if (flags) 608 printf_filtered (" | 0x%x", flags); 609 printf_filtered ("\n"); 610 } 611 612 #ifdef PROCESS_GROUP_TYPE 613 printf_filtered ("Process group = %d\n", (int) tinfo->process_group); 614 #endif 615 616 serial_print_tty_state (stdin_serial, tinfo->ttystate, gdb_stdout); 617 } 618 619 /* NEW_TTY_PREFORK is called before forking a new child process, 620 so we can record the state of ttys in the child to be formed. 621 TTYNAME is null if we are to share the terminal with gdb; 622 or points to a string containing the name of the desired tty. 623 624 NEW_TTY is called in new child processes under Unix, which will 625 become debugger target processes. This actually switches to 626 the terminal specified in the NEW_TTY_PREFORK call. */ 627 628 void 629 new_tty_prefork (const char *ttyname) 630 { 631 /* Save the name for later, for determining whether we and the child 632 are sharing a tty. */ 633 inferior_thisrun_terminal = ttyname; 634 } 635 636 #if !defined(__GO32__) && !defined(_WIN32) 637 /* If RESULT, assumed to be the return value from a system call, is 638 negative, print the error message indicated by errno and exit. 639 MSG should identify the operation that failed. */ 640 static void 641 check_syscall (const char *msg, int result) 642 { 643 if (result < 0) 644 { 645 print_sys_errmsg (msg, errno); 646 _exit (1); 647 } 648 } 649 #endif 650 651 void 652 new_tty (void) 653 { 654 int tty; 655 656 if (inferior_thisrun_terminal == 0) 657 return; 658 #if !defined(__GO32__) && !defined(_WIN32) 659 #ifdef TIOCNOTTY 660 /* Disconnect the child process from our controlling terminal. On some 661 systems (SVR4 for example), this may cause a SIGTTOU, so temporarily 662 ignore SIGTTOU. */ 663 tty = open ("/dev/tty", O_RDWR); 664 if (tty > 0) 665 { 666 void (*osigttou) (); 667 668 osigttou = (void (*)()) signal (SIGTTOU, SIG_IGN); 669 ioctl (tty, TIOCNOTTY, 0); 670 close (tty); 671 signal (SIGTTOU, osigttou); 672 } 673 #endif 674 675 /* Now open the specified new terminal. */ 676 tty = open (inferior_thisrun_terminal, O_RDWR | O_NOCTTY); 677 check_syscall (inferior_thisrun_terminal, tty); 678 679 /* Avoid use of dup2; doesn't exist on all systems. */ 680 if (tty != 0) 681 { 682 close (0); 683 check_syscall ("dup'ing tty into fd 0", dup (tty)); 684 } 685 if (tty != 1) 686 { 687 close (1); 688 check_syscall ("dup'ing tty into fd 1", dup (tty)); 689 } 690 if (tty != 2) 691 { 692 close (2); 693 check_syscall ("dup'ing tty into fd 2", dup (tty)); 694 } 695 696 #ifdef TIOCSCTTY 697 /* Make tty our new controlling terminal. */ 698 if (ioctl (tty, TIOCSCTTY, 0) == -1) 699 /* Mention GDB in warning because it will appear in the inferior's 700 terminal instead of GDB's. */ 701 warning ("GDB: Failed to set controlling terminal: %s", 702 safe_strerror (errno)); 703 #endif 704 705 if (tty > 2) 706 close (tty); 707 #endif /* !go32 && !win32 */ 708 } 709 710 /* NEW_TTY_POSTFORK is called after forking a new child process, and 711 adding it to the inferior table, to store the TTYNAME being used by 712 the child, or null if it sharing the terminal with gdb. */ 713 714 void 715 new_tty_postfork (void) 716 { 717 /* Save the name for later, for determining whether we and the child 718 are sharing a tty. */ 719 720 if (inferior_thisrun_terminal) 721 { 722 struct inferior *inf = current_inferior (); 723 struct terminal_info *tinfo = get_inflow_inferior_data (inf); 724 725 tinfo->run_terminal = xstrdup (inferior_thisrun_terminal); 726 } 727 728 inferior_thisrun_terminal = NULL; 729 } 730 731 732 /* Call set_sigint_trap when you need to pass a signal on to an attached 733 process when handling SIGINT */ 734 735 static void 736 pass_signal (int signo) 737 { 738 #ifndef _WIN32 739 kill (PIDGET (inferior_ptid), SIGINT); 740 #endif 741 } 742 743 static void (*osig) (); 744 static int osig_set; 745 746 void 747 set_sigint_trap (void) 748 { 749 struct inferior *inf = current_inferior (); 750 struct terminal_info *tinfo = get_inflow_inferior_data (inf); 751 752 if (inf->attach_flag || tinfo->run_terminal) 753 { 754 osig = (void (*)()) signal (SIGINT, pass_signal); 755 osig_set = 1; 756 } 757 else 758 osig_set = 0; 759 } 760 761 void 762 clear_sigint_trap (void) 763 { 764 if (osig_set) 765 { 766 signal (SIGINT, osig); 767 osig_set = 0; 768 } 769 } 770 771 772 /* Create a new session if the inferior will run in a different tty. 773 A session is UNIX's way of grouping processes that share a controlling 774 terminal, so a new one is needed if the inferior terminal will be 775 different from GDB's. 776 777 Returns the session id of the new session, 0 if no session was created 778 or -1 if an error occurred. */ 779 pid_t 780 create_tty_session (void) 781 { 782 #ifdef HAVE_SETSID 783 pid_t ret; 784 785 if (!job_control || inferior_thisrun_terminal == 0) 786 return 0; 787 788 ret = setsid (); 789 if (ret == -1) 790 warning ("Failed to create new terminal session: setsid: %s", 791 safe_strerror (errno)); 792 793 return ret; 794 #else 795 return 0; 796 #endif /* HAVE_SETSID */ 797 } 798 799 /* This is here because this is where we figure out whether we (probably) 800 have job control. Just using job_control only does part of it because 801 setpgid or setpgrp might not exist on a system without job control. 802 It might be considered misplaced (on the other hand, process groups and 803 job control are closely related to ttys). 804 805 For a more clean implementation, in libiberty, put a setpgid which merely 806 calls setpgrp and a setpgrp which does nothing (any system with job control 807 will have one or the other). */ 808 int 809 gdb_setpgid (void) 810 { 811 int retval = 0; 812 813 if (job_control) 814 { 815 #if defined (HAVE_TERMIOS) || defined (TIOCGPGRP) 816 #ifdef HAVE_SETPGID 817 /* The call setpgid (0, 0) is supposed to work and mean the same 818 thing as this, but on Ultrix 4.2A it fails with EPERM (and 819 setpgid (getpid (), getpid ()) succeeds). */ 820 retval = setpgid (getpid (), getpid ()); 821 #else 822 #ifdef HAVE_SETPGRP 823 #ifdef SETPGRP_VOID 824 retval = setpgrp (); 825 #else 826 retval = setpgrp (getpid (), getpid ()); 827 #endif 828 #endif /* HAVE_SETPGRP */ 829 #endif /* HAVE_SETPGID */ 830 #endif /* defined (HAVE_TERMIOS) || defined (TIOCGPGRP) */ 831 } 832 833 return retval; 834 } 835 836 /* Get all the current tty settings (including whether we have a 837 tty at all!). We can't do this in _initialize_inflow because 838 serial_fdopen() won't work until the serial_ops_list is 839 initialized, but we don't want to do it lazily either, so 840 that we can guarantee stdin_serial is opened if there is 841 a terminal. */ 842 void 843 initialize_stdin_serial (void) 844 { 845 stdin_serial = serial_fdopen (0); 846 } 847 848 void 849 _initialize_inflow (void) 850 { 851 add_info ("terminal", term_info, 852 _("Print inferior's saved terminal status.")); 853 854 terminal_is_ours = 1; 855 856 /* OK, figure out whether we have job control. If neither termios nor 857 sgtty (i.e. termio or go32), leave job_control 0. */ 858 859 #if defined (HAVE_TERMIOS) 860 /* Do all systems with termios have the POSIX way of identifying job 861 control? I hope so. */ 862 #ifdef _POSIX_JOB_CONTROL 863 job_control = 1; 864 #else 865 #ifdef _SC_JOB_CONTROL 866 job_control = sysconf (_SC_JOB_CONTROL); 867 #else 868 job_control = 0; /* have to assume the worst */ 869 #endif /* _SC_JOB_CONTROL */ 870 #endif /* _POSIX_JOB_CONTROL */ 871 #endif /* HAVE_TERMIOS */ 872 873 #ifdef HAVE_SGTTY 874 #ifdef TIOCGPGRP 875 job_control = 1; 876 #else 877 job_control = 0; 878 #endif /* TIOCGPGRP */ 879 #endif /* sgtty */ 880 881 observer_attach_inferior_exit (inflow_inferior_exit); 882 883 inflow_inferior_data 884 = register_inferior_data_with_cleanup (inflow_inferior_data_cleanup); 885 } 886