An exit handler is a programmer-defined function that is registered at some point during the life of a process and is then automatically called during normal process termination via exit().

The classic use-case: A library that needs guaranteed cleanup:

The handler function must have this exact signature:

void cleanup_function(void)
{
    /* No parameters, no return value */
    /* Perform cleanup here */
}

Key rules for atexit():

• The function takes no arguments and returns void.
• Multiple handlers can be registered — even the same function multiple times.
• Handlers are called in reverse order of registration (last registered = first called).
• Each handler should not call exit() — SUSv3 says behaviour is undefined (on Linux, remaining handlers are still called, but don’t rely on this).
• If a handler calls _exit() or is killed by a signal, remaining handlers are NOT called.
• You cannot deregister a handler once registered with atexit(). Workaround: use a global flag the handler checks.

When exit() runs, registered handlers are called in reverse order of their registration. This is logical: handlers registered first typically set up more fundamental resources that should be cleaned up last.

Inside a handler, you can register additional exit handlers — they are placed at the head of the remaining list and will be called before the handlers already in the queue.

SUSv3 requires an implementation to support at least 32 exit handlers. You can query the implementation-defined limit with:

long max_handlers = sysconf(_SC_ATEXIT_MAX);
printf("Max atexit handlers: %ld\n", max_handlers);

On Linux (glibc), sysconf(_SC_ATEXIT_MAX) returns 2,147,482,647 (the maximum signed 32-bit integer). This is because glibc stores registered handlers in a dynamically allocated linked list, so the limit is effectively infinite — you will run out of memory long before hitting it.

Handlers registered with atexit() have two important limitations:

Exit handlers are not called when a process is terminated by a signal. The recommended approach is:

• Install signal handlers for signals that might arrive (SIGTERM, SIGHUP, SIGINT, etc.).
• In the signal handler, set a global flag.
• The main program loop checks the flag and calls exit() cleanly.
• Because exit() is not async-signal-safe, calling it directly from a signal handler is technically unsafe.

atexit() provides no deregistration mechanism. The standard workaround is to use a global flag:

static int cleanup_enabled = 1;   /* global flag */

void my_cleanup(void)
{
    if (!cleanup_enabled)
        return;                   /* disabled — do nothing */
    /* ... actual cleanup ... */
}

/* To disable: */
cleanup_enabled = 0;

This pattern lets you turn off specific exit handlers at runtime without removing them.

Register four handlers in order A→B→C→D, then call exit(). Watch them execute in reverse: D→C→B→A.

/* demo_atexit_order.c
 * Compile : gcc -Wall -o demo_atexit_order demo_atexit_order.c
 * Run     : ./demo_atexit_order
 */
#include <stdio.h>
#include <stdlib.h>

static void handlerA(void) { printf("handlerA called (registered 1st, called LAST)\n"); }
static void handlerB(void) { printf("handlerB called (registered 2nd)\n"); }
static void handlerC(void) { printf("handlerC called (registered 3rd)\n"); }
static void handlerD(void) { printf("handlerD called (registered 4th, called FIRST)\n"); }

int main(void)
{
    printf("--- Registering handlers A, B, C, D ---\n");

    if (atexit(handlerA) != 0) { perror("atexit A"); exit(1); }
    if (atexit(handlerB) != 0) { perror("atexit B"); exit(1); }
    if (atexit(handlerC) != 0) { perror("atexit C"); exit(1); }
    if (atexit(handlerD) != 0) { perror("atexit D"); exit(1); }

    printf("--- Calling exit(0) now ---\n");
    exit(0);

    /* unreachable */
    return 0;
}

Real-world pattern: atexit handler deletes a temp file. Signal handler sets a flag to trigger clean exit() so the handler still runs on SIGTERM/SIGINT.

/* demo_atexit_tempfile.c
 * Compile : gcc -Wall -o demo_atexit_tempfile demo_atexit_tempfile.c
 * Run     : ./demo_atexit_tempfile
 *           Then in another terminal: kill -SIGTERM <pid>
 *           The temp file is cleaned up automatically.
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>

#define TMPFILE "/tmp/ep_demo_temp.txt"

static volatile sig_atomic_t terminate = 0;

/* ---- Exit handler: always clean up temp file ---- */
static void remove_tmpfile(void)
{
    if (unlink(TMPFILE) == 0)
        printf("  [atexit] Removed temp file: %s\n", TMPFILE);
    else
        /* File may not exist if exit is called before file creation */
        perror("  [atexit] unlink");
}

