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