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

Subversion Repositories openrisc

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

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Common code for executing a program in a sub-process.
2
   Copyright (C) 2005 Free Software Foundation, Inc.
3
   Written by Ian Lance Taylor <ian@airs.com>.
4
 
5
This file is part of the libiberty library.
6
Libiberty is free software; you can redistribute it and/or
7
modify it under the terms of the GNU Library General Public
8
License as published by the Free Software Foundation; either
9
version 2 of the License, or (at your option) any later version.
10
 
11
Libiberty is distributed in the hope that it will be useful,
12
but WITHOUT ANY WARRANTY; without even the implied warranty of
13
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
Library General Public License for more details.
15
 
16
You should have received a copy of the GNU Library General Public
17
License along with libiberty; see the file COPYING.LIB.  If not,
18
write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
19
Boston, MA 02110-1301, USA.  */
20
 
21
#include "config.h"
22
#include "libiberty.h"
23
#include "pex-common.h"
24
 
25
#include <stdio.h>
26
#include <errno.h>
27
#ifdef NEED_DECLARATION_ERRNO
28
extern int errno;
29
#endif
30
#ifdef HAVE_STDLIB_H
31
#include <stdlib.h>
32
#endif
33
#ifdef HAVE_STRING_H
34
#include <string.h>
35
#endif
36
#ifdef HAVE_UNISTD_H
37
#include <unistd.h>
38
#endif
39
 
40
extern int mkstemps (char *, int);
41
 
42
/* This file contains subroutines for the program execution routines
43
   (pex_init, pex_run, etc.).  This file is compiled on all
44
   systems.  */
45
 
46
static void pex_add_remove (struct pex_obj *, const char *, int);
47
static int pex_get_status_and_time (struct pex_obj *, int, const char **,
48
                                    int *);
49
 
50
/* Initialize a pex_obj structure.  */
51
 
52
struct pex_obj *
53
pex_init_common (int flags, const char *pname, const char *tempbase,
54
                 const struct pex_funcs *funcs)
55
{
56
  struct pex_obj *obj;
57
 
58
  obj = XNEW (struct pex_obj);
59
  obj->flags = flags;
60
  obj->pname = pname;
61
  obj->tempbase = tempbase;
62
  obj->next_input = STDIN_FILE_NO;
63
  obj->next_input_name = NULL;
64
  obj->next_input_name_allocated = 0;
65
  obj->stderr_pipe = -1;
66
  obj->count = 0;
67
  obj->children = NULL;
68
  obj->status = NULL;
69
  obj->time = NULL;
70
  obj->number_waited = 0;
71
  obj->input_file = NULL;
72
  obj->read_output = NULL;
73
  obj->read_err = NULL;
74
  obj->remove_count = 0;
75
  obj->remove = NULL;
76
  obj->funcs = funcs;
77
  obj->sysdep = NULL;
78
  return obj;
79
}
80
 
81
/* Add a file to be removed when we are done.  */
82
 
83
static void
84
pex_add_remove (struct pex_obj *obj, const char *name, int allocated)
85
{
86
  char *add;
87
 
88
  ++obj->remove_count;
89
  obj->remove = XRESIZEVEC (char *, obj->remove, obj->remove_count);
90
  if (allocated)
91
    add = (char *) name;
92
  else
93
    add = xstrdup (name);
94
  obj->remove[obj->remove_count - 1] = add;
95
}
96
 
97
/* Generate a temporary file name based on OBJ, FLAGS, and NAME.
98
   Return NULL if we were unable to reserve a temporary filename.
99
 
100
   If non-NULL, the result is either allocated with malloc, or the
101
   same pointer as NAME.  */
