gdb/inflow.c

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