gdb/inflow.c

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