102
static char *
103
temp_file (struct pex_obj *obj, int flags, char *name)
104
{
105
  if (name == NULL)
106
    {
107
      if (obj->tempbase == NULL)
108
        {
109
          name = make_temp_file (NULL);
110
        }
111
      else
112
        {
113
          int len = strlen (obj->tempbase);
114
          int out;
115
 
116
          if (len >= 6
117
              && strcmp (obj->tempbase + len - 6, "XXXXXX") == 0)
118
            name = xstrdup (obj->tempbase);
119
          else
120
            name = concat (obj->tempbase, "XXXXXX", NULL);
121
 
122
          out = mkstemps (name, 0);
123
          if (out < 0)
124
            {
125
              free (name);
126
              return NULL;
127
            }
128
 
129
          /* This isn't obj->funcs->close because we got the
130
             descriptor from mkstemps, not from a function in
131
             obj->funcs.  Calling close here is just like what
132
             make_temp_file does.  */
133
          close (out);
134
        }
135
    }
136
  else if ((flags & PEX_SUFFIX) != 0)
137
    {
138
      if (obj->tempbase == NULL)
139
        name = make_temp_file (name);
140
      else
141
        name = concat (obj->tempbase, name, NULL);
142
    }
143
 
144
  return name;
145
}
146
 
147
 
148
/* As for pex_run (), but permits the environment for the child process
149
   to be specified. */
150
 
151
const char *
152
pex_run_in_environment (struct pex_obj *obj, int flags, const char *executable,
153
                        char * const * argv, char * const * env,
154
                        const char *orig_outname, const char *errname,
155
                        int *err)
