X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Finflow.c;h=ab94c445e4afb2fe7e901d1e49588b46c2d340f2;hb=e1e9e218c189882084a89fdee655a0a523efbaf8;hp=332584c926774f08b4196668f7560c793dd4bfa2;hpb=7e97eb282603d8732bd7a4a8e63e162a38212c14;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/inflow.c b/gdb/inflow.c index 332584c926..ab94c445e4 100644 --- a/gdb/inflow.c +++ b/gdb/inflow.c @@ -1,180 +1,278 @@ /* Low level interface to ptrace, for GDB when running under Unix. - Copyright (C) 1986, 1987, 1989, 1991 Free Software Foundation, Inc. + Copyright 1986-87, 1989, 1991-92, 1995, 1998 Free Software Foundation, Inc. -This file is part of GDB. + This file is part of GDB. -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -You should have received a copy of the GNU General Public License -along with this program; if not, write to the Free Software -Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ -#include #include "defs.h" #include "frame.h" #include "inferior.h" #include "command.h" -#include "signals.h" +#include "serial.h" #include "terminal.h" #include "target.h" +#include "gdbthread.h" -#ifdef USG -#include +#include "gdb_string.h" +#include +#include +#ifdef HAVE_SYS_SELECT_H +#include #endif -/* Some USG-esque systems (some of which are BSD-esque enough so that USG - is not defined) want this header, and it won't do any harm. */ -#include +#ifdef HAVE_TERMIOS +#define PROCESS_GROUP_TYPE pid_t +#endif -#include -#include -#include +#ifdef HAVE_TERMIO +#define PROCESS_GROUP_TYPE int +#endif -extern char *strerror(); /* strings corresponding to errno */ +#ifdef HAVE_SGTTY +#ifdef SHORT_PGRP +/* This is only used for the ultra. Does it have pid_t? */ +#define PROCESS_GROUP_TYPE short +#else +#define PROCESS_GROUP_TYPE int +#endif +#endif /* sgtty */ + +#ifdef HAVE_SYS_IOCTL_H +#include +#endif + +#if defined (SIGIO) && defined (FASYNC) && defined (FD_SET) && defined (F_SETOWN) +static void handle_sigio (int); +#endif -extern struct target_ops child_ops; +extern void _initialize_inflow (void); -/* Nonzero if we are debugging an attached outside process - rather than an inferior. */ +static void pass_signal (int); -int attach_flag; +static void kill_command (char *, int); +static void terminal_ours_1 (int); /* Record terminal status separately for debugger and inferior. */ -/* Does GDB have a terminal (on stdin)? */ -int gdb_has_a_terminal; +static serial_t stdin_serial; + +/* TTY state for the inferior. We save it whenever the inferior stops, and + restore it when it resumes. */ +static serial_ttystate inferior_ttystate; -static TERMINAL sg_inferior; -static TERMINAL sg_ours; +/* Our own tty state, which we restore every time we need to deal with the + terminal. We only set it once, when GDB first starts. The settings of + flags which readline saves and restores and unimportant. */ +static serial_ttystate our_ttystate; +/* fcntl flags for us and the inferior. Saved and restored just like + {our,inferior}_ttystate. */ static int tflags_inferior; static int tflags_ours; -#if defined(TIOCGETC) && !defined(TIOCGETC_BROKEN) -static struct tchars tc_inferior; -static struct tchars tc_ours; -#endif - -#if defined(TIOCGLTC) && !defined(TIOCGLTC_BROKEN) -static struct ltchars ltc_inferior; -static struct ltchars ltc_ours; +#ifdef PROCESS_GROUP_TYPE +/* Process group for us and the inferior. Saved and restored just like + {our,inferior}_ttystate. */ +PROCESS_GROUP_TYPE our_process_group; +PROCESS_GROUP_TYPE inferior_process_group; #endif -#ifdef TIOCLGET -static int lmode_inferior; -static int lmode_ours; -#endif +/* While the inferior is running, we want SIGINT and SIGQUIT to go to the + inferior only. If we have job control, that takes care of it. If not, + we save our handlers in these two variables and set SIGINT and SIGQUIT + to SIG_IGN. */ -#ifdef TIOCGPGRP -# ifdef SHORT_PGRP -static short pgrp_inferior; -static short pgrp_ours; -# else /* not def SHORT_PGRP */ -static int pgrp_inferior; -static int pgrp_ours; -# endif /* not def SHORT_PGRP */ -#else /* not def TIOCGPGRP */ static void (*sigint_ours) (); static void (*sigquit_ours) (); -#endif /* TIOCGPGRP */ /* The name of the tty (from the `tty' command) that we gave to the inferior when it was last started. */ static char *inferior_thisrun_terminal; -/* Nonzero if our terminal settings are in effect. - Zero if the inferior's settings are in effect. */ +/* Nonzero if our terminal settings are in effect. Zero if the + inferior's settings are in effect. Ignored if !gdb_has_a_terminal + (). */ + +int terminal_is_ours; -static int terminal_is_ours; +enum + { + yes, no, have_not_checked + } +gdb_has_a_terminal_flag = have_not_checked; + +/* Does GDB have a terminal (on stdin)? */ +int +gdb_has_a_terminal (void) +{ + switch (gdb_has_a_terminal_flag) + { + case yes: + return 1; + case no: + return 0; + case have_not_checked: + /* Get all the current tty settings (including whether we have a tty at + all!). Can't do this in _initialize_inflow because SERIAL_FDOPEN + won't work until the serial_ops_list is initialized. */ + +#ifdef F_GETFL + tflags_ours = fcntl (0, F_GETFL, 0); +#endif + + gdb_has_a_terminal_flag = no; + stdin_serial = SERIAL_FDOPEN (0); + if (stdin_serial != NULL) + { + our_ttystate = SERIAL_GET_TTY_STATE (stdin_serial); + + if (our_ttystate != NULL) + { + gdb_has_a_terminal_flag = yes; +#ifdef HAVE_TERMIOS + our_process_group = tcgetpgrp (0); +#endif +#ifdef HAVE_TERMIO + our_process_group = getpgrp (); +#endif +#ifdef HAVE_SGTTY + ioctl (0, TIOCGPGRP, &our_process_group); +#endif + } + } + + return gdb_has_a_terminal_flag == yes; + default: + /* "Can't happen". */ + return 0; + } +} /* Macro for printing errors from ioctl operations */ #define OOPSY(what) \ if (result == -1) \ - fprintf(stderr, "[%s failed in terminal_inferior: %s]\n", \ + fprintf_unfiltered(gdb_stderr, "[%s failed in terminal_inferior: %s]\n", \ what, strerror (errno)) -static void terminal_ours_1 (); +static void terminal_ours_1 (int); /* Initialize the terminal settings we record for the inferior, before we actually run the inferior. */ void -terminal_init_inferior () +terminal_init_inferior_with_pgrp (int pgrp) { - sg_inferior = sg_ours; - tflags_inferior = tflags_ours; - -#if defined(TIOCGETC) && !defined(TIOCGETC_BROKEN) - tc_inferior = tc_ours; -#endif - -#if defined(TIOCGLTC) && !defined(TIOCGLTC_BROKEN) - ltc_inferior = ltc_ours; -#endif - -#ifdef TIOCLGET - lmode_inferior = lmode_ours; + if (gdb_has_a_terminal ()) + { + /* We could just as well copy our_ttystate (if we felt like adding + a new function SERIAL_COPY_TTY_STATE). */ + if (inferior_ttystate) + xfree (inferior_ttystate); + inferior_ttystate = SERIAL_GET_TTY_STATE (stdin_serial); + +#ifdef PROCESS_GROUP_TYPE + inferior_process_group = pgrp; #endif -#ifdef TIOCGPGRP - pgrp_inferior = inferior_pid; -#endif /* TIOCGPGRP */ + /* Make sure that next time we call terminal_inferior (which will be + before the program runs, as it needs to be), we install the new + process group. */ + terminal_is_ours = 1; + } +} - terminal_is_ours = 1; +void +terminal_init_inferior (void) +{ +#ifdef PROCESS_GROUP_TYPE + /* This is for Lynx, and should be cleaned up by having Lynx be a separate + debugging target with a version of target_terminal_init_inferior which + passes in the process group to a generic routine which does all the work + (and the non-threaded child_terminal_init_inferior can just pass in + inferior_pid to the same routine). */ + /* We assume INFERIOR_PID is also the child's process group. */ + terminal_init_inferior_with_pgrp (PIDGET (inferior_pid)); +#endif /* PROCESS_GROUP_TYPE */ } /* Put the inferior's terminal settings into effect. This is preparation for starting or resuming the inferior. */ void -terminal_inferior () +terminal_inferior (void) { - int result; - - if (gdb_has_a_terminal && terminal_is_ours && inferior_thisrun_terminal == 0) + if (gdb_has_a_terminal () && terminal_is_ours + && inferior_thisrun_terminal == 0) { + int result; + +#ifdef F_GETFL + /* Is there a reason this is being done twice? It happens both + places we use F_SETFL, so I'm inclined to think perhaps there + is some reason, however perverse. Perhaps not though... */ result = fcntl (0, F_SETFL, tflags_inferior); result = fcntl (0, F_SETFL, tflags_inferior); OOPSY ("fcntl F_SETFL"); - result = ioctl (0, TIOCSETN, &sg_inferior); - OOPSY ("ioctl TIOCSETN"); +#endif -#if defined(TIOCGETC) && !defined(TIOCGETC_BROKEN) - result = ioctl (0, TIOCSETC, &tc_inferior); - OOPSY ("ioctl TIOCSETC"); + /* Because we were careful to not change in or out of raw mode in + terminal_ours, we will not change in our out of raw mode with + this call, so we don't flush any input. */ + result = SERIAL_SET_TTY_STATE (stdin_serial, inferior_ttystate); + OOPSY ("setting tty state"); + + if (!job_control) + { + sigint_ours = (void (*)()) signal (SIGINT, SIG_IGN); +#ifdef SIGQUIT + sigquit_ours = (void (*)()) signal (SIGQUIT, SIG_IGN); #endif -#if defined(TIOCGLTC) && !defined(TIOCGLTC_BROKEN) - result = ioctl (0, TIOCSLTC, <c_inferior); - OOPSY ("ioctl TIOCSLTC"); + } + + /* If attach_flag is set, we don't know whether we are sharing a + terminal with the inferior or not. (attaching a process + without a terminal is one case where we do not; attaching a + process which we ran from the same shell as GDB via `&' is + one case where we do, I think (but perhaps this is not + `sharing' in the sense that we need to save and restore tty + state)). I don't know if there is any way to tell whether we + are sharing a terminal. So what we do is to go through all + the saving and restoring of the tty state, but ignore errors + setting the process group, which will happen if we are not + sharing a terminal). */ + + if (job_control) + { +#ifdef HAVE_TERMIOS + result = tcsetpgrp (0, inferior_process_group); + if (!attach_flag) + OOPSY ("tcsetpgrp"); #endif -#ifdef TIOCLGET - result = ioctl (0, TIOCLSET, &lmode_inferior); - OOPSY ("ioctl TIOCLSET"); + +#ifdef HAVE_SGTTY + result = ioctl (0, TIOCSPGRP, &inferior_process_group); + if (!attach_flag) + OOPSY ("TIOCSPGRP"); #endif + } -#ifdef TIOCGPGRP - result = ioctl (0, TIOCSPGRP, &pgrp_inferior); - /* If we attached to the process, we might or might not be sharing - a terminal. Avoid printing error msg if we are unable to set our - terminal's process group to his process group ID. */ - if (!attach_flag) { - OOPSY ("ioctl TIOCSPGRP"); - } -#else - sigint_ours = (void (*) ()) signal (SIGINT, SIG_IGN); - sigquit_ours = (void (*) ()) signal (SIGQUIT, SIG_IGN); -#endif /* TIOCGPGRP */ } terminal_is_ours = 0; } @@ -188,7 +286,7 @@ terminal_inferior () should be called to get back to a normal state of affairs. */ void -terminal_ours_for_output () +terminal_ours_for_output (void) { terminal_ours_1 (1); } @@ -198,152 +296,199 @@ terminal_ours_for_output () so they can be restored properly later. */ void -terminal_ours () +terminal_ours (void) { terminal_ours_1 (0); } +/* output_only is not used, and should not be used unless we introduce + separate terminal_is_ours and terminal_is_ours_for_output + flags. */ + static void -terminal_ours_1 (output_only) - int output_only; +terminal_ours_1 (int output_only) { - int result; -#ifdef TIOCGPGRP - /* Ignore this signal since it will happen when we try to set the pgrp. */ - void (*osigttou) (); -#endif /* TIOCGPGRP */ - /* Checking inferior_thisrun_terminal is necessary so that if GDB is running in the background, it won't block trying to do the ioctl()'s below. Checking gdb_has_a_terminal avoids attempting all the ioctl's when running in batch. */ - if (inferior_thisrun_terminal != 0 || gdb_has_a_terminal == 0) + if (inferior_thisrun_terminal != 0 || gdb_has_a_terminal () == 0) return; if (!terminal_is_ours) { +#ifdef SIGTTOU + /* Ignore this signal since it will happen when we try to set the + pgrp. */ + void (*osigttou) () = NULL; +#endif + int result; + terminal_is_ours = 1; -#ifdef TIOCGPGRP - osigttou = (void (*) ()) signal (SIGTTOU, SIG_IGN); +#ifdef SIGTTOU + if (job_control) + osigttou = (void (*)()) signal (SIGTTOU, SIG_IGN); +#endif - result = ioctl (0, TIOCGPGRP, &pgrp_inferior); - result = ioctl (0, TIOCSPGRP, &pgrp_ours); + if (inferior_ttystate) + xfree (inferior_ttystate); + inferior_ttystate = SERIAL_GET_TTY_STATE (stdin_serial); +#ifdef HAVE_TERMIOS + inferior_process_group = tcgetpgrp (0); +#endif +#ifdef HAVE_TERMIO + inferior_process_group = getpgrp (); +#endif +#ifdef HAVE_SGTTY + ioctl (0, TIOCGPGRP, &inferior_process_group); +#endif - signal (SIGTTOU, osigttou); -#else - signal (SIGINT, sigint_ours); - signal (SIGQUIT, sigquit_ours); -#endif /* TIOCGPGRP */ + /* Here we used to set ICANON in our ttystate, but I believe this + was an artifact from before when we used readline. Readline sets + the tty state when it needs to. + FIXME-maybe: However, query() expects non-raw mode and doesn't + use readline. Maybe query should use readline (on the other hand, + this only matters for HAVE_SGTTY, not termio or termios, I think). */ - tflags_inferior = fcntl (0, F_GETFL, 0); - result = ioctl (0, TIOCGETP, &sg_inferior); + /* Set tty state to our_ttystate. We don't change in our out of raw + mode, to avoid flushing input. We need to do the same thing + regardless of output_only, because we don't have separate + terminal_is_ours and terminal_is_ours_for_output flags. It's OK, + though, since readline will deal with raw mode when/if it needs to. + */ -#if defined(TIOCGETC) && !defined(TIOCGETC_BROKEN) - result = ioctl (0, TIOCGETC, &tc_inferior); + SERIAL_NOFLUSH_SET_TTY_STATE (stdin_serial, our_ttystate, + inferior_ttystate); + + if (job_control) + { +#ifdef HAVE_TERMIOS + result = tcsetpgrp (0, our_process_group); +#if 0 + /* This fails on Ultrix with EINVAL if you run the testsuite + in the background with nohup, and then log out. GDB never + used to check for an error here, so perhaps there are other + such situations as well. */ + if (result == -1) + fprintf_unfiltered (gdb_stderr, "[tcsetpgrp failed in terminal_ours: %s]\n", + strerror (errno)); #endif -#if defined(TIOCGLTC) && !defined(TIOCGLTC_BROKEN) - result = ioctl (0, TIOCGLTC, <c_inferior); +#endif /* termios */ + +#ifdef HAVE_SGTTY + result = ioctl (0, TIOCSPGRP, &our_process_group); #endif -#ifdef TIOCLGET - result = ioctl (0, TIOCLGET, &lmode_inferior); + } + +#ifdef SIGTTOU + if (job_control) + signal (SIGTTOU, osigttou); #endif - } -#ifdef HAVE_TERMIO - sg_ours.c_lflag |= ICANON; - if (output_only && !(sg_inferior.c_lflag & ICANON)) - sg_ours.c_lflag &= ~ICANON; -#else /* not HAVE_TERMIO */ - sg_ours.sg_flags &= ~RAW & ~CBREAK; - if (output_only) - sg_ours.sg_flags |= (RAW | CBREAK) & sg_inferior.sg_flags; -#endif /* not HAVE_TERMIO */ + if (!job_control) + { + signal (SIGINT, sigint_ours); +#ifdef SIGQUIT + signal (SIGQUIT, sigquit_ours); +#endif + } - result = fcntl (0, F_SETFL, tflags_ours); - result = fcntl (0, F_SETFL, tflags_ours); - result = ioctl (0, TIOCSETN, &sg_ours); +#ifdef F_GETFL + tflags_inferior = fcntl (0, F_GETFL, 0); -#if defined(TIOCGETC) && !defined(TIOCGETC_BROKEN) - result = ioctl (0, TIOCSETC, &tc_ours); -#endif -#if defined(TIOCGLTC) && !defined(TIOCGLTC_BROKEN) - result = ioctl (0, TIOCSLTC, <c_ours); -#endif -#ifdef TIOCLGET - result = ioctl (0, TIOCLSET, &lmode_ours); + /* Is there a reason this is being done twice? It happens both + places we use F_SETFL, so I'm inclined to think perhaps there + is some reason, however perverse. Perhaps not though... */ + result = fcntl (0, F_SETFL, tflags_ours); + result = fcntl (0, F_SETFL, tflags_ours); #endif -#ifdef HAVE_TERMIO - sg_ours.c_lflag |= ICANON; -#else /* not HAVE_TERMIO */ - sg_ours.sg_flags &= ~RAW & ~CBREAK; -#endif /* not HAVE_TERMIO */ + result = result; /* lint */ + } } /* ARGSUSED */ void -term_info (arg, from_tty) - char *arg; - int from_tty; +term_info (char *arg, int from_tty) { target_terminal_info (arg, from_tty); } /* ARGSUSED */ void -child_terminal_info (args, from_tty) - char *args; - int from_tty; +child_terminal_info (char *args, int from_tty) { - register int i; - - if (!gdb_has_a_terminal) { - printf_filtered ("This GDB does not control a terminal.\n"); - return; - } + if (!gdb_has_a_terminal ()) + { + printf_filtered ("This GDB does not control a terminal.\n"); + return; + } -#ifdef TIOCGPGRP printf_filtered ("Inferior's terminal status (currently saved by GDB):\n"); - printf_filtered ("owner pgrp = %d, fcntl flags = 0x%x.\n", - pgrp_inferior, tflags_inferior); -#endif /* TIOCGPGRP */ - -#ifdef HAVE_TERMIO + /* First the fcntl flags. */ + { + int flags; - printf_filtered ("c_iflag = 0x%x, c_oflag = 0x%x,\n", - sg_inferior.c_iflag, sg_inferior.c_oflag); - printf_filtered ("c_cflag = 0x%x, c_lflag = 0x%x, c_line = 0x%x.\n", - sg_inferior.c_cflag, sg_inferior.c_lflag, sg_inferior.c_line); - printf_filtered ("c_cc: "); - for (i = 0; (i < NCC); i += 1) - printf_filtered ("0x%x ", sg_inferior.c_cc[i]); - printf_filtered ("\n"); + flags = tflags_inferior; -#else /* not HAVE_TERMIO */ + printf_filtered ("File descriptor flags = "); - printf_filtered ("sgttyb.sg_flags = 0x%x.\n", sg_inferior.sg_flags); +#ifndef O_ACCMODE +#define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR) +#endif + /* (O_ACCMODE) parens are to avoid Ultrix header file bug */ + switch (flags & (O_ACCMODE)) + { + case O_RDONLY: + printf_filtered ("O_RDONLY"); + break; + case O_WRONLY: + printf_filtered ("O_WRONLY"); + break; + case O_RDWR: + printf_filtered ("O_RDWR"); + break; + } + flags &= ~(O_ACCMODE); -#endif /* not HAVE_TERMIO */ +#ifdef O_NONBLOCK + if (flags & O_NONBLOCK) + printf_filtered (" | O_NONBLOCK"); + flags &= ~O_NONBLOCK; +#endif -#if defined(TIOCGETC) && !defined(TIOCGETC_BROKEN) - printf_filtered ("tchars: "); - for (i = 0; i < (int)sizeof (struct tchars); i++) - printf_filtered ("0x%x ", ((unsigned char *)&tc_inferior)[i]); - printf_filtered ("\n"); +#if defined (O_NDELAY) + /* If O_NDELAY and O_NONBLOCK are defined to the same thing, we will + print it as O_NONBLOCK, which is good cause that is what POSIX + has, and the flag will already be cleared by the time we get here. */ + if (flags & O_NDELAY) + printf_filtered (" | O_NDELAY"); + flags &= ~O_NDELAY; #endif -#if defined(TIOCGLTC) && !defined(TIOCGLTC_BROKEN) - printf_filtered ("ltchars: "); - for (i = 0; i < (int)sizeof (struct ltchars); i++) - printf_filtered ("0x%x ", ((unsigned char *)<c_inferior)[i]); - printf_filtered ("\n"); + if (flags & O_APPEND) + printf_filtered (" | O_APPEND"); + flags &= ~O_APPEND; + +#if defined (O_BINARY) + if (flags & O_BINARY) + printf_filtered (" | O_BINARY"); + flags &= ~O_BINARY; #endif - -#ifdef TIOCLGET - printf_filtered ("lmode: 0x%x\n", lmode_inferior); + + if (flags) + printf_filtered (" | 0x%x", flags); + printf_filtered ("\n"); + } + +#ifdef PROCESS_GROUP_TYPE + printf_filtered ("Process group = %d\n", + (int) inferior_process_group); #endif + + SERIAL_PRINT_TTY_STATE (stdin_serial, inferior_ttystate, gdb_stdout); } /* NEW_TTY_PREFORK is called before forking a new child process, @@ -356,8 +501,7 @@ child_terminal_info (args, from_tty) the terminal specified in the NEW_TTY_PREFORK call. */ void -new_tty_prefork (ttyname) - char *ttyname; +new_tty_prefork (char *ttyname) { /* Save the name for later, for determining whether we and the child are sharing a tty. */ @@ -365,191 +509,257 @@ new_tty_prefork (ttyname) } void -new_tty () +new_tty (void) { register int tty; if (inferior_thisrun_terminal == 0) return; - +#if !defined(__GO32__) && !defined(_WIN32) #ifdef TIOCNOTTY - /* Disconnect the child process from our controlling terminal. */ - tty = open("/dev/tty", O_RDWR); + /* Disconnect the child process from our controlling terminal. On some + systems (SVR4 for example), this may cause a SIGTTOU, so temporarily + ignore SIGTTOU. */ + tty = open ("/dev/tty", O_RDWR); if (tty > 0) { - ioctl(tty, TIOCNOTTY, 0); - close(tty); + void (*osigttou) (); + + osigttou = (void (*)()) signal (SIGTTOU, SIG_IGN); + ioctl (tty, TIOCNOTTY, 0); + close (tty); + signal (SIGTTOU, osigttou); } #endif /* Now open the specified new terminal. */ #ifdef USE_O_NOCTTY - tty = open(inferior_thisrun_terminal, O_RDWR | O_NOCTTY); + tty = open (inferior_thisrun_terminal, O_RDWR | O_NOCTTY); #else - tty = open(inferior_thisrun_terminal, O_RDWR); + tty = open (inferior_thisrun_terminal, O_RDWR); #endif if (tty == -1) { print_sys_errmsg (inferior_thisrun_terminal, errno); - _exit(1); + _exit (1); } /* Avoid use of dup2; doesn't exist on all systems. */ if (tty != 0) - { close (0); dup (tty); } + { + close (0); + dup (tty); + } if (tty != 1) - { close (1); dup (tty); } + { + close (1); + dup (tty); + } if (tty != 2) - { close (2); dup (tty); } + { + close (2); + dup (tty); + } if (tty > 2) - close(tty); + close (tty); +#endif /* !go32 && !win32 */ } /* Kill the inferior process. Make us have no inferior. */ /* ARGSUSED */ static void -kill_command (arg, from_tty) - char *arg; - int from_tty; +kill_command (char *arg, int from_tty) { + /* FIXME: This should not really be inferior_pid (or target_has_execution). + It should be a distinct flag that indicates that a target is active, cuz + some targets don't have processes! */ + if (inferior_pid == 0) error ("The program is not being run."); - if (!query ("Kill the inferior process? ")) + if (!query ("Kill the program being debugged? ")) error ("Not confirmed."); - target_kill (arg, from_tty); + target_kill (); + + init_thread_list (); /* Destroy thread info */ /* Killing off the inferior can leave us with a core file. If so, print the state we are left in. */ - if (target_has_stack) { - printf_filtered ("In %s,\n", current_target->to_longname); - if (selected_frame == NULL) - fputs_filtered ("No selected stack frame.\n", stdout); - else - print_stack_frame (selected_frame, selected_frame_level, 1); - } + if (target_has_stack) + { + printf_filtered ("In %s,\n", target_longname); + if (selected_frame == NULL) + fputs_filtered ("No selected stack frame.\n", gdb_stdout); + else + print_stack_frame (selected_frame, selected_frame_level, 1); + } +} + +/* Call set_sigint_trap when you need to pass a signal on to an attached + process when handling SIGINT */ + +/* ARGSUSED */ +static void +pass_signal (int signo) +{ +#ifndef _WIN32 + kill (PIDGET (inferior_pid), SIGINT); +#endif } -/* The inferior process has died. Long live the inferior! */ +static void (*osig) (); void -generic_mourn_inferior () +set_sigint_trap (void) { - inferior_pid = 0; - attach_flag = 0; - mark_breakpoints_out (); - registers_changed (); - -#ifdef CLEAR_DEFERRED_STORES - /* Delete any pending stores to the inferior... */ - CLEAR_DEFERRED_STORES; -#endif - - reopen_exec_file (); - if (target_has_stack) { - set_current_frame ( create_new_frame (read_register (FP_REGNUM), - read_pc ())); - select_frame (get_current_frame (), 0); - } else { - set_current_frame (0); - select_frame ((FRAME) 0, -1); - } - /* It is confusing to the user for ignore counts to stick around - from previous runs of the inferior. So clear them. */ - breakpoint_clear_ignore_counts (); + if (attach_flag || inferior_thisrun_terminal) + { + osig = (void (*)()) signal (SIGINT, pass_signal); + } } void -child_mourn_inferior () +clear_sigint_trap (void) { - unpush_target (&child_ops); - generic_mourn_inferior (); + if (attach_flag || inferior_thisrun_terminal) + { + signal (SIGINT, osig); + } } -#if 0 -/* This function is just for testing, and on some systems (Sony NewsOS - 3.2) also includes which leads to errors - (since on this system at least sys/time.h is not protected against - multiple inclusion). */ -/* ARGSUSED */ +#if defined (SIGIO) && defined (FASYNC) && defined (FD_SET) && defined (F_SETOWN) +static void (*old_sigio) (); + static void -try_writing_regs_command (arg, from_tty) - char *arg; - int from_tty; +handle_sigio (int signo) { - register int i; - register int value; + int numfds; + fd_set readfds; - if (inferior_pid == 0) - error ("There is no inferior process now."); - - /* A Sun 3/50 or 3/60 (at least) running SunOS 4.0.3 will have a - kernel panic if we try to write past the end of the user area. - Presumably Sun will fix this bug (it has been reported), but it - is tacky to crash the system, so at least on SunOS4 we need to - stop writing when we hit the end of the user area. */ - for (i = 0; i < sizeof (struct user); i += 2) + signal (SIGIO, handle_sigio); + + FD_ZERO (&readfds); + FD_SET (target_activity_fd, &readfds); + numfds = select (target_activity_fd + 1, &readfds, NULL, NULL, NULL); + if (numfds >= 0 && FD_ISSET (target_activity_fd, &readfds)) { - QUIT; - errno = 0; - value = call_ptrace (3, inferior_pid, i, 0); - call_ptrace (6, inferior_pid, i, value); - if (errno == 0) - { - printf (" Succeeded with address 0x%x; value 0x%x (%d).\n", - i, value, value); - } - else if ((i & 0377) == 0) - printf (" Failed at 0x%x.\n", i); +#ifndef _WIN32 + if ((*target_activity_function) ()) + kill (inferior_pid, SIGINT); +#endif } } -#endif - + +static int old_fcntl_flags; + void -_initialize_inflow () +set_sigio_trap (void) { - int result; + if (target_activity_function) + { + old_sigio = (void (*)()) signal (SIGIO, handle_sigio); + fcntl (target_activity_fd, F_SETOWN, getpid ()); + old_fcntl_flags = fcntl (target_activity_fd, F_GETFL, 0); + fcntl (target_activity_fd, F_SETFL, old_fcntl_flags | FASYNC); + } +} - add_info ("terminal", term_info, - "Print inferior's saved terminal status."); +void +clear_sigio_trap (void) +{ + if (target_activity_function) + { + signal (SIGIO, old_sigio); + fcntl (target_activity_fd, F_SETFL, old_fcntl_flags); + } +} +#else /* No SIGIO. */ +void +set_sigio_trap (void) +{ + if (target_activity_function) + internal_error (__FILE__, __LINE__, "failed internal consistency check"); +} -#if 0 - add_com ("try-writing-regs", class_obscure, try_writing_regs_command, - "Try writing all locations in inferior's system block.\n\ -Report which ones can be written."); -#endif +void +clear_sigio_trap (void) +{ + if (target_activity_function) + internal_error (__FILE__, __LINE__, "failed internal consistency check"); +} +#endif /* No SIGIO. */ + + +/* This is here because this is where we figure out whether we (probably) + have job control. Just using job_control only does part of it because + setpgid or setpgrp might not exist on a system without job control. + It might be considered misplaced (on the other hand, process groups and + job control are closely related to ttys). + + For a more clean implementation, in libiberty, put a setpgid which merely + calls setpgrp and a setpgrp which does nothing (any system with job control + will have one or the other). */ +int +gdb_setpgid (void) +{ + int retval = 0; + + if (job_control) + { +#if defined (NEED_POSIX_SETPGID) || (defined (HAVE_TERMIOS) && defined (HAVE_SETPGID)) + /* setpgid (0, 0) is supposed to work and mean the same thing as + this, but on Ultrix 4.2A it fails with EPERM (and + setpgid (getpid (), getpid ()) succeeds). */ + retval = setpgid (getpid (), getpid ()); +#else +#if defined (TIOCGPGRP) +#if defined(USG) && !defined(SETPGRP_ARGS) + retval = setpgrp (); +#else + retval = setpgrp (getpid (), getpid ()); +#endif /* USG */ +#endif /* TIOCGPGRP. */ +#endif /* NEED_POSIX_SETPGID */ + } + return retval; +} + +void +_initialize_inflow (void) +{ + add_info ("terminal", term_info, + "Print inferior's saved terminal status."); add_com ("kill", class_run, kill_command, "Kill execution of program being debugged."); inferior_pid = 0; - /* Get all the current tty settings (including whether we have a tty at - all!). */ + terminal_is_ours = 1; - tflags_ours = fcntl (0, F_GETFL, 0); - OOPSY ("fcntl F_GETFL"); /* Should always work */ + /* OK, figure out whether we have job control. If neither termios nor + sgtty (i.e. termio or go32), leave job_control 0. */ - result = ioctl (0, TIOCGETP, &sg_ours); - if (result == 0) { - gdb_has_a_terminal = 1; - /* Get the rest of the tty settings, then... */ -#if defined(TIOCGETC) && !defined(TIOCGETC_BROKEN) - ioctl (0, TIOCGETC, &tc_ours); -#endif -#if defined(TIOCGLTC) && !defined(TIOCGLTC_BROKEN) - ioctl (0, TIOCGLTC, <c_ours); -#endif -#ifdef TIOCLGET - ioctl (0, TIOCLGET, &lmode_ours); -#endif +#if defined (HAVE_TERMIOS) + /* Do all systems with termios have the POSIX way of identifying job + control? I hope so. */ +#ifdef _POSIX_JOB_CONTROL + job_control = 1; +#else +#ifdef _SC_JOB_CONTROL + job_control = sysconf (_SC_JOB_CONTROL); +#else + job_control = 0; /* have to assume the worst */ +#endif /* _SC_JOB_CONTROL */ +#endif /* _POSIX_JOB_CONTROL */ +#endif /* HAVE_TERMIOS */ + +#ifdef HAVE_SGTTY #ifdef TIOCGPGRP - ioctl (0, TIOCGPGRP, &pgrp_ours); + job_control = 1; +#else + job_control = 0; #endif /* TIOCGPGRP */ - } else { - gdb_has_a_terminal = 0; - } - - terminal_is_ours = 1; +#endif /* sgtty */ }