1 /* Low level interface to ptrace, for GDB when running under Unix.
2 Copyright (C) 1986-2016 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"
35 #ifdef HAVE_SYS_IOCTL_H
36 #include <sys/ioctl.h>
43 extern void _initialize_inflow (void);
45 static void pass_signal (int);
47 static void child_terminal_ours_1 (int);
49 /* Record terminal status separately for debugger and inferior. */
51 static struct serial *stdin_serial;
53 /* Terminal related info we need to keep track of. Each inferior
54 holds an instance of this structure --- we save it whenever the
55 corresponding inferior stops, and restore it to the foreground
56 inferior when it resumes. */
59 /* The name of the tty (from the `tty' command) that we gave to the
60 inferior when it was started. */
63 /* TTY state. We save it whenever the inferior stops, and restore
64 it when it resumes. */
65 serial_ttystate ttystate;
67 #ifdef PROCESS_GROUP_TYPE
68 /* Process group. Saved and restored just like ttystate. */
69 PROCESS_GROUP_TYPE process_group;
72 /* fcntl flags. Saved and restored just like ttystate. */
76 /* Our own tty state, which we restore every time we need to deal with
77 the terminal. This is only set once, when GDB first starts. The
78 settings of flags which readline saves and restores and
80 static struct terminal_info our_terminal_info;
82 /* Snapshot of our own tty state taken during initialization of GDB.
83 This is used as the initial tty state given to each new inferior. */
84 static serial_ttystate initial_gdb_ttystate;
86 static struct terminal_info *get_inflow_inferior_data (struct inferior *);
88 #ifdef PROCESS_GROUP_TYPE
90 /* Return the process group of the current inferior. */
93 inferior_process_group (void)
95 return get_inflow_inferior_data (current_inferior ())->process_group;
99 /* While the inferior is running, we want SIGINT and SIGQUIT to go to the
100 inferior only. If we have job control, that takes care of it. If not,
101 we save our handlers in these two variables and set SIGINT and SIGQUIT
104 static sighandler_t sigint_ours;
105 static sighandler_t sigquit_ours;
107 /* The name of the tty (from the `tty' command) that we're giving to
108 the inferior when starting it up. This is only (and should only
109 be) used as a transient global by new_tty_prefork,
110 create_tty_session, new_tty and new_tty_postfork, all called from
111 fork_inferior, while forking a new child. */
112 static const char *inferior_thisrun_terminal;
114 /* Nonzero if our terminal settings are in effect. Zero if the
115 inferior's settings are in effect. Ignored if !gdb_has_a_terminal
118 int terminal_is_ours;
120 #ifdef PROCESS_GROUP_TYPE
121 static PROCESS_GROUP_TYPE
124 int process_group = -1;
127 process_group = tcgetpgrp (0);
130 process_group = getpgrp ();
133 ioctl (0, TIOCGPGRP, &process_group);
135 return process_group;
139 enum gdb_has_a_terminal_flag_enum
141 yes, no, have_not_checked
143 gdb_has_a_terminal_flag = have_not_checked;
145 /* Set the initial tty state that is to be inherited by new inferiors. */
148 set_initial_gdb_ttystate (void)
150 initial_gdb_ttystate = serial_get_tty_state (stdin_serial);
153 /* Does GDB have a terminal (on stdin)? */
155 gdb_has_a_terminal (void)
157 switch (gdb_has_a_terminal_flag)
163 case have_not_checked:
164 /* Get all the current tty settings (including whether we have a
165 tty at all!). Can't do this in _initialize_inflow because
166 serial_fdopen() won't work until the serial_ops_list is
170 our_terminal_info.tflags = fcntl (0, F_GETFL, 0);
173 gdb_has_a_terminal_flag = no;
174 if (stdin_serial != NULL)
176 our_terminal_info.ttystate = serial_get_tty_state (stdin_serial);
178 if (our_terminal_info.ttystate != NULL)
180 gdb_has_a_terminal_flag = yes;
181 #ifdef PROCESS_GROUP_TYPE
182 our_terminal_info.process_group = gdb_getpgrp ();
187 return gdb_has_a_terminal_flag == yes;
189 /* "Can't happen". */
194 /* Macro for printing errors from ioctl operations */
196 #define OOPSY(what) \
198 fprintf_unfiltered(gdb_stderr, "[%s failed in terminal_inferior: %s]\n", \
199 what, safe_strerror (errno))
201 /* Initialize the terminal settings we record for the inferior,
202 before we actually run the inferior. */
205 child_terminal_init_with_pgrp (int pgrp)
207 struct inferior *inf = current_inferior ();
208 struct terminal_info *tinfo = get_inflow_inferior_data (inf);
210 #ifdef PROCESS_GROUP_TYPE
211 /* Store the process group even without a terminal as it is used not
212 only to reset the tty foreground process group, but also to
213 interrupt the inferior. */
214 tinfo->process_group = pgrp;
217 if (gdb_has_a_terminal ())
219 xfree (tinfo->ttystate);
220 tinfo->ttystate = serial_copy_tty_state (stdin_serial,
221 initial_gdb_ttystate);
223 /* Make sure that next time we call terminal_inferior (which will be
224 before the program runs, as it needs to be), we install the new
226 terminal_is_ours = 1;
230 /* Save the terminal settings again. This is necessary for the TUI
231 when it switches to TUI or non-TUI mode; curses changes the terminal
232 and gdb must be able to restore it correctly. */
235 gdb_save_tty_state (void)
237 if (gdb_has_a_terminal ())
239 xfree (our_terminal_info.ttystate);
240 our_terminal_info.ttystate = serial_get_tty_state (stdin_serial);
245 child_terminal_init (struct target_ops *self)
247 #ifdef PROCESS_GROUP_TYPE
248 /* This is for Lynx, and should be cleaned up by having Lynx be a
249 separate debugging target with a version of target_terminal_init
250 which passes in the process group to a generic routine which does
251 all the work (and the non-threaded child_terminal_init can just
252 pass in inferior_ptid to the same routine). */
253 /* We assume INFERIOR_PID is also the child's process group. */
254 child_terminal_init_with_pgrp (ptid_get_pid (inferior_ptid));
255 #endif /* PROCESS_GROUP_TYPE */
258 /* Put the inferior's terminal settings into effect.
259 This is preparation for starting or resuming the inferior.
261 N.B. Targets that want to use this with async support must build that
262 support on top of this (e.g., the caller still needs to remove stdin
263 from the event loop). E.g., see linux_nat_terminal_inferior. */
266 child_terminal_inferior (struct target_ops *self)
268 struct inferior *inf;
269 struct terminal_info *tinfo;
271 if (!terminal_is_ours)
274 inf = current_inferior ();
275 tinfo = get_inflow_inferior_data (inf);
277 if (gdb_has_a_terminal ()
278 && tinfo->ttystate != NULL
279 && tinfo->run_terminal == NULL)
284 /* Is there a reason this is being done twice? It happens both
285 places we use F_SETFL, so I'm inclined to think perhaps there
286 is some reason, however perverse. Perhaps not though... */
287 result = fcntl (0, F_SETFL, tinfo->tflags);
288 result = fcntl (0, F_SETFL, tinfo->tflags);
289 OOPSY ("fcntl F_SETFL");
292 /* Because we were careful to not change in or out of raw mode in
293 terminal_ours, we will not change in our out of raw mode with
294 this call, so we don't flush any input. */
295 result = serial_set_tty_state (stdin_serial,
297 OOPSY ("setting tty state");
301 sigint_ours = signal (SIGINT, SIG_IGN);
303 sigquit_ours = signal (SIGQUIT, SIG_IGN);
307 /* If attach_flag is set, we don't know whether we are sharing a
308 terminal with the inferior or not. (attaching a process
309 without a terminal is one case where we do not; attaching a
310 process which we ran from the same shell as GDB via `&' is
311 one case where we do, I think (but perhaps this is not
312 `sharing' in the sense that we need to save and restore tty
313 state)). I don't know if there is any way to tell whether we
314 are sharing a terminal. So what we do is to go through all
315 the saving and restoring of the tty state, but ignore errors
316 setting the process group, which will happen if we are not
317 sharing a terminal). */
322 result = tcsetpgrp (0, tinfo->process_group);
323 if (!inf->attach_flag)
328 result = ioctl (0, TIOCSPGRP, &tinfo->process_group);
329 if (!inf->attach_flag)
335 terminal_is_ours = 0;
338 /* Put some of our terminal settings into effect,
339 enough to get proper results from our output,
340 but do not change into or out of RAW mode
341 so that no input is discarded.
343 After doing this, either terminal_ours or terminal_inferior
344 should be called to get back to a normal state of affairs.
346 N.B. The implementation is (currently) no different than
347 child_terminal_ours. See child_terminal_ours_1. */
350 child_terminal_ours_for_output (struct target_ops *self)
352 child_terminal_ours_1 (1);
355 /* Put our terminal settings into effect.
356 First record the inferior's terminal settings
357 so they can be restored properly later.
359 N.B. Targets that want to use this with async support must build that
360 support on top of this (e.g., the caller still needs to add stdin to the
361 event loop). E.g., see linux_nat_terminal_ours. */
364 child_terminal_ours (struct target_ops *self)
366 child_terminal_ours_1 (0);
369 /* output_only is not used, and should not be used unless we introduce
370 separate terminal_is_ours and terminal_is_ours_for_output
374 child_terminal_ours_1 (int output_only)
376 struct inferior *inf;
377 struct terminal_info *tinfo;
379 if (terminal_is_ours)
382 terminal_is_ours = 1;
384 /* Checking inferior->run_terminal is necessary so that
385 if GDB is running in the background, it won't block trying
386 to do the ioctl()'s below. Checking gdb_has_a_terminal
387 avoids attempting all the ioctl's when running in batch. */
389 inf = current_inferior ();
390 tinfo = get_inflow_inferior_data (inf);
392 if (tinfo->run_terminal != NULL || gdb_has_a_terminal () == 0)
397 /* Ignore this signal since it will happen when we try to set the
399 sighandler_t osigttou = NULL;
405 osigttou = signal (SIGTTOU, SIG_IGN);
408 xfree (tinfo->ttystate);
409 tinfo->ttystate = serial_get_tty_state (stdin_serial);
411 #ifdef PROCESS_GROUP_TYPE
412 if (!inf->attach_flag)
413 /* If setpgrp failed in terminal_inferior, this would give us
414 our process group instead of the inferior's. See
415 terminal_inferior for details. */
416 tinfo->process_group = gdb_getpgrp ();
419 /* Here we used to set ICANON in our ttystate, but I believe this
420 was an artifact from before when we used readline. Readline sets
421 the tty state when it needs to.
422 FIXME-maybe: However, query() expects non-raw mode and doesn't
423 use readline. Maybe query should use readline (on the other hand,
424 this only matters for HAVE_SGTTY, not termio or termios, I think). */
426 /* Set tty state to our_ttystate. We don't change in our out of raw
427 mode, to avoid flushing input. We need to do the same thing
428 regardless of output_only, because we don't have separate
429 terminal_is_ours and terminal_is_ours_for_output flags. It's OK,
430 though, since readline will deal with raw mode when/if it needs
433 serial_noflush_set_tty_state (stdin_serial, our_terminal_info.ttystate,
439 result = tcsetpgrp (0, our_terminal_info.process_group);
441 /* This fails on Ultrix with EINVAL if you run the testsuite
442 in the background with nohup, and then log out. GDB never
443 used to check for an error here, so perhaps there are other
444 such situations as well. */
446 fprintf_unfiltered (gdb_stderr,
447 "[tcsetpgrp failed in child_terminal_ours: %s]\n",
448 safe_strerror (errno));
453 result = ioctl (0, TIOCSPGRP, &our_terminal_info.process_group);
459 signal (SIGTTOU, osigttou);
464 signal (SIGINT, sigint_ours);
466 signal (SIGQUIT, sigquit_ours);
471 tinfo->tflags = fcntl (0, F_GETFL, 0);
473 /* Is there a reason this is being done twice? It happens both
474 places we use F_SETFL, so I'm inclined to think perhaps there
475 is some reason, however perverse. Perhaps not though... */
476 result = fcntl (0, F_SETFL, our_terminal_info.tflags);
477 result = fcntl (0, F_SETFL, our_terminal_info.tflags);
482 /* Per-inferior data key. */
483 static const struct inferior_data *inflow_inferior_data;
486 inflow_inferior_data_cleanup (struct inferior *inf, void *arg)
488 struct terminal_info *info = (struct terminal_info *) arg;
490 xfree (info->run_terminal);
491 xfree (info->ttystate);
495 /* Get the current svr4 data. If none is found yet, add it now. This
496 function always returns a valid object. */
498 static struct terminal_info *
499 get_inflow_inferior_data (struct inferior *inf)
501 struct terminal_info *info;
503 info = (struct terminal_info *) inferior_data (inf, inflow_inferior_data);
506 info = XCNEW (struct terminal_info);
507 set_inferior_data (inf, inflow_inferior_data, info);
513 /* This is a "inferior_exit" observer. Releases the TERMINAL_INFO member
514 of the inferior structure. This field is private to inflow.c, and
515 its type is opaque to the rest of GDB. PID is the target pid of
516 the inferior that is about to be removed from the inferior
520 inflow_inferior_exit (struct inferior *inf)
522 struct terminal_info *info;
524 info = (struct terminal_info *) inferior_data (inf, inflow_inferior_data);
527 xfree (info->run_terminal);
528 xfree (info->ttystate);
530 set_inferior_data (inf, inflow_inferior_data, NULL);
535 copy_terminal_info (struct inferior *to, struct inferior *from)
537 struct terminal_info *tinfo_to, *tinfo_from;
539 tinfo_to = get_inflow_inferior_data (to);
540 tinfo_from = get_inflow_inferior_data (from);
542 xfree (tinfo_to->run_terminal);
543 xfree (tinfo_to->ttystate);
545 *tinfo_to = *tinfo_from;
547 if (tinfo_from->run_terminal)
548 tinfo_to->run_terminal
549 = xstrdup (tinfo_from->run_terminal);
551 if (tinfo_from->ttystate)
553 = serial_copy_tty_state (stdin_serial, tinfo_from->ttystate);
557 term_info (char *arg, int from_tty)
559 target_terminal_info (arg, from_tty);
563 child_terminal_info (struct target_ops *self, const char *args, int from_tty)
565 struct inferior *inf;
566 struct terminal_info *tinfo;
568 if (!gdb_has_a_terminal ())
570 printf_filtered (_("This GDB does not control a terminal.\n"));
574 if (ptid_equal (inferior_ptid, null_ptid))
577 inf = current_inferior ();
578 tinfo = get_inflow_inferior_data (inf);
580 printf_filtered (_("Inferior's terminal status "
581 "(currently saved by GDB):\n"));
583 /* First the fcntl flags. */
587 flags = tinfo->tflags;
589 printf_filtered ("File descriptor flags = ");
592 #define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR)
594 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */
595 switch (flags & (O_ACCMODE))
598 printf_filtered ("O_RDONLY");
601 printf_filtered ("O_WRONLY");
604 printf_filtered ("O_RDWR");
607 flags &= ~(O_ACCMODE);
610 if (flags & O_NONBLOCK)
611 printf_filtered (" | O_NONBLOCK");
612 flags &= ~O_NONBLOCK;
615 #if defined (O_NDELAY)
616 /* If O_NDELAY and O_NONBLOCK are defined to the same thing, we will
617 print it as O_NONBLOCK, which is good cause that is what POSIX
618 has, and the flag will already be cleared by the time we get here. */
619 if (flags & O_NDELAY)
620 printf_filtered (" | O_NDELAY");
624 if (flags & O_APPEND)
625 printf_filtered (" | O_APPEND");
628 #if defined (O_BINARY)
629 if (flags & O_BINARY)
630 printf_filtered (" | O_BINARY");
635 printf_filtered (" | 0x%x", flags);
636 printf_filtered ("\n");
639 #ifdef PROCESS_GROUP_TYPE
640 printf_filtered ("Process group = %d\n", (int) tinfo->process_group);
643 serial_print_tty_state (stdin_serial, tinfo->ttystate, gdb_stdout);
646 /* NEW_TTY_PREFORK is called before forking a new child process,
647 so we can record the state of ttys in the child to be formed.
648 TTYNAME is null if we are to share the terminal with gdb;
649 or points to a string containing the name of the desired tty.
651 NEW_TTY is called in new child processes under Unix, which will
652 become debugger target processes. This actually switches to
653 the terminal specified in the NEW_TTY_PREFORK call. */
656 new_tty_prefork (const char *ttyname)
658 /* Save the name for later, for determining whether we and the child
659 are sharing a tty. */
660 inferior_thisrun_terminal = ttyname;
663 #if !defined(__GO32__) && !defined(_WIN32)
664 /* If RESULT, assumed to be the return value from a system call, is
665 negative, print the error message indicated by errno and exit.
666 MSG should identify the operation that failed. */
668 check_syscall (const char *msg, int result)
672 print_sys_errmsg (msg, errno);
683 if (inferior_thisrun_terminal == 0)
685 #if !defined(__GO32__) && !defined(_WIN32)
687 /* Disconnect the child process from our controlling terminal. On some
688 systems (SVR4 for example), this may cause a SIGTTOU, so temporarily
690 tty = open ("/dev/tty", O_RDWR);
693 sighandler_t osigttou;
695 osigttou = signal (SIGTTOU, SIG_IGN);
696 ioctl (tty, TIOCNOTTY, 0);
698 signal (SIGTTOU, osigttou);
702 /* Now open the specified new terminal. */
703 tty = open (inferior_thisrun_terminal, O_RDWR | O_NOCTTY);
704 check_syscall (inferior_thisrun_terminal, tty);
706 /* Avoid use of dup2; doesn't exist on all systems. */
710 check_syscall ("dup'ing tty into fd 0", dup (tty));
715 check_syscall ("dup'ing tty into fd 1", dup (tty));
720 check_syscall ("dup'ing tty into fd 2", dup (tty));
724 /* Make tty our new controlling terminal. */
725 if (ioctl (tty, TIOCSCTTY, 0) == -1)
726 /* Mention GDB in warning because it will appear in the inferior's
727 terminal instead of GDB's. */
728 warning (_("GDB: Failed to set controlling terminal: %s"),
729 safe_strerror (errno));
734 #endif /* !go32 && !win32 */
737 /* NEW_TTY_POSTFORK is called after forking a new child process, and
738 adding it to the inferior table, to store the TTYNAME being used by
739 the child, or null if it sharing the terminal with gdb. */
742 new_tty_postfork (void)
744 /* Save the name for later, for determining whether we and the child
745 are sharing a tty. */
747 if (inferior_thisrun_terminal)
749 struct inferior *inf = current_inferior ();
750 struct terminal_info *tinfo = get_inflow_inferior_data (inf);
752 tinfo->run_terminal = xstrdup (inferior_thisrun_terminal);
755 inferior_thisrun_terminal = NULL;
759 /* Call set_sigint_trap when you need to pass a signal on to an attached
760 process when handling SIGINT. */
763 pass_signal (int signo)
766 kill (ptid_get_pid (inferior_ptid), SIGINT);
770 static sighandler_t osig;
774 set_sigint_trap (void)
776 struct inferior *inf = current_inferior ();
777 struct terminal_info *tinfo = get_inflow_inferior_data (inf);
779 if (inf->attach_flag || tinfo->run_terminal)
781 osig = signal (SIGINT, pass_signal);
789 clear_sigint_trap (void)
793 signal (SIGINT, osig);
799 /* Create a new session if the inferior will run in a different tty.
800 A session is UNIX's way of grouping processes that share a controlling
801 terminal, so a new one is needed if the inferior terminal will be
802 different from GDB's.
804 Returns the session id of the new session, 0 if no session was created
805 or -1 if an error occurred. */
807 create_tty_session (void)
812 if (!job_control || inferior_thisrun_terminal == 0)
817 warning (_("Failed to create new terminal session: setsid: %s"),
818 safe_strerror (errno));
823 #endif /* HAVE_SETSID */
826 /* This is here because this is where we figure out whether we (probably)
827 have job control. Just using job_control only does part of it because
828 setpgid or setpgrp might not exist on a system without job control.
829 It might be considered misplaced (on the other hand, process groups and
830 job control are closely related to ttys).
832 For a more clean implementation, in libiberty, put a setpgid which merely
833 calls setpgrp and a setpgrp which does nothing (any system with job control
834 will have one or the other). */
842 #if defined (HAVE_TERMIOS) || defined (TIOCGPGRP)
844 /* The call setpgid (0, 0) is supposed to work and mean the same
845 thing as this, but on Ultrix 4.2A it fails with EPERM (and
846 setpgid (getpid (), getpid ()) succeeds). */
847 retval = setpgid (getpid (), getpid ());
853 retval = setpgrp (getpid (), getpid ());
855 #endif /* HAVE_SETPGRP */
856 #endif /* HAVE_SETPGID */
857 #endif /* defined (HAVE_TERMIOS) || defined (TIOCGPGRP) */
863 /* Get all the current tty settings (including whether we have a
864 tty at all!). We can't do this in _initialize_inflow because
865 serial_fdopen() won't work until the serial_ops_list is
866 initialized, but we don't want to do it lazily either, so
867 that we can guarantee stdin_serial is opened if there is
870 initialize_stdin_serial (void)
872 stdin_serial = serial_fdopen (0);
876 _initialize_inflow (void)
878 add_info ("terminal", term_info,
879 _("Print inferior's saved terminal status."));
881 terminal_is_ours = 1;
883 /* OK, figure out whether we have job control. If neither termios nor
884 sgtty (i.e. termio or go32), leave job_control 0. */
886 #if defined (HAVE_TERMIOS)
887 /* Do all systems with termios have the POSIX way of identifying job
888 control? I hope so. */
889 #ifdef _POSIX_JOB_CONTROL
892 #ifdef _SC_JOB_CONTROL
893 job_control = sysconf (_SC_JOB_CONTROL);
895 job_control = 0; /* Have to assume the worst. */
896 #endif /* _SC_JOB_CONTROL */
897 #endif /* _POSIX_JOB_CONTROL */
898 #endif /* HAVE_TERMIOS */
905 #endif /* TIOCGPGRP */
908 observer_attach_inferior_exit (inflow_inferior_exit);
911 = register_inferior_data_with_cleanup (NULL, inflow_inferior_data_cleanup);