Завершение процесса после превышения лимита времени - PullRequest
0 голосов
/ 21 ноября 2018

Я уже давно работаю над следующим кодом, но не могу разобраться.Задача - прочитать команду терминала и запускать ее каждые x секунд;если команда не завершила работу в течение времени ожидания, мы хотим завершить процесс и затем снова запустить команду.Любая помощь могла бы быть полезна.Я уверен, что не правильно использую waitpid ();Как мне использовать waitpid для достижения цели?

Кроме того, как мне обнаружить ошибку в дочернем процессе?Планируется уничтожить родительский процесс, если в дочернем процессе произошла ошибка.

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

/*
 * 
 */
int main(int argc, char** argv) {
    int waitingTime;
    if (argc < 3) {
        printf("Invalid number of arguments provided. Please specify a command and exactly one parameter.");
        return (EXIT_FAILURE);
    } 
    // -n parameter specified? If so, set the waiting time.
    if (argc == 5 && strcmp(argv[3], "-n") == 0) {
        waitingTime = atoi(argv[4]);
    } else {
        waitingTime = 5; // Default waiting time.
    }

    char* cmd = (char*)malloc(sizeof(argv[1]));
    cmd = argv[1];
    char* param = (char*)malloc(sizeof(argv[2]));
    param = argv[2];

    // Print the read command and its param
    printf("Command: %s, Parameter: %s, Interval: %d\n\n", cmd, param, waitingTime);    

    pid_t pid;

    for (;;) { 
        // Declared here for scope
        int secsWaited;
        secsWaited = 0;
        pid = fork();

        if (pid == 0) {
            pid = getpid();
            printf("==============\n");
            execlp(cmd, cmd, param, "/", (char *)NULL);
            printf("Excec failed; killing the proccess.");
            kill(pid, SIGKILL);
        } else if (pid > 0) {
            int status, code;
            for (;;) {
                code = waitpid(pid, &status, WNOHANG);
            if (code == 0 && secsWaited >= waitingTime) {
                kill(pid, SIGKILL);
            printf("Child stopped");
            break;
        } else if (code == 0 && secsWaited < waitingTime) {
            secsWaited++;   
                    sleep(1);
                } else {
                    break;
                }
            }

            /*if (!WIFEXITED(status)) {
                printf("Time exceeding, stopping child.");
        // Get parent process id and kill it.
        kill(getpid(), SIGKILL);
        }*/



            // Sleep for the specified time
            sleep(waitingTime - secsWaited);

        } else {
            return (EXIT_FAILURE);
        }

    }      

    free(cmd);
    free(param);       
    return (EXIT_SUCCESS);
}

1 Ответ

0 голосов
/ 21 ноября 2018

Ваша логика была слишком сложной (например, слишком много разных sleep вызовов и if/else релейной логики).

Кроме того, нет необходимости malloc строк argv - они могутиспользовать напрямую.

Я упростила его и немного реструктурировала, чтобы заставить его работать [прошу прощения за бесполезную очистку стиля]:

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

/*
 *
 */
int
main(int argc, char **argv)
{
    int waitingTime;

    if (argc < 3) {
        printf("Invalid number of arguments provided. Please specify a command and exactly one parameter.");
        return (EXIT_FAILURE);
    }
    // -n parameter specified? If so, set the waiting time.
    if (argc == 5 && strcmp(argv[3], "-n") == 0) {
        waitingTime = atoi(argv[4]);
    }
    else {
        waitingTime = 5;                // Default waiting time.
    }

    char *cmd = argv[1];
    char *param = argv[2];

    // Print the read command and its param
    printf("Command: %s, Parameter: %s, Interval: %d\n\n",
        cmd, param, waitingTime);

    pid_t pid;
    int code = -1;
    int status;
    int killflg = 1;

    for (;;) {
        // Declared here for scope
        int secsWaited;

        secsWaited = 0;
        pid = fork();

        // stop on fork failure
        if (pid < 0) {
            killflg = 1;
            break;
        }

        // child process
        if (pid == 0) {
            pid = getpid();
            printf("==============\n");
#if 0
            execlp(cmd, cmd, param, "/", (char *) NULL);
#else
            execlp(cmd, cmd, param, (char *) NULL);
#endif
            printf("Excec failed; killing the proccess.");

// NOTE/BUG: this is the child so pid is zero, so killing it is wrong
#if 0
            kill(pid, SIGKILL);
#else
            exit(1);
#endif
        }

        killflg = 0;
        for (;;) {
            code = waitpid(pid, &status, WNOHANG);
            if (code > 0)
                break;

            if (killflg)
                continue;

            secsWaited++;
            sleep(1);

            if (secsWaited >= waitingTime) {
                printf("timeout\n");
                kill(pid, SIGKILL);
                killflg = 1;
            }
        }

        if (! killflg)
            break;
    }

#if 0
    free(cmd);
    free(param);
#endif

    if (killflg)
        code = EXIT_FAILURE;
    else
        code = EXIT_SUCCESS;

    return code;
}

