gdb/inflow.c

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