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