C：暂停system（）调用

IsQb 发表于 Dev

智商

尝试暂停执行system()呼叫时，C语言出现问题。

线程重复调用某个应用程序（例如某个基准）。每当收到信号时SIGUSR1，暂停执行并在接收时恢复SIGUSR2。

来源看起来像这样：

#include <signal.h>
#include <pthread.h>

void* run_app(sigset_t* signalsBetweenControllerandLoad)
{
    /* assign handler */
    signal(SIGUSR1, pausesignal_handler)
    signal(SIGUSR2, pausesignal_handler)
    pthread_sigmask(SIG_UNBLOCK, signalsBetweenControllerandLoad, NULL))

    /* call application repeatedly */
    while(1) {
        system(SOMECOMMAND);
    }

    return(0);
}

static void pausesignal_handler(int signo)
{
    int caughtSignal;
    caughtSignal = 0;

    /* when SIGUSR1 is received, wait until SIGUSR2 to continue execution */
    if (signo == SIGUSR1) {
        signal(signo, pausesignal_handler);

        while (caughtSignal != SIGUSR2) {
            sigwait (signalsBetweenControllerandLoad, &caughtSignal);
        }
    }
}

当我使用一些命令（例如下面的for循环进行一些计算）而不是system(SOMECOMMAND)这段代码有效时。但是，当处理程序处于活动状态时，不会暂停system（）调用的程序。

int i;
for(i=0;i<10;i++) {
    sleep(1);
    printf("Just a text");
}

有没有一种方法可以通过使用线程信号来暂停system（）命令的执行？甚至还有一种方法可以停止系统调用的应用程序，而无需等待程序完成？

提前非常感谢您！

智商

在@rici的帮助下，我想向您介绍我的（缩短的）结果代码。再次感谢您。简而言之，该代码会派生一个新进程（fork），并在其中执行命令exec。然后父捕获用户定义的信号SIGNAL_PAUSE和SIGNAL_RESUME相应并转发信号到叉形子。每当命令完成时-被捕获waitpid-父级再次分叉并重新启动加载。这将重复进行，直到SIGNAL_STOP被发送到孩子得到aSIGINT并被取消的位置。

#include <pthread.h>
#include <signal.h>
#include <stdio.h>

#define SIGNAL_PAUSE (SIGUSR1)
#define SIGNAL_RESUME (SIGUSR2)
#define SIGNAL_STOP (SIGSYS)

/* File scoped functions */
static void pausesignal_handler(int signo);
static void stopsignal_handler(int signo);
void send_signal_to_load_child(int signo);

/*Set file scope variables as handlers can only have signal-number as argument */
sigset_t* signalsBetweenControllerandLoad;
int restart_benchmark;
pid_t child_pid;

void* Load(char* load_arguments[MAX_NR_LOAD_ARGS], sigset_t* signalsToCatch) {
    int load_ID;
    pid_t p;

    signalsBetweenControllerandLoad = signalsToCatch;

    /* set signal handlers to catch signals from controller */
    signal(SIGNAL_PAUSE, pausesignal_handler)
    signal(SIGNAL_RESUME, pausesignal_handler)
    signal(SIGNAL_STOP, stopsignal_handler)
    pthread_sigmask(SIG_UNBLOCK, signalsBetweenControllerandLoad[load_ID], NULL)

    /* Keep restarting benchmark until Stop signal was received */
    restart_benchmark[load_ID] = 1;

    /* execute benchmark, repeat until stop signal received */
    while(restart_benchmark[load_ID])
    {
        if (child_pid == 0) {
            if ((p = fork()) == 0) {
                execv(load_arguments[0],load_arguments);
                exit(0);
            }
        }

        /* Parent process: Wait until child with benchmark finished and restart it */
        if (p>0) {
            child_pid = p;  /* Make PID available for helper functions */
            wait(child_pid);        /* Wait until child finished */
            child_pid = 0;  /* Reset PID when benchmark finished */
        }
    }

    return(0);
}

static void pausesignal_handler(int signo) {
    static double elapsedTime;
    int caughtSignal;
    caughtSignal = 0;

    if (signo == SIGNAL_PAUSE) {
        send_signal_to_load_child(SIGSTOP);
        printf("Load Paused, waiting for resume signal\n");

        while (restart_benchmark == 1 && caughtSignal != SIGNAL_RESUME) {
            sigwait (signalsBetweenControllerandLoad, &caughtSignal);
            if (caughtSignal == SIGNAL_STOP) {
                printf("Load caught stop signal when waiting for resume\n");
                stopsignal_handler(caughtSignal);
            } else if (caughtSignal != SIGNAL_RESUME) {
                printf("Load caught signal %d which is not Resume (%d), keep waiting...\n",caughtSignal,SIGNAL_RESUME);
            }
        }
        if (restart_benchmark[load_ID]) {
            send_signal_to_load_child(SIGCONT, load_ID);
            printf("Load resumed\n");
        }
    } else {
        printf("Load caught unexpected signal %d.\n",signo);
    }
    /* reassign signals for compatibility reasons */
    signal(SIGNAL_PAUSE, pausesignal_handler);
    signal(SIGNAL_RESUME, pausesignal_handler);
}

static void stopsignal_handler(int signo) {
    double elapsedTime;
    signal(SIGNAL_STOP, stopsignal_handler);
    if (signo == SIGNAL_STOP) {
        restart_benchmark = 0;
        send_signal_to_load_child(SIGINT);
        printf("Load stopped.\n");
    } else {
        printf("catched unexpected stop-signal %d\n",signo);
    }
}

void send_signal_to_load_child(int signo) {
    int dest_pid;
    dest_pid = child_pid;
    printf("Error sending %d to Child: PID not set.\n",signo);
    kill(dest_pid, signo);
}