libiberty/pex-unix.c

   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
   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 #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
  87 static pid_t pex_wait (struct pex_obj *, pid_t, int *, struct pex_time *);
  88
  89 #ifdef HAVE_WAIT4
  90
  91 static pid_t
  92 pex_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
 122 static pid_t
 123 pex_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
 133 static pid_t
 134 pex_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
 174 struct status_list
 175 {
 176   struct status_list *next;
 177   pid_t pid;
 178   int status;
 179   struct pex_time time;
 180 };
 181
 182 static pid_t
 183 pex_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
 268 static void pex_child_error (struct pex_obj *, const char *, const char *, int)
 269      ATTRIBUTE_NORETURN;
 270 static int pex_unix_open_read (struct pex_obj *, const char *, int);
 271 static int pex_unix_open_write (struct pex_obj *, const char *, int);
 272 static 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 *);
 276 static int pex_unix_close (struct pex_obj *, int);
 277 static int pex_unix_wait (struct pex_obj *, long, int *, struct pex_time *,
 278                           int, const char **, int *);
 279 static int pex_unix_pipe (struct pex_obj *, int *, int);
 280 static FILE *pex_unix_fdopenr (struct pex_obj *, int, int);
 281 static FILE *pex_unix_fdopenw (struct pex_obj *, int, int);
 282 static void pex_unix_cleanup (struct pex_obj *);
 283
 284 /* The list of functions we pass to the common routines.  */
 285
 286 const 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
 301 struct pex_obj *
 302 pex_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
 309 static int
 310 pex_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
 318 static int
 319 pex_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
 329 static int
 330 pex_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
 338 static void
 339 pex_child_error (struct pex_obj *obj, const char *executable,
 340                  const char *errmsg, int err)
 341 {
 342 #define writeerr(s) 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
 356 extern char **environ;
 357
 358 static long
 359 pex_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
 476 static int
 477 pex_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
 498 static int
 499 pex_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
 507 static FILE *
 508 pex_unix_fdopenr (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
 509                   int binary ATTRIBUTE_UNUSED)
 510 {
 511   return fdopen (fd, "r");
 512 }
 513
 514 static FILE *
 515 pex_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
 523 static void
 524 pex_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 }