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