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
pex_wait(struct pex_obj * obj ATTRIBUTE_UNUSED,pid_t pid,int * status,struct pex_time * time)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
pex_wait(struct pex_obj * obj ATTRIBUTE_UNUSED,pid_t pid,int * status,struct pex_time * time)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
pex_wait(struct pex_obj * obj ATTRIBUTE_UNUSED,pid_t pid,int * status,struct pex_time * time)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
pex_wait(struct pex_obj * obj,pid_t pid,int * status,struct pex_time * time)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 *, 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 *
pex_init(int flags,const char * pname,const char * tempbase)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
pex_unix_open_read(struct pex_obj * obj ATTRIBUTE_UNUSED,const char * name,int binary ATTRIBUTE_UNUSED)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
pex_unix_open_write(struct pex_obj * obj ATTRIBUTE_UNUSED,const char * name,int binary ATTRIBUTE_UNUSED)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
pex_unix_close(struct pex_obj * obj ATTRIBUTE_UNUSED,int fd)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
pex_child_error(struct pex_obj * obj,const char * executable,const char * errmsg,int err)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
pex_unix_exec_child(struct pex_obj * obj,int flags,const char * executable,char * const * argv,int in,int out,int errdes,const char ** errmsg,int * err)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
pex_unix_wait(struct pex_obj * obj,long pid,int * status,struct pex_time * time,int done,const char ** errmsg,int * err)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
pex_unix_pipe(struct pex_obj * obj ATTRIBUTE_UNUSED,int * p,int binary ATTRIBUTE_UNUSED)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 *
pex_unix_fdopenr(struct pex_obj * obj ATTRIBUTE_UNUSED,int fd,int binary ATTRIBUTE_UNUSED)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
pex_unix_cleanup(struct pex_obj * obj ATTRIBUTE_UNUSED)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 }
514