ОБНОВЛЕНИЕ:

Сейчас программа остановится после одной итерации;если я уберу точку останова на if (! killflg), она будет работать как положено.Я что-то упустил или это просто недоразумение?

Вы правы - мой плохой.В вашем вопросе я пропустил следующее:

Задача - прочитать команду терминала и запускать ее каждые x секунд;

Изменить break на sleep(waitingTime - secsWaited).


Но более надежным способом отслеживания прошедшего времени может быть два вызова time(2):

После killflg = 0 выполните: time_t todbeg = time(NULL); time_t todelap;.Затем вы можете получить истекшее время [где угодно] с помощью: todelap = time(NULL) - todbeg; [здесь, todelap похоже на secsWaited].Это может быть лучше, чем увеличение secsWaited.

time имеет разрешение только в секундах.Для более точного управления рассмотрите возможность использования clock_gettime [имеет наносекундное разрешение].

Вот функция, которую я часто использую для прошедшего времени [в дробных секундах]:

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

double
tvgetf(void)
{
    struct timespec ts;
    double sec;

    clock_gettime(CLOCK_REALTIME,&ts);

    sec = ts.tv_nsec;
    sec /= 1e9;
    sec += ts.tv_sec;

    return sec;
}

/*
 *
 */
int
main(int argc, char **argv)
{
    int waitingTime;

    if (argc < 3) {
        printf("Invalid number of arguments provided. Please specify a command and exactly one parameter.");
        return (EXIT_FAILURE);
    }
    // -n parameter specified? If so, set the waiting time.
    if (argc == 5 && strcmp(argv[3], "-n") == 0) {
        waitingTime = atoi(argv[4]);
    }
    else {
        waitingTime = 5;                // Default waiting time.
    }

    char *cmd = argv[1];
    char *param = argv[2];

    // Print the read command and its param
    printf("Command: %s, Parameter: %s, Interval: %d\n\n", cmd, param, waitingTime);

    pid_t pid;
    int code = -1;
    int status;
    int killflg = 1;
    double todzero = tvgetf();

    for (;;) {
        // Declared here for scope
        double todbeg = tvgetf();
        double todelap;

        pid = fork();

        // stop on fork failure
        if (pid < 0) {
            killflg = 1;
            break;
        }

        // child process
        if (pid == 0) {
            pid = getpid();
            printf("============== (%.9f)\n",tvgetf() - todzero);
            execlp(cmd, cmd, param, (char *) NULL);
            printf("Excec failed; killing the proccess.");
            exit(1);
        }

        killflg = 0;
        for (;;) {
            code = waitpid(pid, &status, WNOHANG);
            if (code > 0)
                break;

            if (killflg)
                continue;

            usleep(1000);

            todelap = tvgetf() - todbeg;
            if (todelap >= waitingTime) {
                printf("timeout\n");
                kill(pid, SIGKILL);
                killflg = 1;
            }
        }

        // do _not_ wait -- we already timed out
        if (killflg)
            continue;

        // get final elapsed time for this round and the amount of time
        // remaining until the next interval
        todelap = tvgetf() - todbeg;
        useconds_t time_to_wait = ((double) waitingTime - todelap) * 1e6;

        // wait until the next time period
        if (time_to_wait > 0)
            usleep(time_to_wait);
    }

    if (killflg)
        code = EXIT_FAILURE;
    else
        code = EXIT_SUCCESS;

    return code;
}

Примечание: Я использовал usleep здесь, но, хотя и немного сложнее, считается, что лучше использовать nanosleep

...