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