Эквивалент Waitpid с тайм-аутом?

Функция может быть прервана сигналом, поэтому вы можете установить таймер перед вызовом waitpid (), и он выйдет с EINTR при срабатывании сигнала таймера. Обновлено: это должно быть так же просто, как вызов alarm (5) перед вызовом waitpid ().

I can use a signal handler for SIGCHLD, and in the signal handler do whatever I was going to do when a child exits, or send a message to a different thread to do some action. But using a signal handler obfuscates the flow of the code a little bit.

Чтобы избежать состояния гонки, вам следует избегать ничего более сложного, чем изменение изменчивого флага в обработчике сигнала.

Думаю, лучший вариант в вашем случае - отправить сигнал родителю. Затем waitpid () установит для errno значение EINTR и вернется. На этом этапе вы проверяете возвращаемое значение waitpid и errno, замечаете, что вам был отправлен сигнал, и предпринимаете соответствующие действия.

Если вы все равно собираетесь использовать сигналы (согласно предложению Стива), вы можете просто отправить сигнал вручную, когда захотите выйти. Это приведет к тому, что waitpid вернет EINTR, и тогда поток сможет выйти. Нет необходимости в периодической тревоге / перезапуске.

Не смешивайте alarm() с wait(). Таким образом вы можете потерять информацию об ошибке.

Используйте трюк с самотрубкой. Это превращает любой сигнал в событие select()able:

int selfpipe[2];
void selfpipe_sigh(int n)
{
    int save_errno = errno;
    (void)write(selfpipe[1], "",1);
    errno = save_errno;
}
void selfpipe_setup(void)
{
    static struct sigaction act;
    if (pipe(selfpipe) == -1) { abort(); }

    fcntl(selfpipe[0],F_SETFL,fcntl(selfpipe[0],F_GETFL)|O_NONBLOCK);
    fcntl(selfpipe[1],F_SETFL,fcntl(selfpipe[1],F_GETFL)|O_NONBLOCK);
    memset(&act, 0, sizeof(act));
    act.sa_handler = selfpipe_sigh;
    sigaction(SIGCHLD, &act, NULL);
}

Тогда ваша функция, похожая на waitpid, будет выглядеть так:

int selfpipe_waitpid(void)
{
    static char dummy[4096];
    fd_set rfds;
    struct timeval tv;
    int died = 0, st;

    tv.tv_sec = 5;
    tv.tv_usec = 0;
    FD_ZERO(&rfds);
    FD_SET(selfpipe[0], &rfds);
    if (select(selfpipe[0]+1, &rfds, NULL, NULL, &tv) > 0) {
       while (read(selfpipe[0],dummy,sizeof(dummy)) > 0);
       while (waitpid(-1, &st, WNOHANG) != -1) died++;
    }
    return died;
}

Вы можете увидеть в selfpipe_waitpid(), как вы можете контролировать тайм-аут и даже смешивать с другими вводами-выводами на основе select().

Я думал, что select вернет EINTR, когда SIGCHLD получит сигнал от ребенка. Я считаю, что это должно сработать:

while(1)
{
  int retval = select(0, NULL, NULL, NULL, &tv, &mask);
  if (retval == -1 && errno == EINTR) // some signal
  { 
      pid_t pid = (waitpid(-1, &st, WNOHANG) == 0);
      if (pid != 0) // some child signaled
  }
  else if (retval == 0)
  {
      // timeout
      break;
  }
  else // error
}

Примечание: вы можете использовать pselect, чтобы переопределить текущий sigmask и избежать прерываний из-за ненужных сигналов.

Форк промежуточного потомка, который разветвляет реальный потомок и процесс тайм-аута и ожидает всех (обоих) своих потомков. Когда один выйдет, он убьет другого и выйдет.

pid_t intermediate_pid = fork();
if (intermediate_pid == 0) {
    pid_t worker_pid = fork();
    if (worker_pid == 0) {
        do_work();
        _exit(0);
    }

    pid_t timeout_pid = fork();
    if (timeout_pid == 0) {
        sleep(timeout_time);
        _exit(0);
    }

    pid_t exited_pid = wait(NULL);
    if (exited_pid == worker_pid) {
        kill(timeout_pid, SIGKILL);
    } else {
        kill(worker_pid, SIGKILL); // Or something less violent if you prefer
    }
    wait(NULL); // Collect the other process
    _exit(0); // Or some more informative status
}
waitpid(intermediate_pid, 0, 0);