/* ---- Signal handler: set flag, let main() call exit() ---- */
static void sig_handler(int sig)
{
    (void)sig;
    terminate = 1;
    /* Do NOT call exit() here — it is not async-signal-safe */
}

int main(void)
{
    int fd;
    struct sigaction sa;

    /* Register signal handlers for clean termination */
    sa.sa_handler = sig_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    sigaction(SIGTERM, &sa, NULL);
    sigaction(SIGINT,  &sa, NULL);

    /* Register atexit handler BEFORE creating the resource */
    if (atexit(remove_tmpfile) != 0) {
        perror("atexit");
        exit(EXIT_FAILURE);
    }

    /* Create temp file */
    fd = open(TMPFILE, O_WRONLY | O_CREAT | O_TRUNC, 0600);
    if (fd == -1) { perror("open"); exit(EXIT_FAILURE); }
    write(fd, "temporary data\n", 15);
    close(fd);
    printf("Created temp file: %s\n", TMPFILE);
    printf("PID = %d  — send SIGTERM to test cleanup.\n", getpid());
    printf("Sleeping 30 seconds (Ctrl-C also works) ...\n");

    /* Main loop — exit cleanly on signal so atexit handler runs */
    while (!terminate)
        sleep(1);

    printf("Signal received — calling exit() ...\n");
    exit(EXIT_SUCCESS);   /* ← atexit handler will be called here */
}

Shows the double-cleanup problem when child calls exit() and the fix using _exit() in the child.

/* demo_atexit_fork.c
 * Compile : gcc -Wall -o demo_atexit_fork demo_atexit_fork.c
 * Run     : ./demo_atexit_fork 0   → child uses exit()  → double handler call
 *           ./demo_atexit_fork 1   → child uses _exit() → handler called once
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

static int call_count = 0;

static void cleanup_handler(void)
{
    call_count++;
    printf("  cleanup_handler called (PID %d, call_count=%d)\n",
           getpid(), call_count);
}

int main(int argc, char *argv[])
{
    int child_use_exit = (argc > 1 && argv[1][0] == '0') ? 1 : 0;
    pid_t pid;

    /* Register handler before fork() */
    if (atexit(cleanup_handler) != 0) { perror("atexit"); exit(1); }

    pid = fork();
    if (pid == -1) { perror("fork"); exit(1); }

    if (pid == 0) {
        /* CHILD */
        printf("Child (PID %d): using %s\n", getpid(),
               child_use_exit ? "exit() — handler will run (double cleanup!)"
                              : "_exit() — handler skipped (correct!)");

        if (child_use_exit)
            exit(EXIT_SUCCESS);    /* triggers inherited atexit handler! */
        else
            _exit(EXIT_SUCCESS);   /* skips atexit handlers — correct for child */
    }

    /* PARENT */
    waitpid(pid, NULL, 0);
    printf("Parent (PID %d): calling exit()\n", getpid());
    exit(EXIT_SUCCESS);   /* parent's atexit handler runs once */
}

Answer: An exit handler is a programmer-defined function registered via atexit() or on_exit() that is automatically called during normal process termination — i.e., when exit() is called or when main() returns. Exit handlers are not called when the process calls _exit() directly, or when the process is terminated abnormally by a signal (including SIGKILL).

Answer: In reverse order of registration. The last function registered with atexit() is called first when exit() runs. This ensures that handlers performing higher-level cleanup (registered later) run before handlers performing lower-level cleanup (registered earlier). If the same function is registered multiple times, it is called multiple times.

Answer: A child created by fork() inherits a copy of its parent’s atexit handler registrations. If both parent and child call exit(), both will execute the registered handlers, which can cause double cleanup bugs. The standard solution is to call _exit() in the child process instead of exit(), so only the parent runs the atexit handlers.

Answer: All atexit handler registrations are removed when a process calls exec(). This is necessarily so because exec() replaces the process’s entire code segment — the handler functions no longer exist in memory. The new program loaded by exec() starts with no atexit handlers registered.

Answer: SUSv3 states that calling exit() from within an atexit handler causes undefined behaviour (on Linux, remaining handlers are still called, but this is non-portable). If an atexit handler needs to abort the exit process, it should call _exit() directly (which will stop all remaining handlers) or use raise() to send a signal. Portable applications should simply avoid calling exit() inside atexit handlers.

Answer: atexit() provides no deregistration mechanism. The standard workaround is to protect the handler body with a global flag: set the flag to 1 when the cleanup should run; the handler checks the flag and returns immediately if it is 0. To disable the handler, set the flag to 0 before calling exit(). The handler function is still called, but performs no action.