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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [libiberty/] [pex-unix.c] - Blame information for rev 840

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Utilities to execute a program in a subprocess (possibly linked by pipes
2
   with other subprocesses), and wait for it.  Generic Unix version
3
   (also used for UWIN and VMS).
4 225 jeremybenn
   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2009
5 24 jeremybenn
   Free Software Foundation, Inc.
6
 
7
This file is part of the libiberty library.
8
Libiberty is free software; you can redistribute it and/or
9
modify it under the terms of the GNU Library General Public
10
License as published by the Free Software Foundation; either
11
version 2 of the License, or (at your option) any later version.
12
 
13
Libiberty 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 GNU
16
Library General Public License for more details.
17
 
18
You should have received a copy of the GNU Library General Public
19
License along with libiberty; see the file COPYING.LIB.  If not,
20
write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
21
Boston, MA 02110-1301, USA.  */
22
 
23
#include "config.h"
24
#include "libiberty.h"
25
#include "pex-common.h"
26
 
27
#include <stdio.h>
28
#include <signal.h>
29
#include <errno.h>
30
#ifdef NEED_DECLARATION_ERRNO
31
extern int errno;
32
#endif
33
#ifdef HAVE_STDLIB_H
34
#include <stdlib.h>
35
#endif
36
#ifdef HAVE_STRING_H
37
#include <string.h>
38
#endif
39
#ifdef HAVE_UNISTD_H
40
#include <unistd.h>
41
#endif
42
 
43
#include <sys/types.h>
44
 
45
#ifdef HAVE_FCNTL_H
46
#include <fcntl.h>
47
#endif
48
#ifdef HAVE_SYS_WAIT_H
49
#include <sys/wait.h>
50
#endif
51
#ifdef HAVE_GETRUSAGE
52
#include <sys/time.h>
53
#include <sys/resource.h>
54
#endif
55
#ifdef HAVE_SYS_STAT_H
56
#include <sys/stat.h>
57
#endif
58
 
59
 
60
#ifdef vfork /* Autoconf may define this to fork for us. */
61
# define VFORK_STRING "fork"
62
#else
63
# define VFORK_STRING "vfork"
64
#endif
65
#ifdef HAVE_VFORK_H
66
#include <vfork.h>
67
#endif
68 225 jeremybenn
#if defined(VMS) && defined (__LONG_POINTERS)
69
#ifndef __CHAR_PTR32
70
typedef char * __char_ptr32
71
__attribute__ ((mode (SI)));
72
#endif
73 24 jeremybenn
 
74 225 jeremybenn
typedef __char_ptr32 *__char_ptr_char_ptr32
75
__attribute__ ((mode (SI)));
76 24 jeremybenn
 
77 225 jeremybenn
/* Return a 32 bit pointer to an array of 32 bit pointers
78
   given a 64 bit pointer to an array of 64 bit pointers.  */
79
 
80
static __char_ptr_char_ptr32
81
to_ptr32 (char **ptr64)
82
{
83
  int argc;
84
  __char_ptr_char_ptr32 short_argv;
85
 
86
  for (argc=0; ptr64[argc]; argc++);
87
 
88
  /* Reallocate argv with 32 bit pointers.  */
89
  short_argv = (__char_ptr_char_ptr32) decc$malloc
90
    (sizeof (__char_ptr32) * (argc + 1));
91
 
92
  for (argc=0; ptr64[argc]; argc++)
93
    short_argv[argc] = (__char_ptr32) decc$strdup (ptr64[argc]);
94
 
95
  short_argv[argc] = (__char_ptr32) 0;
96
  return short_argv;
97
 
98
}
99
#else
100
#define to_ptr32(argv) argv
101
#endif
102
 
103 24 jeremybenn
/* File mode to use for private and world-readable files.  */
104
 
105
#if defined (S_IRUSR) && defined (S_IWUSR) && defined (S_IRGRP) && defined (S_IWGRP) && defined (S_IROTH) && defined (S_IWOTH)
106
#define PUBLIC_MODE  \
107
    (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)
108
#else
109
#define PUBLIC_MODE 0666
110
#endif
111
 
112
/* Get the exit status of a particular process, and optionally get the
113
   time that it took.  This is simple if we have wait4, slightly
114
   harder if we have waitpid, and is a pain if we only have wait.  */
115
 
116
static pid_t pex_wait (struct pex_obj *, pid_t, int *, struct pex_time *);
117
 
118
#ifdef HAVE_WAIT4
119
 
120
static pid_t
121
pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
122
          struct pex_time *time)
