OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [inflow.c] - Blame information for rev 157

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* 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
 
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
 
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 131 jeremybenn
/* JPB: Some picky Ubuntu GCC compilers don't like the result of dup being
513
   ignored (even if you cast it to void). So capture the value and ignore
514
   THAT. */
515 24 jeremybenn
void
516
new_tty (void)
517
{
518 131 jeremybenn
  int  res;                     /* For dup result */
519 24 jeremybenn
  int tty;
520
 
521
  if (inferior_thisrun_terminal == 0)
522
    return;
523
#if !defined(__GO32__) && !defined(_WIN32)
524
#ifdef TIOCNOTTY
525
  /* Disconnect the child process from our controlling terminal.  On some
526
     systems (SVR4 for example), this may cause a SIGTTOU, so temporarily
527
     ignore SIGTTOU. */
528
  tty = open ("/dev/tty", O_RDWR);
529
  if (tty > 0)
530
    {
531
      void (*osigttou) ();
532
 
533
      osigttou = (void (*)()) signal (SIGTTOU, SIG_IGN);
534
      ioctl (tty, TIOCNOTTY, 0);
535
      close (tty);
536
      signal (SIGTTOU, osigttou);
537
    }
538
#endif
539
 
540
  /* Now open the specified new terminal.  */
541
  tty = open (inferior_thisrun_terminal, O_RDWR | O_NOCTTY);
542
  if (tty == -1)
543
    {
544
      print_sys_errmsg (inferior_thisrun_terminal, errno);
545
      _exit (1);
546
    }
547
 
548
  /* Avoid use of dup2; doesn't exist on all systems.  */
549
  if (tty != 0)
550
    {
551
      close (0);
552 131 jeremybenn
      res = dup (tty);
553 24 jeremybenn
    }
554
  if (tty != 1)
555
    {
556
      close (1);
557 131 jeremybenn
      res = dup (tty);
558 24 jeremybenn
    }
559
  if (tty != 2)
560
    {
561
      close (2);
562 131 jeremybenn
      res = dup (tty);
563 24 jeremybenn
    }
564
  if (tty > 2)
565
    close (tty);
566
#endif /* !go32 && !win32 */
567
}
568
 
569
/* Kill the inferior process.  Make us have no inferior.  */
570
 
571
static void
572
kill_command (char *arg, int from_tty)
573
{
574
  /* FIXME:  This should not really be inferior_ptid (or target_has_execution).
575
     It should be a distinct flag that indicates that a target is active, cuz
576
     some targets don't have processes! */
577
 
578
  if (ptid_equal (inferior_ptid, null_ptid))
579
    error (_("The program is not being run."));
580
  if (!query ("Kill the program being debugged? "))
581
    error (_("Not confirmed."));
582
  target_kill ();
583
 
584
  init_thread_list ();          /* Destroy thread info */
585
 
586
  /* Killing off the inferior can leave us with a core file.  If so,
587
     print the state we are left in.  */
588
  if (target_has_stack)
589
    {
590
      printf_filtered (_("In %s,\n"), target_longname);
591
      print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
592
    }
593
  bfd_cache_close_all ();
594
}
595
 
596
/* Call set_sigint_trap when you need to pass a signal on to an attached
597
   process when handling SIGINT */
598
 
599
static void
600
pass_signal (int signo)
601
{
602
#ifndef _WIN32
603
  kill (PIDGET (inferior_ptid), SIGINT);
604
#endif
605
}
606
 
607
static void (*osig) ();
608
 
609
void
610
set_sigint_trap (void)
611
{
612
  if (attach_flag || inferior_thisrun_terminal)
613
    {
614
      osig = (void (*)()) signal (SIGINT, pass_signal);
615
    }
616
}
617
 
618
void
619
clear_sigint_trap (void)
620
{
621
  if (attach_flag || inferior_thisrun_terminal)
622
    {
623
      signal (SIGINT, osig);
624
    }
625
}
626
 
627
#if defined (SIGIO) && defined (FASYNC) && defined (FD_SET) && defined (F_SETOWN)
628
static void (*old_sigio) ();
629
 
630
static void
631
handle_sigio (int signo)
632
{
633
  int numfds;
634
  fd_set readfds;
635
 
636
  signal (SIGIO, handle_sigio);
637
 
638
  FD_ZERO (&readfds);
639
  FD_SET (target_activity_fd, &readfds);
640
  numfds = gdb_select (target_activity_fd + 1, &readfds, NULL, NULL, NULL);
641
  if (numfds >= 0 && FD_ISSET (target_activity_fd, &readfds))
642
    {
643
#ifndef _WIN32
644
      if ((*target_activity_function) ())
645
        kill (PIDGET (inferior_ptid), SIGINT);
646
#endif
647
    }
648
}
649
 
