gdb/inflow.c

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