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 4 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 30#include "gdb_string.h" 31#include <signal.h> 32#include <fcntl.h> 33#include "gdb_select.h" 34 35#include "inflow.h" 36 37#ifdef HAVE_SYS_IOCTL_H 38#include <sys/ioctl.h> 39#endif 40 41#ifndef O_NOCTTY 42#define O_NOCTTY 0 43#endif 44 45#if defined (SIGIO) && defined (FASYNC) && defined (FD_SET) && defined (F_SETOWN) 46static void handle_sigio (int); 47#endif 48 49extern void _initialize_inflow (void); 50 51static void pass_signal (int); 52 53static void kill_command (char *, int); 54 55static void terminal_ours_1 (int); 56 57/* Record terminal status separately for debugger and inferior. */ 58 59static struct serial *stdin_serial; 60 61/* TTY state for the inferior. We save it whenever the inferior stops, and 62 restore it when it resumes. */ 63static serial_ttystate inferior_ttystate; 64 65/* Our own tty state, which we restore every time we need to deal with the 66 terminal. We only set it once, when GDB first starts. The settings of 67 flags which readline saves and restores and unimportant. */ 68static serial_ttystate our_ttystate; 69 70/* fcntl flags for us and the inferior. Saved and restored just like 71 {our,inferior}_ttystate. */ 72static int tflags_inferior; 73static int tflags_ours; 74 75#ifdef PROCESS_GROUP_TYPE 76/* Process group for us and the inferior. Saved and restored just like 77 {our,inferior}_ttystate. */ 78PROCESS_GROUP_TYPE our_process_group; 79PROCESS_GROUP_TYPE inferior_process_group; 80#endif 81 82/* While the inferior is running, we want SIGINT and SIGQUIT to go to the 83 inferior only. If we have job control, that takes care of it. If not, 84 we save our handlers in these two variables and set SIGINT and SIGQUIT 85 to SIG_IGN. */ 86 87static void (*sigint_ours) (); 88static void (*sigquit_ours) (); 89 90/* The name of the tty (from the `tty' command) that we gave to the inferior 91 when it was last started. */ 92 93static const char *inferior_thisrun_terminal; 94 95/* Nonzero if our terminal settings are in effect. Zero if the 96 inferior's settings are in effect. Ignored if !gdb_has_a_terminal 97 (). */ 98 99int terminal_is_ours; 100 101enum 102 { 103 yes, no, have_not_checked 104 } 105gdb_has_a_terminal_flag = have_not_checked; 106 107/* Does GDB have a terminal (on stdin)? */ 108int 109gdb_has_a_terminal (void) 110{ 111 switch (gdb_has_a_terminal_flag) 112 { 113 case yes: 114 return 1; 115 case no: 116 return 0; 117 case have_not_checked: 118 /* Get all the current tty settings (including whether we have a 119 tty at all!). Can't do this in _initialize_inflow because 120 serial_fdopen() won't work until the serial_ops_list is 121 initialized. */ 122 123#ifdef F_GETFL 124 tflags_ours = fcntl (0, F_GETFL, 0); 125#endif 126 127 gdb_has_a_terminal_flag = no; 128 if (stdin_serial != NULL) 129 { 130 our_ttystate = serial_get_tty_state (stdin_serial); 131 132 if (our_ttystate != NULL) 133 { 134 gdb_has_a_terminal_flag = yes; 135#ifdef HAVE_TERMIOS 136 our_process_group = tcgetpgrp (0); 137#endif 138#ifdef HAVE_TERMIO 139 our_process_group = getpgrp (); 140#endif 141#ifdef HAVE_SGTTY 142 ioctl (0, TIOCGPGRP, &our_process_group); 143#endif 144 } 145 } 146 147 return gdb_has_a_terminal_flag == yes; 148 default: 149 /* "Can't happen". */ 150 return 0; 151 } 152} 153 154/* Macro for printing errors from ioctl operations */ 155 156#define OOPSY(what) \ 157 if (result == -1) \ 158 fprintf_unfiltered(gdb_stderr, "[%s failed in terminal_inferior: %s]\n", \ 159 what, safe_strerror (errno)) 160 161static void terminal_ours_1 (int); 162 163/* Initialize the terminal settings we record for the inferior, 164 before we actually run the inferior. */ 165 166void 167terminal_init_inferior_with_pgrp (int pgrp) 168{ 169 if (gdb_has_a_terminal ()) 170 { 171 /* We could just as well copy our_ttystate (if we felt like 172 adding a new function serial_copy_tty_state()). */ 173 if (inferior_ttystate) 174 xfree (inferior_ttystate); 175 inferior_ttystate = serial_get_tty_state (stdin_serial); 176 177#ifdef PROCESS_GROUP_TYPE 178 inferior_process_group = pgrp; 179#endif 180 181 /* Make sure that next time we call terminal_inferior (which will be 182 before the program runs, as it needs to be), we install the new 183 process group. */ 184 terminal_is_ours = 1; 185 } 186} 187 188/* Save the terminal settings again. This is necessary for the TUI 189 when it switches to TUI or non-TUI mode; curses changes the terminal 190 and gdb must be able to restore it correctly. */ 191 192void 193terminal_save_ours (void) 194{ 195 if (gdb_has_a_terminal ()) 196 { 197 /* We could just as well copy our_ttystate (if we felt like adding 198 a new function serial_copy_tty_state). */ 199 if (our_ttystate) 200 xfree (our_ttystate); 201 our_ttystate = serial_get_tty_state (stdin_serial); 202 } 203} 204 205void 206terminal_init_inferior (void) 207{ 208#ifdef PROCESS_GROUP_TYPE 209 /* This is for Lynx, and should be cleaned up by having Lynx be a separate 210 debugging target with a version of target_terminal_init_inferior which 211 passes in the process group to a generic routine which does all the work 212 (and the non-threaded child_terminal_init_inferior can just pass in 213 inferior_ptid to the same routine). */ 214 /* We assume INFERIOR_PID is also the child's process group. */ 215 terminal_init_inferior_with_pgrp (PIDGET (inferior_ptid)); 216#endif /* PROCESS_GROUP_TYPE */ 217} 218 219/* Put the inferior's terminal settings into effect. 220 This is preparation for starting or resuming the inferior. */ 221 222void 223terminal_inferior (void) 224{ 225 if (gdb_has_a_terminal () && terminal_is_ours 226 && inferior_ttystate != NULL 227 && inferior_thisrun_terminal == 0) 228 { 229 int result; 230 231#ifdef F_GETFL 232 /* Is there a reason this is being done twice? It happens both 233 places we use F_SETFL, so I'm inclined to think perhaps there 234 is some reason, however perverse. Perhaps not though... */ 235 result = fcntl (0, F_SETFL, tflags_inferior); 236 result = fcntl (0, F_SETFL, tflags_inferior); 237 OOPSY ("fcntl F_SETFL"); 238#endif 239 240 /* Because we were careful to not change in or out of raw mode in 241 terminal_ours, we will not change in our out of raw mode with 242 this call, so we don't flush any input. */ 243 result = serial_set_tty_state (stdin_serial, inferior_ttystate); 244 OOPSY ("setting tty state"); 245 246 if (!job_control) 247 { 248 sigint_ours = (void (*)()) signal (SIGINT, SIG_IGN); 249#ifdef SIGQUIT 250 sigquit_ours = (void (*)()) signal (SIGQUIT, SIG_IGN); 251#endif 252 } 253 254 /* If attach_flag is set, we don't know whether we are sharing a 255 terminal with the inferior or not. (attaching a process 256 without a terminal is one case where we do not; attaching a 257 process which we ran from the same shell as GDB via `&' is 258 one case where we do, I think (but perhaps this is not 259 `sharing' in the sense that we need to save and restore tty 260 state)). I don't know if there is any way to tell whether we 261 are sharing a terminal. So what we do is to go through all 262 the saving and restoring of the tty state, but ignore errors 263 setting the process group, which will happen if we are not 264 sharing a terminal). */ 265 266 if (job_control) 267 { 268#ifdef HAVE_TERMIOS 269 result = tcsetpgrp (0, inferior_process_group); 270 if (!attach_flag) 271 OOPSY ("tcsetpgrp"); 272#endif 273 274#ifdef HAVE_SGTTY 275 result = ioctl (0, TIOCSPGRP, &inferior_process_group); 276 if (!attach_flag) 277 OOPSY ("TIOCSPGRP"); 278#endif 279 } 280 281 } 282 terminal_is_ours = 0; 283} 284 285/* Put some of our terminal settings into effect, 286 enough to get proper results from our output, 287 but do not change into or out of RAW mode 288 so that no input is discarded. 289 290 After doing this, either terminal_ours or terminal_inferior 291 should be called to get back to a normal state of affairs. */ 292 293void 294terminal_ours_for_output (void) 295{ 296 terminal_ours_1 (1); 297} 298 299/* Put our terminal settings into effect. 300 First record the inferior's terminal settings 301 so they can be restored properly later. */ 302 303void 304terminal_ours (void) 305{ 306 terminal_ours_1 (0); 307} 308 309/* output_only is not used, and should not be used unless we introduce 310 separate terminal_is_ours and terminal_is_ours_for_output 311 flags. */ 312 313static void 314terminal_ours_1 (int output_only) 315{ 316 /* Checking inferior_thisrun_terminal is necessary so that 317 if GDB is running in the background, it won't block trying 318 to do the ioctl()'s below. Checking gdb_has_a_terminal 319 avoids attempting all the ioctl's when running in batch. */ 320 if (inferior_thisrun_terminal != 0 || gdb_has_a_terminal () == 0) 321 return; 322 323 if (!terminal_is_ours) 324 { 325#ifdef SIGTTOU 326 /* Ignore this signal since it will happen when we try to set the 327 pgrp. */ 328 void (*osigttou) () = NULL; 329#endif 330 int result; 331 332 terminal_is_ours = 1; 333 334#ifdef SIGTTOU 335 if (job_control) 336 osigttou = (void (*)()) signal (SIGTTOU, SIG_IGN); 337#endif 338 339 if (inferior_ttystate) 340 xfree (inferior_ttystate); 341 inferior_ttystate = serial_get_tty_state (stdin_serial); 342#ifdef HAVE_TERMIOS 343 inferior_process_group = tcgetpgrp (0); 344#endif 345#ifdef HAVE_TERMIO 346 inferior_process_group = getpgrp (); 347#endif 348#ifdef HAVE_SGTTY 349 ioctl (0, TIOCGPGRP, &inferior_process_group); 350#endif 351 352 /* Here we used to set ICANON in our ttystate, but I believe this 353 was an artifact from before when we used readline. Readline sets 354 the tty state when it needs to. 355 FIXME-maybe: However, query() expects non-raw mode and doesn't 356 use readline. Maybe query should use readline (on the other hand, 357 this only matters for HAVE_SGTTY, not termio or termios, I think). */ 358 359 /* Set tty state to our_ttystate. We don't change in our out of raw 360 mode, to avoid flushing input. We need to do the same thing 361 regardless of output_only, because we don't have separate 362 terminal_is_ours and terminal_is_ours_for_output flags. It's OK, 363 though, since readline will deal with raw mode when/if it needs to. 364 */ 365 366 serial_noflush_set_tty_state (stdin_serial, our_ttystate, 367 inferior_ttystate); 368 369 if (job_control) 370 { 371#ifdef HAVE_TERMIOS 372 result = tcsetpgrp (0, our_process_group); 373#if 0 374 /* This fails on Ultrix with EINVAL if you run the testsuite 375 in the background with nohup, and then log out. GDB never 376 used to check for an error here, so perhaps there are other 377 such situations as well. */ 378 if (result == -1) 379 fprintf_unfiltered (gdb_stderr, "[tcsetpgrp failed in terminal_ours: %s]\n", 380 safe_strerror (errno)); 381#endif 382#endif /* termios */ 383 384#ifdef HAVE_SGTTY 385 result = ioctl (0, TIOCSPGRP, &our_process_group); 386#endif 387 } 388 389#ifdef SIGTTOU 390 if (job_control) 391 signal (SIGTTOU, osigttou); 392#endif 393 394 if (!job_control) 395 { 396 signal (SIGINT, sigint_ours); 397#ifdef SIGQUIT 398 signal (SIGQUIT, sigquit_ours); 399#endif 400 } 401 402#ifdef F_GETFL 403 tflags_inferior = fcntl (0, F_GETFL, 0); 404 405 /* Is there a reason this is being done twice? It happens both 406 places we use F_SETFL, so I'm inclined to think perhaps there 407 is some reason, however perverse. Perhaps not though... */ 408 result = fcntl (0, F_SETFL, tflags_ours); 409 result = fcntl (0, F_SETFL, tflags_ours); 410#endif 411 412 result = result; /* lint */ 413 } 414} 415 416void 417term_info (char *arg, int from_tty) 418{ 419 target_terminal_info (arg, from_tty); 420} 421 422void 423child_terminal_info (char *args, int from_tty) 424{ 425 if (!gdb_has_a_terminal ()) 426 { 427 printf_filtered (_("This GDB does not control a terminal.\n")); 428 return; 429 } 430 431 printf_filtered (_("Inferior's terminal status (currently saved by GDB):\n")); 432 433 /* First the fcntl flags. */ 434 { 435 int flags; 436 437 flags = tflags_inferior; 438 439 printf_filtered ("File descriptor flags = "); 440 441#ifndef O_ACCMODE 442#define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR) 443#endif 444 /* (O_ACCMODE) parens are to avoid Ultrix header file bug */ 445 switch (flags & (O_ACCMODE)) 446 { 447 case O_RDONLY: 448 printf_filtered ("O_RDONLY"); 449 break; 450 case O_WRONLY: 451 printf_filtered ("O_WRONLY"); 452 break; 453 case O_RDWR: 454 printf_filtered ("O_RDWR"); 455 break; 456 } 457 flags &= ~(O_ACCMODE); 458 459#ifdef O_NONBLOCK 460 if (flags & O_NONBLOCK) 461 printf_filtered (" | O_NONBLOCK"); 462 flags &= ~O_NONBLOCK; 463#endif 464 465#if defined (O_NDELAY) 466 /* If O_NDELAY and O_NONBLOCK are defined to the same thing, we will 467 print it as O_NONBLOCK, which is good cause that is what POSIX 468 has, and the flag will already be cleared by the time we get here. */ 469 if (flags & O_NDELAY) 470 printf_filtered (" | O_NDELAY"); 471 flags &= ~O_NDELAY; 472#endif 473 474 if (flags & O_APPEND) 475 printf_filtered (" | O_APPEND"); 476 flags &= ~O_APPEND; 477 478#if defined (O_BINARY) 479 if (flags & O_BINARY) 480 printf_filtered (" | O_BINARY"); 481 flags &= ~O_BINARY; 482#endif 483 484 if (flags) 485 printf_filtered (" | 0x%x", flags); 486 printf_filtered ("\n"); 487 } 488 489#ifdef PROCESS_GROUP_TYPE 490 printf_filtered ("Process group = %d\n", 491 (int) inferior_process_group); 492#endif 493 494 serial_print_tty_state (stdin_serial, inferior_ttystate, gdb_stdout); 495} 496 497/* NEW_TTY_PREFORK is called before forking a new child process, 498 so we can record the state of ttys in the child to be formed. 499 TTYNAME is null if we are to share the terminal with gdb; 500 or points to a string containing the name of the desired tty. 501 502 NEW_TTY is called in new child processes under Unix, which will 503 become debugger target processes. This actually switches to 504 the terminal specified in the NEW_TTY_PREFORK call. */ 505 506void 507new_tty_prefork (const char *ttyname) 508{ 509 /* Save the name for later, for determining whether we and the child 510 are sharing a tty. */ 511 inferior_thisrun_terminal = ttyname; 512} 513 514void 515new_tty (void) 516{ 517 int tty; 518 519 if (inferior_thisrun_terminal == 0) 520 return; 521#if !defined(__GO32__) && !defined(_WIN32) 522#ifdef TIOCNOTTY 523 /* Disconnect the child process from our controlling terminal. On some 524 systems (SVR4 for example), this may cause a SIGTTOU, so temporarily 525 ignore SIGTTOU. */ 526 tty = open ("/dev/tty", O_RDWR); 527 if (tty > 0) 528 { 529 void (*osigttou) (); 530 531 osigttou = (void (*)()) signal (SIGTTOU, SIG_IGN); 532 ioctl (tty, TIOCNOTTY, 0); 533 close (tty); 534 signal (SIGTTOU, osigttou); 535 } 536#endif 537 538 /* Now open the specified new terminal. */ 539 tty = open (inferior_thisrun_terminal, O_RDWR | O_NOCTTY); 540 if (tty == -1) 541 { 542 print_sys_errmsg (inferior_thisrun_terminal, errno); 543 _exit (1); 544 } 545 546 /* Avoid use of dup2; doesn't exist on all systems. */ 547 if (tty != 0) 548 { 549 close (0); 550 dup (tty); 551 } 552 if (tty != 1) 553 { 554 close (1); 555 dup (tty); 556 } 557 if (tty != 2) 558 { 559 close (2); 560 dup (tty); 561 } 562 if (tty > 2) 563 close (tty); 564#endif /* !go32 && !win32 */ 565} 566 567/* Kill the inferior process. Make us have no inferior. */ 568 569static void 570kill_command (char *arg, int from_tty) 571{ 572 /* FIXME: This should not really be inferior_ptid (or target_has_execution). 573 It should be a distinct flag that indicates that a target is active, cuz 574 some targets don't have processes! */ 575 576 if (ptid_equal (inferior_ptid, null_ptid)) 577 error (_("The program is not being run.")); 578 if (!query ("Kill the program being debugged? ")) 579 error (_("Not confirmed.")); 580 target_kill (); 581 582 init_thread_list (); /* Destroy thread info */ 583 584 /* Killing off the inferior can leave us with a core file. If so, 585 print the state we are left in. */ 586 if (target_has_stack) 587 { 588 printf_filtered (_("In %s,\n"), target_longname); 589 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC); 590 } 591 bfd_cache_close_all (); 592} 593 594/* Call set_sigint_trap when you need to pass a signal on to an attached 595 process when handling SIGINT */ 596 597static void 598pass_signal (int signo) 599{ 600#ifndef _WIN32 601 kill (PIDGET (inferior_ptid), SIGINT); 602#endif 603} 604 605static void (*osig) (); 606 607void 608set_sigint_trap (void) 609{ 610 if (attach_flag || inferior_thisrun_terminal) 611 { 612 osig = (void (*)()) signal (SIGINT, pass_signal); 613 } 614} 615 616void 617clear_sigint_trap (void) 618{ 619 if (attach_flag || inferior_thisrun_terminal) 620 { 621 signal (SIGINT, osig); 622 } 623} 624 625#if defined (SIGIO) && defined (FASYNC) && defined (FD_SET) && defined (F_SETOWN) 626static void (*old_sigio) (); 627 628static void 629handle_sigio (int signo) 630{ 631 int numfds; 632 fd_set readfds; 633 634 signal (SIGIO, handle_sigio); 635 636 FD_ZERO (&readfds); 637 FD_SET (target_activity_fd, &readfds); 638 numfds = gdb_select (target_activity_fd + 1, &readfds, NULL, NULL, NULL); 639 if (numfds >= 0 && FD_ISSET (target_activity_fd, &readfds)) 640 { 641#ifndef _WIN32 642 if ((*target_activity_function) ()) 643 kill (PIDGET (inferior_ptid), SIGINT); 644#endif 645 } 646} 647 648static int old_fcntl_flags; 649 650void 651set_sigio_trap (void) 652{ 653 if (target_activity_function) 654 { 655 old_sigio = (void (*)()) signal (SIGIO, handle_sigio); 656 fcntl (target_activity_fd, F_SETOWN, getpid ()); 657 old_fcntl_flags = fcntl (target_activity_fd, F_GETFL, 0); 658 fcntl (target_activity_fd, F_SETFL, old_fcntl_flags | FASYNC); 659 } 660} 661 662void 663clear_sigio_trap (void) 664{ 665 if (target_activity_function) 666 { 667 signal (SIGIO, old_sigio); 668 fcntl (target_activity_fd, F_SETFL, old_fcntl_flags); 669 } 670} 671#else /* No SIGIO. */ 672void 673set_sigio_trap (void) 674{ 675 if (target_activity_function) 676 internal_error (__FILE__, __LINE__, _("failed internal consistency check")); 677} 678 679void 680clear_sigio_trap (void) 681{ 682 if (target_activity_function) 683 internal_error (__FILE__, __LINE__, _("failed internal consistency check")); 684} 685#endif /* No SIGIO. */ 686 687 688/* This is here because this is where we figure out whether we (probably) 689 have job control. Just using job_control only does part of it because 690 setpgid or setpgrp might not exist on a system without job control. 691 It might be considered misplaced (on the other hand, process groups and 692 job control are closely related to ttys). 693 694 For a more clean implementation, in libiberty, put a setpgid which merely 695 calls setpgrp and a setpgrp which does nothing (any system with job control 696 will have one or the other). */ 697int 698gdb_setpgid (void) 699{ 700 int retval = 0; 701 702 if (job_control) 703 { 704#if defined (HAVE_TERMIOS) || defined (TIOCGPGRP) 705#ifdef HAVE_SETPGID 706 /* The call setpgid (0, 0) is supposed to work and mean the same 707 thing as this, but on Ultrix 4.2A it fails with EPERM (and 708 setpgid (getpid (), getpid ()) succeeds). */ 709 retval = setpgid (getpid (), getpid ()); 710#else 711#ifdef HAVE_SETPGRP 712#ifdef SETPGRP_VOID 713 retval = setpgrp (); 714#else 715 retval = setpgrp (getpid (), getpid ()); 716#endif 717#endif /* HAVE_SETPGRP */ 718#endif /* HAVE_SETPGID */ 719#endif /* defined (HAVE_TERMIOS) || defined (TIOCGPGRP) */ 720 } 721 722 return retval; 723} 724 725/* Get all the current tty settings (including whether we have a 726 tty at all!). We can't do this in _initialize_inflow because 727 serial_fdopen() won't work until the serial_ops_list is 728 initialized, but we don't want to do it lazily either, so 729 that we can guarantee stdin_serial is opened if there is 730 a terminal. */ 731void 732initialize_stdin_serial (void) 733{ 734 stdin_serial = serial_fdopen (0); 735} 736 737void 738_initialize_inflow (void) 739{ 740 add_info ("terminal", term_info, 741 _("Print inferior's saved terminal status.")); 742 743 add_com ("kill", class_run, kill_command, 744 _("Kill execution of program being debugged.")); 745 746 inferior_ptid = null_ptid; 747 748 terminal_is_ours = 1; 749 750 /* OK, figure out whether we have job control. If neither termios nor 751 sgtty (i.e. termio or go32), leave job_control 0. */ 752 753#if defined (HAVE_TERMIOS) 754 /* Do all systems with termios have the POSIX way of identifying job 755 control? I hope so. */ 756#ifdef _POSIX_JOB_CONTROL 757 job_control = 1; 758#else 759#ifdef _SC_JOB_CONTROL 760 job_control = sysconf (_SC_JOB_CONTROL); 761#else 762 job_control = 0; /* have to assume the worst */ 763#endif /* _SC_JOB_CONTROL */ 764#endif /* _POSIX_JOB_CONTROL */ 765#endif /* HAVE_TERMIOS */ 766 767#ifdef HAVE_SGTTY 768#ifdef TIOCGPGRP 769 job_control = 1; 770#else 771 job_control = 0; 772#endif /* TIOCGPGRP */ 773#endif /* sgtty */ 774} 775