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