The Three Kernel Sleep States

/* Demonstrate EINTR from an interruptible sleep */
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>

void handler(int sig) {
    printf("Handler: caught signal %d\n", sig);
}

int main(void) {
    struct sigaction sa;
    sa.sa_handler = handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;  /* No SA_RESTART -- system call will NOT restart */
    sigaction(SIGINT, &sa, NULL);

    printf("Sleeping for 60 seconds (press Ctrl+C to interrupt)\n");
    int ret = sleep(60);  /* TASK_INTERRUPTIBLE sleep */

    if (ret > 0) {
        printf("sleep() returned early! %d seconds remaining\n", ret);
    }

    printf("read() from stdin...\n");
    char buf[64];
    ssize_t n = read(STDIN_FILENO, buf, sizeof(buf));
    if (n == -1) {
        if (errno == EINTR)
            printf("read() was interrupted by signal (EINTR)\n");
        else
            printf("read() error: %s\n", strerror(errno));
    }

    return 0;
}

$ ./sleep_demo
Sleeping for 60 seconds (press Ctrl+C to interrupt)
^C
Handler: caught signal 2
sleep() returned early! 55 seconds remaining
read() from stdin...
^C
Handler: caught signal 2
read() was interrupted by signal (EINTR)

/* Safe read wrapper that handles EINTR automatically */
ssize_t safe_read(int fd, void *buf, size_t count) {
    ssize_t n;
    while ((n = read(fd, buf, count)) == -1 && errno == EINTR)
        continue;  /* restart if interrupted by signal */
    return n;     /* real error or success */
}

The Four Hardware Exception Signals

Why You Cannot Safely Ignore or Block These Signals

/* sigsegv_handler_wrong.c - Demonstrates the infinite loop problem */
#include <stdio.h>
#include <signal.h>

int counter = 0;

void bad_handler(int sig) {
    counter++;
    printf("Handler called (count=%d) — returning normally\n", counter);
    if (counter > 5) {
        /* Force exit to avoid running forever in this demo */
        printf("Stopping demo at count 5\n");
        _exit(1);
    }
    /* Normal return here re-executes the faulting instruction */
}

int main(void) {
    signal(SIGSEGV, bad_handler);

    printf("About to dereference null pointer...\n");
    int *p = NULL;
    *p = 42;   /* SIGSEGV -- handler called, returns, re-executes, loops! */
    return 0;
}

/* sigsegv_recovery.c - Correct: use siglongjmp to escape the fault */
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <setjmp.h>

static sigjmp_buf recovery_point;

void safe_handler(int sig) {
    printf("Caught signal %d — jumping to recovery point\n", sig);
    siglongjmp(recovery_point, 1);  /* jump OUT of handler safely */
}

int main(void) {
    struct sigaction sa;
    sa.sa_handler = safe_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    sigaction(SIGSEGV, &sa, NULL);
    sigaction(SIGFPE,  &sa, NULL);

    /* Set up the recovery point */
    if (sigsetjmp(recovery_point, 1) == 0) {
        /* Normal path: try risky operation */
        printf("Attempting risky operation...\n");
        int *p = NULL;
        *p = 42;  /* causes SIGSEGV */
        printf("This line is never reached\n");
    } else {
        /* Recovery path: siglongjmp brought us here */
        printf("Recovered from hardware fault. Continuing safely.\n");
    }

    printf("Program continues after recovery\n");
    return 0;
}

$ gcc -g sigsegv_recovery.c -o sigsegv_recovery
$ ./sigsegv_recovery
Attempting risky operation...
Caught signal 11 — jumping to recovery point
Recovered from hardware fault. Continuing safely.
Program continues after recovery

/* sigfpe_demo.c - Integer divide by zero */
#include <stdio.h>
#include <signal.h>
#include <setjmp.h>
#include <stdlib.h>

static sigjmp_buf jmp_env;

void fpe_handler(int sig) {
    printf("SIGFPE: arithmetic exception (divide by zero?)\n");
    siglongjmp(jmp_env, 1);
}

int main(void) {
    signal(SIGFPE, fpe_handler);

    int a = 100, b = 0;

    if (sigsetjmp(jmp_env, 1) == 0) {
        printf("Dividing %d / %d\n", a, b);
        int result = a / b;  /* triggers SIGFPE */
        printf("Result: %d\n", result);
    } else {
        printf("Division failed, using default value 0\n");
    }

    printf("Done.\n");
    return 0;
}

Synchronous vs Asynchronous

/* sync_vs_async.c - Demonstrate synchronous signal delivery */
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void handler(int sig) {
    printf("Handler: got signal %d\n", sig);
}

int main(void) {
    signal(SIGUSR1, handler);

    printf("Before raise(SIGUSR1)\n");
    raise(SIGUSR1);   /* SYNCHRONOUS: handler runs NOW, before raise() returns */
    printf("After raise(SIGUSR1) -- handler already ran\n");

    /* Compare: sending to another process (asynchronous) */
    /* The receiving process handles it "sometime later" */
    printf("\nSending SIGUSR1 to shell (PID=%d)\n", getppid());
    kill(getppid(), SIGUSR1);  /* shell handles it asynchronously */
    printf("kill() returned -- shell may not have handled it yet\n");

    return 0;
}

$ ./sync_vs_async
Before raise(SIGUSR1)
Handler: got signal 10
After raise(SIGUSR1) -- handler already ran
Sending SIGUSR1 to shell (PID=1234)
kill() returned -- shell may not have handled it yet

/* kill_self.c - Send signals to own process group */
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>

void handler(int sig) {
    printf("  [Handler invoked for signal %d]\n", sig);
}

int main(void) {
    signal(SIGUSR1, handler);
    signal(SIGUSR2, handler);

    /* Three ways to send a signal to yourself synchronously */

    /* Method 1: raise() */
    printf("1. Using raise(SIGUSR1)\n");
    raise(SIGUSR1);
    printf("   Back in main after raise\n");

    /* Method 2: kill() with own PID */
    printf("2. Using kill(getpid(), SIGUSR2)\n");
    kill(getpid(), SIGUSR2);
    printf("   Back in main after kill\n");

    /* Method 3: killpg() to send to own process group */
    printf("3. Using killpg(0, SIGUSR1) -- sends to own process group\n");
    killpg(0, SIGUSR1);
    printf("   Back in main after killpg\n");

    return 0;
}