Signal safety

Learn signal safety and reentrant functions.

Signal safety

A signal handler can interrupt the program at any point. So inside a handler you should only call reentrant functions.

Functions like malloc, printf, fopen are not reentrant; they hold internal static state. In a handler, write and _exit are safe. For a flag variable you use volatile sig_atomic_t; its read and write are indivisible.

volatile sig_atomic_t

volatile tells the compiler to read the variable from memory on every access without optimization. sig_atomic_t is a type guaranteed to have indivisible read and write.

The handler sets a flag; the main loop checks the flag and reacts. This is the core pattern of safe signal communication. For example, declare volatile sig_atomic_t flag = 0; and set flag = 1; in the handler. The main code waits with while (!flag).

Exercise Safe flag

Declare volatile sig_atomic_t flag = 0;. Write void handler(int sig) with flag = 1;. Register with signal(SIGUSR1, handler);. Call raise(SIGUSR1); and print with printf("flag=%d\n", flag);.

Show example solution

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

volatile sig_atomic_t flag = 0;

void handler(int sig) {
    flag = 1;
}

int main(void) {
    signal(SIGUSR1, handler);
    raise(SIGUSR1);
    printf("flag=%d\n", flag);
    return 0;
}

Test yourself

Match safety concepts

volatile

Prevents optimization
sig_atomic_t

Indivisible type
write

Safe function
malloc

Not safe
Which function is safe in a signal handler?
- write
- printf
- malloc
- fopen
Show answer

write — write is a reentrant system call.

Flag type

volatile ____ flag = 0;

Show answer

volatile sig_atomic_t flag = 0;

Next lesson: Summary - Signal handling

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies