gdb/inflow.c

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