How to make a function async-signal-safe?

问题:

I have the following sigaction handler function

void signal_term_handler(int sig)
{
    printf("EXIT :TERM signal Received!\n");
    int rc = flock(pid_file, LOCK_UN | LOCK_NB);
    if(rc) {
        char *piderr = "PID file unlock failed!";
        fprintf(stderr, "%s\n", piderr);
        printf(piderr);
    }
    abort();
}

Someone told me that flock and printf aren't async-signal-safe. And I could not find an alternate async-signal-safe function for flockin this list.

and according to the above link:

when a signal interrupts an unsafe function and the signal-catching function calls an unsafe function, the behavior is undefined

Are there a way to make flock async-signal-safe? Or is there another solution to execute flock when I receive TERM signal?

回答1:

You can use fcntl() as an alternative to flock().

回答2:

flock() is generally async-signal-safe because it is a system call. Its semantics make it hard to implement it differently. It is not in POSIX's list of async-signal-safe functions because it is not in POSIX at all.

You likely do not need the explicit unlock because flock() locks are released automatically when all file descriptors referring to the open file description are closed.

The printf() and fprintf() calls should be replaced with appropriate write() calls. The stdio functions are not in the list of async-signal-safe functions and are often strongly async-signal-unsafe.

The abort() call is probably best replaced by setting the signal to the default action and resending it to self; this way, shells know that your program exited because of the signal and can abort command sequences when appropriate.

回答3:

You can use exit() instead of abort() in your signal handler, and then put your unsafe functions in an exit handler using atexit().

update: In general, you should not put any potentially blocking system calls in your signal handler. One way to avoid this is to just set a flag in your signal handler, and then perform the functions you wanted in the context of your main loop.

volatile int shutdown = 0;

void signal_term_handler(int sig)
{
    shutdown = 1;
}

void cleanup() {
    printf("EXIT :TERM signal Received!\n");
    int rc = flock(pid_file, LOCK_UN | LOCK_NB);
    if(rc) {
        char *piderr = "PID file unlock failed!";
        fprintf(stderr, "%s\n", piderr);
        printf(piderr);
    }
}

void *workerFunction(void *arg) {
    while (!shutdown) {
       ... do stuff ...
    }
    return NULL;
}

int main(int argc, char *argv[]) {
    //...
    pthread_create(...,workerFunction,...);
    pthread_join(...);
    cleanup();
    return 0;
}