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