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