gdb/inflow.c

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