123
{
124
  pid_t ret;
125
  struct rusage r;
126
 
127
#ifdef HAVE_WAITPID
128
  if (time == NULL)
129
    return waitpid (pid, status, 0);
130
#endif
131
 
132
  ret = wait4 (pid, status, 0, &r);
133
 
134
  if (time != NULL)
135
    {
136
      time->user_seconds = r.ru_utime.tv_sec;
137
      time->user_microseconds= r.ru_utime.tv_usec;
138
      time->system_seconds = r.ru_stime.tv_sec;
139
      time->system_microseconds= r.ru_stime.tv_usec;
140
    }
141
 
142
  return ret;
143
}
144
 
145
#else /* ! defined (HAVE_WAIT4) */
146
 
147
#ifdef HAVE_WAITPID
148
 
149
#ifndef HAVE_GETRUSAGE
150
 
151
static pid_t
152
pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
153
          struct pex_time *time)
154
{
155
  if (time != NULL)
156
    memset (time, 0, sizeof (struct pex_time));
157
  return waitpid (pid, status, 0);
158
}
159
 
160
#else /* defined (HAVE_GETRUSAGE) */
161
 
162
static pid_t
163
pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
164
          struct pex_time *time)
165
{
166
  struct rusage r1, r2;
167
  pid_t ret;
168
 
169
  if (time == NULL)
170
    return waitpid (pid, status, 0);
171
 
172
  getrusage (RUSAGE_CHILDREN, &r1);
173
 
174
  ret = waitpid (pid, status, 0);
175
  if (ret < 0)
176
    return ret;
177
 
178
  getrusage (RUSAGE_CHILDREN, &r2);
179
 
180
  time->user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
181
  time->user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
182
  if (r2.ru_utime.tv_usec < r1.ru_utime.tv_usec)
183
    {
184
      --time->user_seconds;
185
      time->user_microseconds += 1000000;
186
    }
187
 
188
  time->system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
189
  time->system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
190
  if (r2.ru_stime.tv_usec < r1.ru_stime.tv_usec)
191
    {
192
      --time->system_seconds;
193
      time->system_microseconds += 1000000;
194
    }
195
 
196
  return ret;
197
}
198
 
199
#endif /* defined (HAVE_GETRUSAGE) */
200
 
201
#else /* ! defined (HAVE_WAITPID) */
202
 
203
struct status_list
204
{
205
  struct status_list *next;
206
  pid_t pid;
207
  int status;
208
  struct pex_time time;
209
};
210
 
211
static pid_t
212
pex_wait (struct pex_obj *obj, pid_t pid, int *status, struct pex_time *time)
213
{
214
  struct status_list **pp;
215
 
216
  for (pp = (struct status_list **) &obj->sysdep;
217
       *pp != NULL;
218
       pp = &(*pp)->next)
219
    {
220
      if ((*pp)->pid == pid)
221
        {
222
          struct status_list *p;
223
 
224
          p = *pp;
225
          *status = p->status;
226
          if (time != NULL)
227
            *time = p->time;
228
          *pp = p->next;
229
          free (p);
230
          return pid;
231
        }
232
    }
233
 
234
  while (1)
235
    {
236
      pid_t cpid;
237
      struct status_list *psl;
238
      struct pex_time pt;
239
#ifdef HAVE_GETRUSAGE
240
      struct rusage r1, r2;
241
#endif
242
 
243
      if (time != NULL)
244
        {
245
#ifdef HAVE_GETRUSAGE
246
          getrusage (RUSAGE_CHILDREN, &r1);
247
#else
248
          memset (&pt, 0, sizeof (struct pex_time));
249
#endif
250
        }
251
 
252
      cpid = wait (status);
253
 
254
#ifdef HAVE_GETRUSAGE
255
      if (time != NULL && cpid >= 0)
256
        {
257
          getrusage (RUSAGE_CHILDREN, &r2);
258
 
259
          pt.user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
260
          pt.user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
261
          if (pt.user_microseconds < 0)
262
            {
263
              --pt.user_seconds;
264
              pt.user_microseconds += 1000000;
265
            }
266
 
267
          pt.system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
268
          pt.system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
269
          if (pt.system_microseconds < 0)
270
            {
271
              --pt.system_seconds;
272
              pt.system_microseconds += 1000000;
273
            }
274
        }
275
#endif
276
 
277
      if (cpid < 0 || cpid == pid)
278
        {
279
          if (time != NULL)
280
            *time = pt;
281
          return cpid;
282
        }
283
 
284
      psl = XNEW (struct status_list);
285
      psl->pid = cpid;
286
      psl->status = *status;
287
      if (time != NULL)
288
        psl->time = pt;
289
      psl->next = (struct status_list *) obj->sysdep;
290
      obj->sysdep = (void *) psl;
291
    }
292
}
293
 
