misc-utils/waitpid.c

   1 /*
   2  * waitpid(1) - wait for process termination
   3  *
   4  * Copyright (C) 2022 Thomas Weißschuh <thomas@t-8ch.de>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it would be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  */
  20
  21 #include <sys/epoll.h>
  22 #include <sys/timerfd.h>
  23 #include <assert.h>
  24 #include <stdlib.h>
  25 #include <errno.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #include <stdbool.h>
  29 #include <getopt.h>
  30
  31 #include "pidfd-utils.h"
  32 #include "c.h"
  33 #include "nls.h"
  34 #include "xalloc.h"
  35 #include "strutils.h"
  36 #include "exitcodes.h"
  37 #include "timeutils.h"
  38 #include "optutils.h"
  39
  40 #define EXIT_TIMEOUT_EXPIRED 3
  41
  42 #define TIMEOUT_SOCKET_IDX UINT64_MAX
  43
  44 #define err_nosys(exitcode, ...) \
  45         err(errno == ENOSYS ? EXIT_NOTSUPP : exitcode, __VA_ARGS__)
  46
  47 static bool verbose = false;
  48 static struct timespec timeout;
  49 static bool allow_exited = false;
  50 static size_t count;
  51
  52 static pid_t *parse_pids(size_t n_strings, char * const *strings)
  53 {
  54         pid_t *pids = xcalloc(n_strings, sizeof(*pids));
  55
  56         for (size_t i = 0; i < n_strings; i++)
  57                 pids[i] = strtopid_or_err(strings[i], _("failed to parse pid"));
  58
  59         return pids;
  60 }
  61
  62 static int *open_pidfds(size_t n_pids, pid_t *pids)
  63 {
  64         int *pidfds = xcalloc(n_pids, sizeof(*pidfds));
  65
  66         for (size_t i = 0; i < n_pids; i++) {
  67                 pidfds[i] = pidfd_open(pids[i], 0);
  68                 if (pidfds[i] == -1) {
  69                         if (allow_exited && errno == ESRCH) {
  70                                 warnx(_("PID %d has exited, skipping"), pids[i]);
  71                                 continue;
  72                         }
  73                         err_nosys(EXIT_FAILURE, _("could not open pid %u"), pids[i]);
  74                 }
  75         }
  76
  77         return pidfds;
  78 }
  79
  80 static int open_timeoutfd(void)
  81 {
  82         int fd;
  83         struct itimerspec timer = {};
  84
  85         if (!timeout.tv_sec && !timeout.tv_nsec)
  86                 return -1;
  87
  88         timer.it_value = timeout;
  89
  90         fd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC);
  91         if (fd == -1)
  92                 err_nosys(EXIT_FAILURE, _("could not create timerfd"));
  93
  94         if (timerfd_settime(fd, 0, &timer, NULL))
  95                 err_nosys(EXIT_FAILURE, _("could not set timer"));
  96
  97         return fd;
  98
  99 }
 100
 101 static size_t add_listeners(int epll, size_t n_pids, int * const pidfds, int timeoutfd)
 102 {
 103         size_t skipped = 0;
 104         struct epoll_event evt = {
 105                 .events = EPOLLIN,
 106         };
 107
 108         if (timeoutfd != -1) {
 109                 evt.data.u64 = TIMEOUT_SOCKET_IDX;
 110                 if (epoll_ctl(epll, EPOLL_CTL_ADD, timeoutfd, &evt))
 111                         err_nosys(EXIT_FAILURE, _("could not add timerfd"));
 112         }
 113
 114         for (size_t i = 0; i < n_pids; i++) {
 115                 if (pidfds[i] == -1) {
 116                         skipped++;
 117                         continue;
 118                 }
 119                 evt.data.u64 = i;
 120                 if (epoll_ctl(epll, EPOLL_CTL_ADD, pidfds[i], &evt))
 121                         err_nosys(EXIT_FAILURE, _("could not add listener"));
 122         }
 123
 124         return n_pids - skipped;
 125 }
 126
 127 static void wait_for_exits(int epll, size_t active_pids, pid_t * const pids,
 128                            int * const pidfds)
 129 {
 130         while (active_pids) {
 131                 struct epoll_event evt;
 132                 int ret, fd;
 133
 134                 ret = epoll_wait(epll, &evt, 1, -1);
 135                 if (ret == -1) {
 136                         if (errno == EINTR)
 137                                 continue;
 138                         else
 139                                 err_nosys(EXIT_FAILURE, _("failure during wait"));
 140                 }
 141                 if (evt.data.u64 == TIMEOUT_SOCKET_IDX) {
 142                         if (verbose)
 143                                 printf(_("Timeout expired\n"));
 144                         exit(EXIT_TIMEOUT_EXPIRED);
 145                 }
 146                 if (verbose)
 147                         printf(_("PID %d finished\n"), pids[evt.data.u64]);
 148                 assert((size_t) ret <= active_pids);
 149                 fd = pidfds[evt.data.u64];
 150                 epoll_ctl(epll, EPOLL_CTL_DEL, fd, NULL);
 151                 active_pids -= ret;
 152         }
 153 }
 154
 155 static void __attribute__((__noreturn__)) usage(void)
 156 {
 157         FILE *out = stdout;
 158
 159         fputs(USAGE_HEADER, out);
 160         fprintf(out, _(" %s [options] pid...\n"), program_invocation_short_name);
 161
 162         fputs(USAGE_OPTIONS, out);
 163         fputs(_(" -v, --verbose           be more verbose\n"), out);
 164         fputs(_(" -t, --timeout=<timeout> wait at most timeout seconds\n"), out);
 165         fputs(_(" -e, --exited            allow exited PIDs\n"), out);
 166         fputs(_(" -c, --count=<count>     number of process exits to wait for\n"), out);
 167
 168         fputs(USAGE_SEPARATOR, out);
 169         fprintf(out, USAGE_HELP_OPTIONS(25));
 170
 171         fprintf(out, USAGE_MAN_TAIL("waitpid(1)"));
 172
 173         exit(EXIT_SUCCESS);
 174 }
 175
 176 static int parse_options(int argc, char **argv)
 177 {
 178         int c;
 179         static const struct option longopts[] = {
 180                 { "verbose", no_argument,       NULL, 'v' },
 181                 { "timeout", required_argument, NULL, 't' },
 182                 { "exited",  no_argument,       NULL, 'e' },
 183                 { "count",   required_argument, NULL, 'c' },
 184                 { "version", no_argument,       NULL, 'V' },
 185                 { "help",    no_argument,       NULL, 'h' },
 186                 { 0 }
 187         };
 188         static const ul_excl_t excl[] = {       /* rows and cols in ASCII order */
 189                 { 'c', 'e' },
 190                 { 0 }
 191         };
 192         int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
 193
 194         while ((c = getopt_long (argc, argv, "vVht:c:e", longopts, NULL)) != -1) {
 195
 196                 err_exclusive_options(c, longopts, excl, excl_st);
 197
 198                 switch (c) {
 199                 case 'v':
 200                         verbose = true;
 201                         break;
 202                 case 't':
 203                         strtotimespec_or_err(optarg, &timeout,
 204                                              _("Could not parse timeout"));
 205                         break;
 206                 case 'e':
 207                         allow_exited = true;
 208                         break;
 209                 case 'c':
 210                         count = str2num_or_err(optarg, 10, _("Invalid count"),
 211                                                1, INT64_MAX);
 212                         break;
 213                 case 'V':
 214                         print_version(EXIT_SUCCESS);
 215                 case 'h':
 216                         usage();
 217                 default:
 218                         errtryhelp(EXIT_FAILURE);
 219                 }
 220         }
 221
 222         return optind;
 223 }
 224
 225 int main(int argc, char **argv)
 226 {
 227         int pid_idx, epoll, timeoutfd, *pidfds;
 228         size_t n_pids, active_pids;
 229
 230         setlocale(LC_ALL, "");
 231         bindtextdomain(PACKAGE, LOCALEDIR);
 232         textdomain(PACKAGE);
 233
 234         pid_idx = parse_options(argc, argv);
 235         n_pids = argc - pid_idx;
 236         if (!n_pids)
 237                 errx(EXIT_FAILURE, _("no PIDs specified"));
 238
 239         if (count && count > n_pids)
 240                 errx(EXIT_FAILURE,
 241                      _("can't want for %zu of %zu PIDs"), count, n_pids);
 242
 243         pid_t *pids = parse_pids(argc - pid_idx, argv + pid_idx);
 244
 245         pidfds = open_pidfds(n_pids, pids);
 246         timeoutfd = open_timeoutfd();
 247         epoll = epoll_create(n_pids);
 248         if (epoll == -1)
 249                 err_nosys(EXIT_FAILURE, _("could not create epoll"));
 250
 251         active_pids = add_listeners(epoll, n_pids, pidfds, timeoutfd);
 252         if (count)
 253                 active_pids = min(active_pids, count);
 254         wait_for_exits(epoll, active_pids, pids, pidfds);
 255 }