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