gdb/inflow.c

   1 /* Low level interface to ptrace, for GDB when running under Unix.
   2    Copyright (C) 1986-2019 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 "observable.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 "gdbsupport/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 (target_terminal_state);
  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 terminal when
  58    the inferior is resumed in the foreground.  */
  59 struct terminal_info
  60 {
  61   terminal_info () = default;
  62   ~terminal_info ();
  63
  64   terminal_info &operator= (const terminal_info &) = default;
  65
  66   /* The name of the tty (from the `tty' command) that we gave to the
  67      inferior when it was started.  */
  68   char *run_terminal = nullptr;
  69
  70   /* TTY state.  We save it whenever the inferior stops, and restore
  71      it when it resumes in the foreground.  */
  72   serial_ttystate ttystate {};
  73
  74 #ifdef HAVE_TERMIOS_H
  75   /* The terminal's foreground process group.  Saved whenever the
  76      inferior stops.  This is the pgrp displayed by "info terminal".
  77      Note that this may be not the inferior's actual process group,
  78      since each inferior that we spawn has its own process group, and
  79      only one can be in the foreground at a time.  When the inferior
  80      resumes, if we can determine the inferior's actual pgrp, then we
  81      make that the foreground pgrp instead of what was saved here.
  82      While it's a bit arbitrary which inferior's pgrp ends up in the
  83      foreground when we resume several inferiors, this at least makes
  84      'resume inf1+inf2' + 'stop all' + 'resume inf2' end up with
  85      inf2's pgrp in the foreground instead of inf1's (which would be
  86      problematic since it would be left stopped: Ctrl-C wouldn't work,
  87      for example).  */
  88   pid_t process_group = 0;
  89 #endif
  90
  91   /* fcntl flags.  Saved and restored just like ttystate.  */
  92   int tflags = 0;
  93 };
  94
  95 /* Our own tty state, which we restore every time we need to deal with
  96    the terminal.  This is set once, when GDB first starts, and then
  97    whenever we enter/leave TUI mode (gdb_save_tty_state).  The
  98    settings of flags which readline saves and restores are
  99    unimportant.  */
 100 static struct terminal_info our_terminal_info;
 101
 102 /* Snapshot of the initial tty state taken during initialization of
 103    GDB, before readline/ncurses have had a chance to change it.  This
 104    is used as the initial tty state given to each new spawned
 105    inferior.  Unlike our_terminal_info, this is only ever set
 106    once.  */
 107 static serial_ttystate initial_gdb_ttystate;
 108
 109 static struct terminal_info *get_inflow_inferior_data (struct inferior *);
 110
 111 /* While the inferior is running, we want SIGINT and SIGQUIT to go to the
 112    inferior only.  If we have job control, that takes care of it.  If not,
 113    we save our handlers in these two variables and set SIGINT and SIGQUIT
 114    to SIG_IGN.  */
 115
 116 static sighandler_t sigint_ours;
 117 #ifdef SIGQUIT
 118 static sighandler_t sigquit_ours;
 119 #endif
 120
 121 /* The name of the tty (from the `tty' command) that we're giving to
 122    the inferior when starting it up.  This is only (and should only
 123    be) used as a transient global by new_tty_prefork,
 124    create_tty_session, new_tty and new_tty_postfork, all called from
 125    fork_inferior, while forking a new child.  */
 126 static const char *inferior_thisrun_terminal;
 127
 128 /* Track who owns GDB's terminal (is it GDB or some inferior?).  While
 129    target_terminal::is_ours() etc. tracks the core's intention and is
 130    independent of the target backend, this tracks the actual state of
 131    GDB's own tty.  So for example,
 132
 133      (target_terminal::is_inferior () && gdb_tty_state == terminal_is_ours)
 134
 135    is true when the (native) inferior is not sharing a terminal with
 136    GDB (e.g., because we attached to an inferior that is running on a
 137    different terminal).  */
 138 static target_terminal_state gdb_tty_state = target_terminal_state::is_ours;
 139
 140 /* See terminal.h.  */
 141
 142 void
 143 set_initial_gdb_ttystate (void)
 144 {
 145   /* Note we can't do any of this in _initialize_inflow because at
 146      that point stdin_serial has not been created yet.  */
 147
 148   initial_gdb_ttystate = serial_get_tty_state (stdin_serial);
 149
 150   if (initial_gdb_ttystate != NULL)
 151     {
 152       our_terminal_info.ttystate
 153         = serial_copy_tty_state (stdin_serial, initial_gdb_ttystate);
 154 #ifdef F_GETFL
 155       our_terminal_info.tflags = fcntl (0, F_GETFL, 0);
 156 #endif
 157 #ifdef HAVE_TERMIOS_H
 158       our_terminal_info.process_group = tcgetpgrp (0);
 159 #endif
 160     }
 161 }
 162
 163 /* Does GDB have a terminal (on stdin)?  */
 164
 165 static int
 166 gdb_has_a_terminal (void)
 167 {
 168   return initial_gdb_ttystate != NULL;
 169 }
 170
 171 /* Macro for printing errors from ioctl operations */
 172
 173 #define OOPSY(what)     \
 174   if (result == -1)     \
 175     fprintf_unfiltered(gdb_stderr, "[%s failed in terminal_inferior: %s]\n", \
 176             what, safe_strerror (errno))
 177
 178 /* Initialize the terminal settings we record for the inferior,
 179    before we actually run the inferior.  */
 180
 181 void
 182 child_terminal_init (struct target_ops *self)
 183 {
 184   if (!gdb_has_a_terminal ())
 185     return;
 186
 187   inferior *inf = current_inferior ();
 188   terminal_info *tinfo = get_inflow_inferior_data (inf);
 189
 190 #ifdef HAVE_TERMIOS_H
 191   /* A child we spawn should be a process group leader (PGID==PID) at
 192      this point, though that may not be true if we're attaching to an
 193      existing process.  */
 194   tinfo->process_group = inf->pid;
 195 #endif
 196
 197   xfree (tinfo->ttystate);
 198   tinfo->ttystate = serial_copy_tty_state (stdin_serial, initial_gdb_ttystate);
 199 }
 200
 201 /* Save the terminal settings again.  This is necessary for the TUI
 202    when it switches to TUI or non-TUI mode;  curses changes the terminal
 203    and gdb must be able to restore it correctly.  */
 204
 205 void
 206 gdb_save_tty_state (void)
 207 {
 208   if (gdb_has_a_terminal ())
 209     {
 210       xfree (our_terminal_info.ttystate);
 211       our_terminal_info.ttystate = serial_get_tty_state (stdin_serial);
 212     }
 213 }
 214
 215 /* Try to determine whether TTY is GDB's input terminal.  Returns
 216    TRIBOOL_UNKNOWN if we can't tell.  */
 217
 218 static tribool
 219 is_gdb_terminal (const char *tty)
 220 {
 221   struct stat gdb_tty;
 222   struct stat other_tty;
 223   int res;
 224
 225   res = stat (tty, &other_tty);
 226   if (res == -1)
 227     return TRIBOOL_UNKNOWN;
 228
 229   res = fstat (STDIN_FILENO, &gdb_tty);
 230   if (res == -1)
 231     return TRIBOOL_UNKNOWN;
 232
 233   return ((gdb_tty.st_dev == other_tty.st_dev
 234            && gdb_tty.st_ino == other_tty.st_ino)
 235           ? TRIBOOL_TRUE
 236           : TRIBOOL_FALSE);
 237 }
 238
 239 /* Helper for sharing_input_terminal.  Try to determine whether
 240    inferior INF is using the same TTY for input as GDB is.  Returns
 241    TRIBOOL_UNKNOWN if we can't tell.  */
 242
 243 static tribool
 244 sharing_input_terminal_1 (inferior *inf)
 245 {
 246   /* Using host-dependent code here is fine, because the
 247      child_terminal_foo functions are meant to be used by child/native
 248      targets.  */
 249 #if defined (__linux__) || defined (__sun__)
 250   char buf[100];
 251
 252   xsnprintf (buf, sizeof (buf), "/proc/%d/fd/0", inf->pid);
 253   return is_gdb_terminal (buf);
 254 #else
 255   return TRIBOOL_UNKNOWN;
 256 #endif
 257 }
 258
 259 /* Return true if the inferior is using the same TTY for input as GDB
 260    is.  If this is true, then we save/restore terminal flags/state.
 261
 262    This is necessary because if inf->attach_flag is set, we don't
 263    offhand know whether we are sharing a terminal with the inferior or
 264    not.  Attaching a process without a terminal is one case where we
 265    do not; attaching a process which we ran from the same shell as GDB
 266    via `&' is one case where we do.
 267
 268    If we can't determine, we assume the TTY is being shared.  This
 269    works OK if you're only debugging one inferior.  However, if you're
 270    debugging more than one inferior, and e.g., one is spawned by GDB
 271    with "run" (sharing terminal with GDB), and another is attached to
 272    (and running on a different terminal, as is most common), then it
 273    matters, because we can only restore the terminal settings of one
 274    of the inferiors, and in that scenario, we want to restore the
 275    settings of the "run"'ed inferior.
 276
 277    Note, this is not the same as determining whether GDB and the
 278    inferior are in the same session / connected to the same
 279    controlling tty.  An inferior (fork child) may call setsid,
 280    disconnecting itself from the ctty, while still leaving
 281    stdin/stdout/stderr associated with the original terminal.  If
 282    we're debugging that process, we should also save/restore terminal
 283    settings.  */
 284
 285 static bool
 286 sharing_input_terminal (inferior *inf)
 287 {
 288   terminal_info *tinfo = get_inflow_inferior_data (inf);
 289
 290   tribool res = sharing_input_terminal_1 (inf);
 291
 292   if (res == TRIBOOL_UNKNOWN)
 293     {
 294       /* As fallback, if we can't determine by stat'ing the inferior's
 295          tty directly (because it's not supported on this host) and
 296          the child was spawned, check whether run_terminal is our tty.
 297          This isn't ideal, since this is checking the child's
 298          controlling terminal, not the input terminal (which may have
 299          been redirected), but is still better than nothing.  A false
 300          positive ("set inferior-tty" points to our terminal, but I/O
 301          was redirected) is much more likely than a false negative
 302          ("set inferior-tty" points to some other terminal, and then
 303          output was redirected to our terminal), and with a false
 304          positive we just end up trying to save/restore terminal
 305          settings when we didn't need to or we actually can't.  */
 306       if (tinfo->run_terminal != NULL)
 307         res = is_gdb_terminal (tinfo->run_terminal);
 308
 309       /* If we still can't determine, assume yes.  */
 310       if (res == TRIBOOL_UNKNOWN)
 311         return true;
 312     }
 313
 314   return res == TRIBOOL_TRUE;
 315 }
 316
 317 /* Put the inferior's terminal settings into effect.  This is
 318    preparation for starting or resuming the inferior.  */
 319
 320 void
 321 child_terminal_inferior (struct target_ops *self)
 322 {
 323   /* If we resume more than one inferior in the foreground on GDB's
 324      terminal, then the first inferior's terminal settings "win".
 325      Note that every child process is put in its own process group, so
 326      the first process that ends up resumed ends up determining which
 327      process group the kernel forwards Ctrl-C/Ctrl-Z (SIGINT/SIGTTOU)
 328      to.  */
 329   if (gdb_tty_state == target_terminal_state::is_inferior)
 330     return;
 331
 332   inferior *inf = current_inferior ();
 333   terminal_info *tinfo = get_inflow_inferior_data (inf);
 334
 335   if (gdb_has_a_terminal ()
 336       && tinfo->ttystate != NULL
 337       && sharing_input_terminal (inf))
 338     {
 339       int result;
 340
 341       /* Ignore SIGTTOU since it will happen when we try to set the
 342          terminal's state (if gdb_tty_state is currently
 343          ours_for_output).  */
 344       scoped_ignore_sigttou ignore_sigttou;
 345
 346 #ifdef F_GETFL
 347       result = fcntl (0, F_SETFL, tinfo->tflags);
 348       OOPSY ("fcntl F_SETFL");
 349 #endif
 350
 351       result = serial_set_tty_state (stdin_serial, tinfo->ttystate);
 352       OOPSY ("setting tty state");
 353
 354       if (!job_control)
 355         {
 356           sigint_ours = signal (SIGINT, SIG_IGN);
 357 #ifdef SIGQUIT
 358           sigquit_ours = signal (SIGQUIT, SIG_IGN);
 359 #endif
 360         }
 361
 362       if (job_control)
 363         {
 364 #ifdef HAVE_TERMIOS_H
 365           /* If we can't tell the inferior's actual process group,
 366              then restore whatever was the foreground pgrp the last
 367              time the inferior was running.  See also comments
 368              describing terminal_state::process_group.  */
 369 #ifdef HAVE_GETPGID
 370           result = tcsetpgrp (0, getpgid (inf->pid));
 371 #else
 372           result = tcsetpgrp (0, tinfo->process_group);
 373 #endif
 374           if (result == -1)
 375             {
 376 #if 0
 377               /* This fails if either GDB has no controlling terminal,
 378                  e.g., running under 'setsid(1)', or if the inferior
 379                  is not attached to GDB's controlling terminal.  E.g.,
 380                  if it called setsid to create a new session or used
 381                  the TIOCNOTTY ioctl, or simply if we've attached to a
 382                  process running on another terminal and we couldn't
 383                  tell whether it was sharing GDB's terminal (and so
 384                  assumed yes).  */
 385               fprintf_unfiltered
 386                 (gdb_stderr,
 387                  "[tcsetpgrp failed in child_terminal_inferior: %s]\n",
 388                  safe_strerror (errno));
 389 #endif
 390             }
 391 #endif
 392         }
 393
 394       gdb_tty_state = target_terminal_state::is_inferior;
 395     }
 396 }
 397
 398 /* Put some of our terminal settings into effect,
 399    enough to get proper results from our output,
 400    but do not change into or out of RAW mode
 401    so that no input is discarded.
 402
 403    After doing this, either terminal_ours or terminal_inferior
 404    should be called to get back to a normal state of affairs.
 405
 406    N.B. The implementation is (currently) no different than
 407    child_terminal_ours.  See child_terminal_ours_1.  */
 408
 409 void
 410 child_terminal_ours_for_output (struct target_ops *self)
 411 {
 412   child_terminal_ours_1 (target_terminal_state::is_ours_for_output);
 413 }
 414
 415 /* Put our terminal settings into effect.
 416    First record the inferior's terminal settings
 417    so they can be restored properly later.
 418
 419    N.B. Targets that want to use this with async support must build that
 420    support on top of this (e.g., the caller still needs to add stdin to the
 421    event loop).  E.g., see linux_nat_terminal_ours.  */
 422
 423 void
 424 child_terminal_ours (struct target_ops *self)
 425 {
 426   child_terminal_ours_1 (target_terminal_state::is_ours);
 427 }
 428
 429 /* Save the current terminal settings in the inferior's terminal_info
 430    cache.  */
 431
 432 void
 433 child_terminal_save_inferior (struct target_ops *self)
 434 {
 435   /* Avoid attempting all the ioctl's when running in batch.  */
 436   if (!gdb_has_a_terminal ())
 437     return;
 438
 439   inferior *inf = current_inferior ();
 440   terminal_info *tinfo = get_inflow_inferior_data (inf);
 441
 442   /* No need to save/restore if the inferior is not sharing GDB's
 443      tty.  */
 444   if (!sharing_input_terminal (inf))
 445     return;
 446
 447   xfree (tinfo->ttystate);
 448   tinfo->ttystate = serial_get_tty_state (stdin_serial);
 449
 450 #ifdef HAVE_TERMIOS_H
 451   tinfo->process_group = tcgetpgrp (0);
 452 #endif
 453
 454 #ifdef F_GETFL
 455   tinfo->tflags = fcntl (0, F_GETFL, 0);
 456 #endif
 457 }
 458
 459 /* Switch terminal state to DESIRED_STATE, either is_ours, or
 460    is_ours_for_output.  */
 461
 462 static void
 463 child_terminal_ours_1 (target_terminal_state desired_state)
 464 {
 465   gdb_assert (desired_state != target_terminal_state::is_inferior);
 466
 467   /* Avoid attempting all the ioctl's when running in batch.  */
 468   if (!gdb_has_a_terminal ())
 469     return;
 470
 471   if (gdb_tty_state != desired_state)
 472     {
 473       int result ATTRIBUTE_UNUSED;
 474
 475       /* Ignore SIGTTOU since it will happen when we try to set the
 476          terminal's pgrp.  */
 477       scoped_ignore_sigttou ignore_sigttou;
 478
 479       /* Set tty state to our_ttystate.  */
 480       serial_set_tty_state (stdin_serial, our_terminal_info.ttystate);
 481
 482       /* If we only want output, then leave the inferior's pgrp in the
 483          foreground, so that Ctrl-C/Ctrl-Z reach the inferior
 484          directly.  */
 485       if (job_control && desired_state == target_terminal_state::is_ours)
 486         {
 487 #ifdef HAVE_TERMIOS_H
 488           result = tcsetpgrp (0, our_terminal_info.process_group);
 489 #if 0
 490           /* This fails on Ultrix with EINVAL if you run the testsuite
 491              in the background with nohup, and then log out.  GDB never
 492              used to check for an error here, so perhaps there are other
 493              such situations as well.  */
 494           if (result == -1)
 495             fprintf_unfiltered (gdb_stderr,
 496                                 "[tcsetpgrp failed in child_terminal_ours: %s]\n",
 497                                 safe_strerror (errno));
 498 #endif
 499 #endif /* termios */
 500         }
 501
 502       if (!job_control && desired_state == target_terminal_state::is_ours)
 503         {
 504           signal (SIGINT, sigint_ours);
 505 #ifdef SIGQUIT
 506           signal (SIGQUIT, sigquit_ours);
 507 #endif
 508         }
 509
 510 #ifdef F_GETFL
 511       result = fcntl (0, F_SETFL, our_terminal_info.tflags);
 512 #endif
 513
 514       gdb_tty_state = desired_state;
 515     }
 516 }
 517
 518 /* Interrupt the inferior.  Implementation of target_interrupt for
 519    child/native targets.  */
 520
 521 void
 522 child_interrupt (struct target_ops *self)
 523 {
 524   /* Interrupt the first inferior that has a resumed thread.  */
 525   thread_info *resumed = NULL;
 526   for (thread_info *thr : all_non_exited_threads ())
 527     {
 528       if (thr->executing)
 529         {
 530           resumed = thr;
 531           break;
 532         }
 533       if (thr->suspend.waitstatus_pending_p)
 534         resumed = thr;
 535     }
 536
 537   if (resumed != NULL)
 538     {
 539       /* Note that unlike pressing Ctrl-C on the controlling terminal,
 540          here we only interrupt one process, not the whole process
 541          group.  This is because interrupting a process group (with
 542          either Ctrl-C or with kill(3) with negative PID) sends a
 543          SIGINT to each process in the process group, and we may not
 544          be debugging all processes in the process group.  */
 545 #ifndef _WIN32
 546       kill (resumed->inf->pid, SIGINT);
 547 #endif
 548     }
 549 }
 550
 551 /* Pass a Ctrl-C to the inferior as-if a Ctrl-C was pressed while the
 552    inferior was in the foreground.  Implementation of
 553    target_pass_ctrlc for child/native targets.  */
 554
 555 void
 556 child_pass_ctrlc (struct target_ops *self)
 557 {
 558   gdb_assert (!target_terminal::is_ours ());
 559
 560 #ifdef HAVE_TERMIOS_H
 561   if (job_control)
 562     {
 563       pid_t term_pgrp = tcgetpgrp (0);
 564
 565       /* If there's any inferior sharing our terminal, pass the SIGINT
 566          to the terminal's foreground process group.  This acts just
 567          like the user typed a ^C on the terminal while the inferior
 568          was in the foreground.  Note that using a negative process
 569          number in kill() is a System V-ism.  The proper BSD interface
 570          is killpg().  However, all modern BSDs support the System V
 571          interface too.  */
 572
 573       if (term_pgrp != -1 && term_pgrp != our_terminal_info.process_group)
 574         {
 575           kill (-term_pgrp, SIGINT);
 576           return;
 577         }
 578     }
 579 #endif
 580
 581   /* Otherwise, pass the Ctrl-C to the first inferior that was resumed
 582      in the foreground.  */
 583   for (inferior *inf : all_inferiors ())
 584     {
 585       if (inf->terminal_state != target_terminal_state::is_ours)
 586         {
 587           gdb_assert (inf->pid != 0);
 588
 589 #ifndef _WIN32
 590           kill (inf->pid, SIGINT);
 591 #endif
 592           return;
 593         }
 594     }
 595
 596   /* If no inferior was resumed in the foreground, then how did the
 597      !is_ours assert above pass?  */
 598   gdb_assert_not_reached ("no inferior resumed in the fg found");
 599 }
 600
 601 /* Per-inferior data key.  */
 602 static const struct inferior_key<terminal_info> inflow_inferior_data;
 603
 604 terminal_info::~terminal_info ()
 605 {
 606   xfree (run_terminal);
 607   xfree (ttystate);
 608 }
 609
 610 /* Get the current svr4 data.  If none is found yet, add it now.  This
 611    function always returns a valid object.  */
 612
 613 static struct terminal_info *
 614 get_inflow_inferior_data (struct inferior *inf)
 615 {
 616   struct terminal_info *info;
 617
 618   info = inflow_inferior_data.get (inf);
 619   if (info == NULL)
 620     info = inflow_inferior_data.emplace (inf);
 621
 622   return info;
 623 }
 624
 625 /* This is a "inferior_exit" observer.  Releases the TERMINAL_INFO member
 626    of the inferior structure.  This field is private to inflow.c, and
 627    its type is opaque to the rest of GDB.  PID is the target pid of
 628    the inferior that is about to be removed from the inferior
 629    list.  */
 630
 631 static void
 632 inflow_inferior_exit (struct inferior *inf)
 633 {
 634   inf->terminal_state = target_terminal_state::is_ours;
 635   inflow_inferior_data.clear (inf);
 636 }
 637
 638 void
 639 copy_terminal_info (struct inferior *to, struct inferior *from)
 640 {
 641   struct terminal_info *tinfo_to, *tinfo_from;
 642
 643   tinfo_to = get_inflow_inferior_data (to);
 644   tinfo_from = get_inflow_inferior_data (from);
 645
 646   xfree (tinfo_to->run_terminal);
 647   xfree (tinfo_to->ttystate);
 648
 649   *tinfo_to = *tinfo_from;
 650
 651   if (tinfo_from->run_terminal)
 652     tinfo_to->run_terminal
 653       = xstrdup (tinfo_from->run_terminal);
 654
 655   if (tinfo_from->ttystate)
 656     tinfo_to->ttystate
 657       = serial_copy_tty_state (stdin_serial, tinfo_from->ttystate);
 658
 659   to->terminal_state = from->terminal_state;
 660 }
 661
 662 /* See terminal.h.  */
 663
 664 void
 665 swap_terminal_info (inferior *a, inferior *b)
 666 {
 667   terminal_info *info_a = inflow_inferior_data.get (a);
 668   terminal_info *info_b = inflow_inferior_data.get (b);
 669
 670   inflow_inferior_data.set (a, info_b);
 671   inflow_inferior_data.set (b, info_a);
 672
 673   std::swap (a->terminal_state, b->terminal_state);
 674 }
 675
 676 static void
 677 info_terminal_command (const char *arg, int from_tty)
 678 {
 679   target_terminal::info (arg, from_tty);
 680 }
 681
 682 void
 683 child_terminal_info (struct target_ops *self, const char *args, int from_tty)
 684 {
 685   struct inferior *inf;
 686   struct terminal_info *tinfo;
 687
 688   if (!gdb_has_a_terminal ())
 689     {
 690       printf_filtered (_("This GDB does not control a terminal.\n"));
 691       return;
 692     }
 693
 694   if (inferior_ptid == null_ptid)
 695     return;
 696
 697   inf = current_inferior ();
 698   tinfo = get_inflow_inferior_data (inf);
 699
 700   printf_filtered (_("Inferior's terminal status "
 701                      "(currently saved by GDB):\n"));
 702
 703   /* First the fcntl flags.  */
 704   {
 705     int flags;
 706
 707     flags = tinfo->tflags;
 708
 709     printf_filtered ("File descriptor flags = ");
 710
 711 #ifndef O_ACCMODE
 712 #define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR)
 713 #endif
 714     /* (O_ACCMODE) parens are to avoid Ultrix header file bug.  */
 715     switch (flags & (O_ACCMODE))
 716       {
 717       case O_RDONLY:
 718         printf_filtered ("O_RDONLY");
 719         break;
 720       case O_WRONLY:
 721         printf_filtered ("O_WRONLY");
 722         break;
 723       case O_RDWR:
 724         printf_filtered ("O_RDWR");
 725         break;
 726       }
 727     flags &= ~(O_ACCMODE);
 728
 729 #ifdef O_NONBLOCK
 730     if (flags & O_NONBLOCK)
 731       printf_filtered (" | O_NONBLOCK");
 732     flags &= ~O_NONBLOCK;
 733 #endif
 734
 735 #if defined (O_NDELAY)
 736     /* If O_NDELAY and O_NONBLOCK are defined to the same thing, we will
 737        print it as O_NONBLOCK, which is good cause that is what POSIX
 738        has, and the flag will already be cleared by the time we get here.  */
 739     if (flags & O_NDELAY)
 740       printf_filtered (" | O_NDELAY");
 741     flags &= ~O_NDELAY;
 742 #endif
 743
 744     if (flags & O_APPEND)
 745       printf_filtered (" | O_APPEND");
 746     flags &= ~O_APPEND;
 747
 748 #if defined (O_BINARY)
 749     if (flags & O_BINARY)
 750       printf_filtered (" | O_BINARY");
 751     flags &= ~O_BINARY;
 752 #endif
 753
 754     if (flags)
 755       printf_filtered (" | 0x%x", flags);
 756     printf_filtered ("\n");
 757   }
 758
 759 #ifdef HAVE_TERMIOS_H
 760   printf_filtered ("Process group = %d\n", (int) tinfo->process_group);
 761 #endif
 762
 763   serial_print_tty_state (stdin_serial, tinfo->ttystate, gdb_stdout);
 764 }
 765 \f
 766 /* NEW_TTY_PREFORK is called before forking a new child process,
 767    so we can record the state of ttys in the child to be formed.
 768    TTYNAME is null if we are to share the terminal with gdb;
 769    or points to a string containing the name of the desired tty.
 770
 771    NEW_TTY is called in new child processes under Unix, which will
 772    become debugger target processes.  This actually switches to
 773    the terminal specified in the NEW_TTY_PREFORK call.  */
 774
 775 void
 776 new_tty_prefork (const char *ttyname)
 777 {
 778   /* Save the name for later, for determining whether we and the child
 779      are sharing a tty.  */
 780   inferior_thisrun_terminal = ttyname;
 781 }
 782
 783 #if !defined(__GO32__) && !defined(_WIN32)
 784 /* If RESULT, assumed to be the return value from a system call, is
 785    negative, print the error message indicated by errno and exit.
 786    MSG should identify the operation that failed.  */
 787 static void
 788 check_syscall (const char *msg, int result)
 789 {
 790   if (result < 0)
 791     {
 792       print_sys_errmsg (msg, errno);
 793       _exit (1);
 794     }
 795 }
 796 #endif
 797
 798 void
 799 new_tty (void)
 800 {
 801   if (inferior_thisrun_terminal == 0)
 802     return;
 803 #if !defined(__GO32__) && !defined(_WIN32)
 804   int tty;
 805
 806 #ifdef TIOCNOTTY
 807   /* Disconnect the child process from our controlling terminal.  On some
 808      systems (SVR4 for example), this may cause a SIGTTOU, so temporarily
 809      ignore SIGTTOU.  */
 810   tty = open ("/dev/tty", O_RDWR);
 811   if (tty > 0)
 812     {
 813       scoped_ignore_sigttou ignore_sigttou;
 814
 815       ioctl (tty, TIOCNOTTY, 0);
 816       close (tty);
 817     }
 818 #endif
 819
 820   /* Now open the specified new terminal.  */
 821   tty = open (inferior_thisrun_terminal, O_RDWR | O_NOCTTY);
 822   check_syscall (inferior_thisrun_terminal, tty);
 823
 824   /* Avoid use of dup2; doesn't exist on all systems.  */
 825   if (tty != 0)
 826     {
 827       close (0);
 828       check_syscall ("dup'ing tty into fd 0", dup (tty));
 829     }
 830   if (tty != 1)
 831     {
 832       close (1);
 833       check_syscall ("dup'ing tty into fd 1", dup (tty));
 834     }
 835   if (tty != 2)
 836     {
 837       close (2);
 838       check_syscall ("dup'ing tty into fd 2", dup (tty));
 839     }
 840
 841 #ifdef TIOCSCTTY
 842   /* Make tty our new controlling terminal.  */
 843   if (ioctl (tty, TIOCSCTTY, 0) == -1)
 844     /* Mention GDB in warning because it will appear in the inferior's
 845        terminal instead of GDB's.  */
 846     warning (_("GDB: Failed to set controlling terminal: %s"),
 847              safe_strerror (errno));
 848 #endif
 849
 850   if (tty > 2)
 851     close (tty);
 852 #endif /* !go32 && !win32 */
 853 }
 854
 855 /* NEW_TTY_POSTFORK is called after forking a new child process, and
 856    adding it to the inferior table, to store the TTYNAME being used by
 857    the child, or null if it sharing the terminal with gdb.  */
 858
 859 void
 860 new_tty_postfork (void)
 861 {
 862   /* Save the name for later, for determining whether we and the child
 863      are sharing a tty.  */
 864
 865   if (inferior_thisrun_terminal)
 866     {
 867       struct inferior *inf = current_inferior ();
 868       struct terminal_info *tinfo = get_inflow_inferior_data (inf);
 869
 870       tinfo->run_terminal = xstrdup (inferior_thisrun_terminal);
 871     }
 872
 873   inferior_thisrun_terminal = NULL;
 874 }
 875
 876 \f
 877 /* Call set_sigint_trap when you need to pass a signal on to an attached
 878    process when handling SIGINT.  */
 879
 880 static void
 881 pass_signal (int signo)
 882 {
 883 #ifndef _WIN32
 884   kill (inferior_ptid.pid (), SIGINT);
 885 #endif
 886 }
 887
 888 static sighandler_t osig;
 889 static int osig_set;
 890
 891 void
 892 set_sigint_trap (void)
 893 {
 894   struct inferior *inf = current_inferior ();
 895   struct terminal_info *tinfo = get_inflow_inferior_data (inf);
 896
 897   if (inf->attach_flag || tinfo->run_terminal)
 898     {
 899       osig = signal (SIGINT, pass_signal);
 900       osig_set = 1;
 901     }
 902   else
 903     osig_set = 0;
 904 }
 905
 906 void
 907 clear_sigint_trap (void)
 908 {
 909   if (osig_set)
 910     {
 911       signal (SIGINT, osig);
 912       osig_set = 0;
 913     }
 914 }
 915 \f
 916
 917 /* Create a new session if the inferior will run in a different tty.
 918    A session is UNIX's way of grouping processes that share a controlling
 919    terminal, so a new one is needed if the inferior terminal will be
 920    different from GDB's.
 921
 922    Returns the session id of the new session, 0 if no session was created
 923    or -1 if an error occurred.  */
 924 pid_t
 925 create_tty_session (void)
 926 {
 927 #ifdef HAVE_SETSID
 928   pid_t ret;
 929
 930   if (!job_control || inferior_thisrun_terminal == 0)
 931     return 0;
 932
 933   ret = setsid ();
 934   if (ret == -1)
 935     warning (_("Failed to create new terminal session: setsid: %s"),
 936              safe_strerror (errno));
 937
 938   return ret;
 939 #else
 940   return 0;
 941 #endif /* HAVE_SETSID */
 942 }
 943
 944 /* Get all the current tty settings (including whether we have a
 945    tty at all!).  We can't do this in _initialize_inflow because
 946    serial_fdopen() won't work until the serial_ops_list is
 947    initialized, but we don't want to do it lazily either, so
 948    that we can guarantee stdin_serial is opened if there is
 949    a terminal.  */
 950 void
 951 initialize_stdin_serial (void)
 952 {
 953   stdin_serial = serial_fdopen (0);
 954 }
 955
 956 void
 957 _initialize_inflow (void)
 958 {
 959   add_info ("terminal", info_terminal_command,
 960             _("Print inferior's saved terminal status."));
 961
 962   /* OK, figure out whether we have job control.  */
 963   have_job_control ();
 964
 965   gdb::observers::inferior_exit.attach (inflow_inferior_exit);
 966 }