На удивление просто :)

Вы даже можете опустить промежуточный дочерний элемент, если уверены, что ни один другой модуль в программе не создает собственных дочерних процессов.

В силу обстоятельств мне абсолютно необходимо, чтобы это выполнялось в основном потоке, и было не очень просто использовать трюк self-pipe или eventfd, потому что мой цикл epoll выполнялся в другом потоке. Я придумал это, собрав вместе другие обработчики переполнения стека. Обратите внимание, что в целом гораздо безопаснее делать это другими способами, но это просто. Если кто-то захочет прокомментировать, насколько это действительно плохо, то я весь уши.

ПРИМЕЧАНИЕ: абсолютно необходимо заблокировать обработку сигналов в любом потоке, кроме того, в котором вы хотите запустить это. Я делаю это по умолчанию, так как считаю беспорядочным обрабатывать сигналы в случайных потоках.

static void ctlWaitPidTimeout(pid_t child, useconds_t usec, int *timedOut) {
    int rc = -1;

    static pthread_mutex_t alarmMutex = PTHREAD_MUTEX_INITIALIZER;

    TRACE("ctlWaitPidTimeout: waiting on %lu\n", (unsigned long) child);

    /**
     * paranoid, in case this was called twice in a row by different
     * threads, which could quickly turn very messy.
     */
    pthread_mutex_lock(&alarmMutex);

    /* set the alarm handler */
    struct sigaction alarmSigaction;
    struct sigaction oldSigaction;

    sigemptyset(&alarmSigaction.sa_mask);
    alarmSigaction.sa_flags   = 0;
    alarmSigaction.sa_handler = ctlAlarmSignalHandler;
    sigaction(SIGALRM, &alarmSigaction, &oldSigaction);

    /* set alarm, because no alarm is fired when the first argument is 0, 1 is used instead */
    ualarm((usec == 0) ? 1 : usec, 0);

    /* wait for the child we just killed */
    rc = waitpid(child, NULL, 0);

    /* if errno == EINTR, the alarm went off, set timedOut to true */
    *timedOut = (rc == -1 && errno == EINTR);

    /* in case we did not time out, unset the current alarm so it doesn't bother us later */
    ualarm(0, 0);

    /* restore old signal action */
    sigaction(SIGALRM, &oldSigaction, NULL);

    pthread_mutex_unlock(&alarmMutex);

    TRACE("ctlWaitPidTimeout: timeout wait done, rc = %d, error = '%s'\n", rc, (rc == -1) ? strerror(errno) : "none");
}

static void ctlAlarmSignalHandler(int s) {
    TRACE("ctlAlarmSignalHandler: alarm occured, %d\n", s);
}

РЕДАКТИРОВАТЬ: С тех пор я перешел на использование решения, которое хорошо интегрируется с моим существующим циклом событий на основе epoll (), используя timerfd. Я действительно не теряю никакой независимости от платформы, поскольку я все равно использовал epoll, и я получаю дополнительный сон, потому что я знаю, что нечестивая комбинация многопоточности и сигналов UNIX не повредит моей программе снова.

Это интересный вопрос. Я обнаружил, что sigtimedwait может это сделать.

РЕДАКТИРОВАТЬ 2016/08/29: Спасибо за предложение Марка Эдингтона. Я протестировал ваш пример на Ubuntu 16.04, он работает, как ожидалось.

Примечание: это работает только для дочерних процессов. Жалко, что, похоже, нет эквивалентного способа Window WaitForSingleObject (unrelated_process_handle, timeout) в Linux / Unix для получения уведомлений о завершении несвязанного процесса в течение тайм-аута.

Хорошо, пример кода Марка Эдингтона - здесь:

