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       /* Ignore this signal since it will happen when we try to set the
 321          pgrp.  */
 322       void (*osigttou) ();
 323       int result;
 324
 325       terminal_is_ours = 1;
 326
 327 #ifdef SIGTTOU
 328       if (job_control)
 329         osigttou = (void (*)()) signal (SIGTTOU, SIG_IGN);
 330 #endif
 331
 332       if (inferior_ttystate)
 333         xfree (inferior_ttystate);
 334       inferior_ttystate = SERIAL_GET_TTY_STATE (stdin_serial);
 335 #ifdef HAVE_TERMIOS
 336       inferior_process_group = tcgetpgrp (0);
 337 #endif
 338 #ifdef HAVE_TERMIO
 339       inferior_process_group = getpgrp ();
 340 #endif
 341 #ifdef HAVE_SGTTY
 342       ioctl (0, TIOCGPGRP, &inferior_process_group);
 343 #endif
 344
 345       /* Here we used to set ICANON in our ttystate, but I believe this
 346          was an artifact from before when we used readline.  Readline sets
 347          the tty state when it needs to.
 348          FIXME-maybe: However, query() expects non-raw mode and doesn't
 349          use readline.  Maybe query should use readline (on the other hand,
 350          this only matters for HAVE_SGTTY, not termio or termios, I think).  */
 351
 352       /* Set tty state to our_ttystate.  We don't change in our out of raw
 353          mode, to avoid flushing input.  We need to do the same thing
 354          regardless of output_only, because we don't have separate
 355          terminal_is_ours and terminal_is_ours_for_output flags.  It's OK,
 356          though, since readline will deal with raw mode when/if it needs to.
 357        */
 358
 359       SERIAL_NOFLUSH_SET_TTY_STATE (stdin_serial, our_ttystate,
 360                                     inferior_ttystate);
 361
 362       if (job_control)
 363         {
 364 #ifdef HAVE_TERMIOS
 365           result = tcsetpgrp (0, our_process_group);
 366 #if 0
 367           /* This fails on Ultrix with EINVAL if you run the testsuite
 368              in the background with nohup, and then log out.  GDB never
 369              used to check for an error here, so perhaps there are other
 370              such situations as well.  */
 371           if (result == -1)
 372             fprintf_unfiltered (gdb_stderr, "[tcsetpgrp failed in terminal_ours: %s]\n",
 373                                 strerror (errno));
 374 #endif
 375 #endif /* termios */
 376
 377 #ifdef HAVE_SGTTY
 378           result = ioctl (0, TIOCSPGRP, &our_process_group);
 379 #endif
 380         }
 381
 382 #ifdef SIGTTOU
 383       if (job_control)
 384         signal (SIGTTOU, osigttou);
 385 #endif
 386
 387       if (!job_control)
 388         {
 389           signal (SIGINT, sigint_ours);
 390 #ifdef SIGQUIT
 391           signal (SIGQUIT, sigquit_ours);
 392 #endif
 393         }
 394
 395 #ifdef F_GETFL
 396       tflags_inferior = fcntl (0, F_GETFL, 0);
 397
 398       /* Is there a reason this is being done twice?  It happens both
 399          places we use F_SETFL, so I'm inclined to think perhaps there
 400          is some reason, however perverse.  Perhaps not though...  */
 401       result = fcntl (0, F_SETFL, tflags_ours);
 402       result = fcntl (0, F_SETFL, tflags_ours);
 403 #endif
 404
 405       result = result;          /* lint */
 406     }
 407 }
 408
 409 /* ARGSUSED */
 410 void
 411 term_info (char *arg, int from_tty)
 412 {
 413   target_terminal_info (arg, from_tty);
 414 }
 415
 416 /* ARGSUSED */
 417 void
 418 child_terminal_info (char *args, int from_tty)
 419 {
 420   if (!gdb_has_a_terminal ())
 421     {
 422       printf_filtered ("This GDB does not control a terminal.\n");
 423       return;
 424     }
 425
 426   printf_filtered ("Inferior's terminal status (currently saved by GDB):\n");
 427
 428   /* First the fcntl flags.  */
 429   {
 430     int flags;
 431
 432     flags = tflags_inferior;
 433
 434     printf_filtered ("File descriptor flags = ");
 435
 436 #ifndef O_ACCMODE
 437 #define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR)
 438 #endif
 439     /* (O_ACCMODE) parens are to avoid Ultrix header file bug */
 440     switch (flags & (O_ACCMODE))
 441       {
 442       case O_RDONLY:
 443         printf_filtered ("O_RDONLY");
 444         break;
 445       case O_WRONLY:
 446         printf_filtered ("O_WRONLY");
 447         break;
 448       case O_RDWR:
 449         printf_filtered ("O_RDWR");
 450         break;
 451       }
 452     flags &= ~(O_ACCMODE);
 453
 454 #ifdef O_NONBLOCK
 455     if (flags & O_NONBLOCK)
 456       printf_filtered (" | O_NONBLOCK");
 457     flags &= ~O_NONBLOCK;
 458 #endif
 459
 460 #if defined (O_NDELAY)
 461     /* If O_NDELAY and O_NONBLOCK are defined to the same thing, we will
 462        print it as O_NONBLOCK, which is good cause that is what POSIX
 463        has, and the flag will already be cleared by the time we get here.  */
 464     if (flags & O_NDELAY)
 465       printf_filtered (" | O_NDELAY");
 466     flags &= ~O_NDELAY;
 467 #endif
 468
 469     if (flags & O_APPEND)
 470       printf_filtered (" | O_APPEND");
 471     flags &= ~O_APPEND;
 472
 473 #if defined (O_BINARY)
 474     if (flags & O_BINARY)
 475       printf_filtered (" | O_BINARY");
 476     flags &= ~O_BINARY;
 477 #endif
 478
 479     if (flags)
 480       printf_filtered (" | 0x%x", flags);
 481     printf_filtered ("\n");
 482   }
 483
 484 #ifdef PROCESS_GROUP_TYPE
 485   printf_filtered ("Process group = %d\n",
 486                    (int) inferior_process_group);
 487 #endif
 488
 489   SERIAL_PRINT_TTY_STATE (stdin_serial, inferior_ttystate, gdb_stdout);
 490 }
 491 \f
 492 /* NEW_TTY_PREFORK is called before forking a new child process,
 493    so we can record the state of ttys in the child to be formed.
 494    TTYNAME is null if we are to share the terminal with gdb;
 495    or points to a string containing the name of the desired tty.
 496
 497    NEW_TTY is called in new child processes under Unix, which will
 498    become debugger target processes.  This actually switches to
 499    the terminal specified in the NEW_TTY_PREFORK call.  */
 500
 501 void
 502 new_tty_prefork (char *ttyname)
 503 {
 504   /* Save the name for later, for determining whether we and the child
 505      are sharing a tty.  */
 506   inferior_thisrun_terminal = ttyname;
 507 }
 508
 509 void
 510 new_tty (void)
 511 {
 512   register int tty;
 513
 514   if (inferior_thisrun_terminal == 0)
 515     return;
 516 #if !defined(__GO32__) && !defined(_WIN32)
 517 #ifdef TIOCNOTTY
 518   /* Disconnect the child process from our controlling terminal.  On some
 519      systems (SVR4 for example), this may cause a SIGTTOU, so temporarily
 520      ignore SIGTTOU. */
 521   tty = open ("/dev/tty", O_RDWR);
 522   if (tty > 0)
 523     {
 524       void (*osigttou) ();
 525
 526       osigttou = (void (*)()) signal (SIGTTOU, SIG_IGN);
 527       ioctl (tty, TIOCNOTTY, 0);
 528       close (tty);
 529       signal (SIGTTOU, osigttou);
 530     }
 531 #endif
 532
 533   /* Now open the specified new terminal.  */
 534
 535 #ifdef USE_O_NOCTTY
 536   tty = open (inferior_thisrun_terminal, O_RDWR | O_NOCTTY);
 537 #else
 538   tty = open (inferior_thisrun_terminal, O_RDWR);
 539 #endif
 540   if (tty == -1)
 541     {
 542       print_sys_errmsg (inferior_thisrun_terminal, errno);
 543       _exit (1);
 544     }
 545
 546   /* Avoid use of dup2; doesn't exist on all systems.  */
 547   if (tty != 0)
 548     {
 549       close (0);
 550       dup (tty);
 551     }
 552   if (tty != 1)
 553     {
 554       close (1);
 555       dup (tty);
 556     }
 557   if (tty != 2)
 558     {
 559       close (2);
 560       dup (tty);
 561     }
 562   if (tty > 2)
 563     close (tty);
 564 #endif /* !go32 && !win32 */
 565 }
 566 \f
 567 /* Kill the inferior process.  Make us have no inferior.  */
 568
 569 /* ARGSUSED */
 570 static void
 571 kill_command (char *arg, int from_tty)
 572 {
 573   /* FIXME:  This should not really be inferior_pid (or target_has_execution).
 574      It should be a distinct flag that indicates that a target is active, cuz
 575      some targets don't have processes! */
 576
 577   if (inferior_pid == 0)
 578     error ("The program is not being run.");
 579   if (!query ("Kill the program being debugged? "))
 580     error ("Not confirmed.");
 581   target_kill ();
 582
 583   init_thread_list ();          /* Destroy thread info */
 584
 585   /* Killing off the inferior can leave us with a core file.  If so,
 586      print the state we are left in.  */
 587   if (target_has_stack)
 588     {
 589       printf_filtered ("In %s,\n", target_longname);
 590       if (selected_frame == NULL)
 591         fputs_filtered ("No selected stack frame.\n", gdb_stdout);
 592       else
 593         print_stack_frame (selected_frame, selected_frame_level, 1);
 594     }
 595 }
 596 \f
 597 /* Call set_sigint_trap when you need to pass a signal on to an attached
 598    process when handling SIGINT */
 599
 600 /* ARGSUSED */
 601 static void
 602 pass_signal (int signo)
 603 {
 604 #ifndef _WIN32
 605   kill (PIDGET (inferior_pid), SIGINT);
 606 #endif
 607 }
 608
 609 static void (*osig) ();
 610
 611 void
 612 set_sigint_trap (void)
 613 {
 614   if (attach_flag || inferior_thisrun_terminal)
 615     {
 616       osig = (void (*)()) signal (SIGINT, pass_signal);
 617     }
 618 }
 619
 620 void
 621 clear_sigint_trap (void)
 622 {
 623   if (attach_flag || inferior_thisrun_terminal)
 624     {
 625       signal (SIGINT, osig);
 626     }
 627 }
 628 \f
 629 #if defined (SIGIO) && defined (FASYNC) && defined (FD_SET) && defined (F_SETOWN)
 630 static void (*old_sigio) ();
 631
 632 static void
 633 handle_sigio (int signo)
 634 {
 635   int numfds;
 636   fd_set readfds;
 637
 638   signal (SIGIO, handle_sigio);
 639
 640   FD_ZERO (&readfds);
 641   FD_SET (target_activity_fd, &readfds);
 642   numfds = select (target_activity_fd + 1, &readfds, NULL, NULL, NULL);
 643   if (numfds >= 0 && FD_ISSET (target_activity_fd, &readfds))
 644     {
 645 #ifndef _WIN32
 646       if ((*target_activity_function) ())
 647         kill (inferior_pid, SIGINT);
 648 #endif
 649     }
 650 }
 651
 652 static int old_fcntl_flags;
 653
 654 void
 655 set_sigio_trap (void)
 656 {
 657   if (target_activity_function)
 658     {
 659       old_sigio = (void (*)()) signal (SIGIO, handle_sigio);
 660       fcntl (target_activity_fd, F_SETOWN, getpid ());
 661       old_fcntl_flags = fcntl (target_activity_fd, F_GETFL, 0);
 662       fcntl (target_activity_fd, F_SETFL, old_fcntl_flags | FASYNC);
 663     }
 664 }
 665
 666 void
 667 clear_sigio_trap (void)
 668 {
 669   if (target_activity_function)
 670     {
 671       signal (SIGIO, old_sigio);
 672       fcntl (target_activity_fd, F_SETFL, old_fcntl_flags);
 673     }
 674 }
 675 #else /* No SIGIO.  */
 676 void
 677 set_sigio_trap (void)
 678 {
 679   if (target_activity_function)
 680     abort ();
 681 }
 682
 683 void
 684 clear_sigio_trap (void)
 685 {
 686   if (target_activity_function)
 687     abort ();
 688 }
 689 #endif /* No SIGIO.  */
 690 \f
 691
 692 /* This is here because this is where we figure out whether we (probably)
 693    have job control.  Just using job_control only does part of it because
 694    setpgid or setpgrp might not exist on a system without job control.
 695    It might be considered misplaced (on the other hand, process groups and
 696    job control are closely related to ttys).
 697
 698    For a more clean implementation, in libiberty, put a setpgid which merely
 699    calls setpgrp and a setpgrp which does nothing (any system with job control
 700    will have one or the other).  */
 701 int
 702 gdb_setpgid (void)
 703 {
 704   int retval = 0;
 705
 706   if (job_control)
 707     {
 708 #if defined (NEED_POSIX_SETPGID) || (defined (HAVE_TERMIOS) && defined (HAVE_SETPGID))
 709       /* setpgid (0, 0) is supposed to work and mean the same thing as
 710          this, but on Ultrix 4.2A it fails with EPERM (and
 711          setpgid (getpid (), getpid ()) succeeds).  */
 712       retval = setpgid (getpid (), getpid ());
 713 #else
 714 #if defined (TIOCGPGRP)
 715 #if defined(USG) && !defined(SETPGRP_ARGS)
 716       retval = setpgrp ();
 717 #else
 718       retval = setpgrp (getpid (), getpid ());
 719 #endif /* USG */
 720 #endif /* TIOCGPGRP.  */
 721 #endif /* NEED_POSIX_SETPGID */
 722     }
 723   return retval;
 724 }
 725
 726 void
 727 _initialize_inflow (void)
 728 {
 729   add_info ("terminal", term_info,
 730             "Print inferior's saved terminal status.");
 731
 732   add_com ("kill", class_run, kill_command,
 733            "Kill execution of program being debugged.");
 734
 735   inferior_pid = 0;
 736
 737   terminal_is_ours = 1;
 738
 739   /* OK, figure out whether we have job control.  If neither termios nor
 740      sgtty (i.e. termio or go32), leave job_control 0.  */
 741
 742 #if defined (HAVE_TERMIOS)
 743   /* Do all systems with termios have the POSIX way of identifying job
 744      control?  I hope so.  */
 745 #ifdef _POSIX_JOB_CONTROL
 746   job_control = 1;
 747 #else
 748 #ifdef _SC_JOB_CONTROL
 749   job_control = sysconf (_SC_JOB_CONTROL);
 750 #else
 751   job_control = 0;              /* have to assume the worst */
 752 #endif /* _SC_JOB_CONTROL */
 753 #endif /* _POSIX_JOB_CONTROL */
 754 #endif /* HAVE_TERMIOS */
 755
 756 #ifdef HAVE_SGTTY
 757 #ifdef TIOCGPGRP
 758   job_control = 1;
 759 #else
 760   job_control = 0;
 761 #endif /* TIOCGPGRP */
 762 #endif /* sgtty */
 763 }