650
static int old_fcntl_flags;
651
 
652
void
653
set_sigio_trap (void)
654
{
655
  if (target_activity_function)
656
    {
657
      old_sigio = (void (*)()) signal (SIGIO, handle_sigio);
658
      fcntl (target_activity_fd, F_SETOWN, getpid ());
659
      old_fcntl_flags = fcntl (target_activity_fd, F_GETFL, 0);
660
      fcntl (target_activity_fd, F_SETFL, old_fcntl_flags | FASYNC);
661
    }
662
}
663
 
664
void
665
clear_sigio_trap (void)
666
{
667
  if (target_activity_function)
668
    {
669
      signal (SIGIO, old_sigio);
670
      fcntl (target_activity_fd, F_SETFL, old_fcntl_flags);
671
    }
672
}
673
#else /* No SIGIO.  */
674
void
675
set_sigio_trap (void)
676
{
677
  if (target_activity_function)
678
    internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
679
}
680
 
681
void
682
clear_sigio_trap (void)
683
{
684
  if (target_activity_function)
685
    internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
686
}
687
#endif /* No SIGIO.  */
688
 
689
 
690
/* This is here because this is where we figure out whether we (probably)
691
   have job control.  Just using job_control only does part of it because
692
   setpgid or setpgrp might not exist on a system without job control.
693
   It might be considered misplaced (on the other hand, process groups and
694
   job control are closely related to ttys).
695
 
696
   For a more clean implementation, in libiberty, put a setpgid which merely
697
   calls setpgrp and a setpgrp which does nothing (any system with job control
698
   will have one or the other).  */
699
int
700
gdb_setpgid (void)
701
{
702
  int retval = 0;
703
 
704
  if (job_control)
705
    {
706
#if defined (HAVE_TERMIOS) || defined (TIOCGPGRP)
707
#ifdef HAVE_SETPGID
708
      /* The call setpgid (0, 0) is supposed to work and mean the same
709
         thing as this, but on Ultrix 4.2A it fails with EPERM (and
710
         setpgid (getpid (), getpid ()) succeeds).  */
711
      retval = setpgid (getpid (), getpid ());
712
#else
713
#ifdef HAVE_SETPGRP
714
#ifdef SETPGRP_VOID 
715
      retval = setpgrp ();
716
#else
717
      retval = setpgrp (getpid (), getpid ());
718
#endif
719
#endif /* HAVE_SETPGRP */
720
#endif /* HAVE_SETPGID */
721
#endif /* defined (HAVE_TERMIOS) || defined (TIOCGPGRP) */
722
    }
723
 
724
  return retval;
725
}
726
 
727
/* Get all the current tty settings (including whether we have a
728
   tty at all!).  We can't do this in _initialize_inflow because
729
   serial_fdopen() won't work until the serial_ops_list is
730
   initialized, but we don't want to do it lazily either, so
731
   that we can guarantee stdin_serial is opened if there is
732
   a terminal.  */
733
void
734
initialize_stdin_serial (void)
735
{
736
  stdin_serial = serial_fdopen (0);
737
}
738
 
739
void
740
_initialize_inflow (void)
741
{
742
  add_info ("terminal", term_info,
743
            _("Print inferior's saved terminal status."));
744
 
745
  add_com ("kill", class_run, kill_command,
746
           _("Kill execution of program being debugged."));
747
 
748
  inferior_ptid = null_ptid;
749
 
750
  terminal_is_ours = 1;
751
 
752
  /* OK, figure out whether we have job control.  If neither termios nor
753
     sgtty (i.e. termio or go32), leave job_control 0.  */
754
 
755
#if defined (HAVE_TERMIOS)
756
  /* Do all systems with termios have the POSIX way of identifying job
757
     control?  I hope so.  */
758
#ifdef _POSIX_JOB_CONTROL
759
  job_control = 1;
760
#else
761
#ifdef _SC_JOB_CONTROL
762
  job_control = sysconf (_SC_JOB_CONTROL);
763
#else
764
  job_control = 0;               /* have to assume the worst */
765
#endif /* _SC_JOB_CONTROL */
766
#endif /* _POSIX_JOB_CONTROL */
767
#endif /* HAVE_TERMIOS */
768
 
769
#ifdef HAVE_SGTTY
770
#ifdef TIOCGPGRP
771
  job_control = 1;
772
#else
773
  job_control = 0;
774
#endif /* TIOCGPGRP */
775
#endif /* sgtty */
776
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.