URL
https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk
Subversion Repositories openrisc_me
[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [libiberty/] [pex-common.c] - Rev 302
Go to most recent revision | Compare with Previous | Blame | View Log
/* Common code for executing a program in a sub-process. Copyright (C) 2005 Free Software Foundation, Inc. Written by Ian Lance Taylor <ian@airs.com>. This file is part of the libiberty library. Libiberty is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. Libiberty is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with libiberty; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ #include "config.h" #include "libiberty.h" #include "pex-common.h" #include <stdio.h> #include <errno.h> #ifdef NEED_DECLARATION_ERRNO extern int errno; #endif #ifdef HAVE_STDLIB_H #include <stdlib.h> #endif #ifdef HAVE_STRING_H #include <string.h> #endif #ifdef HAVE_UNISTD_H #include <unistd.h> #endif extern int mkstemps (char *, int); /* This file contains subroutines for the program execution routines (pex_init, pex_run, etc.). This file is compiled on all systems. */ static void pex_add_remove (struct pex_obj *, const char *, int); static int pex_get_status_and_time (struct pex_obj *, int, const char **, int *); /* Initialize a pex_obj structure. */ struct pex_obj * pex_init_common (int flags, const char *pname, const char *tempbase, const struct pex_funcs *funcs) { struct pex_obj *obj; obj = XNEW (struct pex_obj); obj->flags = flags; obj->pname = pname; obj->tempbase = tempbase; obj->next_input = STDIN_FILE_NO; obj->next_input_name = NULL; obj->next_input_name_allocated = 0; obj->stderr_pipe = -1; obj->count = 0; obj->children = NULL; obj->status = NULL; obj->time = NULL; obj->number_waited = 0; obj->input_file = NULL; obj->read_output = NULL; obj->read_err = NULL; obj->remove_count = 0; obj->remove = NULL; obj->funcs = funcs; obj->sysdep = NULL; return obj; } /* Add a file to be removed when we are done. */ static void pex_add_remove (struct pex_obj *obj, const char *name, int allocated) { char *add; ++obj->remove_count; obj->remove = XRESIZEVEC (char *, obj->remove, obj->remove_count); if (allocated) add = (char *) name; else add = xstrdup (name); obj->remove[obj->remove_count - 1] = add; } /* Generate a temporary file name based on OBJ, FLAGS, and NAME. Return NULL if we were unable to reserve a temporary filename. If non-NULL, the result is either allocated with malloc, or the same pointer as NAME. */ static char * temp_file (struct pex_obj *obj, int flags, char *name) { if (name == NULL) { if (obj->tempbase == NULL) { name = make_temp_file (NULL); } else { int len = strlen (obj->tempbase); int out; if (len >= 6 && strcmp (obj->tempbase + len - 6, "XXXXXX") == 0) name = xstrdup (obj->tempbase); else name = concat (obj->tempbase, "XXXXXX", NULL); out = mkstemps (name, 0); if (out < 0) { free (name); return NULL; } /* This isn't obj->funcs->close because we got the descriptor from mkstemps, not from a function in obj->funcs. Calling close here is just like what make_temp_file does. */ close (out); } } else if ((flags & PEX_SUFFIX) != 0) { if (obj->tempbase == NULL) name = make_temp_file (name); else name = concat (obj->tempbase, name, NULL); } return name; } /* As for pex_run (), but permits the environment for the child process to be specified. */ const char * pex_run_in_environment (struct pex_obj *obj, int flags, const char *executable, char * const * argv, char * const * env, const char *orig_outname, const char *errname, int *err) { const char *errmsg; int in, out, errdes; char *outname; int outname_allocated; int p[2]; int toclose; pid_t pid; in = -1; out = -1; errdes = -1; outname = (char *) orig_outname; outname_allocated = 0; /* If the user called pex_input_file, close the file now. */ if (obj->input_file) { if (fclose (obj->input_file) == EOF) { errmsg = "closing pipeline input file"; goto error_exit; } obj->input_file = NULL; } /* Set IN. */ if (obj->next_input_name != NULL) { /* We have to make sure that the previous process has completed before we try to read the file. */ if (!pex_get_status_and_time (obj, 0, &errmsg, err)) goto error_exit; in = obj->funcs->open_read (obj, obj->next_input_name, (flags & PEX_BINARY_INPUT) != 0); if (in < 0) { *err = errno; errmsg = "open temporary file"; goto error_exit; } if (obj->next_input_name_allocated) { free (obj->next_input_name); obj->next_input_name_allocated = 0; } obj->next_input_name = NULL; } else { in = obj->next_input; if (in < 0) { *err = 0; errmsg = "pipeline already complete"; goto error_exit; } } /* Set OUT and OBJ->NEXT_INPUT/OBJ->NEXT_INPUT_NAME. */ if ((flags & PEX_LAST) != 0) { if (outname == NULL) out = STDOUT_FILE_NO; else if ((flags & PEX_SUFFIX) != 0) { outname = concat (obj->tempbase, outname, NULL); outname_allocated = 1; } obj->next_input = -1; } else if ((obj->flags & PEX_USE_PIPES) == 0) { outname = temp_file (obj, flags, outname); if (! outname) { *err = 0; errmsg = "could not create temporary file"; goto error_exit; } if (outname != orig_outname) outname_allocated = 1; if ((obj->flags & PEX_SAVE_TEMPS) == 0) { pex_add_remove (obj, outname, outname_allocated); outname_allocated = 0; } /* Hand off ownership of outname to the next stage. */ obj->next_input_name = outname; obj->next_input_name_allocated = outname_allocated; outname_allocated = 0; } else { if (obj->funcs->pipe (obj, p, (flags & PEX_BINARY_OUTPUT) != 0) < 0) { *err = errno; errmsg = "pipe"; goto error_exit; } out = p[WRITE_PORT]; obj->next_input = p[READ_PORT]; } if (out < 0) { out = obj->funcs->open_write (obj, outname, (flags & PEX_BINARY_OUTPUT) != 0); if (out < 0) { *err = errno; errmsg = "open temporary output file"; goto error_exit; } } if (outname_allocated) { free (outname); outname_allocated = 0; } /* Set ERRDES. */ if (errname != NULL && (flags & PEX_STDERR_TO_PIPE) != 0) { *err = 0; errmsg = "both ERRNAME and PEX_STDERR_TO_PIPE specified."; goto error_exit; } if (obj->stderr_pipe != -1) { *err = 0; errmsg = "PEX_STDERR_TO_PIPE used in the middle of pipeline"; goto error_exit; } if (errname == NULL) { if (flags & PEX_STDERR_TO_PIPE) { if (obj->funcs->pipe (obj, p, (flags & PEX_BINARY_ERROR) != 0) < 0) { *err = errno; errmsg = "pipe"; goto error_exit; } errdes = p[WRITE_PORT]; obj->stderr_pipe = p[READ_PORT]; } else { errdes = STDERR_FILE_NO; } } else { errdes = obj->funcs->open_write (obj, errname, (flags & PEX_BINARY_ERROR) != 0); if (errdes < 0) { *err = errno; errmsg = "open error file"; goto error_exit; } } /* If we are using pipes, the child process has to close the next input pipe. */ if ((obj->flags & PEX_USE_PIPES) == 0) toclose = -1; else toclose = obj->next_input; /* Run the program. */ pid = obj->funcs->exec_child (obj, flags, executable, argv, env, in, out, errdes, toclose, &errmsg, err); if (pid < 0) goto error_exit; ++obj->count; obj->children = XRESIZEVEC (pid_t, obj->children, obj->count); obj->children[obj->count - 1] = pid; return NULL; error_exit: if (in >= 0 && in != STDIN_FILE_NO) obj->funcs->close (obj, in); if (out >= 0 && out != STDOUT_FILE_NO) obj->funcs->close (obj, out); if (errdes >= 0 && errdes != STDERR_FILE_NO) obj->funcs->close (obj, errdes); if (outname_allocated) free (outname); return errmsg; } /* Run a program. */ const char * pex_run (struct pex_obj *obj, int flags, const char *executable, char * const * argv, const char *orig_outname, const char *errname, int *err) { return pex_run_in_environment (obj, flags, executable, argv, NULL, orig_outname, errname, err); } /* Return a FILE pointer for a temporary file to fill with input for the pipeline. */ FILE * pex_input_file (struct pex_obj *obj, int flags, const char *in_name) { char *name = (char *) in_name; FILE *f; /* This must be called before the first pipeline stage is run, and there must not have been any other input selected. */ if (obj->count != 0 || (obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO) || obj->next_input_name) { errno = EINVAL; return NULL; } name = temp_file (obj, flags, name); if (! name) return NULL; f = fopen (name, (flags & PEX_BINARY_OUTPUT) ? "wb" : "w"); if (! f) { free (name); return NULL; } obj->input_file = f; obj->next_input_name = name; obj->next_input_name_allocated = (name != in_name); return f; } /* Return a stream for a pipe connected to the standard input of the first stage of the pipeline. */ FILE * pex_input_pipe (struct pex_obj *obj, int binary) { int p[2]; FILE *f; /* You must call pex_input_pipe before the first pex_run or pex_one. */ if (obj->count > 0) goto usage_error; /* You must be using pipes. Implementations that don't support pipes clear this flag before calling pex_init_common. */ if (! (obj->flags & PEX_USE_PIPES)) goto usage_error; /* If we have somehow already selected other input, that's a mistake. */ if ((obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO) || obj->next_input_name) goto usage_error; if (obj->funcs->pipe (obj, p, binary != 0) < 0) return NULL; f = obj->funcs->fdopenw (obj, p[WRITE_PORT], binary != 0); if (! f) { int saved_errno = errno; obj->funcs->close (obj, p[READ_PORT]); obj->funcs->close (obj, p[WRITE_PORT]); errno = saved_errno; return NULL; } obj->next_input = p[READ_PORT]; return f; usage_error: errno = EINVAL; return NULL; } /* Return a FILE pointer for the output of the last program executed. */ FILE * pex_read_output (struct pex_obj *obj, int binary) { if (obj->next_input_name != NULL) { const char *errmsg; int err; /* We have to make sure that the process has completed before we try to read the file. */ if (!pex_get_status_and_time (obj, 0, &errmsg, &err)) { errno = err; return NULL; } obj->read_output = fopen (obj->next_input_name, binary ? "rb" : "r"); if (obj->next_input_name_allocated) { free (obj->next_input_name); obj->next_input_name_allocated = 0; } obj->next_input_name = NULL; } else { int o; o = obj->next_input; if (o < 0 || o == STDIN_FILE_NO) return NULL; obj->read_output = obj->funcs->fdopenr (obj, o, binary); obj->next_input = -1; } return obj->read_output; } FILE * pex_read_err (struct pex_obj *obj, int binary) { int o; o = obj->stderr_pipe; if (o < 0 || o == STDIN_FILE_NO) return NULL; obj->read_err = obj->funcs->fdopenr (obj, o, binary); return obj->read_err; } /* Get the exit status and, if requested, the resource time for all the child processes. Return 0 on failure, 1 on success. */ static int pex_get_status_and_time (struct pex_obj *obj, int done, const char **errmsg, int *err) { int ret; int i; if (obj->number_waited == obj->count) return 1; obj->status = XRESIZEVEC (int, obj->status, obj->count); if ((obj->flags & PEX_RECORD_TIMES) != 0) obj->time = XRESIZEVEC (struct pex_time, obj->time, obj->count); ret = 1; for (i = obj->number_waited; i < obj->count; ++i) { if (obj->funcs->wait (obj, obj->children[i], &obj->status[i], obj->time == NULL ? NULL : &obj->time[i], done, errmsg, err) < 0) ret = 0; } obj->number_waited = i; return ret; } /* Get exit status of executed programs. */ int pex_get_status (struct pex_obj *obj, int count, int *vector) { if (obj->status == NULL) { const char *errmsg; int err; if (!pex_get_status_and_time (obj, 0, &errmsg, &err)) return 0; } if (count > obj->count) { memset (vector + obj->count, 0, (count - obj->count) * sizeof (int)); count = obj->count; } memcpy (vector, obj->status, count * sizeof (int)); return 1; } /* Get process times of executed programs. */ int pex_get_times (struct pex_obj *obj, int count, struct pex_time *vector) { if (obj->status == NULL) { const char *errmsg; int err; if (!pex_get_status_and_time (obj, 0, &errmsg, &err)) return 0; } if (obj->time == NULL) return 0; if (count > obj->count) { memset (vector + obj->count, 0, (count - obj->count) * sizeof (struct pex_time)); count = obj->count; } memcpy (vector, obj->time, count * sizeof (struct pex_time)); return 1; } /* Free a pex_obj structure. */ void pex_free (struct pex_obj *obj) { if (obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO) obj->funcs->close (obj, obj->next_input); /* If the caller forgot to wait for the children, we do it here, to avoid zombies. */ if (obj->status == NULL) { const char *errmsg; int err; obj->flags &= ~ PEX_RECORD_TIMES; pex_get_status_and_time (obj, 1, &errmsg, &err); } if (obj->next_input_name_allocated) free (obj->next_input_name); if (obj->children != NULL) free (obj->children); if (obj->status != NULL) free (obj->status); if (obj->time != NULL) free (obj->time); if (obj->read_output != NULL) fclose (obj->read_output); if (obj->read_err != NULL) fclose (obj->read_err); if (obj->remove_count > 0) { int i; for (i = 0; i < obj->remove_count; ++i) { remove (obj->remove[i]); free (obj->remove[i]); } free (obj->remove); } if (obj->funcs->cleanup != NULL) obj->funcs->cleanup (obj); free (obj); }
Go to most recent revision | Compare with Previous | Blame | View Log