1 /* Low level interface to ptrace, for GDB when running under Unix.
2 Copyright (C) 1986-2018 Free Software Foundation, Inc.
4 This file is part of GDB.
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.
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.
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/>. */
26 #include "gdbthread.h"
30 #include "gdb_select.h"
37 #include "job-control.h"
39 #ifdef HAVE_SYS_IOCTL_H
40 #include <sys/ioctl.h>
47 static void pass_signal (int);
49 static void child_terminal_ours_1 (target_terminal_state
);
51 /* Record terminal status separately for debugger and inferior. */
53 static struct serial
*stdin_serial
;
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. */
61 /* The name of the tty (from the `tty' command) that we gave to the
62 inferior when it was started. */
65 /* TTY state. We save it whenever the inferior stops, and restore
66 it when it resumes in the foreground. */
67 serial_ttystate ttystate
;
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,
86 /* fcntl flags. Saved and restored just like ttystate. */
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
95 static struct terminal_info our_terminal_info
;
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
102 static serial_ttystate initial_gdb_ttystate
;
104 static struct terminal_info
*get_inflow_inferior_data (struct inferior
*);
106 /* RAII class used to ignore SIGTTOU in a scope. */
108 class scoped_ignore_sigttou
111 scoped_ignore_sigttou ()
115 m_osigttou
= signal (SIGTTOU
, SIG_IGN
);
119 ~scoped_ignore_sigttou ()
123 signal (SIGTTOU
, m_osigttou
);
127 DISABLE_COPY_AND_ASSIGN (scoped_ignore_sigttou
);
131 sighandler_t m_osigttou
= NULL
;
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
140 static sighandler_t sigint_ours
;
141 static sighandler_t sigquit_ours
;
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
;
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,
155 (target_terminal::is_inferior () && gdb_tty_state == terminal_is_ours)
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
;
162 /* See terminal.h. */
165 set_initial_gdb_ttystate (void)
167 /* Note we can't do any of this in _initialize_inflow because at
168 that point stdin_serial has not been created yet. */
170 initial_gdb_ttystate
= serial_get_tty_state (stdin_serial
);
172 if (initial_gdb_ttystate
!= NULL
)
174 our_terminal_info
.ttystate
175 = serial_copy_tty_state (stdin_serial
, initial_gdb_ttystate
);
177 our_terminal_info
.tflags
= fcntl (0, F_GETFL
, 0);
179 #ifdef HAVE_TERMIOS_H
180 our_terminal_info
.process_group
= tcgetpgrp (0);
185 /* Does GDB have a terminal (on stdin)? */
188 gdb_has_a_terminal (void)
190 return initial_gdb_ttystate
!= NULL
;
193 /* Macro for printing errors from ioctl operations */
195 #define OOPSY(what) \
197 fprintf_unfiltered(gdb_stderr, "[%s failed in terminal_inferior: %s]\n", \
198 what, safe_strerror (errno))
200 /* Initialize the terminal settings we record for the inferior,
201 before we actually run the inferior. */
204 child_terminal_init (struct target_ops
*self
)
206 if (!gdb_has_a_terminal ())
209 inferior
*inf
= current_inferior ();
210 terminal_info
*tinfo
= get_inflow_inferior_data (inf
);
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
216 tinfo
->process_group
= inf
->pid
;
219 xfree (tinfo
->ttystate
);
220 tinfo
->ttystate
= serial_copy_tty_state (stdin_serial
, initial_gdb_ttystate
);
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. */
228 gdb_save_tty_state (void)
230 if (gdb_has_a_terminal ())
232 xfree (our_terminal_info
.ttystate
);
233 our_terminal_info
.ttystate
= serial_get_tty_state (stdin_serial
);
237 /* Try to determine whether TTY is GDB's input terminal. Returns
238 TRIBOOL_UNKNOWN if we can't tell. */
241 is_gdb_terminal (const char *tty
)
244 struct stat other_tty
;
247 res
= stat (tty
, &other_tty
);
249 return TRIBOOL_UNKNOWN
;
251 res
= fstat (STDIN_FILENO
, &gdb_tty
);
253 return TRIBOOL_UNKNOWN
;
255 return ((gdb_tty
.st_dev
== other_tty
.st_dev
256 && gdb_tty
.st_ino
== other_tty
.st_ino
)
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. */
266 sharing_input_terminal_1 (inferior
*inf
)
268 /* Using host-dependent code here is fine, because the
269 child_terminal_foo functions are meant to be used by child/native
271 #if defined (__linux__) || defined (__sun__)
274 xsnprintf (buf
, sizeof (buf
), "/proc/%d/fd/0", inf
->pid
);
275 return is_gdb_terminal (buf
);
277 return TRIBOOL_UNKNOWN
;
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.
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.
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.
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
308 sharing_input_terminal (inferior
*inf
)
310 terminal_info
*tinfo
= get_inflow_inferior_data (inf
);
312 tribool res
= sharing_input_terminal_1 (inf
);
314 if (res
== TRIBOOL_UNKNOWN
)
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
);
331 /* If we still can't determine, assume yes. */
332 if (res
== TRIBOOL_UNKNOWN
)
336 return res
== TRIBOOL_TRUE
;
339 /* Put the inferior's terminal settings into effect. This is
340 preparation for starting or resuming the inferior. */
343 child_terminal_inferior (struct target_ops
*self
)
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)
351 if (gdb_tty_state
== target_terminal_state::is_inferior
)
354 inferior
*inf
= current_inferior ();
355 terminal_info
*tinfo
= get_inflow_inferior_data (inf
);
357 if (gdb_has_a_terminal ()
358 && tinfo
->ttystate
!= NULL
359 && sharing_input_terminal (inf
))
363 /* Ignore SIGTTOU since it will happen when we try to set the
364 terminal's state (if gdb_tty_state is currently
366 scoped_ignore_sigttou ignore_sigttou
;
369 result
= fcntl (0, F_SETFL
, tinfo
->tflags
);
370 OOPSY ("fcntl F_SETFL");
373 result
= serial_set_tty_state (stdin_serial
, tinfo
->ttystate
);
374 OOPSY ("setting tty state");
378 sigint_ours
= signal (SIGINT
, SIG_IGN
);
380 sigquit_ours
= signal (SIGQUIT
, SIG_IGN
);
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. */
392 result
= tcsetpgrp (0, getpgid (inf
->pid
));
394 result
= tcsetpgrp (0, tinfo
->process_group
);
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
409 "[tcsetpgrp failed in child_terminal_inferior: %s]\n",
410 safe_strerror (errno
));
416 gdb_tty_state
= target_terminal_state::is_inferior
;
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.
425 After doing this, either terminal_ours or terminal_inferior
426 should be called to get back to a normal state of affairs.
428 N.B. The implementation is (currently) no different than
429 child_terminal_ours. See child_terminal_ours_1. */
432 child_terminal_ours_for_output (struct target_ops
*self
)
434 child_terminal_ours_1 (target_terminal_state::is_ours_for_output
);
437 /* Put our terminal settings into effect.
438 First record the inferior's terminal settings
439 so they can be restored properly later.
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. */
446 child_terminal_ours (struct target_ops
*self
)
448 child_terminal_ours_1 (target_terminal_state::is_ours
);
451 /* Save the current terminal settings in the inferior's terminal_info
455 child_terminal_save_inferior (struct target_ops
*self
)
457 /* Avoid attempting all the ioctl's when running in batch. */
458 if (!gdb_has_a_terminal ())
461 inferior
*inf
= current_inferior ();
462 terminal_info
*tinfo
= get_inflow_inferior_data (inf
);
464 /* No need to save/restore if the inferior is not sharing GDB's
466 if (!sharing_input_terminal (inf
))
469 xfree (tinfo
->ttystate
);
470 tinfo
->ttystate
= serial_get_tty_state (stdin_serial
);
472 tinfo
->process_group
= tcgetpgrp (0);
475 tinfo
->tflags
= fcntl (0, F_GETFL
, 0);
479 /* Switch terminal state to DESIRED_STATE, either is_ours, or
480 is_ours_for_output. */
483 child_terminal_ours_1 (target_terminal_state desired_state
)
485 gdb_assert (desired_state
!= target_terminal_state::is_inferior
);
487 /* Avoid attempting all the ioctl's when running in batch. */
488 if (!gdb_has_a_terminal ())
491 if (gdb_tty_state
!= desired_state
)
493 int result ATTRIBUTE_UNUSED
;
495 /* Ignore SIGTTOU since it will happen when we try to set the
497 scoped_ignore_sigttou ignore_sigttou
;
499 /* Set tty state to our_ttystate. */
500 serial_set_tty_state (stdin_serial
, our_terminal_info
.ttystate
);
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
505 if (job_control
&& desired_state
== target_terminal_state::is_ours
)
507 #ifdef HAVE_TERMIOS_H
508 result
= tcsetpgrp (0, our_terminal_info
.process_group
);
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. */
515 fprintf_unfiltered (gdb_stderr
,
516 "[tcsetpgrp failed in child_terminal_ours: %s]\n",
517 safe_strerror (errno
));
522 if (!job_control
&& desired_state
== target_terminal_state::is_ours
)
524 signal (SIGINT
, sigint_ours
);
526 signal (SIGQUIT
, sigquit_ours
);
531 result
= fcntl (0, F_SETFL
, our_terminal_info
.tflags
);
534 gdb_tty_state
= desired_state
;
538 /* Interrupt the inferior. Implementation of target_interrupt for
539 child/native targets. */
542 child_interrupt (struct target_ops
*self
)
544 /* Interrupt the first inferior that has a resumed thread. */
546 thread_info
*resumed
= NULL
;
547 ALL_NON_EXITED_THREADS (thr
)
554 if (thr
->suspend
.waitstatus_pending_p
)
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
);
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. */
575 child_pass_ctrlc (struct target_ops
*self
)
577 gdb_assert (!target_terminal::is_ours ());
579 #ifdef HAVE_TERMIOS_H
582 pid_t term_pgrp
= tcgetpgrp (0);
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
592 if (term_pgrp
!= -1 && term_pgrp
!= our_terminal_info
.process_group
)
594 kill (-term_pgrp
, SIGINT
);
600 /* Otherwise, pass the Ctrl-C to the first inferior that was resumed
601 in the foreground. */
605 if (inf
->terminal_state
!= target_terminal_state::is_ours
)
607 gdb_assert (inf
->pid
!= 0);
609 kill (inf
->pid
, SIGINT
);
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");
619 /* Per-inferior data key. */
620 static const struct inferior_data
*inflow_inferior_data
;
623 inflow_inferior_data_cleanup (struct inferior
*inf
, void *arg
)
625 struct terminal_info
*info
= (struct terminal_info
*) arg
;
627 xfree (info
->run_terminal
);
628 xfree (info
->ttystate
);
632 /* Get the current svr4 data. If none is found yet, add it now. This
633 function always returns a valid object. */
635 static struct terminal_info
*
636 get_inflow_inferior_data (struct inferior
*inf
)
638 struct terminal_info
*info
;
640 info
= (struct terminal_info
*) inferior_data (inf
, inflow_inferior_data
);
643 info
= XCNEW (struct terminal_info
);
644 set_inferior_data (inf
, inflow_inferior_data
, info
);
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
657 inflow_inferior_exit (struct inferior
*inf
)
659 struct terminal_info
*info
;
661 inf
->terminal_state
= target_terminal_state::is_ours
;
663 info
= (struct terminal_info
*) inferior_data (inf
, inflow_inferior_data
);
666 xfree (info
->run_terminal
);
667 xfree (info
->ttystate
);
669 set_inferior_data (inf
, inflow_inferior_data
, NULL
);
674 copy_terminal_info (struct inferior
*to
, struct inferior
*from
)
676 struct terminal_info
*tinfo_to
, *tinfo_from
;
678 tinfo_to
= get_inflow_inferior_data (to
);
679 tinfo_from
= get_inflow_inferior_data (from
);
681 xfree (tinfo_to
->run_terminal
);
682 xfree (tinfo_to
->ttystate
);
684 *tinfo_to
= *tinfo_from
;
686 if (tinfo_from
->run_terminal
)
687 tinfo_to
->run_terminal
688 = xstrdup (tinfo_from
->run_terminal
);
690 if (tinfo_from
->ttystate
)
692 = serial_copy_tty_state (stdin_serial
, tinfo_from
->ttystate
);
694 to
->terminal_state
= from
->terminal_state
;
698 info_terminal_command (const char *arg
, int from_tty
)
700 target_terminal::info (arg
, from_tty
);
704 child_terminal_info (struct target_ops
*self
, const char *args
, int from_tty
)
706 struct inferior
*inf
;
707 struct terminal_info
*tinfo
;
709 if (!gdb_has_a_terminal ())
711 printf_filtered (_("This GDB does not control a terminal.\n"));
715 if (ptid_equal (inferior_ptid
, null_ptid
))
718 inf
= current_inferior ();
719 tinfo
= get_inflow_inferior_data (inf
);
721 printf_filtered (_("Inferior's terminal status "
722 "(currently saved by GDB):\n"));
724 /* First the fcntl flags. */
728 flags
= tinfo
->tflags
;
730 printf_filtered ("File descriptor flags = ");
733 #define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR)
735 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */
736 switch (flags
& (O_ACCMODE
))
739 printf_filtered ("O_RDONLY");
742 printf_filtered ("O_WRONLY");
745 printf_filtered ("O_RDWR");
748 flags
&= ~(O_ACCMODE
);
751 if (flags
& O_NONBLOCK
)
752 printf_filtered (" | O_NONBLOCK");
753 flags
&= ~O_NONBLOCK
;
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");
765 if (flags
& O_APPEND
)
766 printf_filtered (" | O_APPEND");
769 #if defined (O_BINARY)
770 if (flags
& O_BINARY
)
771 printf_filtered (" | O_BINARY");
776 printf_filtered (" | 0x%x", flags
);
777 printf_filtered ("\n");
780 #ifdef HAVE_TERMIOS_H
781 printf_filtered ("Process group = %d\n", (int) tinfo
->process_group
);
784 serial_print_tty_state (stdin_serial
, tinfo
->ttystate
, gdb_stdout
);
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.
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. */
797 new_tty_prefork (const char *ttyname
)
799 /* Save the name for later, for determining whether we and the child
800 are sharing a tty. */
801 inferior_thisrun_terminal
= ttyname
;
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. */
809 check_syscall (const char *msg
, int result
)
813 print_sys_errmsg (msg
, errno
);
824 if (inferior_thisrun_terminal
== 0)
826 #if !defined(__GO32__) && !defined(_WIN32)
828 /* Disconnect the child process from our controlling terminal. On some
829 systems (SVR4 for example), this may cause a SIGTTOU, so temporarily
831 tty
= open ("/dev/tty", O_RDWR
);
834 scoped_ignore_sigttou ignore_sigttou
;
836 ioctl (tty
, TIOCNOTTY
, 0);
841 /* Now open the specified new terminal. */
842 tty
= open (inferior_thisrun_terminal
, O_RDWR
| O_NOCTTY
);
843 check_syscall (inferior_thisrun_terminal
, tty
);
845 /* Avoid use of dup2; doesn't exist on all systems. */
849 check_syscall ("dup'ing tty into fd 0", dup (tty
));
854 check_syscall ("dup'ing tty into fd 1", dup (tty
));
859 check_syscall ("dup'ing tty into fd 2", dup (tty
));
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
));
873 #endif /* !go32 && !win32 */
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. */
881 new_tty_postfork (void)
883 /* Save the name for later, for determining whether we and the child
884 are sharing a tty. */
886 if (inferior_thisrun_terminal
)
888 struct inferior
*inf
= current_inferior ();
889 struct terminal_info
*tinfo
= get_inflow_inferior_data (inf
);
891 tinfo
->run_terminal
= xstrdup (inferior_thisrun_terminal
);
894 inferior_thisrun_terminal
= NULL
;
898 /* Call set_sigint_trap when you need to pass a signal on to an attached
899 process when handling SIGINT. */
902 pass_signal (int signo
)
905 kill (ptid_get_pid (inferior_ptid
), SIGINT
);
909 static sighandler_t osig
;
913 set_sigint_trap (void)
915 struct inferior
*inf
= current_inferior ();
916 struct terminal_info
*tinfo
= get_inflow_inferior_data (inf
);
918 if (inf
->attach_flag
|| tinfo
->run_terminal
)
920 osig
= signal (SIGINT
, pass_signal
);
928 clear_sigint_trap (void)
932 signal (SIGINT
, osig
);
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.
943 Returns the session id of the new session, 0 if no session was created
944 or -1 if an error occurred. */
946 create_tty_session (void)
951 if (!job_control
|| inferior_thisrun_terminal
== 0)
956 warning (_("Failed to create new terminal session: setsid: %s"),
957 safe_strerror (errno
));
962 #endif /* HAVE_SETSID */
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
972 initialize_stdin_serial (void)
974 stdin_serial
= serial_fdopen (0);
978 _initialize_inflow (void)
980 add_info ("terminal", info_terminal_command
,
981 _("Print inferior's saved terminal status."));
983 /* OK, figure out whether we have job control. */
986 observer_attach_inferior_exit (inflow_inferior_exit
);
989 = register_inferior_data_with_cleanup (NULL
, inflow_inferior_data_cleanup
);