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