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 (scb->fd, 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 (scb->fd, 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           OOPSY ("tcsetpgrp");
 329 #endif
 330
 331 #ifdef HAVE_SGTTY
 332           result = ioctl (0, TIOCSPGRP, our_process_group);
 333           OOPSY ("TIOCSPGRP");
 334 #endif
 335         }
 336
 337 #ifdef SIGTTOU
 338       if (job_control)
 339         signal (SIGTTOU, osigttou);
 340 #endif
 341
 342       if (!job_control)
 343         {
 344           signal (SIGINT, sigint_ours);
 345           signal (SIGQUIT, sigquit_ours);
 346         }
 347
 348 #ifdef F_GETFL
 349       tflags_inferior = fcntl (0, F_GETFL, 0);
 350
 351       /* Is there a reason this is being done twice?  It happens both
 352          places we use F_SETFL, so I'm inclined to think perhaps there
 353          is some reason, however perverse.  Perhaps not though...  */
 354       result = fcntl (0, F_SETFL, tflags_ours);
 355       result = fcntl (0, F_SETFL, tflags_ours);
 356 #endif
 357
 358       result = result;  /* lint */
 359     }
 360 }
 361
 362 /* ARGSUSED */
 363 void
 364 term_info (arg, from_tty)
 365      char *arg;
 366      int from_tty;
 367 {
 368   target_terminal_info (arg, from_tty);
 369 }
 370
 371 /* ARGSUSED */
 372 void
 373 child_terminal_info (args, from_tty)
 374      char *args;
 375      int from_tty;
 376 {
 377   if (!gdb_has_a_terminal ())
 378     {
 379       printf_filtered ("This GDB does not control a terminal.\n");
 380       return;
 381     }
 382
 383   printf_filtered ("Inferior's terminal status (currently saved by GDB):\n");
 384
 385   /* First the fcntl flags.  */
 386   {
 387     int flags;
 388
 389     flags = tflags_inferior;
 390
 391     printf_filtered ("File descriptor flags = ");
 392
 393 #ifndef O_ACCMODE
 394 #define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR)
 395 #endif
 396     /* (O_ACCMODE) parens are to avoid Ultrix header file bug */
 397     switch (flags & (O_ACCMODE))
 398       {
 399       case O_RDONLY: printf_filtered ("O_RDONLY"); break;
 400       case O_WRONLY: printf_filtered ("O_WRONLY"); break;
 401       case O_RDWR: printf_filtered ("O_RDWR"); break;
 402       }
 403     flags &= ~(O_ACCMODE);
 404
 405 #ifdef O_NONBLOCK
 406     if (flags & O_NONBLOCK)
 407       printf_filtered (" | O_NONBLOCK");
 408     flags &= ~O_NONBLOCK;
 409 #endif
 410
 411 #if defined (O_NDELAY)
 412     /* If O_NDELAY and O_NONBLOCK are defined to the same thing, we will
 413        print it as O_NONBLOCK, which is good cause that is what POSIX
 414        has, and the flag will already be cleared by the time we get here.  */
 415     if (flags & O_NDELAY)
 416       printf_filtered (" | O_NDELAY");
 417     flags &= ~O_NDELAY;
 418 #endif
 419
 420     if (flags & O_APPEND)
 421       printf_filtered (" | O_APPEND");
 422     flags &= ~O_APPEND;
 423
 424 #if defined (O_BINARY)
 425     if (flags & O_BINARY)
 426       printf_filtered (" | O_BINARY");
 427     flags &= ~O_BINARY;
 428 #endif
 429
 430     if (flags)
 431       printf_filtered (" | 0x%x", flags);
 432     printf_filtered ("\n");
 433   }
 434
 435 #ifdef PROCESS_GROUP_TYPE
 436   printf_filtered ("Process group = %d\n", inferior_process_group);
 437 #endif
 438
 439   SERIAL_PRINT_TTY_STATE (stdin_serial, inferior_ttystate);
 440 }
 441 \f
 442 /* NEW_TTY_PREFORK is called before forking a new child process,
 443    so we can record the state of ttys in the child to be formed.
 444    TTYNAME is null if we are to share the terminal with gdb;
 445    or points to a string containing the name of the desired tty.
 446
 447    NEW_TTY is called in new child processes under Unix, which will
 448    become debugger target processes.  This actually switches to
 449    the terminal specified in the NEW_TTY_PREFORK call.  */
 450
 451 void
 452 new_tty_prefork (ttyname)
 453      char *ttyname;
 454 {
 455   /* Save the name for later, for determining whether we and the child
 456      are sharing a tty.  */
 457   inferior_thisrun_terminal = ttyname;
 458 }
 459
 460 void
 461 new_tty ()
 462 {
 463   register int tty;
 464
 465   if (inferior_thisrun_terminal == 0)
 466     return;
 467 #if !defined(__GO32__)
 468 #ifdef TIOCNOTTY
 469   /* Disconnect the child process from our controlling terminal.  On some
 470      systems (SVR4 for example), this may cause a SIGTTOU, so temporarily
 471      ignore SIGTTOU. */
 472   tty = open("/dev/tty", O_RDWR);
 473   if (tty > 0)
 474     {
 475       void (*osigttou) ();
 476
 477       osigttou = (void (*)()) signal(SIGTTOU, SIG_IGN);
 478       ioctl(tty, TIOCNOTTY, 0);
 479       close(tty);
 480       signal(SIGTTOU, osigttou);
 481     }
 482 #endif
 483
 484   /* Now open the specified new terminal.  */
 485
 486 #ifdef USE_O_NOCTTY
 487   tty = open(inferior_thisrun_terminal, O_RDWR | O_NOCTTY);
 488 #else
 489   tty = open(inferior_thisrun_terminal, O_RDWR);
 490 #endif
 491   if (tty == -1)
 492     {
 493       print_sys_errmsg (inferior_thisrun_terminal, errno);
 494       _exit(1);
 495     }
 496
 497   /* Avoid use of dup2; doesn't exist on all systems.  */
 498   if (tty != 0)
 499     { close (0); dup (tty); }
 500   if (tty != 1)
 501     { close (1); dup (tty); }
 502   if (tty != 2)
 503     { close (2); dup (tty); }
 504   if (tty > 2)
 505     close(tty);
 506 #endif /* !go32 */
 507 }
 508 \f
 509 /* Kill the inferior process.  Make us have no inferior.  */
 510
 511 /* ARGSUSED */
 512 static void
 513 kill_command (arg, from_tty)
 514      char *arg;
 515      int from_tty;
 516 {
 517   /* Shouldn't this be target_has_execution?  FIXME.  */
 518   if (inferior_pid == 0)
 519     error ("The program is not being run.");
 520   if (!query ("Kill the program being debugged? "))
 521     error ("Not confirmed.");
 522   target_kill ();
 523
 524   /* Killing off the inferior can leave us with a core file.  If so,
 525      print the state we are left in.  */
 526   if (target_has_stack) {
 527     printf_filtered ("In %s,\n", current_target->to_longname);
 528     if (selected_frame == NULL)
 529       fputs_filtered ("No selected stack frame.\n", stdout);
 530     else
 531       print_stack_frame (selected_frame, selected_frame_level, 1);
 532   }
 533 }
 534
 535 /* The inferior process has died.  Long live the inferior!  */
 536
 537 void
 538 generic_mourn_inferior ()
 539 {
 540   inferior_pid = 0;
 541   attach_flag = 0;
 542   breakpoint_init_inferior ();
 543   registers_changed ();
 544
 545 #ifdef CLEAR_DEFERRED_STORES
 546   /* Delete any pending stores to the inferior... */
 547   CLEAR_DEFERRED_STORES;
 548 #endif
 549
 550   reopen_exec_file ();
 551   reinit_frame_cache ();
 552
 553   /* It is confusing to the user for ignore counts to stick around
 554      from previous runs of the inferior.  So clear them.  */
 555   breakpoint_clear_ignore_counts ();
 556 }
 557 \f
 558 /* Call set_sigint_trap when you need to pass a signal on to an attached
 559    process when handling SIGINT */
 560
 561 /* ARGSUSED */
 562 static void
 563 pass_signal (signo)
 564     int signo;
 565 {
 566   kill (inferior_pid, SIGINT);
 567 }
 568
 569 static void (*osig)();
 570
 571 void
 572 set_sigint_trap()
 573 {
 574   osig = (void (*) ()) signal (SIGINT, pass_signal);
 575 }
 576
 577 void
 578 clear_sigint_trap()
 579 {
 580   signal (SIGINT, osig);
 581 }
 582 \f
 583
 584 int job_control;
 585
 586 /* This is here because this is where we figure out whether we (probably)
 587    have job control.  Just using job_control only does part of it because
 588    setpgid or setpgrp might not exist on a system without job control.
 589    It might be considered misplaced (on the other hand, process groups and
 590    job control are closely related to ttys).
 591
 592    For a more clean implementation, in libiberty, put a setpgid which merely
 593    calls setpgrp and a setpgrp which does nothing (any system with job control
 594    will have one or the other).  */
 595 int
 596 gdb_setpgid ()
 597 {
 598   int retval = 0;
 599   if (job_control)
 600     {
 601 #if defined (NEED_POSIX_SETPGID) || defined (HAVE_TERMIOS)
 602       /* Do all systems with termios have setpgid?  I hope so.  */
 603       /* setpgid (0, 0) is supposed to work and mean the same thing as
 604          this, but on Ultrix 4.2A it fails with EPERM (and
 605          setpgid (getpid (), getpid ()) succeeds).  */
 606       retval = setpgid (getpid (), getpid ());
 607 #else
 608 #if defined (TIOCGPGRP)
 609 #if defined(USG) && !defined(SETPGRP_ARGS)
 610       retval = setpgrp ();
 611 #else
 612       retval = setpgrp (getpid (), getpid ());
 613 #endif /* USG */
 614 #endif /* TIOCGPGRP.  */
 615 #endif /* NEED_POSIX_SETPGID */
 616     }
 617   return retval;
 618 }
 619
 620 void
 621 _initialize_inflow ()
 622 {
 623   add_info ("terminal", term_info,
 624            "Print inferior's saved terminal status.");
 625
 626   add_com ("kill", class_run, kill_command,
 627            "Kill execution of program being debugged.");
 628
 629   inferior_pid = 0;
 630
 631   terminal_is_ours = 1;
 632
 633   /* OK, figure out whether we have job control.  If neither termios nor
 634      sgtty (i.e. termio or go32), leave job_control 0.  */
 635
 636 #if defined (HAVE_TERMIOS)
 637   /* Do all systems with termios have the POSIX way of identifying job
 638      control?  I hope so.  */
 639 #ifdef _POSIX_JOB_CONTROL
 640   job_control = 1;
 641 #else
 642   job_control = sysconf (_SC_JOB_CONTROL);
 643 #endif
 644 #endif /* termios */
 645
 646 #ifdef HAVE_SGTTY
 647 #ifdef TIOCGPGRP
 648   job_control = 1;
 649 #else
 650   job_control = 0;
 651 #endif /* TIOCGPGRP */
 652 #endif /* sgtty */
 653 }