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       result = result;          /* lint */
 413     }
 414 }
 415
 416 void
 417 term_info (char *arg, int from_tty)
 418 {
 419   target_terminal_info (arg, from_tty);
 420 }
 421
 422 void
 423 child_terminal_info (char *args, int from_tty)
 424 {
 425   if (!gdb_has_a_terminal ())
 426     {
 427       printf_filtered (_("This GDB does not control a terminal.\n"));
 428       return;
 429     }
 430
 431   printf_filtered (_("Inferior's terminal status (currently saved by GDB):\n"));
 432
 433   /* First the fcntl flags.  */
 434   {
 435     int flags;
 436
 437     flags = tflags_inferior;
 438
 439     printf_filtered ("File descriptor flags = ");
 440
 441 #ifndef O_ACCMODE
 442 #define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR)
 443 #endif
 444     /* (O_ACCMODE) parens are to avoid Ultrix header file bug */
 445     switch (flags & (O_ACCMODE))
 446       {
 447       case O_RDONLY:
 448         printf_filtered ("O_RDONLY");
 449         break;
 450       case O_WRONLY:
 451         printf_filtered ("O_WRONLY");
 452         break;
 453       case O_RDWR:
 454         printf_filtered ("O_RDWR");
 455         break;
 456       }
 457     flags &= ~(O_ACCMODE);
 458
 459 #ifdef O_NONBLOCK
 460     if (flags & O_NONBLOCK)
 461       printf_filtered (" | O_NONBLOCK");
 462     flags &= ~O_NONBLOCK;
 463 #endif
 464
 465 #if defined (O_NDELAY)
 466     /* If O_NDELAY and O_NONBLOCK are defined to the same thing, we will
 467        print it as O_NONBLOCK, which is good cause that is what POSIX
 468        has, and the flag will already be cleared by the time we get here.  */
 469     if (flags & O_NDELAY)
 470       printf_filtered (" | O_NDELAY");
 471     flags &= ~O_NDELAY;
 472 #endif
 473
 474     if (flags & O_APPEND)
 475       printf_filtered (" | O_APPEND");
 476     flags &= ~O_APPEND;
 477
 478 #if defined (O_BINARY)
 479     if (flags & O_BINARY)
 480       printf_filtered (" | O_BINARY");
 481     flags &= ~O_BINARY;
 482 #endif
 483
 484     if (flags)
 485       printf_filtered (" | 0x%x", flags);
 486     printf_filtered ("\n");
 487   }
 488
 489 #ifdef PROCESS_GROUP_TYPE
 490   printf_filtered ("Process group = %d\n",
 491                    (int) inferior_process_group);
 492 #endif
 493
 494   serial_print_tty_state (stdin_serial, inferior_ttystate, gdb_stdout);
 495 }
 496 \f
 497 /* NEW_TTY_PREFORK is called before forking a new child process,
 498    so we can record the state of ttys in the child to be formed.
 499    TTYNAME is null if we are to share the terminal with gdb;
 500    or points to a string containing the name of the desired tty.
 501
 502    NEW_TTY is called in new child processes under Unix, which will
 503    become debugger target processes.  This actually switches to
 504    the terminal specified in the NEW_TTY_PREFORK call.  */
 505
 506 void
 507 new_tty_prefork (const char *ttyname)
 508 {
 509   /* Save the name for later, for determining whether we and the child
 510      are sharing a tty.  */
 511   inferior_thisrun_terminal = ttyname;
 512 }
 513
 514 void
 515 new_tty (void)
 516 {
 517   int tty;
 518
 519   if (inferior_thisrun_terminal == 0)
 520     return;
 521 #if !defined(__GO32__) && !defined(_WIN32)
 522 #ifdef TIOCNOTTY
 523   /* Disconnect the child process from our controlling terminal.  On some
 524      systems (SVR4 for example), this may cause a SIGTTOU, so temporarily
 525      ignore SIGTTOU. */
 526   tty = open ("/dev/tty", O_RDWR);
 527   if (tty > 0)
 528     {
 529       void (*osigttou) ();
 530
 531       osigttou = (void (*)()) signal (SIGTTOU, SIG_IGN);
 532       ioctl (tty, TIOCNOTTY, 0);
 533       close (tty);
 534       signal (SIGTTOU, osigttou);
 535     }
 536 #endif
 537
 538   /* Now open the specified new terminal.  */
 539   tty = open (inferior_thisrun_terminal, O_RDWR | O_NOCTTY);
 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 static void
 570 kill_command (char *arg, int from_tty)
 571 {
 572   /* FIXME:  This should not really be inferior_ptid (or target_has_execution).
 573      It should be a distinct flag that indicates that a target is active, cuz
 574      some targets don't have processes! */
 575
 576   if (ptid_equal (inferior_ptid, null_ptid))
 577     error (_("The program is not being run."));
 578   if (!query ("Kill the program being debugged? "))
 579     error (_("Not confirmed."));
 580   target_kill ();
 581
 582   init_thread_list ();          /* Destroy thread info */
 583
 584   /* Killing off the inferior can leave us with a core file.  If so,
 585      print the state we are left in.  */
 586   if (target_has_stack)
 587     {
 588       printf_filtered (_("In %s,\n"), target_longname);
 589       print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
 590     }
 591   bfd_cache_close_all ();
 592 }
 593 \f
 594 /* Call set_sigint_trap when you need to pass a signal on to an attached
 595    process when handling SIGINT */
 596
 597 static void
 598 pass_signal (int signo)
 599 {
 600 #ifndef _WIN32
 601   kill (PIDGET (inferior_ptid), SIGINT);
 602 #endif
 603 }
 604
 605 static void (*osig) ();
 606
 607 void
 608 set_sigint_trap (void)
 609 {
 610   if (attach_flag || inferior_thisrun_terminal)
 611     {
 612       osig = (void (*)()) signal (SIGINT, pass_signal);
 613     }
 614 }
 615
 616 void
 617 clear_sigint_trap (void)
 618 {
 619   if (attach_flag || inferior_thisrun_terminal)
 620     {
 621       signal (SIGINT, osig);
 622     }
 623 }
 624 \f
 625 #if defined (SIGIO) && defined (FASYNC) && defined (FD_SET) && defined (F_SETOWN)
 626 static void (*old_sigio) ();
 627
 628 static void
 629 handle_sigio (int signo)
 630 {
 631   int numfds;
 632   fd_set readfds;
 633
 634   signal (SIGIO, handle_sigio);
 635
 636   FD_ZERO (&readfds);
 637   FD_SET (target_activity_fd, &readfds);
 638   numfds = gdb_select (target_activity_fd + 1, &readfds, NULL, NULL, NULL);
 639   if (numfds >= 0 && FD_ISSET (target_activity_fd, &readfds))
 640     {
 641 #ifndef _WIN32
 642       if ((*target_activity_function) ())
 643         kill (PIDGET (inferior_ptid), SIGINT);
 644 #endif
 645     }
 646 }
 647
 648 static int old_fcntl_flags;
 649
 650 void
 651 set_sigio_trap (void)
 652 {
 653   if (target_activity_function)
 654     {
 655       old_sigio = (void (*)()) signal (SIGIO, handle_sigio);
 656       fcntl (target_activity_fd, F_SETOWN, getpid ());
 657       old_fcntl_flags = fcntl (target_activity_fd, F_GETFL, 0);
 658       fcntl (target_activity_fd, F_SETFL, old_fcntl_flags | FASYNC);
 659     }
 660 }
 661
 662 void
 663 clear_sigio_trap (void)
 664 {
 665   if (target_activity_function)
 666     {
 667       signal (SIGIO, old_sigio);
 668       fcntl (target_activity_fd, F_SETFL, old_fcntl_flags);
 669     }
 670 }
 671 #else /* No SIGIO.  */
 672 void
 673 set_sigio_trap (void)
 674 {
 675   if (target_activity_function)
 676     internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
 677 }
 678
 679 void
 680 clear_sigio_trap (void)
 681 {
 682   if (target_activity_function)
 683     internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
 684 }
 685 #endif /* No SIGIO.  */
 686 \f
 687
 688 /* This is here because this is where we figure out whether we (probably)
 689    have job control.  Just using job_control only does part of it because
 690    setpgid or setpgrp might not exist on a system without job control.
 691    It might be considered misplaced (on the other hand, process groups and
 692    job control are closely related to ttys).
 693
 694    For a more clean implementation, in libiberty, put a setpgid which merely
 695    calls setpgrp and a setpgrp which does nothing (any system with job control
 696    will have one or the other).  */
 697 int
 698 gdb_setpgid (void)
 699 {
 700   int retval = 0;
 701
 702   if (job_control)
 703     {
 704 #if defined (HAVE_TERMIOS) || defined (TIOCGPGRP)
 705 #ifdef HAVE_SETPGID
 706       /* The call setpgid (0, 0) is supposed to work and mean the same
 707          thing as this, but on Ultrix 4.2A it fails with EPERM (and
 708          setpgid (getpid (), getpid ()) succeeds).  */
 709       retval = setpgid (getpid (), getpid ());
 710 #else
 711 #ifdef HAVE_SETPGRP
 712 #ifdef SETPGRP_VOID
 713       retval = setpgrp ();
 714 #else
 715       retval = setpgrp (getpid (), getpid ());
 716 #endif
 717 #endif /* HAVE_SETPGRP */
 718 #endif /* HAVE_SETPGID */
 719 #endif /* defined (HAVE_TERMIOS) || defined (TIOCGPGRP) */
 720     }
 721
 722   return retval;
 723 }
 724
 725 /* Get all the current tty settings (including whether we have a
 726    tty at all!).  We can't do this in _initialize_inflow because
 727    serial_fdopen() won't work until the serial_ops_list is
 728    initialized, but we don't want to do it lazily either, so
 729    that we can guarantee stdin_serial is opened if there is
 730    a terminal.  */
 731 void
 732 initialize_stdin_serial (void)
 733 {
 734   stdin_serial = serial_fdopen (0);
 735 }
 736
 737 void
 738 _initialize_inflow (void)
 739 {
 740   add_info ("terminal", term_info,
 741             _("Print inferior's saved terminal status."));
 742
 743   add_com ("kill", class_run, kill_command,
 744            _("Kill execution of program being debugged."));
 745
 746   inferior_ptid = null_ptid;
 747
 748   terminal_is_ours = 1;
 749
 750   /* OK, figure out whether we have job control.  If neither termios nor
 751      sgtty (i.e. termio or go32), leave job_control 0.  */
 752
 753 #if defined (HAVE_TERMIOS)
 754   /* Do all systems with termios have the POSIX way of identifying job
 755      control?  I hope so.  */
 756 #ifdef _POSIX_JOB_CONTROL
 757   job_control = 1;
 758 #else
 759 #ifdef _SC_JOB_CONTROL
 760   job_control = sysconf (_SC_JOB_CONTROL);
 761 #else
 762   job_control = 0;              /* have to assume the worst */
 763 #endif /* _SC_JOB_CONTROL */
 764 #endif /* _POSIX_JOB_CONTROL */
 765 #endif /* HAVE_TERMIOS */
 766
 767 #ifdef HAVE_SGTTY
 768 #ifdef TIOCGPGRP
 769   job_control = 1;
 770 #else
 771   job_control = 0;
 772 #endif /* TIOCGPGRP */
 773 #endif /* sgtty */
 774 }