c проверять сигналы каждые n секунд

Question

Я пытаюсь написать программу, которая каждые 5 секунд проверяет все полученные сигналы и изменяет их выход в зависимости от них.Моя главная проблема - заставить код фактически ждать 5 секунд, так как функция sleep () прерывается, как только обрабатывается сигнал.Я попытался разделить программу на два процесса, чтобы только ребенок работал с сигналами и передавал их по каналу.Проблема в том, что, будучи блокированным каналом, после первых 5 секунд родитель просто попытается прочитать там, в основном делая сон бесполезным.

Теоретически я должен быть в состоянии решить такую ​​проблему, просто используябиблиотеки, которые я включил (или, в качестве альтернативы, с библиотекой pthread, это назначение), в противном случае я увидел, что могу использовать другие библиотеки, чтобы канал не блокировал, но на данный момент у меня нет идей, как это исправить (я также пыталсянеудачная попытка с потоком).

Я прилагаю код для справки, заранее спасибо.

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int p[2];//pipe

void sigHandler (int sig) {
    char c;
    switch (sig) {
        case SIGUSR1:
            c = '1';
        break;
        case SIGUSR2:
            c = '2';
        break;
        case SIGALRM:
            c = '0';
        break;
        case SIGSTOP:
            exit (0);
        break;
    }
    write(p[1], &c, sizeof(char));
}


int main(int argc, char **argv) {
    int signals[3], sig, i;
    for (i=0; i< 3; i++) {
        signals[i] =0;
    }
    pid_t pid;
    char csig;
    pipe(p);

    /*fork code*/
    pid = fork();

    /*parent*/
    if (pid) { 
        close(p[1]);
        int proceed = 1;

        /*cycle keeps on indefinitely*/
        while (proceed) {
            sleep(15); //increased the time so I have time to send signals
            while (read(p[0], &csig, sizeof(char)) > 0) {
                sig=atoi(&csig);
                signals[sig]++;

                /*if alternating sigals, error*/
                if (signals[1] && signals[2]) {
                    printf("Error: alternating SIGUSR1 and SIGUSR2\n%d\t%d\n", signals[1], signals[2]);

                }
                /*if 2 consecutive signals, success*/
                if (signals[sig] == 2) {
                    printf("Success: two consecutive SIGUSR1 or SIGUSR2\n");
                }
                /*if three consecutive signals, exit*/
                if (signals[sig] == 3) {
                    kill(pid, SIGSTOP);
                    proceed = 0;
                    break;
                }
                /*make 0 any non repeating signal != sig*/
                for(i = 0; i< 3; i++) {
                    if (i != sig) {
                        signals[i] = 0;
                    }
                }
            }
        }
    /*child*/
    } else {
        close(p[0]);
        signal(SIGUSR1, sigHandler);
        signal(SIGUSR2, sigHandler);
        signal(SIGALRM, sigHandler);
        signal(SIGSTOP, sigHandler);
        while (1) {
            sleep(5); //no need to do anything else
        }
        exit(1);

    }
    return 0;
}

Answer 1

clock_nanosleep позволяет вам спать до абсолютного времени.Вы можете повторно вызывать эту функцию, пока не будет достигнуто желаемое время.

struct timespec time_now;
clock_gettime(CLOCK_REALTIME, &time_now);
time_now.tv_sec += 5;
time_now.tv_nsec = 0;
while(clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &time_now, NULL) == EINTR);

Это заставит ваш поток несколько раз спать, пока он не завершит 5-секундный сон.В вашем обработчике сигналов вы продолжаете добавлять полученные сигналы в массив и обрабатываете его после окончания сна.

Answer 2

Почему так сложно?Сигналы являются отдельными процессами (и, возможно, отдельными потоками в том же процессе, когда используются потоки POSIX), поэтому нет смысла использовать несколько процессов только для обработки сигналов.

Рассмотрим следующую программу:

#define  _POSIX_C_SOURCE  200809L
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <time.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>

static const char *signal_name(const int signum)
{
    switch (signum) {
    case SIGUSR1: return "SIGUSR1";
    case SIGUSR2: return "SIGUSR2";
    case SIGALRM: return "SIGALRM";
    case SIGSTOP: return "SIGSTOP";
    case SIGINT:  return "SIGINT";
    default:      return "unnamed";
    }
}

int main(void)
{
    siginfo_t  info;
    sigset_t   mask;
    int        signum;

    sigemptyset(&mask);
    sigaddset(&mask, SIGUSR1);
    sigaddset(&mask, SIGUSR2);
    sigaddset(&mask, SIGALRM);
    sigaddset(&mask, SIGSTOP);
    sigaddset(&mask, SIGINT);

    /* Block the signals in mask. */
    if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1) {
        fprintf(stderr, "Cannot block signals: %s.\n", strerror(errno));
        exit(EXIT_FAILURE);
    }

    printf("Process %d is ready for USR1 and USR2 signals.\n", (int)getpid());
    fflush(stdout);

    /* Ensure we receive a SIGALRM signal in five seconds or so. */
    alarm(5);

    while (1) {

        /* Receive one of the signals in mask. */ 
        signum = sigwaitinfo(&mask, &info);
        if (signum == -1) {
            const int  err = errno;

            /* EINTR should not happen, but if it did, it would be okay. */
            if (err == EINTR)
                continue;

            fprintf(stderr, "sigwaitinfo() failed: %s (%d).\n", strerror(err), err);
            exit(EXIT_FAILURE);
        }

        /* Describe the received signal. */
        if (info.si_pid)
            printf("Received %s (signal %d) from process %d.\n", signal_name(signum), signum, (int)info.si_pid);
        else
            printf("Received %s (signal %d).\n", signal_name(signum), signum);
        fflush(stdout);

        /* It is time to exit, if we receive INT or STOP, */
        if (signum == SIGINT || signum == SIGSTOP)
            break;

        /* or an ALRM timeout; don't be fooled by kill()/sigqueue() SIGALRM. */
        if (signum == SIGALRM && !info.si_pid)
            break;
    }

    printf("Done.\n");
    return EXIT_SUCCESS;
}

mask содержит набор сигналов, заблокированных и полученных только через sigwaitinfo().alarm(5) гарантирует, что сигнал SIGALRM будет доставлен примерно через пять секунд.Если установлено значение info.si_pid, сигнал был отправлен с помощью kill() (или аналогичных системных вызовов для ОС).

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

Вы не можетеобмануть программу, отправив ей сигнал SIGALRM, потому что ядро ​​устанавливает поле .si_pid структуры siginfo_t для процесса отправки;для всех «подлинных» сигналов тревоги он будет равен нулю.

Помните, что стандартные сигналы Unix / POSIX не ставятся в очередь и могут иметь задержку (например, спящие и таймеры могут доставляться позже, чем предполагалось).

Answer 3

1. Вычислить, сколько времени будет через пять секунд.Сохраните это время.
2. Вычислите, сколько времени пройдет до времени, которое вы вычислили в шаге 1.
3. Спите столько времени.
4. Проверьте время.
5. Если это время или время, которое вы сохранили на шаге 1, все готово.
6. Перейти к шагу 2.