/* The program creates a child process and waits for it to finish. If a timeout
 * elapses the child is killed. Waiting is done using sigtimedwait(). Race
 * condition is avoided by blocking the SIGCHLD signal before fork().
 */
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>

static pid_t fork_child (void)
{
    int p = fork ();

    if (p == -1) {
        perror ("fork");
        exit (1);
    }

    if (p == 0) {
        puts ("child: sleeping...");
        sleep (10);
        puts ("child: exiting");
        exit (0);
    }

    return p;
}

int main (int argc, char *argv[])
{
    sigset_t mask;
    sigset_t orig_mask;
    struct timespec timeout;
    pid_t pid;

    sigemptyset (&mask);
    sigaddset (&mask, SIGCHLD);

    if (sigprocmask(SIG_BLOCK, &mask, &orig_mask) < 0) {
        perror ("sigprocmask");
        return 1;
    }

    pid = fork_child ();

    timeout.tv_sec = 5;
    timeout.tv_nsec = 0;

    do {
        if (sigtimedwait(&mask, NULL, &timeout) < 0) {
            if (errno == EINTR) {
                /* Interrupted by a signal other than SIGCHLD. */
                continue;
            }
            else if (errno == EAGAIN) {
                printf ("Timeout, killing child\n");
                kill (pid, SIGKILL);
            }
            else {
                perror ("sigtimedwait");
                return 1;
            }
        }

        break;
    } while (1);

    if (waitpid(pid, NULL, 0) < 0) {
        perror ("waitpid");
        return 1;
    }

    return 0;
}

Вместо прямого вызова waitpid () вы можете вызвать sigtimedwait () с помощью SIGCHLD (который будет отправлен родительскому процессу после выхода дочернего процесса) и дождаться, когда он будет доставлен в текущий поток, как указано в названии функции, параметр тайм-аута поддерживается.

пожалуйста, проверьте следующий фрагмент кода для подробностей

static bool waitpid_with_timeout(pid_t pid, int timeout_ms, int* status) {
    sigset_t child_mask, old_mask;
    sigemptyset(&child_mask);
    sigaddset(&child_mask, SIGCHLD);

    if (sigprocmask(SIG_BLOCK, &child_mask, &old_mask) == -1) {
        printf("*** sigprocmask failed: %s\n", strerror(errno));
        return false;
    }

    timespec ts;
    ts.tv_sec = MSEC_TO_SEC(timeout_ms);
    ts.tv_nsec = (timeout_ms % 1000) * 1000000;
    int ret = TEMP_FAILURE_RETRY(sigtimedwait(&child_mask, NULL, &ts));
    int saved_errno = errno;

    // Set the signals back the way they were.
    if (sigprocmask(SIG_SETMASK, &old_mask, NULL) == -1) {
        printf("*** sigprocmask failed: %s\n", strerror(errno));
        if (ret == 0) {
            return false;
        }
    }
    if (ret == -1) {
        errno = saved_errno;
        if (errno == EAGAIN) {
            errno = ETIMEDOUT;
        } else {
            printf("*** sigtimedwait failed: %s\n", strerror(errno));
        }
        return false;
    }

    pid_t child_pid = waitpid(pid, status, WNOHANG);
    if (child_pid != pid) {
        if (child_pid != -1) {
            printf("*** Waiting for pid %d, got pid %d instead\n", pid, child_pid);
        } else {
            printf("*** waitpid failed: %s\n", strerror(errno));
        }
        return false;
    }
    return true;
}

См .: https://android.googlesource.com/platform/frameworks/native/+/master/cmds/dumpstate/DumpstateUtil.cpp#46

Если ваша программа работает только на современных ядрах Linux (5.3 или новее), предпочтительным способом является использование pidfd_open (https://lwn.net/Articles/789023/https://man7.org/linux/man-pages/man2/pidfd_open.2.html).

Этот системный вызов возвращает файловый дескриптор, представляющий процесс, и затем вы можете использовать select, poll или epoll, точно так же, как вы ожидаете от других типов файловых дескрипторов.

Например,

int fd = pidfd_open(pid, 0);
struct pollfd pfd = {fd, POLLIN, 0};
poll(&pfd, 1, 1000) == 1;