inflow.c revision 98944
1/* Low level interface to ptrace, for GDB when running under Unix.
2   Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
3   1996, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
4
5   This file is part of GDB.
6
7   This program is free software; you can redistribute it and/or modify
8   it under the terms of the GNU General Public License as published by
9   the Free Software Foundation; either version 2 of the License, or
10   (at your option) any later version.
11
12   This program is distributed in the hope that it will be useful,
13   but WITHOUT ANY WARRANTY; without even the implied warranty of
14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   GNU General Public License for more details.
16
17   You should have received a copy of the GNU General Public License
18   along with this program; if not, write to the Free Software
19   Foundation, Inc., 59 Temple Place - Suite 330,
20   Boston, MA 02111-1307, USA.  */
21
22#include "defs.h"
23#include "frame.h"
24#include "inferior.h"
25#include "command.h"
26#include "serial.h"
27#include "terminal.h"
28#include "target.h"
29#include "gdbthread.h"
30
31#include "gdb_string.h"
32#include <signal.h>
33#include <fcntl.h>
34#ifdef HAVE_SYS_SELECT_H
35#include <sys/select.h>
36#endif
37
38#ifdef HAVE_TERMIOS
39#define PROCESS_GROUP_TYPE pid_t
40#endif
41
42#ifdef HAVE_TERMIO
43#define PROCESS_GROUP_TYPE int
44#endif
45
46#ifdef HAVE_SGTTY
47#ifdef SHORT_PGRP
48/* This is only used for the ultra.  Does it have pid_t?  */
49#define PROCESS_GROUP_TYPE short
50#else
51#define PROCESS_GROUP_TYPE int
52#endif
53#endif /* sgtty */
54
55#ifdef HAVE_SYS_IOCTL_H
56#include <sys/ioctl.h>
57#endif
58
59#if defined (SIGIO) && defined (FASYNC) && defined (FD_SET) && defined (F_SETOWN)
60static void handle_sigio (int);
61#endif
62
63extern void _initialize_inflow (void);
64
65static void pass_signal (int);
66
67static void kill_command (char *, int);
68
69static void terminal_ours_1 (int);
70
71/* Record terminal status separately for debugger and inferior.  */
72
73static struct serial *stdin_serial;
74
75/* TTY state for the inferior.  We save it whenever the inferior stops, and
76   restore it when it resumes.  */
77static serial_ttystate inferior_ttystate;
78
79/* Our own tty state, which we restore every time we need to deal with the
80   terminal.  We only set it once, when GDB first starts.  The settings of
81   flags which readline saves and restores and unimportant.  */
82static serial_ttystate our_ttystate;
83
84/* fcntl flags for us and the inferior.  Saved and restored just like
85   {our,inferior}_ttystate.  */
86static int tflags_inferior;
87static int tflags_ours;
88
89#ifdef PROCESS_GROUP_TYPE
90/* Process group for us and the inferior.  Saved and restored just like
91   {our,inferior}_ttystate.  */
92PROCESS_GROUP_TYPE our_process_group;
93PROCESS_GROUP_TYPE inferior_process_group;
94#endif
95
96/* While the inferior is running, we want SIGINT and SIGQUIT to go to the
97   inferior only.  If we have job control, that takes care of it.  If not,
98   we save our handlers in these two variables and set SIGINT and SIGQUIT
99   to SIG_IGN.  */
100
101static void (*sigint_ours) ();
102static void (*sigquit_ours) ();
103
104/* The name of the tty (from the `tty' command) that we gave to the inferior
105   when it was last started.  */
106
107static char *inferior_thisrun_terminal;
108
109/* Nonzero if our terminal settings are in effect.  Zero if the
110   inferior's settings are in effect.  Ignored if !gdb_has_a_terminal
111   ().  */
112
113int terminal_is_ours;
114
115enum
116  {
117    yes, no, have_not_checked
118  }
119gdb_has_a_terminal_flag = have_not_checked;
120
121/* Does GDB have a terminal (on stdin)?  */
122int
123gdb_has_a_terminal (void)
124{
125  switch (gdb_has_a_terminal_flag)
126    {
127    case yes:
128      return 1;
129    case no:
130      return 0;
131    case have_not_checked:
132      /* Get all the current tty settings (including whether we have a
133         tty at all!).  Can't do this in _initialize_inflow because
134         serial_fdopen() won't work until the serial_ops_list is
135         initialized.  */
136
137#ifdef F_GETFL
138      tflags_ours = fcntl (0, F_GETFL, 0);
139#endif
140
141      gdb_has_a_terminal_flag = no;
142      stdin_serial = serial_fdopen (0);
143      if (stdin_serial != NULL)
144	{
145	  our_ttystate = serial_get_tty_state (stdin_serial);
146
147	  if (our_ttystate != NULL)
148	    {
149	      gdb_has_a_terminal_flag = yes;
150#ifdef HAVE_TERMIOS
151	      our_process_group = tcgetpgrp (0);
152#endif
153#ifdef HAVE_TERMIO
154	      our_process_group = getpgrp ();
155#endif
156#ifdef HAVE_SGTTY
157	      ioctl (0, TIOCGPGRP, &our_process_group);
158#endif
159	    }
160	}
161
162      return gdb_has_a_terminal_flag == yes;
163    default:
164      /* "Can't happen".  */
165      return 0;
166    }
167}
168
169/* Macro for printing errors from ioctl operations */
170
171#define	OOPSY(what)	\
172  if (result == -1)	\
173    fprintf_unfiltered(gdb_stderr, "[%s failed in terminal_inferior: %s]\n", \
174	    what, strerror (errno))
175
176static void terminal_ours_1 (int);
177
178/* Initialize the terminal settings we record for the inferior,
179   before we actually run the inferior.  */
180
181void
182terminal_init_inferior_with_pgrp (int pgrp)
183{
184  if (gdb_has_a_terminal ())
185    {
186      /* We could just as well copy our_ttystate (if we felt like
187         adding a new function serial_copy_tty_state()).  */
188      if (inferior_ttystate)
189	xfree (inferior_ttystate);
190      inferior_ttystate = serial_get_tty_state (stdin_serial);
191
192#ifdef PROCESS_GROUP_TYPE
193      inferior_process_group = pgrp;
194#endif
195
196      /* Make sure that next time we call terminal_inferior (which will be
197         before the program runs, as it needs to be), we install the new
198         process group.  */
199      terminal_is_ours = 1;
200    }
201}
202
203void
204terminal_init_inferior (void)
205{
206#ifdef PROCESS_GROUP_TYPE
207  /* This is for Lynx, and should be cleaned up by having Lynx be a separate
208     debugging target with a version of target_terminal_init_inferior which
209     passes in the process group to a generic routine which does all the work
210     (and the non-threaded child_terminal_init_inferior can just pass in
211     inferior_ptid to the same routine).  */
212  /* We assume INFERIOR_PID is also the child's process group.  */
213  terminal_init_inferior_with_pgrp (PIDGET (inferior_ptid));
214#endif /* PROCESS_GROUP_TYPE */
215}
216
217/* Put the inferior's terminal settings into effect.
218   This is preparation for starting or resuming the inferior.  */
219
220void
221terminal_inferior (void)
222{
223  if (gdb_has_a_terminal () && terminal_is_ours
224      && inferior_thisrun_terminal == 0)
225    {
226      int result;
227
228#ifdef F_GETFL
229      /* Is there a reason this is being done twice?  It happens both
230         places we use F_SETFL, so I'm inclined to think perhaps there
231         is some reason, however perverse.  Perhaps not though...  */
232      result = fcntl (0, F_SETFL, tflags_inferior);
233      result = fcntl (0, F_SETFL, tflags_inferior);
234      OOPSY ("fcntl F_SETFL");
235#endif
236
237      /* Because we were careful to not change in or out of raw mode in
238         terminal_ours, we will not change in our out of raw mode with
239         this call, so we don't flush any input.  */
240      result = serial_set_tty_state (stdin_serial, inferior_ttystate);
241      OOPSY ("setting tty state");
242
243      if (!job_control)
244	{
245	  sigint_ours = (void (*)()) signal (SIGINT, SIG_IGN);
246#ifdef SIGQUIT
247	  sigquit_ours = (void (*)()) signal (SIGQUIT, SIG_IGN);
248#endif
249	}
250
251      /* If attach_flag is set, we don't know whether we are sharing a
252         terminal with the inferior or not.  (attaching a process
253         without a terminal is one case where we do not; attaching a
254         process which we ran from the same shell as GDB via `&' is
255         one case where we do, I think (but perhaps this is not
256         `sharing' in the sense that we need to save and restore tty
257         state)).  I don't know if there is any way to tell whether we
258         are sharing a terminal.  So what we do is to go through all
259         the saving and restoring of the tty state, but ignore errors
260         setting the process group, which will happen if we are not
261         sharing a terminal).  */
262
263      if (job_control)
264	{
265#ifdef HAVE_TERMIOS
266	  result = tcsetpgrp (0, inferior_process_group);
267	  if (!attach_flag)
268	    OOPSY ("tcsetpgrp");
269#endif
270
271#ifdef HAVE_SGTTY
272	  result = ioctl (0, TIOCSPGRP, &inferior_process_group);
273	  if (!attach_flag)
274	    OOPSY ("TIOCSPGRP");
275#endif
276	}
277
278    }
279  terminal_is_ours = 0;
280}
281
282/* Put some of our terminal settings into effect,
283   enough to get proper results from our output,
284   but do not change into or out of RAW mode
285   so that no input is discarded.
286
287   After doing this, either terminal_ours or terminal_inferior
288   should be called to get back to a normal state of affairs.  */
289
290void
291terminal_ours_for_output (void)
292{
293  terminal_ours_1 (1);
294}
295
296/* Put our terminal settings into effect.
297   First record the inferior's terminal settings
298   so they can be restored properly later.  */
299
300void
301terminal_ours (void)
302{
303  terminal_ours_1 (0);
304}
305
306/* output_only is not used, and should not be used unless we introduce
307   separate terminal_is_ours and terminal_is_ours_for_output
308   flags.  */
309
310static void
311terminal_ours_1 (int output_only)
312{
313  /* Checking inferior_thisrun_terminal is necessary so that
314     if GDB is running in the background, it won't block trying
315     to do the ioctl()'s below.  Checking gdb_has_a_terminal
316     avoids attempting all the ioctl's when running in batch.  */
317  if (inferior_thisrun_terminal != 0 || gdb_has_a_terminal () == 0)
318    return;
319
320  if (!terminal_is_ours)
321    {
322#ifdef SIGTTOU
323      /* Ignore this signal since it will happen when we try to set the
324         pgrp.  */
325      void (*osigttou) () = NULL;
326#endif
327      int result;
328
329      terminal_is_ours = 1;
330
331#ifdef SIGTTOU
332      if (job_control)
333	osigttou = (void (*)()) signal (SIGTTOU, SIG_IGN);
334#endif
335
336      if (inferior_ttystate)
337	xfree (inferior_ttystate);
338      inferior_ttystate = serial_get_tty_state (stdin_serial);
339#ifdef HAVE_TERMIOS
340      inferior_process_group = tcgetpgrp (0);
341#endif
342#ifdef HAVE_TERMIO
343      inferior_process_group = getpgrp ();
344#endif
345#ifdef HAVE_SGTTY
346      ioctl (0, TIOCGPGRP, &inferior_process_group);
347#endif
348
349      /* Here we used to set ICANON in our ttystate, but I believe this
350         was an artifact from before when we used readline.  Readline sets
351         the tty state when it needs to.
352         FIXME-maybe: However, query() expects non-raw mode and doesn't
353         use readline.  Maybe query should use readline (on the other hand,
354         this only matters for HAVE_SGTTY, not termio or termios, I think).  */
355
356      /* Set tty state to our_ttystate.  We don't change in our out of raw
357         mode, to avoid flushing input.  We need to do the same thing
358         regardless of output_only, because we don't have separate
359         terminal_is_ours and terminal_is_ours_for_output flags.  It's OK,
360         though, since readline will deal with raw mode when/if it needs to.
361       */
362
363      serial_noflush_set_tty_state (stdin_serial, our_ttystate,
364				    inferior_ttystate);
365
366      if (job_control)
367	{
368#ifdef HAVE_TERMIOS
369	  result = tcsetpgrp (0, our_process_group);
370#if 0
371	  /* This fails on Ultrix with EINVAL if you run the testsuite
372	     in the background with nohup, and then log out.  GDB never
373	     used to check for an error here, so perhaps there are other
374	     such situations as well.  */
375	  if (result == -1)
376	    fprintf_unfiltered (gdb_stderr, "[tcsetpgrp failed in terminal_ours: %s]\n",
377				strerror (errno));
378#endif
379#endif /* termios */
380
381#ifdef HAVE_SGTTY
382	  result = ioctl (0, TIOCSPGRP, &our_process_group);
383#endif
384	}
385
386#ifdef SIGTTOU
387      if (job_control)
388	signal (SIGTTOU, osigttou);
389#endif
390
391      if (!job_control)
392	{
393	  signal (SIGINT, sigint_ours);
394#ifdef SIGQUIT
395	  signal (SIGQUIT, sigquit_ours);
396#endif
397	}
398
399#ifdef F_GETFL
400      tflags_inferior = fcntl (0, F_GETFL, 0);
401
402      /* Is there a reason this is being done twice?  It happens both
403         places we use F_SETFL, so I'm inclined to think perhaps there
404         is some reason, however perverse.  Perhaps not though...  */
405      result = fcntl (0, F_SETFL, tflags_ours);
406      result = fcntl (0, F_SETFL, tflags_ours);
407#endif
408
409      result = result;		/* lint */
410    }
411}
412
413/* ARGSUSED */
414void
415term_info (char *arg, int from_tty)
416{
417  target_terminal_info (arg, from_tty);
418}
419
420/* ARGSUSED */
421void
422child_terminal_info (char *args, int from_tty)
423{
424  if (!gdb_has_a_terminal ())
425    {
426      printf_filtered ("This GDB does not control a terminal.\n");
427      return;
428    }
429
430  printf_filtered ("Inferior's terminal status (currently saved by GDB):\n");
431
432  /* First the fcntl flags.  */
433  {
434    int flags;
435
436    flags = tflags_inferior;
437
438    printf_filtered ("File descriptor flags = ");
439
440#ifndef O_ACCMODE
441#define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR)
442#endif
443    /* (O_ACCMODE) parens are to avoid Ultrix header file bug */
444    switch (flags & (O_ACCMODE))
445      {
446      case O_RDONLY:
447	printf_filtered ("O_RDONLY");
448	break;
449      case O_WRONLY:
450	printf_filtered ("O_WRONLY");
451	break;
452      case O_RDWR:
453	printf_filtered ("O_RDWR");
454	break;
455      }
456    flags &= ~(O_ACCMODE);
457
458#ifdef O_NONBLOCK
459    if (flags & O_NONBLOCK)
460      printf_filtered (" | O_NONBLOCK");
461    flags &= ~O_NONBLOCK;
462#endif
463
464#if defined (O_NDELAY)
465    /* If O_NDELAY and O_NONBLOCK are defined to the same thing, we will
466       print it as O_NONBLOCK, which is good cause that is what POSIX
467       has, and the flag will already be cleared by the time we get here.  */
468    if (flags & O_NDELAY)
469      printf_filtered (" | O_NDELAY");
470    flags &= ~O_NDELAY;
471#endif
472
473    if (flags & O_APPEND)
474      printf_filtered (" | O_APPEND");
475    flags &= ~O_APPEND;
476
477#if defined (O_BINARY)
478    if (flags & O_BINARY)
479      printf_filtered (" | O_BINARY");
480    flags &= ~O_BINARY;
481#endif
482
483    if (flags)
484      printf_filtered (" | 0x%x", flags);
485    printf_filtered ("\n");
486  }
487
488#ifdef PROCESS_GROUP_TYPE
489  printf_filtered ("Process group = %d\n",
490		   (int) inferior_process_group);
491#endif
492
493  serial_print_tty_state (stdin_serial, inferior_ttystate, gdb_stdout);
494}
495
496/* NEW_TTY_PREFORK is called before forking a new child process,
497   so we can record the state of ttys in the child to be formed.
498   TTYNAME is null if we are to share the terminal with gdb;
499   or points to a string containing the name of the desired tty.
500
501   NEW_TTY is called in new child processes under Unix, which will
502   become debugger target processes.  This actually switches to
503   the terminal specified in the NEW_TTY_PREFORK call.  */
504
505void
506new_tty_prefork (char *ttyname)
507{
508  /* Save the name for later, for determining whether we and the child
509     are sharing a tty.  */
510  inferior_thisrun_terminal = ttyname;
511}
512
513void
514new_tty (void)
515{
516  register int tty;
517
518  if (inferior_thisrun_terminal == 0)
519    return;
520#if !defined(__GO32__) && !defined(_WIN32)
521#ifdef TIOCNOTTY
522  /* Disconnect the child process from our controlling terminal.  On some
523     systems (SVR4 for example), this may cause a SIGTTOU, so temporarily
524     ignore SIGTTOU. */
525  tty = open ("/dev/tty", O_RDWR);
526  if (tty > 0)
527    {
528      void (*osigttou) ();
529
530      osigttou = (void (*)()) signal (SIGTTOU, SIG_IGN);
531      ioctl (tty, TIOCNOTTY, 0);
532      close (tty);
533      signal (SIGTTOU, osigttou);
534    }
535#endif
536
537  /* Now open the specified new terminal.  */
538
539#ifdef USE_O_NOCTTY
540  tty = open (inferior_thisrun_terminal, O_RDWR | O_NOCTTY);
541#else
542  tty = open (inferior_thisrun_terminal, O_RDWR);
543#endif
544  if (tty == -1)
545    {
546      print_sys_errmsg (inferior_thisrun_terminal, errno);
547      _exit (1);
548    }
549
550  /* Avoid use of dup2; doesn't exist on all systems.  */
551  if (tty != 0)
552    {
553      close (0);
554      dup (tty);
555    }
556  if (tty != 1)
557    {
558      close (1);
559      dup (tty);
560    }
561  if (tty != 2)
562    {
563      close (2);
564      dup (tty);
565    }
566  if (tty > 2)
567    close (tty);
568#endif /* !go32 && !win32 */
569}
570
571/* Kill the inferior process.  Make us have no inferior.  */
572
573/* ARGSUSED */
574static void
575kill_command (char *arg, int from_tty)
576{
577  /* FIXME:  This should not really be inferior_ptid (or target_has_execution).
578     It should be a distinct flag that indicates that a target is active, cuz
579     some targets don't have processes! */
580
581  if (ptid_equal (inferior_ptid, null_ptid))
582    error ("The program is not being run.");
583  if (!query ("Kill the program being debugged? "))
584    error ("Not confirmed.");
585  target_kill ();
586
587  init_thread_list ();		/* Destroy thread info */
588
589  /* Killing off the inferior can leave us with a core file.  If so,
590     print the state we are left in.  */
591  if (target_has_stack)
592    {
593      printf_filtered ("In %s,\n", target_longname);
594      if (selected_frame == NULL)
595	fputs_filtered ("No selected stack frame.\n", gdb_stdout);
596      else
597	print_stack_frame (selected_frame, selected_frame_level, 1);
598    }
599}
600
601/* Call set_sigint_trap when you need to pass a signal on to an attached
602   process when handling SIGINT */
603
604/* ARGSUSED */
605static void
606pass_signal (int signo)
607{
608#ifndef _WIN32
609  kill (PIDGET (inferior_ptid), SIGINT);
610#endif
611}
612
613static void (*osig) ();
614
615void
616set_sigint_trap (void)
617{
618  if (attach_flag || inferior_thisrun_terminal)
619    {
620      osig = (void (*)()) signal (SIGINT, pass_signal);
621    }
622}
623
624void
625clear_sigint_trap (void)
626{
627  if (attach_flag || inferior_thisrun_terminal)
628    {
629      signal (SIGINT, osig);
630    }
631}
632
633#if defined (SIGIO) && defined (FASYNC) && defined (FD_SET) && defined (F_SETOWN)
634static void (*old_sigio) ();
635
636static void
637handle_sigio (int signo)
638{
639  int numfds;
640  fd_set readfds;
641
642  signal (SIGIO, handle_sigio);
643
644  FD_ZERO (&readfds);
645  FD_SET (target_activity_fd, &readfds);
646  numfds = select (target_activity_fd + 1, &readfds, NULL, NULL, NULL);
647  if (numfds >= 0 && FD_ISSET (target_activity_fd, &readfds))
648    {
649#ifndef _WIN32
650      if ((*target_activity_function) ())
651	kill (PIDGET (inferior_ptid), SIGINT);
652#endif
653    }
654}
655
656static int old_fcntl_flags;
657
658void
659set_sigio_trap (void)
660{
661  if (target_activity_function)
662    {
663      old_sigio = (void (*)()) signal (SIGIO, handle_sigio);
664      fcntl (target_activity_fd, F_SETOWN, getpid ());
665      old_fcntl_flags = fcntl (target_activity_fd, F_GETFL, 0);
666      fcntl (target_activity_fd, F_SETFL, old_fcntl_flags | FASYNC);
667    }
668}
669
670void
671clear_sigio_trap (void)
672{
673  if (target_activity_function)
674    {
675      signal (SIGIO, old_sigio);
676      fcntl (target_activity_fd, F_SETFL, old_fcntl_flags);
677    }
678}
679#else /* No SIGIO.  */
680void
681set_sigio_trap (void)
682{
683  if (target_activity_function)
684    internal_error (__FILE__, __LINE__, "failed internal consistency check");
685}
686
687void
688clear_sigio_trap (void)
689{
690  if (target_activity_function)
691    internal_error (__FILE__, __LINE__, "failed internal consistency check");
692}
693#endif /* No SIGIO.  */
694
695
696/* This is here because this is where we figure out whether we (probably)
697   have job control.  Just using job_control only does part of it because
698   setpgid or setpgrp might not exist on a system without job control.
699   It might be considered misplaced (on the other hand, process groups and
700   job control are closely related to ttys).
701
702   For a more clean implementation, in libiberty, put a setpgid which merely
703   calls setpgrp and a setpgrp which does nothing (any system with job control
704   will have one or the other).  */
705int
706gdb_setpgid (void)
707{
708  int retval = 0;
709
710  if (job_control)
711    {
712#if defined (HAVE_TERMIOS) || defined (TIOCGPGRP)
713#ifdef HAVE_SETPGID
714      /* The call setpgid (0, 0) is supposed to work and mean the same
715         thing as this, but on Ultrix 4.2A it fails with EPERM (and
716         setpgid (getpid (), getpid ()) succeeds).  */
717      retval = setpgid (getpid (), getpid ());
718#else
719#ifdef HAVE_SETPGRP
720#ifdef SETPGRP_VOID
721      retval = setpgrp ();
722#else
723      retval = setpgrp (getpid (), getpid ());
724#endif
725#endif /* HAVE_SETPGRP */
726#endif /* HAVE_SETPGID */
727#endif /* defined (HAVE_TERMIOS) || defined (TIOCGPGRP) */
728    }
729
730  return retval;
731}
732
733void
734_initialize_inflow (void)
735{
736  add_info ("terminal", term_info,
737	    "Print inferior's saved terminal status.");
738
739  add_com ("kill", class_run, kill_command,
740	   "Kill execution of program being debugged.");
741
742  inferior_ptid = null_ptid;
743
744  terminal_is_ours = 1;
745
746  /* OK, figure out whether we have job control.  If neither termios nor
747     sgtty (i.e. termio or go32), leave job_control 0.  */
748
749#if defined (HAVE_TERMIOS)
750  /* Do all systems with termios have the POSIX way of identifying job
751     control?  I hope so.  */
752#ifdef _POSIX_JOB_CONTROL
753  job_control = 1;
754#else
755#ifdef _SC_JOB_CONTROL
756  job_control = sysconf (_SC_JOB_CONTROL);
757#else
758  job_control = 0;		/* have to assume the worst */
759#endif /* _SC_JOB_CONTROL */
760#endif /* _POSIX_JOB_CONTROL */
761#endif /* HAVE_TERMIOS */
762
763#ifdef HAVE_SGTTY
764#ifdef TIOCGPGRP
765  job_control = 1;
766#else
767  job_control = 0;
768#endif /* TIOCGPGRP */
769#endif /* sgtty */
770}
771