156
{
157
  const char *errmsg;
158
  int in, out, errdes;
159
  char *outname;
160
  int outname_allocated;
161
  int p[2];
162
  int toclose;
163 225 jeremybenn
  pid_t pid;
164 24 jeremybenn
 
165
  in = -1;
166
  out = -1;
167
  errdes = -1;
168
  outname = (char *) orig_outname;
169
  outname_allocated = 0;
170
 
171
  /* If the user called pex_input_file, close the file now.  */
172
  if (obj->input_file)
173
    {
174
      if (fclose (obj->input_file) == EOF)
175
        {
176
          errmsg = "closing pipeline input file";
177
          goto error_exit;
178
        }
179
      obj->input_file = NULL;
180
    }
181
 
182
  /* Set IN.  */
183
 
184
  if (obj->next_input_name != NULL)
185
    {
186
      /* We have to make sure that the previous process has completed
187
         before we try to read the file.  */
188
      if (!pex_get_status_and_time (obj, 0, &errmsg, err))
189
        goto error_exit;
190
 
191
      in = obj->funcs->open_read (obj, obj->next_input_name,
192
                                  (flags & PEX_BINARY_INPUT) != 0);
193
      if (in < 0)
194
        {
195
          *err = errno;
196
          errmsg = "open temporary file";
197
          goto error_exit;
198
        }
199
      if (obj->next_input_name_allocated)
200
        {
201
          free (obj->next_input_name);
202
          obj->next_input_name_allocated = 0;
203
        }
204
      obj->next_input_name = NULL;
205
    }
206
  else
207
    {
208
      in = obj->next_input;
209
      if (in < 0)
210
        {
211
          *err = 0;
212
          errmsg = "pipeline already complete";
213
          goto error_exit;
214
        }
215
    }
216
 
217
  /* Set OUT and OBJ->NEXT_INPUT/OBJ->NEXT_INPUT_NAME.  */
218
 
219
  if ((flags & PEX_LAST) != 0)
220
    {
221
      if (outname == NULL)
222
        out = STDOUT_FILE_NO;
223
      else if ((flags & PEX_SUFFIX) != 0)
224
        {
225
          outname = concat (obj->tempbase, outname, NULL);
226
          outname_allocated = 1;
227
        }
228
      obj->next_input = -1;
229
    }
230
  else if ((obj->flags & PEX_USE_PIPES) == 0)
231
    {
232
      outname = temp_file (obj, flags, outname);
233
      if (! outname)
234
        {
235
          *err = 0;
236
          errmsg = "could not create temporary file";
237
          goto error_exit;
238
        }
239
 
240
      if (outname != orig_outname)
241
        outname_allocated = 1;
242
 
243
      if ((obj->flags & PEX_SAVE_TEMPS) == 0)
244
        {
245
          pex_add_remove (obj, outname, outname_allocated);
246
          outname_allocated = 0;
247
        }
248
 
249
      /* Hand off ownership of outname to the next stage.  */
250
      obj->next_input_name = outname;
251
      obj->next_input_name_allocated = outname_allocated;
252
      outname_allocated = 0;
253
    }
254
  else
255
    {
256
      if (obj->funcs->pipe (obj, p, (flags & PEX_BINARY_OUTPUT) != 0) < 0)
257
        {
258
          *err = errno;
259
          errmsg = "pipe";
260
          goto error_exit;
261
        }
262
 
263
      out = p[WRITE_PORT];
264
      obj->next_input = p[READ_PORT];
265
    }
266
 
267
  if (out < 0)
268
    {
269
      out = obj->funcs->open_write (obj, outname,
270
                                    (flags & PEX_BINARY_OUTPUT) != 0);
271
      if (out < 0)
272
        {
273
          *err = errno;
274
          errmsg = "open temporary output file";
275
          goto error_exit;
276
        }
277
    }
278
 
279
  if (outname_allocated)
280
    {
281
      free (outname);
282
      outname_allocated = 0;
283
    }
284
 
285
  /* Set ERRDES.  */
286
 
287
  if (errname != NULL && (flags & PEX_STDERR_TO_PIPE) != 0)
288
    {
289
      *err = 0;
290
      errmsg = "both ERRNAME and PEX_STDERR_TO_PIPE specified.";
291
      goto error_exit;
292
    }
293
 
294
  if (obj->stderr_pipe != -1)
295
    {
296
      *err = 0;
297
      errmsg = "PEX_STDERR_TO_PIPE used in the middle of pipeline";
298
      goto error_exit;
299
    }
300
 
301
  if (errname == NULL)
302
    {
303
      if (flags & PEX_STDERR_TO_PIPE)
304
        {
305
          if (obj->funcs->pipe (obj, p, (flags & PEX_BINARY_ERROR) != 0) < 0)
306
            {
307
              *err = errno;
308
              errmsg = "pipe";
309
              goto error_exit;
310
            }
311
 
312
          errdes = p[WRITE_PORT];
313
          obj->stderr_pipe = p[READ_PORT];
314
        }
315
      else
316
        {
317
          errdes = STDERR_FILE_NO;
318
        }
319
    }
320
  else
321
    {
322
      errdes = obj->funcs->open_write (obj, errname,
323
                                       (flags & PEX_BINARY_ERROR) != 0);
324
      if (errdes < 0)
325
        {
326
          *err = errno;
327
          errmsg = "open error file";
328
          goto error_exit;
329
        }
330
    }
331
 
332
  /* If we are using pipes, the child process has to close the next
333
     input pipe.  */
334
 
335
  if ((obj->flags & PEX_USE_PIPES) == 0)
336
    toclose = -1;
337
  else
338
    toclose = obj->next_input;
339
 
340
  /* Run the program.  */
341
 
342
  pid = obj->funcs->exec_child (obj, flags, executable, argv, env,
343
                                in, out, errdes, toclose, &errmsg, err);
344
  if (pid < 0)
345
    goto error_exit;
346
 
347
  ++obj->count;
348 225 jeremybenn
  obj->children = XRESIZEVEC (pid_t, obj->children, obj->count);
349 24 jeremybenn
  obj->children[obj->count - 1] = pid;
350
 
351
  return NULL;
352
 
353
 error_exit:
354
  if (in >= 0 && in != STDIN_FILE_NO)
355
    obj->funcs->close (obj, in);
356
  if (out >= 0 && out != STDOUT_FILE_NO)
357
    obj->funcs->close (obj, out);
358
  if (errdes >= 0 && errdes != STDERR_FILE_NO)
359
    obj->funcs->close (obj, errdes);
360
  if (outname_allocated)
361
    free (outname);
362
  return errmsg;
363
}
364
 
365
/* Run a program.  */
366
 
367
const char *
368
pex_run (struct pex_obj *obj, int flags, const char *executable,
369
         char * const * argv, const char *orig_outname, const char *errname,
370
         int *err)
371
{
372
  return pex_run_in_environment (obj, flags, executable, argv, NULL,
373
                                 orig_outname, errname, err);
374
}
375
 
