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