294
#endif /* ! defined (HAVE_WAITPID) */
295
#endif /* ! defined (HAVE_WAIT4) */
296
 
297
static void pex_child_error (struct pex_obj *, const char *, const char *, int)
298
     ATTRIBUTE_NORETURN;
299
static int pex_unix_open_read (struct pex_obj *, const char *, int);
300
static int pex_unix_open_write (struct pex_obj *, const char *, int);
301
static pid_t pex_unix_exec_child (struct pex_obj *, int, const char *,
302
                                 char * const *, char * const *,
303
                                 int, int, int, int,
304
                                 const char **, int *);
305
static int pex_unix_close (struct pex_obj *, int);
306
static int pex_unix_wait (struct pex_obj *, pid_t, int *, struct pex_time *,
307
                          int, const char **, int *);
308
static int pex_unix_pipe (struct pex_obj *, int *, int);
309
static FILE *pex_unix_fdopenr (struct pex_obj *, int, int);
310
static FILE *pex_unix_fdopenw (struct pex_obj *, int, int);
311
static void pex_unix_cleanup (struct pex_obj *);
312
 
313
/* The list of functions we pass to the common routines.  */
314
 
315
const struct pex_funcs funcs =
316
{
317
  pex_unix_open_read,
318
  pex_unix_open_write,
319
  pex_unix_exec_child,
320
  pex_unix_close,
321
  pex_unix_wait,
322
  pex_unix_pipe,
323
  pex_unix_fdopenr,
324
  pex_unix_fdopenw,
325
  pex_unix_cleanup
326
};
327
 
328
/* Return a newly initialized pex_obj structure.  */
329
 
330
struct pex_obj *
331
pex_init (int flags, const char *pname, const char *tempbase)
332
{
333
  return pex_init_common (flags, pname, tempbase, &funcs);
334
}
335
 
336
/* Open a file for reading.  */
337
 
338
static int
339
pex_unix_open_read (struct pex_obj *obj ATTRIBUTE_UNUSED, const char *name,
340
                    int binary ATTRIBUTE_UNUSED)
341
{
342
  return open (name, O_RDONLY);
343
}
344
 
345
/* Open a file for writing.  */
346
 
347
static int
348
pex_unix_open_write (struct pex_obj *obj ATTRIBUTE_UNUSED, const char *name,
349
                     int binary ATTRIBUTE_UNUSED)
350
{
351
  /* Note that we can't use O_EXCL here because gcc may have already
352
     created the temporary file via make_temp_file.  */
353
  return open (name, O_WRONLY | O_CREAT | O_TRUNC, PUBLIC_MODE);
354
}
355
 
356
/* Close a file.  */
357
 
358
static int
359
pex_unix_close (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd)
360
{
361
  return close (fd);
362
}
363
 
364
/* Report an error from a child process.  We don't use stdio routines,
365
   because we might be here due to a vfork call.  */
366
 
367
static void
368
pex_child_error (struct pex_obj *obj, const char *executable,
369
                 const char *errmsg, int err)
370
{
371
#define writeerr(s) (void) write (STDERR_FILE_NO, s, strlen (s))
372
  writeerr (obj->pname);
373
  writeerr (": error trying to exec '");
374
  writeerr (executable);
375
  writeerr ("': ");
376
  writeerr (errmsg);
377
  writeerr (": ");
378
  writeerr (xstrerror (err));
379
  writeerr ("\n");
380
  _exit (-1);
381
}
382
 
383
/* Execute a child.  */
384
 
385
extern char **environ;
386
 
387
static pid_t
388
pex_unix_exec_child (struct pex_obj *obj, int flags, const char *executable,
389
                     char * const * argv, char * const * env,
390
                     int in, int out, int errdes,
391
                     int toclose, const char **errmsg, int *err)