376
/* Return a FILE pointer for a temporary file to fill with input for
377
   the pipeline.  */
378
FILE *
379
pex_input_file (struct pex_obj *obj, int flags, const char *in_name)
380
{
381
  char *name = (char *) in_name;
382
  FILE *f;
383
 
384
  /* This must be called before the first pipeline stage is run, and
385
     there must not have been any other input selected.  */
386
  if (obj->count != 0
387
      || (obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO)
388
      || obj->next_input_name)
389
    {
390
      errno = EINVAL;
391
      return NULL;
392
    }
393
 
394
  name = temp_file (obj, flags, name);
395
  if (! name)
396
    return NULL;
397
 
398
  f = fopen (name, (flags & PEX_BINARY_OUTPUT) ? "wb" : "w");
399
  if (! f)
400
    {
401
      free (name);
402
      return NULL;
403
    }
404
 
405
  obj->input_file = f;
406
  obj->next_input_name = name;
407
  obj->next_input_name_allocated = (name != in_name);
408
 
409
  return f;
410
}
411
 
412
/* Return a stream for a pipe connected to the standard input of the
413
   first stage of the pipeline.  */
414
FILE *
415
pex_input_pipe (struct pex_obj *obj, int binary)
416
{
417
  int p[2];
418
  FILE *f;
419
 
420
  /* You must call pex_input_pipe before the first pex_run or pex_one.  */
421
  if (obj->count > 0)
422
    goto usage_error;
423
 
424
  /* You must be using pipes.  Implementations that don't support
425
     pipes clear this flag before calling pex_init_common.  */
426
  if (! (obj->flags & PEX_USE_PIPES))
427
    goto usage_error;
428
 
429
  /* If we have somehow already selected other input, that's a
430
     mistake.  */
431
  if ((obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO)
432
      || obj->next_input_name)
433
    goto usage_error;
434
 
435
  if (obj->funcs->pipe (obj, p, binary != 0) < 0)
436
    return NULL;
437
 
438
  f = obj->funcs->fdopenw (obj, p[WRITE_PORT], binary != 0);
439
  if (! f)
440
    {
441
      int saved_errno = errno;
442
      obj->funcs->close (obj, p[READ_PORT]);
443
      obj->funcs->close (obj, p[WRITE_PORT]);
444
      errno = saved_errno;
445
      return NULL;
446
    }
447
 
448
  obj->next_input = p[READ_PORT];
449
 
450
  return f;
451
 
452
 usage_error:
453
  errno = EINVAL;
454
  return NULL;
455
}
456
 
457
/* Return a FILE pointer for the output of the last program
458
   executed.  */
459
 
460
FILE *
461
pex_read_output (struct pex_obj *obj, int binary)
462
{
463
  if (obj->next_input_name != NULL)
464
    {
465
      const char *errmsg;
466
      int err;
467
 
468
      /* We have to make sure that the process has completed before we
469
         try to read the file.  */
470
      if (!pex_get_status_and_time (obj, 0, &errmsg, &err))
471
        {
472
          errno = err;
473
          return NULL;
474
        }
475
 
476
      obj->read_output = fopen (obj->next_input_name, binary ? "rb" : "r");
477
 
478
      if (obj->next_input_name_allocated)
479
        {
480
          free (obj->next_input_name);
481
          obj->next_input_name_allocated = 0;
482
        }
483
      obj->next_input_name = NULL;
484
    }
485
  else
486
    {
487
      int o;
488
 
489
      o = obj->next_input;
490
      if (o < 0 || o == STDIN_FILE_NO)
491
        return NULL;
492
      obj->read_output = obj->funcs->fdopenr (obj, o, binary);
493
      obj->next_input = -1;
494
    }
495
 
496
  return obj->read_output;
497
}
498
 
499
FILE *
500
pex_read_err (struct pex_obj *obj, int binary)
501
{
502
  int o;
503
 
504
  o = obj->stderr_pipe;
505
  if (o < 0 || o == STDIN_FILE_NO)
506
    return NULL;
507
  obj->read_err = obj->funcs->fdopenr (obj, o, binary);
508
  return obj->read_err;
509
}
510
 
