gdb/inflow.c

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