392
{
393
  pid_t pid;
394
 
395
  /* We declare these to be volatile to avoid warnings from gcc about
396
     them being clobbered by vfork.  */
397
  volatile int sleep_interval;
398
  volatile int retries;
399
 
400
  sleep_interval = 1;
401
  pid = -1;
402
  for (retries = 0; retries < 4; ++retries)
403
    {
404
      pid = vfork ();
405
      if (pid >= 0)
406
        break;
407
      sleep (sleep_interval);
408
      sleep_interval *= 2;
409
    }
410
 
411
  switch (pid)
412
    {
413
    case -1:
414
      *err = errno;
415
      *errmsg = VFORK_STRING;
416
      return (pid_t) -1;
417
 
418
    case 0:
419
      /* Child process.  */
420
      if (in != STDIN_FILE_NO)
421
        {
422
          if (dup2 (in, STDIN_FILE_NO) < 0)
423
            pex_child_error (obj, executable, "dup2", errno);
424
          if (close (in) < 0)
425
            pex_child_error (obj, executable, "close", errno);
426
        }
427
      if (out != STDOUT_FILE_NO)
428
        {
429
          if (dup2 (out, STDOUT_FILE_NO) < 0)
430
            pex_child_error (obj, executable, "dup2", errno);
431
          if (close (out) < 0)
432
            pex_child_error (obj, executable, "close", errno);
433
        }
434
      if (errdes != STDERR_FILE_NO)
435
        {
436
          if (dup2 (errdes, STDERR_FILE_NO) < 0)
437
            pex_child_error (obj, executable, "dup2", errno);
438
          if (close (errdes) < 0)
439
            pex_child_error (obj, executable, "close", errno);
440
        }
441
      if (toclose >= 0)
442
        {
443
          if (close (toclose) < 0)
444
            pex_child_error (obj, executable, "close", errno);
445
        }
446
      if ((flags & PEX_STDERR_TO_STDOUT) != 0)
447
        {
448
          if (dup2 (STDOUT_FILE_NO, STDERR_FILE_NO) < 0)
449
            pex_child_error (obj, executable, "dup2", errno);
450
        }
451
 
452
      if (env)
453
        environ = (char**) env;
454
 
455
      if ((flags & PEX_SEARCH) != 0)
456
        {
457 225 jeremybenn
          execvp (executable, to_ptr32 (argv));
458 24 jeremybenn
          pex_child_error (obj, executable, "execvp", errno);
459
        }
460
      else
461
        {
462 225 jeremybenn
          execv (executable, to_ptr32 (argv));
463 24 jeremybenn
          pex_child_error (obj, executable, "execv", errno);
464
        }
465
 
466
      /* NOTREACHED */
467
      return (pid_t) -1;
468
 
469
    default:
470
      /* Parent process.  */
471
      if (in != STDIN_FILE_NO)
472
        {
473
          if (close (in) < 0)
474
            {
475
              *err = errno;
476
              *errmsg = "close";
477
              return (pid_t) -1;
478
            }
479
        }
480
      if (out != STDOUT_FILE_NO)
481
        {
482
          if (close (out) < 0)
483
            {
484
              *err = errno;
485
              *errmsg = "close";
486
              return (pid_t) -1;
487
            }
488
        }
489
      if (errdes != STDERR_FILE_NO)
490
        {
491
          if (close (errdes) < 0)
492
            {
493
              *err = errno;
494
              *errmsg = "close";
495
              return (pid_t) -1;
496
            }
497
        }
498
 
499
      return pid;
500
    }
501
}
502
 
503
/* Wait for a child process to complete.  */
504
 
505
static int
506
pex_unix_wait (struct pex_obj *obj, pid_t pid, int *status,
507
               struct pex_time *time, int done, const char **errmsg,
508
               int *err)
509
{
510
  /* If we are cleaning up when the caller didn't retrieve process
511
     status for some reason, encourage the process to go away.  */
512
  if (done)
513
    kill (pid, SIGTERM);
514
 
515
  if (pex_wait (obj, pid, status, time) < 0)
516
    {
517
      *err = errno;
518
      *errmsg = "wait";
519
      return -1;
520
    }
521
 
522
  return 0;
523
}
524
 
525
/* Create a pipe.  */
526
 
527
static int
528
pex_unix_pipe (struct pex_obj *obj ATTRIBUTE_UNUSED, int *p,
529
               int binary ATTRIBUTE_UNUSED)
530
{
531
  return pipe (p);
532
}
533
 
534
/* Get a FILE pointer to read from a file descriptor.  */
535
 
536
static FILE *
537
pex_unix_fdopenr (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
538
                  int binary ATTRIBUTE_UNUSED)
539
{
540
  return fdopen (fd, "r");
541
}
542
 
543
static FILE *
544
pex_unix_fdopenw (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
545
                  int binary ATTRIBUTE_UNUSED)
546
{
547
  if (fcntl (fd, F_SETFD, FD_CLOEXEC) < 0)
548
    return NULL;
549
  return fdopen (fd, "w");
550
}
551
 
552
static void
553
pex_unix_cleanup (struct pex_obj *obj ATTRIBUTE_UNUSED)
554
{
555
#if !defined (HAVE_WAIT4) && !defined (HAVE_WAITPID)
556
  while (obj->sysdep != NULL)
557
    {
558
      struct status_list *this;
559
      struct status_list *next;
560
 
561
      this = (struct status_list *) obj->sysdep;
562
      next = this->next;
563
      free (this);
564
      obj->sysdep = (void *) next;
565
    }
566
#endif
567
}

powered by: WebSVN 2.1.0

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