2009-11-17 22:47:20 +00:00
|
|
|
/*-
|
|
|
|
* Copyright (c) 2004-2009, Jilles Tjoelker
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with
|
|
|
|
* or without modification, are permitted provided that the
|
|
|
|
* following conditions are met:
|
|
|
|
*
|
|
|
|
* 1. Redistributions of source code must retain the above
|
|
|
|
* copyright notice, this list of conditions and the
|
|
|
|
* following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the
|
|
|
|
* above copyright notice, this list of conditions and
|
|
|
|
* the following disclaimer in the documentation and/or
|
|
|
|
* other materials provided with the distribution.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
|
|
|
|
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
|
|
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
|
|
|
|
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
|
|
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY
|
|
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
|
|
|
|
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
|
|
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
|
|
|
|
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
|
|
|
|
* OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/event.h>
|
|
|
|
#include <sys/time.h>
|
|
|
|
#include <sys/wait.h>
|
|
|
|
|
|
|
|
#include <err.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <signal.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <sysexits.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
|
|
|
|
static void
|
|
|
|
usage(void)
|
|
|
|
{
|
|
|
|
|
2020-01-26 10:49:24 +00:00
|
|
|
errx(EX_USAGE, "usage: pwait [-t timeout] [-v] pid ...");
|
2009-11-17 22:47:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* pwait - wait for processes to terminate
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
main(int argc, char *argv[])
|
|
|
|
{
|
2017-03-07 22:16:55 +00:00
|
|
|
struct itimerval itv;
|
2009-11-17 22:47:20 +00:00
|
|
|
int kq;
|
|
|
|
struct kevent *e;
|
2017-03-07 22:16:55 +00:00
|
|
|
int tflag, verbose;
|
2020-01-26 10:51:57 +00:00
|
|
|
int opt, nleft, n, i, status;
|
2009-11-17 22:47:20 +00:00
|
|
|
long pid;
|
|
|
|
char *s, *end;
|
2017-03-07 22:16:55 +00:00
|
|
|
double timeout;
|
2009-11-17 22:47:20 +00:00
|
|
|
|
2017-03-07 22:16:55 +00:00
|
|
|
tflag = verbose = 0;
|
|
|
|
memset(&itv, 0, sizeof(itv));
|
|
|
|
while ((opt = getopt(argc, argv, "t:v")) != -1) {
|
2009-11-17 22:47:20 +00:00
|
|
|
switch (opt) {
|
2017-03-07 22:16:55 +00:00
|
|
|
case 't':
|
|
|
|
tflag = 1;
|
|
|
|
errno = 0;
|
|
|
|
timeout = strtod(optarg, &end);
|
|
|
|
if (end == optarg || errno == ERANGE ||
|
|
|
|
timeout < 0)
|
|
|
|
errx(EX_DATAERR, "timeout value");
|
|
|
|
switch(*end) {
|
|
|
|
case 0:
|
|
|
|
case 's':
|
|
|
|
break;
|
|
|
|
case 'h':
|
|
|
|
timeout *= 60;
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
case 'm':
|
|
|
|
timeout *= 60;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
errx(EX_DATAERR, "timeout unit");
|
|
|
|
}
|
|
|
|
if (timeout > 100000000L)
|
|
|
|
errx(EX_DATAERR, "timeout value");
|
|
|
|
itv.it_value.tv_sec = (time_t)timeout;
|
|
|
|
timeout -= (time_t)timeout;
|
|
|
|
itv.it_value.tv_usec =
|
|
|
|
(suseconds_t)(timeout * 1000000UL);
|
|
|
|
break;
|
2009-11-17 22:47:20 +00:00
|
|
|
case 'v':
|
|
|
|
verbose = 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
usage();
|
|
|
|
/* NOTREACHED */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
argc -= optind;
|
|
|
|
argv += optind;
|
|
|
|
|
|
|
|
if (argc == 0)
|
|
|
|
usage();
|
|
|
|
|
|
|
|
kq = kqueue();
|
|
|
|
if (kq == -1)
|
2020-01-26 10:49:24 +00:00
|
|
|
err(EX_OSERR, "kqueue");
|
2009-11-17 22:47:20 +00:00
|
|
|
|
2017-03-07 22:16:55 +00:00
|
|
|
e = malloc((argc + tflag) * sizeof(struct kevent));
|
2009-11-17 22:47:20 +00:00
|
|
|
if (e == NULL)
|
2020-01-26 10:49:24 +00:00
|
|
|
err(EX_OSERR, "malloc");
|
2009-11-17 22:47:20 +00:00
|
|
|
nleft = 0;
|
|
|
|
for (n = 0; n < argc; n++) {
|
|
|
|
s = argv[n];
|
|
|
|
if (!strncmp(s, "/proc/", 6)) /* Undocumented Solaris compat */
|
|
|
|
s += 6;
|
|
|
|
errno = 0;
|
|
|
|
pid = strtol(s, &end, 10);
|
|
|
|
if (pid < 0 || *end != '\0' || errno != 0) {
|
|
|
|
warnx("%s: bad process id", s);
|
|
|
|
continue;
|
|
|
|
}
|
2020-01-26 10:51:57 +00:00
|
|
|
for (i = 0; i < nleft; i++) {
|
2009-11-17 22:47:20 +00:00
|
|
|
if (e[i].ident == (uintptr_t)pid)
|
2020-01-26 10:51:57 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (i < nleft) {
|
|
|
|
/* Duplicate. */
|
|
|
|
continue;
|
2009-11-17 22:47:20 +00:00
|
|
|
}
|
2020-01-26 10:51:57 +00:00
|
|
|
EV_SET(e + nleft, pid, EVFILT_PROC, EV_ADD, NOTE_EXIT, 0, NULL);
|
|
|
|
if (kevent(kq, e + nleft, 1, NULL, 0, NULL) == -1)
|
|
|
|
warn("%ld", pid);
|
|
|
|
else
|
|
|
|
nleft++;
|
2009-11-17 22:47:20 +00:00
|
|
|
}
|
|
|
|
|
2020-01-26 10:54:16 +00:00
|
|
|
if (nleft > 0 && tflag) {
|
2017-03-07 22:16:55 +00:00
|
|
|
/*
|
|
|
|
* Explicitly detect SIGALRM so that an exit status of 124
|
|
|
|
* can be returned rather than 142.
|
|
|
|
*/
|
|
|
|
EV_SET(e + nleft, SIGALRM, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
|
|
|
|
if (kevent(kq, e + nleft, 1, NULL, 0, NULL) == -1)
|
|
|
|
err(EX_OSERR, "kevent");
|
|
|
|
/* Ignore SIGALRM to not interrupt kevent(2). */
|
|
|
|
signal(SIGALRM, SIG_IGN);
|
|
|
|
if (setitimer(ITIMER_REAL, &itv, NULL) == -1)
|
|
|
|
err(EX_OSERR, "setitimer");
|
|
|
|
}
|
2009-11-17 22:47:20 +00:00
|
|
|
while (nleft > 0) {
|
2017-03-07 22:16:55 +00:00
|
|
|
n = kevent(kq, NULL, 0, e, nleft + tflag, NULL);
|
2009-11-17 22:47:20 +00:00
|
|
|
if (n == -1)
|
2020-01-26 10:49:24 +00:00
|
|
|
err(EX_OSERR, "kevent");
|
2017-03-07 22:16:55 +00:00
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
if (e[i].filter == EVFILT_SIGNAL) {
|
|
|
|
if (verbose)
|
|
|
|
printf("timeout\n");
|
2020-01-26 10:49:24 +00:00
|
|
|
exit(124);
|
2017-03-07 22:16:55 +00:00
|
|
|
}
|
|
|
|
if (verbose) {
|
2009-11-17 22:47:20 +00:00
|
|
|
status = e[i].data;
|
|
|
|
if (WIFEXITED(status))
|
|
|
|
printf("%ld: exited with status %d.\n",
|
|
|
|
(long)e[i].ident,
|
|
|
|
WEXITSTATUS(status));
|
|
|
|
else if (WIFSIGNALED(status))
|
|
|
|
printf("%ld: killed by signal %d.\n",
|
|
|
|
(long)e[i].ident,
|
|
|
|
WTERMSIG(status));
|
|
|
|
else
|
|
|
|
printf("%ld: terminated.\n",
|
|
|
|
(long)e[i].ident);
|
|
|
|
}
|
2017-03-07 22:16:55 +00:00
|
|
|
--nleft;
|
|
|
|
}
|
2009-11-17 22:47:20 +00:00
|
|
|
}
|
|
|
|
|
2013-01-16 18:15:25 +00:00
|
|
|
exit(EX_OK);
|
2009-11-17 22:47:20 +00:00
|
|
|
}
|