How to make a function async-signal-safe?

Question

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

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

Possible duplicate of [How to avoid using printf in a signal handler?](https://stackoverflow.com/questions/16891019/how-to-avoid-using-printf-in-a-signal-handler) for `printf`, https://stackoverflow.com/questions/16979059/use-flock-in-the-sigaction-handler for `flock`. — Ciro Santilli OurBigBook.com, Sep 20 '17 at 06:29

score 4 · Accepted Answer · answered Jun 06 '13 at 17:12

4

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

answered Jun 06 '13 at 17:12

grasbueschel

879
2
8
24

Be aware that the semantics of `fcntl()` locks are different from and less useful than those of `flock()`. – jilles Jun 07 '13 at 15:15
In fact I can use fcntl to develop a new property flock() function as indicated in this [topic](http://stackoverflow.com/questions/16988256/how-to-lock-and-unlock-pid-file-with-fcntl). Thank you for the answer – MOHAMED Jun 07 '13 at 17:21

score 4 · Answer 2 · answered Jun 06 '13 at 21:21

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.

Can I use `flock()` without problems in the sigaction handler? — MOHAMED, Jun 07 '13 at 07:53

Markku K. · Answer 3 · 2013-06-06T19:37:24.293

~~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;
}

Exit-handlers may be called synchronously. Doing so from an asynchronously invoked signal handler make them run how? — alk, Jun 06 '13 at 17:56
Right, I didn't read the question carefully enough. I guess I was answering a more basic question about how to avoid unsafe functions in a signal handler. In this case, you would want to replace exit() with something like setting a shutdown flag. — Markku K., Jun 06 '13 at 19:28

How to make a function async-signal-safe?

3 Answers3

Linked