Process Address Space

Process Identifiers & Credentials

Files, I/O & Directories

Signals

Timers

IPC, Locks & Resources

Example 1 — Verifying Signal Disposition Reset by exec()

/* signal_exec_demo.c — Show that caught signals revert to default after exec() */
/* child_prog.c — a small program to exec into */
/* Compile: gcc -o child_prog child_prog.c  */
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

int main(void)
{
    /* After exec(), SIGUSR1 disposition is back to default (terminate) */
    struct sigaction sa;
    sigaction(SIGUSR1, NULL, &sa);
    if (sa.sa_handler == SIG_DFL)
        printf("[child_prog] SIGUSR1 = SIG_DFL (default) after exec()\n");
    else if (sa.sa_handler == SIG_IGN)
        printf("[child_prog] SIGUSR1 = SIG_IGN (ignored) after exec()\n");
    else
        printf("[child_prog] SIGUSR1 has a custom handler after exec()\n");
    return 0;
}

/* signal_exec_demo.c — Main program */
#define _GNU_SOURCE
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <sys/wait.h>

static void my_handler(int sig) { (void)sig; }

int main(void)
{
    /* Install a custom handler for SIGUSR1 */
    struct sigaction sa = { .sa_handler = my_handler };
    sigaction(SIGUSR1, &sa, NULL);
    printf("[parent] SIGUSR1 has custom handler\n");

    /* Ignore SIGUSR2 */
    signal(SIGUSR2, SIG_IGN);
    printf("[parent] SIGUSR2 is ignored\n");

    pid_t pid = fork();
    if (pid == 0) {
        /* exec() replaces caught handlers with SIG_DFL.
           Ignored signals (SIG_IGN) stay ignored after exec(). */
        char *args[] = { "./child_prog", NULL };
        execv("./child_prog", args);
        _exit(1);
    }
    waitpid(pid, NULL, 0);
    return 0;
}
/*
 * Output:
 * [parent] SIGUSR1 has custom handler
 * [parent] SIGUSR2 is ignored
 * [child_prog] SIGUSR1 = SIG_DFL (default) after exec()
 *
 * SIGUSR2 would still be SIG_IGN in child_prog — ignored
 * signals survive exec(). Only CAUGHT signals revert to default.
 */

Example 2 — File Offset Sharing After fork()

/* fork_offset.c — Parent and child share file offset after fork() */
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/wait.h>

int main(void)
{
    /* Create a test file */
    int fd = open("/tmp/fork_test.txt", O_RDWR | O_CREAT | O_TRUNC, 0600);
    write(fd, "ABCDEFGHIJ", 10);
    lseek(fd, 0, SEEK_SET);   /* Rewind to start */

    pid_t pid = fork();
    if (pid == 0) {
        /* Child reads 3 bytes — advances SHARED offset by 3 */
        char buf[4] = {0};
        read(fd, buf, 3);
        printf("[Child]  read '%s' (offset now at 3)\n", buf);
        _exit(0);
    }
    waitpid(pid, NULL, 0);

    /* Parent continues reading — offset is at 3 (child moved it!) */
    char buf[8] = {0};
    read(fd, buf, 7);
    printf("[Parent] read '%s' (expected: DEFGHIJ)\n", buf);

    close(fd);
    unlink("/tmp/fork_test.txt");
    return 0;
}
/*
 * Output:
 * [Child]  read 'ABC' (offset now at 3)
 * [Parent] read 'DEFGHIJ' (expected: DEFGHIJ)
 *
 * Parent and child share the same open file description including
 * the file offset — child advancing it affects parent.
 */

Example 3 — Close-on-Exec Flag

/* cloexec_demo.c — FD_CLOEXEC closes fd automatically on exec() */
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/wait.h>

int main(void)
{
    /* Open fd without close-on-exec */
    int fd_normal = open("/dev/null", O_RDONLY);

    /* Open fd with close-on-exec */
    int fd_cloexec = open("/dev/null", O_RDONLY | O_CLOEXEC);

    /* Or set it after the fact: */
    /* fcntl(fd_cloexec, F_SETFD, FD_CLOEXEC); */

    printf("Normal fd: %d, CLOEXEC fd: %d\n", fd_normal, fd_cloexec);

    pid_t pid = fork();
    if (pid == 0) {
        /* exec a shell that checks if the fds are open */
        char cmd[128];
        snprintf(cmd, sizeof(cmd),
                 "ls -l /proc/%d/fd 2>&1 | grep -E '%d|%d'",
                 getpid(), fd_normal, fd_cloexec);

        char *args[] = { "/bin/sh", "-c", cmd, NULL };
        execv("/bin/sh", args);
        _exit(1);
    }
    waitpid(pid, NULL, 0);
    /*
     * Output will show fd_normal is open in child after exec(),
     * but fd_cloexec will NOT appear (it was closed by exec()).
     */
    close(fd_normal);
    close(fd_cloexec);
    return 0;
}

28.5 — Chapter Summary

28.6 — Exercise

/* exercise_28_1.c — Benchmark fork() vs vfork() with immediate child exit */
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <unistd.h>

#define DEFAULT_ITER 100000

int main(int argc, char *argv[])
{
    int iterations = (argc > 1) ? atoi(argv[1]) : DEFAULT_ITER;
    struct timeval t1, t2;

    printf("Benchmarking %d iterations...\n\n", iterations);

    /* --- fork() --- */
    gettimeofday(&t1, NULL);
    for (int i = 0; i < iterations; i++) {
        pid_t pid = fork();
        if (pid == -1) { perror("fork"); exit(1); }
        if (pid == 0)  _exit(0);
        if (waitpid(pid, NULL, 0) == -1) { perror("waitpid"); exit(1); }
    }
    gettimeofday(&t2, NULL);

    double fork_sec = (t2.tv_sec - t1.tv_sec)
                    + (t2.tv_usec - t1.tv_usec) / 1e6;

    /* --- vfork() --- */
    gettimeofday(&t1, NULL);
    for (int i = 0; i < iterations; i++) {
        pid_t pid = vfork();
        if (pid == -1) { perror("vfork"); exit(1); }
        if (pid == 0)  _exit(0);    /* Must use _exit, NOT exit() */
        if (waitpid(pid, NULL, 0) == -1) { perror("waitpid"); exit(1); }
    }
    gettimeofday(&t2, NULL);

    double vfork_sec = (t2.tv_sec - t1.tv_sec)
                     + (t2.tv_usec - t1.tv_usec) / 1e6;

    printf("fork():  %6.2f s  (%8.0f/s)\n",
           fork_sec,  iterations / fork_sec);
    printf("vfork(): %6.2f s  (%8.0f/s)\n",
           vfork_sec, iterations / vfork_sec);
    printf("Speedup: %.1fx\n", fork_sec / vfork_sec);

    return 0;
}
/* Compile: gcc -O2 -o exercise_28_1 exercise_28_1.c
   Run:     time ./exercise_28_1 100000
   Try:     time ./exercise_28_1 100000  (with small malloc before loop)
            to see how process size affects fork() but not vfork()  */

Interview Questions