gdb/inflow.c

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