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