gdb/inflow.c

   1 /* Low level interface to ptrace, for GDB when running under Unix.
   2    Copyright (C) 1986-2017 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 #include <signal.h>
  29 #include <fcntl.h>
  30 #include "gdb_select.h"
  31
  32 #include "inflow.h"
  33 #include "gdbcmd.h"
  34 #ifdef HAVE_TERMIOS_H
  35 #include <termios.h>
  36 #endif
  37 #include "job-control.h"
  38
  39 #ifdef HAVE_SYS_IOCTL_H
  40 #include <sys/ioctl.h>
  41 #endif
  42
  43 #ifndef O_NOCTTY
  44 #define O_NOCTTY 0
  45 #endif
  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 HAVE_TERMIOS_H
  70   /* Process group.  Saved and restored just like ttystate.  */
  71   pid_t 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 set once, when GDB first starts, and then
  80    whenever we enter/leave TUI mode (gdb_save_tty_state).  The
  81    settings of flags which readline saves and restores are
  82    unimportant.  */
  83 static struct terminal_info our_terminal_info;
  84
  85 /* Snapshot of the initial tty state taken during initialization of
  86    GDB, before readline/ncurses have had a chance to change it.  This
  87    is used as the initial tty state given to each new spawned
  88    inferior.  Unlike our_terminal_info, this is only ever set
  89    once.  */
  90 static serial_ttystate initial_gdb_ttystate;
  91
  92 static struct terminal_info *get_inflow_inferior_data (struct inferior *);
  93
  94 #ifdef HAVE_TERMIOS_H
  95
  96 /* Return the process group of the current inferior.  */
  97
  98 pid_t
  99 inferior_process_group (void)
 100 {
 101   return get_inflow_inferior_data (current_inferior ())->process_group;
 102 }
 103 #endif
 104
 105 /* While the inferior is running, we want SIGINT and SIGQUIT to go to the
 106    inferior only.  If we have job control, that takes care of it.  If not,
 107    we save our handlers in these two variables and set SIGINT and SIGQUIT
 108    to SIG_IGN.  */
 109
 110 static sighandler_t sigint_ours;
 111 static sighandler_t sigquit_ours;
 112
 113 /* The name of the tty (from the `tty' command) that we're giving to
 114    the inferior when starting it up.  This is only (and should only
 115    be) used as a transient global by new_tty_prefork,
 116    create_tty_session, new_tty and new_tty_postfork, all called from
 117    fork_inferior, while forking a new child.  */
 118 static const char *inferior_thisrun_terminal;
 119
 120 /* Nonzero if our terminal settings are in effect.  Zero if the
 121    inferior's settings are in effect.  Ignored if !gdb_has_a_terminal
 122    ().  */
 123
 124 int terminal_is_ours;
 125
 126 /* See terminal.h.  */
 127
 128 void
 129 set_initial_gdb_ttystate (void)
 130 {
 131   /* Note we can't do any of this in _initialize_inflow because at
 132      that point stdin_serial has not been created yet.  */
 133
 134   initial_gdb_ttystate = serial_get_tty_state (stdin_serial);
 135
 136   if (initial_gdb_ttystate != NULL)
 137     {
 138       our_terminal_info.ttystate
 139         = serial_copy_tty_state (stdin_serial, initial_gdb_ttystate);
 140 #ifdef F_GETFL
 141       our_terminal_info.tflags = fcntl (0, F_GETFL, 0);
 142 #endif
 143 #ifdef HAVE_TERMIOS_H
 144       our_terminal_info.process_group = tcgetpgrp (0);
 145 #endif
 146     }
 147 }
 148
 149 /* Does GDB have a terminal (on stdin)?  */
 150
 151 static int
 152 gdb_has_a_terminal (void)
 153 {
 154   return initial_gdb_ttystate != NULL;
 155 }
 156
 157 /* Macro for printing errors from ioctl operations */
 158
 159 #define OOPSY(what)     \
 160   if (result == -1)     \
 161     fprintf_unfiltered(gdb_stderr, "[%s failed in terminal_inferior: %s]\n", \
 162             what, safe_strerror (errno))
 163
 164 /* Initialize the terminal settings we record for the inferior,
 165    before we actually run the inferior.  */
 166
 167 void
 168 child_terminal_init_with_pgrp (int pgrp)
 169 {
 170   struct inferior *inf = current_inferior ();
 171   struct terminal_info *tinfo = get_inflow_inferior_data (inf);
 172
 173 #ifdef HAVE_TERMIOS_H
 174   /* Store the process group even without a terminal as it is used not
 175      only to reset the tty foreground process group, but also to
 176      interrupt the inferior.  */
 177   tinfo->process_group = pgrp;
 178 #endif
 179
 180   if (gdb_has_a_terminal ())
 181     {
 182       xfree (tinfo->ttystate);
 183       tinfo->ttystate = serial_copy_tty_state (stdin_serial,
 184                                                initial_gdb_ttystate);
 185
 186       /* Make sure that next time we call terminal_inferior (which will be
 187          before the program runs, as it needs to be), we install the new
 188          process group.  */
 189       terminal_is_ours = 1;
 190     }
 191 }
 192
 193 /* Save the terminal settings again.  This is necessary for the TUI
 194    when it switches to TUI or non-TUI mode;  curses changes the terminal
 195    and gdb must be able to restore it correctly.  */
 196
 197 void
 198 gdb_save_tty_state (void)
 199 {
 200   if (gdb_has_a_terminal ())
 201     {
 202       xfree (our_terminal_info.ttystate);
 203       our_terminal_info.ttystate = serial_get_tty_state (stdin_serial);
 204     }
 205 }
 206
 207 void
 208 child_terminal_init (struct target_ops *self)
 209 {
 210 #ifdef HAVE_TERMIOS_H
 211   /* This is for Lynx, and should be cleaned up by having Lynx be a
 212      separate debugging target with a version of target_terminal::init
 213      which passes in the process group to a generic routine which does
 214      all the work (and the non-threaded child_terminal_init can just
 215      pass in inferior_ptid to the same routine).  */
 216   /* We assume INFERIOR_PID is also the child's process group.  */
 217   child_terminal_init_with_pgrp (ptid_get_pid (inferior_ptid));
 218 #endif /* HAVE_TERMIOS_H */
 219 }
 220
 221 /* Put the inferior's terminal settings into effect.
 222    This is preparation for starting or resuming the inferior.
 223
 224    N.B. Targets that want to use this with async support must build that
 225    support on top of this (e.g., the caller still needs to remove stdin
 226    from the event loop).  E.g., see linux_nat_terminal_inferior.  */
 227
 228 void
 229 child_terminal_inferior (struct target_ops *self)
 230 {
 231   struct inferior *inf;
 232   struct terminal_info *tinfo;
 233
 234   if (!terminal_is_ours)
 235     return;
 236
 237   inf = current_inferior ();
 238   tinfo = get_inflow_inferior_data (inf);
 239
 240   if (gdb_has_a_terminal ()
 241       && tinfo->ttystate != NULL
 242       && tinfo->run_terminal == NULL)
 243     {
 244       int result;
 245
 246 #ifdef F_GETFL
 247       /* Is there a reason this is being done twice?  It happens both
 248          places we use F_SETFL, so I'm inclined to think perhaps there
 249          is some reason, however perverse.  Perhaps not though...  */
 250       result = fcntl (0, F_SETFL, tinfo->tflags);
 251       result = fcntl (0, F_SETFL, tinfo->tflags);
 252       OOPSY ("fcntl F_SETFL");
 253 #endif
 254
 255       result = serial_set_tty_state (stdin_serial, tinfo->ttystate);
 256       OOPSY ("setting tty state");
 257
 258       if (!job_control)
 259         {
 260           sigint_ours = signal (SIGINT, SIG_IGN);
 261 #ifdef SIGQUIT
 262           sigquit_ours = signal (SIGQUIT, SIG_IGN);
 263 #endif
 264         }
 265
 266       /* If attach_flag is set, we don't know whether we are sharing a
 267          terminal with the inferior or not.  (attaching a process
 268          without a terminal is one case where we do not; attaching a
 269          process which we ran from the same shell as GDB via `&' is
 270          one case where we do, I think (but perhaps this is not
 271          `sharing' in the sense that we need to save and restore tty
 272          state)).  I don't know if there is any way to tell whether we
 273          are sharing a terminal.  So what we do is to go through all
 274          the saving and restoring of the tty state, but ignore errors
 275          setting the process group, which will happen if we are not
 276          sharing a terminal).  */
 277
 278       if (job_control)
 279         {
 280 #ifdef HAVE_TERMIOS_H
 281           result = tcsetpgrp (0, tinfo->process_group);
 282           if (!inf->attach_flag)
 283             OOPSY ("tcsetpgrp");
 284 #endif
 285         }
 286     }
 287   terminal_is_ours = 0;
 288 }
 289
 290 /* Put some of our terminal settings into effect,
 291    enough to get proper results from our output,
 292    but do not change into or out of RAW mode
 293    so that no input is discarded.
 294
 295    After doing this, either terminal_ours or terminal_inferior
 296    should be called to get back to a normal state of affairs.
 297
 298    N.B. The implementation is (currently) no different than
 299    child_terminal_ours.  See child_terminal_ours_1.  */
 300
 301 void
 302 child_terminal_ours_for_output (struct target_ops *self)
 303 {
 304   child_terminal_ours_1 (1);
 305 }
 306
 307 /* Put our terminal settings into effect.
 308    First record the inferior's terminal settings
 309    so they can be restored properly later.
 310
 311    N.B. Targets that want to use this with async support must build that
 312    support on top of this (e.g., the caller still needs to add stdin to the
 313    event loop).  E.g., see linux_nat_terminal_ours.  */
 314
 315 void
 316 child_terminal_ours (struct target_ops *self)
 317 {
 318   child_terminal_ours_1 (0);
 319 }
 320
 321 /* output_only is not used, and should not be used unless we introduce
 322    separate terminal_is_ours and terminal_is_ours_for_output
 323    flags.  */
 324
 325 static void
 326 child_terminal_ours_1 (int output_only)
 327 {
 328   struct inferior *inf;
 329   struct terminal_info *tinfo;
 330
 331   if (terminal_is_ours)
 332     return;
 333
 334   terminal_is_ours = 1;
 335
 336   /* Checking inferior->run_terminal is necessary so that
 337      if GDB is running in the background, it won't block trying
 338      to do the ioctl()'s below.  Checking gdb_has_a_terminal
 339      avoids attempting all the ioctl's when running in batch.  */
 340
 341   inf = current_inferior ();
 342   tinfo = get_inflow_inferior_data (inf);
 343
 344   if (tinfo->run_terminal != NULL || gdb_has_a_terminal () == 0)
 345     return;
 346   else
 347     {
 348 #ifdef SIGTTOU
 349       /* Ignore this signal since it will happen when we try to set the
 350          pgrp.  */
 351       sighandler_t osigttou = NULL;
 352 #endif
 353       int result ATTRIBUTE_UNUSED;
 354
 355 #ifdef SIGTTOU
 356       if (job_control)
 357         osigttou = signal (SIGTTOU, SIG_IGN);
 358 #endif
 359
 360       xfree (tinfo->ttystate);
 361       tinfo->ttystate = serial_get_tty_state (stdin_serial);
 362
 363 #ifdef HAVE_TERMIOS_H
 364       if (!inf->attach_flag)
 365         /* If tcsetpgrp failed in terminal_inferior, this would give us
 366            our process group instead of the inferior's.  See
 367            terminal_inferior for details.  */
 368         tinfo->process_group = tcgetpgrp (0);
 369 #endif
 370
 371       /* Set tty state to our_ttystate.  */
 372       serial_set_tty_state (stdin_serial, our_terminal_info.ttystate);
 373
 374       if (job_control)
 375         {
 376 #ifdef HAVE_TERMIOS_H
 377           result = tcsetpgrp (0, our_terminal_info.process_group);
 378 #if 0
 379           /* This fails on Ultrix with EINVAL if you run the testsuite
 380              in the background with nohup, and then log out.  GDB never
 381              used to check for an error here, so perhaps there are other
 382              such situations as well.  */
 383           if (result == -1)
 384             fprintf_unfiltered (gdb_stderr,
 385                                 "[tcsetpgrp failed in child_terminal_ours: %s]\n",
 386                                 safe_strerror (errno));
 387 #endif
 388 #endif /* termios */
 389         }
 390
 391 #ifdef SIGTTOU
 392       if (job_control)
 393         signal (SIGTTOU, osigttou);
 394 #endif
 395
 396       if (!job_control)
 397         {
 398           signal (SIGINT, sigint_ours);
 399 #ifdef SIGQUIT
 400           signal (SIGQUIT, sigquit_ours);
 401 #endif
 402         }
 403
 404 #ifdef F_GETFL
 405       tinfo->tflags = fcntl (0, F_GETFL, 0);
 406
 407       /* Is there a reason this is being done twice?  It happens both
 408          places we use F_SETFL, so I'm inclined to think perhaps there
 409          is some reason, however perverse.  Perhaps not though...  */
 410       result = fcntl (0, F_SETFL, our_terminal_info.tflags);
 411       result = fcntl (0, F_SETFL, our_terminal_info.tflags);
 412 #endif
 413     }
 414 }
 415
 416 /* Per-inferior data key.  */
 417 static const struct inferior_data *inflow_inferior_data;
 418
 419 static void
 420 inflow_inferior_data_cleanup (struct inferior *inf, void *arg)
 421 {
 422   struct terminal_info *info = (struct terminal_info *) arg;
 423
 424   xfree (info->run_terminal);
 425   xfree (info->ttystate);
 426   xfree (info);
 427 }
 428
 429 /* Get the current svr4 data.  If none is found yet, add it now.  This
 430    function always returns a valid object.  */
 431
 432 static struct terminal_info *
 433 get_inflow_inferior_data (struct inferior *inf)
 434 {
 435   struct terminal_info *info;
 436
 437   info = (struct terminal_info *) inferior_data (inf, inflow_inferior_data);
 438   if (info == NULL)
 439     {
 440       info = XCNEW (struct terminal_info);
 441       set_inferior_data (inf, inflow_inferior_data, info);
 442     }
 443
 444   return info;
 445 }
 446
 447 /* This is a "inferior_exit" observer.  Releases the TERMINAL_INFO member
 448    of the inferior structure.  This field is private to inflow.c, and
 449    its type is opaque to the rest of GDB.  PID is the target pid of
 450    the inferior that is about to be removed from the inferior
 451    list.  */
 452
 453 static void
 454 inflow_inferior_exit (struct inferior *inf)
 455 {
 456   struct terminal_info *info;
 457
 458   info = (struct terminal_info *) inferior_data (inf, inflow_inferior_data);
 459   if (info != NULL)
 460     {
 461       xfree (info->run_terminal);
 462       xfree (info->ttystate);
 463       xfree (info);
 464       set_inferior_data (inf, inflow_inferior_data, NULL);
 465     }
 466 }
 467
 468 void
 469 copy_terminal_info (struct inferior *to, struct inferior *from)
 470 {
 471   struct terminal_info *tinfo_to, *tinfo_from;
 472
 473   tinfo_to = get_inflow_inferior_data (to);
 474   tinfo_from = get_inflow_inferior_data (from);
 475
 476   xfree (tinfo_to->run_terminal);
 477   xfree (tinfo_to->ttystate);
 478
 479   *tinfo_to = *tinfo_from;
 480
 481   if (tinfo_from->run_terminal)
 482     tinfo_to->run_terminal
 483       = xstrdup (tinfo_from->run_terminal);
 484
 485   if (tinfo_from->ttystate)
 486     tinfo_to->ttystate
 487       = serial_copy_tty_state (stdin_serial, tinfo_from->ttystate);
 488 }
 489
 490 void
 491 info_terminal_command (char *arg, int from_tty)
 492 {
 493   target_terminal::info (arg, from_tty);
 494 }
 495
 496 void
 497 child_terminal_info (struct target_ops *self, const char *args, int from_tty)
 498 {
 499   struct inferior *inf;
 500   struct terminal_info *tinfo;
 501
 502   if (!gdb_has_a_terminal ())
 503     {
 504       printf_filtered (_("This GDB does not control a terminal.\n"));
 505       return;
 506     }
 507
 508   if (ptid_equal (inferior_ptid, null_ptid))
 509     return;
 510
 511   inf = current_inferior ();
 512   tinfo = get_inflow_inferior_data (inf);
 513
 514   printf_filtered (_("Inferior's terminal status "
 515                      "(currently saved by GDB):\n"));
 516
 517   /* First the fcntl flags.  */
 518   {
 519     int flags;
 520
 521     flags = tinfo->tflags;
 522
 523     printf_filtered ("File descriptor flags = ");
 524
 525 #ifndef O_ACCMODE
 526 #define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR)
 527 #endif
 528     /* (O_ACCMODE) parens are to avoid Ultrix header file bug.  */
 529     switch (flags & (O_ACCMODE))
 530       {
 531       case O_RDONLY:
 532         printf_filtered ("O_RDONLY");
 533         break;
 534       case O_WRONLY:
 535         printf_filtered ("O_WRONLY");
 536         break;
 537       case O_RDWR:
 538         printf_filtered ("O_RDWR");
 539         break;
 540       }
 541     flags &= ~(O_ACCMODE);
 542
 543 #ifdef O_NONBLOCK
 544     if (flags & O_NONBLOCK)
 545       printf_filtered (" | O_NONBLOCK");
 546     flags &= ~O_NONBLOCK;
 547 #endif
 548
 549 #if defined (O_NDELAY)
 550     /* If O_NDELAY and O_NONBLOCK are defined to the same thing, we will
 551        print it as O_NONBLOCK, which is good cause that is what POSIX
 552        has, and the flag will already be cleared by the time we get here.  */
 553     if (flags & O_NDELAY)
 554       printf_filtered (" | O_NDELAY");
 555     flags &= ~O_NDELAY;
 556 #endif
 557
 558     if (flags & O_APPEND)
 559       printf_filtered (" | O_APPEND");
 560     flags &= ~O_APPEND;
 561
 562 #if defined (O_BINARY)
 563     if (flags & O_BINARY)
 564       printf_filtered (" | O_BINARY");
 565     flags &= ~O_BINARY;
 566 #endif
 567
 568     if (flags)
 569       printf_filtered (" | 0x%x", flags);
 570     printf_filtered ("\n");
 571   }
 572
 573 #ifdef HAVE_TERMIOS_H
 574   printf_filtered ("Process group = %d\n", (int) tinfo->process_group);
 575 #endif
 576
 577   serial_print_tty_state (stdin_serial, tinfo->ttystate, gdb_stdout);
 578 }
 579 \f
 580 /* NEW_TTY_PREFORK is called before forking a new child process,
 581    so we can record the state of ttys in the child to be formed.
 582    TTYNAME is null if we are to share the terminal with gdb;
 583    or points to a string containing the name of the desired tty.
 584
 585    NEW_TTY is called in new child processes under Unix, which will
 586    become debugger target processes.  This actually switches to
 587    the terminal specified in the NEW_TTY_PREFORK call.  */
 588
 589 void
 590 new_tty_prefork (const char *ttyname)
 591 {
 592   /* Save the name for later, for determining whether we and the child
 593      are sharing a tty.  */
 594   inferior_thisrun_terminal = ttyname;
 595 }
 596
 597 #if !defined(__GO32__) && !defined(_WIN32)
 598 /* If RESULT, assumed to be the return value from a system call, is
 599    negative, print the error message indicated by errno and exit.
 600    MSG should identify the operation that failed.  */
 601 static void
 602 check_syscall (const char *msg, int result)
 603 {
 604   if (result < 0)
 605     {
 606       print_sys_errmsg (msg, errno);
 607       _exit (1);
 608     }
 609 }
 610 #endif
 611
 612 void
 613 new_tty (void)
 614 {
 615   int tty;
 616
 617   if (inferior_thisrun_terminal == 0)
 618     return;
 619 #if !defined(__GO32__) && !defined(_WIN32)
 620 #ifdef TIOCNOTTY
 621   /* Disconnect the child process from our controlling terminal.  On some
 622      systems (SVR4 for example), this may cause a SIGTTOU, so temporarily
 623      ignore SIGTTOU.  */
 624   tty = open ("/dev/tty", O_RDWR);
 625   if (tty > 0)
 626     {
 627       sighandler_t osigttou;
 628
 629       osigttou = signal (SIGTTOU, SIG_IGN);
 630       ioctl (tty, TIOCNOTTY, 0);
 631       close (tty);
 632       signal (SIGTTOU, osigttou);
 633     }
 634 #endif
 635
 636   /* Now open the specified new terminal.  */
 637   tty = open (inferior_thisrun_terminal, O_RDWR | O_NOCTTY);
 638   check_syscall (inferior_thisrun_terminal, tty);
 639
 640   /* Avoid use of dup2; doesn't exist on all systems.  */
 641   if (tty != 0)
 642     {
 643       close (0);
 644       check_syscall ("dup'ing tty into fd 0", dup (tty));
 645     }
 646   if (tty != 1)
 647     {
 648       close (1);
 649       check_syscall ("dup'ing tty into fd 1", dup (tty));
 650     }
 651   if (tty != 2)
 652     {
 653       close (2);
 654       check_syscall ("dup'ing tty into fd 2", dup (tty));
 655     }
 656
 657 #ifdef TIOCSCTTY
 658   /* Make tty our new controlling terminal.  */
 659   if (ioctl (tty, TIOCSCTTY, 0) == -1)
 660     /* Mention GDB in warning because it will appear in the inferior's
 661        terminal instead of GDB's.  */
 662     warning (_("GDB: Failed to set controlling terminal: %s"),
 663              safe_strerror (errno));
 664 #endif
 665
 666   if (tty > 2)
 667     close (tty);
 668 #endif /* !go32 && !win32 */
 669 }
 670
 671 /* NEW_TTY_POSTFORK is called after forking a new child process, and
 672    adding it to the inferior table, to store the TTYNAME being used by
 673    the child, or null if it sharing the terminal with gdb.  */
 674
 675 void
 676 new_tty_postfork (void)
 677 {
 678   /* Save the name for later, for determining whether we and the child
 679      are sharing a tty.  */
 680
 681   if (inferior_thisrun_terminal)
 682     {
 683       struct inferior *inf = current_inferior ();
 684       struct terminal_info *tinfo = get_inflow_inferior_data (inf);
 685
 686       tinfo->run_terminal = xstrdup (inferior_thisrun_terminal);
 687     }
 688
 689   inferior_thisrun_terminal = NULL;
 690 }
 691
 692 \f
 693 /* Call set_sigint_trap when you need to pass a signal on to an attached
 694    process when handling SIGINT.  */
 695
 696 static void
 697 pass_signal (int signo)
 698 {
 699 #ifndef _WIN32
 700   kill (ptid_get_pid (inferior_ptid), SIGINT);
 701 #endif
 702 }
 703
 704 static sighandler_t osig;
 705 static int osig_set;
 706
 707 void
 708 set_sigint_trap (void)
 709 {
 710   struct inferior *inf = current_inferior ();
 711   struct terminal_info *tinfo = get_inflow_inferior_data (inf);
 712
 713   if (inf->attach_flag || tinfo->run_terminal)
 714     {
 715       osig = signal (SIGINT, pass_signal);
 716       osig_set = 1;
 717     }
 718   else
 719     osig_set = 0;
 720 }
 721
 722 void
 723 clear_sigint_trap (void)
 724 {
 725   if (osig_set)
 726     {
 727       signal (SIGINT, osig);
 728       osig_set = 0;
 729     }
 730 }
 731 \f
 732
 733 /* Create a new session if the inferior will run in a different tty.
 734    A session is UNIX's way of grouping processes that share a controlling
 735    terminal, so a new one is needed if the inferior terminal will be
 736    different from GDB's.
 737
 738    Returns the session id of the new session, 0 if no session was created
 739    or -1 if an error occurred.  */
 740 pid_t
 741 create_tty_session (void)
 742 {
 743 #ifdef HAVE_SETSID
 744   pid_t ret;
 745
 746   if (!job_control || inferior_thisrun_terminal == 0)
 747     return 0;
 748
 749   ret = setsid ();
 750   if (ret == -1)
 751     warning (_("Failed to create new terminal session: setsid: %s"),
 752              safe_strerror (errno));
 753
 754   return ret;
 755 #else
 756   return 0;
 757 #endif /* HAVE_SETSID */
 758 }
 759
 760 /* Get all the current tty settings (including whether we have a
 761    tty at all!).  We can't do this in _initialize_inflow because
 762    serial_fdopen() won't work until the serial_ops_list is
 763    initialized, but we don't want to do it lazily either, so
 764    that we can guarantee stdin_serial is opened if there is
 765    a terminal.  */
 766 void
 767 initialize_stdin_serial (void)
 768 {
 769   stdin_serial = serial_fdopen (0);
 770 }
 771
 772 void
 773 _initialize_inflow (void)
 774 {
 775   add_info ("terminal", info_terminal_command,
 776             _("Print inferior's saved terminal status."));
 777
 778   terminal_is_ours = 1;
 779
 780   /* OK, figure out whether we have job control.  */
 781   have_job_control ();
 782
 783   observer_attach_inferior_exit (inflow_inferior_exit);
 784
 785   inflow_inferior_data
 786     = register_inferior_data_with_cleanup (NULL, inflow_inferior_data_cleanup);
 787 }