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., 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, 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 = xmalloc (sizeof (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 *, int, int, int,
 274                                  const char **, int *);
 275 static int pex_unix_close (struct pex_obj *, int);
 276 static int pex_unix_wait (struct pex_obj *, long, int *, struct pex_time *,
 277                           int, const char **, int *);
 278 static int pex_unix_pipe (struct pex_obj *, int *, int);
 279 static FILE *pex_unix_fdopenr (struct pex_obj *, int, int);
 280 static void pex_unix_cleanup (struct pex_obj *);
 281
 282 /* The list of functions we pass to the common routines.  */
 283
 284 const struct pex_funcs funcs =
 285 {
 286   pex_unix_open_read,
 287   pex_unix_open_write,
 288   pex_unix_exec_child,
 289   pex_unix_close,
 290   pex_unix_wait,
 291   pex_unix_pipe,
 292   pex_unix_fdopenr,
 293   pex_unix_cleanup
 294 };
 295
 296 /* Return a newly initialized pex_obj structure.  */
 297
 298 struct pex_obj *
 299 pex_init (int flags, const char *pname, const char *tempbase)
 300 {
 301   return pex_init_common (flags, pname, tempbase, &funcs);
 302 }
 303
 304 /* Open a file for reading.  */
 305
 306 static int
 307 pex_unix_open_read (struct pex_obj *obj ATTRIBUTE_UNUSED, const char *name,
 308                     int binary ATTRIBUTE_UNUSED)
 309 {
 310   return open (name, O_RDONLY);
 311 }
 312
 313 /* Open a file for writing.  */
 314
 315 static int
 316 pex_unix_open_write (struct pex_obj *obj ATTRIBUTE_UNUSED, const char *name,
 317                      int binary ATTRIBUTE_UNUSED)
 318 {
 319   /* Note that we can't use O_EXCL here because gcc may have already
 320      created the temporary file via make_temp_file.  */
 321   return open (name, O_WRONLY | O_CREAT | O_TRUNC, PUBLIC_MODE);
 322 }
 323
 324 /* Close a file.  */
 325
 326 static int
 327 pex_unix_close (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd)
 328 {
 329   return close (fd);
 330 }
 331
 332 /* Report an error from a child process.  We don't use stdio routines,
 333    because we might be here due to a vfork call.  */
 334
 335 static void
 336 pex_child_error (struct pex_obj *obj, const char *executable,
 337                  const char *errmsg, int err)
 338 {
 339 #define writeerr(s) write (STDERR_FILE_NO, s, strlen (s))
 340   writeerr (obj->pname);
 341   writeerr (": error trying to exec '");
 342   writeerr (executable);
 343   writeerr ("': ");
 344   writeerr (errmsg);
 345   writeerr (": ");
 346   writeerr (xstrerror (err));
 347   writeerr ("\n");
 348   _exit (-1);
 349 }
 350
 351 /* Execute a child.  */
 352
 353 static long
 354 pex_unix_exec_child (struct pex_obj *obj, int flags, const char *executable,
 355                      char * const * argv, int in, int out, int errdes,
 356                      const char **errmsg, int *err)
 357 {
 358   pid_t pid;
 359   /* We declare these to be volatile to avoid warnings from gcc about
 360      them being clobbered by vfork.  */
 361   volatile int sleep_interval;
 362   volatile int retries;
 363
 364   sleep_interval = 1;
 365   pid = -1;
 366   for (retries = 0; retries < 4; ++retries)
 367     {
 368       pid = vfork ();
 369       if (pid >= 0)
 370         break;
 371       sleep (sleep_interval);
 372       sleep_interval *= 2;
 373     }
 374
 375   switch (pid)
 376     {
 377     case -1:
 378       *err = errno;
 379       *errmsg = VFORK_STRING;
 380       return -1;
 381
 382     case 0:
 383       /* Child process.  */
 384       if (in != STDIN_FILE_NO)
 385         {
 386           if (dup2 (in, STDIN_FILE_NO) < 0)
 387             pex_child_error (obj, executable, "dup2", errno);
 388           if (close (in) < 0)
 389             pex_child_error (obj, executable, "close", errno);
 390         }
 391       if (out != STDOUT_FILE_NO)
 392         {
 393           if (dup2 (out, STDOUT_FILE_NO) < 0)
 394             pex_child_error (obj, executable, "dup2", errno);
 395           if (close (out) < 0)
 396             pex_child_error (obj, executable, "close", errno);
 397         }
 398       if (errdes != STDERR_FILE_NO)
 399         {
 400           if (dup2 (errdes, STDERR_FILE_NO) < 0)
 401             pex_child_error (obj, executable, "dup2", errno);
 402           if (close (errdes) < 0)
 403             pex_child_error (obj, executable, "close", errno);
 404         }
 405       if ((flags & PEX_STDERR_TO_STDOUT) != 0)
 406         {
 407           if (dup2 (STDOUT_FILE_NO, STDERR_FILE_NO) < 0)
 408             pex_child_error (obj, executable, "dup2", errno);
 409         }
 410       if ((flags & PEX_SEARCH) != 0)
 411         {
 412           execvp (executable, argv);
 413           pex_child_error (obj, executable, "execvp", errno);
 414         }
 415       else
 416         {
 417           execv (executable, argv);
 418           pex_child_error (obj, executable, "execv", errno);
 419         }
 420
 421       /* NOTREACHED */
 422       return -1;
 423
 424     default:
 425       /* Parent process.  */
 426       if (in != STDIN_FILE_NO)
 427         {
 428           if (close (in) < 0)
 429             {
 430               *err = errno;
 431               *errmsg = "close";
 432               return -1;
 433             }
 434         }
 435       if (out != STDOUT_FILE_NO)
 436         {
 437           if (close (out) < 0)
 438             {
 439               *err = errno;
 440               *errmsg = "close";
 441               return -1;
 442             }
 443         }
 444       if (errdes != STDERR_FILE_NO)
 445         {
 446           if (close (errdes) < 0)
 447             {
 448               *err = errno;
 449               *errmsg = "close";
 450               return -1;
 451             }
 452         }
 453
 454       return (long) pid;
 455     }
 456 }
 457
 458 /* Wait for a child process to complete.  */
 459
 460 static int
 461 pex_unix_wait (struct pex_obj *obj, long pid, int *status,
 462                struct pex_time *time, int done, const char **errmsg,
 463                int *err)
 464 {
 465   /* If we are cleaning up when the caller didn't retrieve process
 466      status for some reason, encourage the process to go away.  */
 467   if (done)
 468     kill (pid, SIGTERM);
 469
 470   if (pex_wait (obj, pid, status, time) < 0)
 471     {
 472       *err = errno;
 473       *errmsg = "wait";
 474       return -1;
 475     }
 476
 477   return 0;
 478 }
 479
 480 /* Create a pipe.  */
 481
 482 static int
 483 pex_unix_pipe (struct pex_obj *obj ATTRIBUTE_UNUSED, int *p,
 484                int binary ATTRIBUTE_UNUSED)
 485 {
 486   return pipe (p);
 487 }
 488
 489 /* Get a FILE pointer to read from a file descriptor.  */
 490
 491 static FILE *
 492 pex_unix_fdopenr (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
 493                   int binary ATTRIBUTE_UNUSED)
 494 {
 495   return fdopen (fd, "r");
 496 }
 497
 498 static void
 499 pex_unix_cleanup (struct pex_obj *obj ATTRIBUTE_UNUSED)
 500 {
 501 #if !defined (HAVE_WAIT4) && !defined (HAVE_WAITPID)
 502   while (obj->sysdep != NULL)
 503     {
 504       struct status_list *this;
 505       struct status_list *next;
 506
 507       this = (struct status_list *) obj->sysdep;
 508       next = this->next;
 509       free (this);
 510       obj->sysdep = (void *) next;
 511     }
 512 #endif
 513 }