511
/* Get the exit status and, if requested, the resource time for all
512
   the child processes.  Return 0 on failure, 1 on success.  */
513
 
514
static int
515
pex_get_status_and_time (struct pex_obj *obj, int done, const char **errmsg,
516
                         int *err)
517
{
518
  int ret;
519
  int i;
520
 
521
  if (obj->number_waited == obj->count)
522
    return 1;
523
 
524
  obj->status = XRESIZEVEC (int, obj->status, obj->count);
525
  if ((obj->flags & PEX_RECORD_TIMES) != 0)
526
    obj->time = XRESIZEVEC (struct pex_time, obj->time, obj->count);
527
 
528
  ret = 1;
529
  for (i = obj->number_waited; i < obj->count; ++i)
530
    {
531
      if (obj->funcs->wait (obj, obj->children[i], &obj->status[i],
532
                            obj->time == NULL ? NULL : &obj->time[i],
533
                            done, errmsg, err) < 0)
534
        ret = 0;
535
    }
536
  obj->number_waited = i;
537
 
538
  return ret;
539
}
540
 
541
/* Get exit status of executed programs.  */
542
 
543
int
544
pex_get_status (struct pex_obj *obj, int count, int *vector)
545
{
546
  if (obj->status == NULL)
547
    {
548
      const char *errmsg;
549
      int err;
550
 
551
      if (!pex_get_status_and_time (obj, 0, &errmsg, &err))
552
        return 0;
553
    }
554
 
555
  if (count > obj->count)
556
    {
557
      memset (vector + obj->count, 0, (count - obj->count) * sizeof (int));
558
      count = obj->count;
559
    }
560
 
561
  memcpy (vector, obj->status, count * sizeof (int));
562
 
563
  return 1;
564
}
565
 
566
/* Get process times of executed programs.  */
567
 
568
int
569
pex_get_times (struct pex_obj *obj, int count, struct pex_time *vector)
570
{
571
  if (obj->status == NULL)
572
    {
573
      const char *errmsg;
574
      int err;
575
 
576
      if (!pex_get_status_and_time (obj, 0, &errmsg, &err))
577
        return 0;
578
    }
579
 
580
  if (obj->time == NULL)
581
    return 0;
582
 
583
  if (count > obj->count)
584
    {
585
      memset (vector + obj->count, 0,
586
              (count - obj->count) * sizeof (struct pex_time));
587
      count = obj->count;
588
    }
589
 
590
  memcpy (vector, obj->time, count * sizeof (struct pex_time));
591
 
592
  return 1;
593
}
594
 
595
/* Free a pex_obj structure.  */
596
 
597
void
598
pex_free (struct pex_obj *obj)
599
{
600
  if (obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO)
601
    obj->funcs->close (obj, obj->next_input);
602
 
603
  /* If the caller forgot to wait for the children, we do it here, to
604
     avoid zombies.  */
605
  if (obj->status == NULL)
606
    {
607
      const char *errmsg;
608
      int err;
609
 
610
      obj->flags &= ~ PEX_RECORD_TIMES;
611
      pex_get_status_and_time (obj, 1, &errmsg, &err);
612
    }
613
 
614
  if (obj->next_input_name_allocated)
615
    free (obj->next_input_name);
616
  if (obj->children != NULL)
617
    free (obj->children);
618
  if (obj->status != NULL)
619
    free (obj->status);
620
  if (obj->time != NULL)
621
    free (obj->time);
622
  if (obj->read_output != NULL)
623
    fclose (obj->read_output);
624
  if (obj->read_err != NULL)
625
    fclose (obj->read_err);
626
 
627
  if (obj->remove_count > 0)
628
    {
629
      int i;
630
 
631
      for (i = 0; i < obj->remove_count; ++i)
632
        {
633
          remove (obj->remove[i]);
634
          free (obj->remove[i]);
635
        }
636
      free (obj->remove);
637
    }
638
 
639
  if (obj->funcs->cleanup != NULL)
640
    obj->funcs->cleanup (obj);
641
 
642
  free (obj);
643
}

powered by: WebSVN 2.1.0

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