The fork() System Call

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

/*
 * Demonstrating Undefined Execution Order
 * 
 * Run this multiple times - you may see different orderings!
 * This is expected and correct behavior.
 */
 
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
 
int main() {
    printf("Before fork: PID %d\n", getpid());
    
    pid_t pid = fork();
    
    if (pid == -1) {
        perror("fork");
        return 1;
    }
    
    /* 
     * Which prints first? UNDEFINED!
     * 
     * On a single-core system: Scheduler chooses one
     * On multi-core: They may interleave or print simultaneously
     * 
     * Factors affecting order:
     * - System load
     * - Kernel scheduler algorithm (CFS, etc.)
     * - Number of CPUs
     * - Priority settings
     * - Random timing variations
     */
    
    if (pid == 0) {
        printf("Child: I am PID %d, running...\n", getpid());
        printf("Child: Step 1\n");
        printf("Child: Step 2\n");
        printf("Child: Step 3\n");
        _exit(0);
    } else {
        printf("Parent: I am PID %d, child is %d\n", getpid(), pid);
        printf("Parent: Step A\n");
        printf("Parent: Step B\n");
        printf("Parent: Step C\n");
        wait(NULL);
    }
    
    return 0;
}
 
/*
 * Possible outputs (among many):
 *
 * Run 1:                        Run 2:
 * Before fork: PID 1000         Before fork: PID 1000
 * Parent: I am PID 1000...      Child: I am PID 1001...
 * Parent: Step A                Parent: I am PID 1000...
 * Child: I am PID 1001...       Child: Step 1
 * Parent: Step B                Parent: Step A
 * Child: Step 1                 Child: Step 2
 * ...                           ...
 *
 * NEVER write code that assumes a particular order!
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

Linux CFS and fork():
======================
 
BEFORE FORK:
┌─────────────────────────────────────────────────────┐
│ CFS Red-Black Tree (runqueue)                       │
│                                                     │
│         Process A (vruntime: 100ms)                 │
│        /         \                                  │
│   Process B      Parent                             │
│  (vruntime:      (vruntime: 150ms)                  │
│   80ms)                                             │
└─────────────────────────────────────────────────────┘
 
AFTER FORK:
┌─────────────────────────────────────────────────────┐
│ CFS Red-Black Tree (runqueue)                       │
│                                                     │
│         Process A (vruntime: 100ms)                 │
│        /         \                                  │
│   Process B      Parent                             │
│  (vruntime:      (vruntime: 150ms)                  │
│   80ms)             \                               │
│                     Child                           │
│                    (vruntime: ~150ms)               │
│                    (inherits parent's vruntime)     │
└─────────────────────────────────────────────────────┘
 
CFS Policy:
1. Child inherits parent's vruntime (virtual runtime)
2. This prevents fork() from being used to gain unfair CPU time
3. Child might run first if its vruntime is slightly adjusted
4. Both compete fairly for CPU time going forward
 
Historical Note:
- Older Linux kernels ran parent first (avoid COW copy on child stack)
- Then child-first became default (assume fork+exec pattern)
- Current: Scheduler decides based on fairness metrics

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

SINGLE-CORE EXECUTION (Time-sliced):
====================================
 
Time →
├────┤ Parent runs
     ├────┤ Context switch, Child runs
          ├────┤ Context switch, Parent runs
               ├────┤ Context switch, Child runs
 
     Only ONE process executes at any instant.
     Interleaving, but not true parallelism.
 
 
MULTI-CORE EXECUTION (True Parallelism):
========================================
 
          Core 0          Core 1
Time →   ├────────────┤  ├────────────┤
         │   Parent   │  │   Child    │
         │  Running   │  │  Running   │
         │            │  │            │
         ├────────────┤  ├────────────┤
 
     BOTH processes execute at the SAME instant.
     True parallelism, not just interleaving.
 
 
IMPLICATIONS:
 
1. Output interleaving is possible:
   printf("A") in parent and printf("1") in child
   might produce "A1", "1A", or even "A1" atomically
   (depends on stdio buffering)
 
2. Shared resources (files, pipes) may be accessed
   simultaneously - need proper synchronization
 
3. Race conditions are real-time, not just scheduler quirks
 
4. Performance can genuinely scale with cores (if workload permits)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

/*
 * Demonstrating True Parallel Execution
 * Run on multi-core system to observe simultaneous execution
 */
 
#define _GNU_SOURCE
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sched.h>
#include <time.h>
 
long long get_time_ns() {
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return ts.tv_sec * 1000000000LL + ts.tv_nsec;
}
 
void busy_work(int iterations) {
    volatile long sum = 0;
    for (int i = 0; i < iterations; i++) {
        sum += i;
    }
}
 
int main() {
    printf("System has %d CPUs\n", sysconf(_SC_NPROCESSORS_ONLN));
    
    long long fork_time = get_time_ns();
    
    pid_t pid = fork();
    
    if (pid == 0) {
        /* CHILD */
        long long start = get_time_ns();
        int cpu = sched_getcpu();  /* Which CPU are we on? */
        
        printf("Child PID %d started on CPU %d at +%lld ns\n",
               getpid(), cpu, start - fork_time);
        
        busy_work(100000000);
        
        long long end = get_time_ns();
        printf("Child finished at +%lld ns (duration: %lld ms)\n",
               end - fork_time, (end - start) / 1000000);
        
        _exit(0);
    }
    
    /* PARENT */
    long long start = get_time_ns();
    int cpu = sched_getcpu();
    
    printf("Parent PID %d started on CPU %d at +%lld ns\n",
           getpid(), cpu, start - fork_time);
    
    busy_work(100000000);
    
    long long end = get_time_ns();
    printf("Parent finished at +%lld ns (duration: %lld ms)\n",
           end - fork_time, (end - start) / 1000000);
    
    wait(NULL);
    
    /*
     * On multi-core system:
     * - Parent and child may run on different CPUs
     * - Both may start nearly simultaneously
     * - Total time ≈ one worker time (parallel execution)
     *
     * On single-core system:
     * - Both run on CPU 0
     * - Total time ≈ two worker times (sequential)
     */
    
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

/*
 * Demonstrating Process Independence After fork()
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
 
int shared_var = 100;  /* NOT actually shared after fork! */
 
void signal_handler(int sig) {
    printf("Process %d received signal %d\n", getpid(), sig);
}
 
int main() {
    signal(SIGUSR1, signal_handler);
    
    pid_t pid = fork();
    
    if (pid == 0) {
        /* CHILD */
        printf("Child: Initial shared_var = %d\n", shared_var);
        
        /* Modify 'shared' variable - only affects child */
        shared_var = 999;
        printf("Child: After modification, shared_var = %d\n", shared_var);
        
        /* Sleep to allow parent to send signal */
        sleep(2);
        
        /* Child can exit - parent keeps running */
        printf("Child: Exiting... parent unaffected\n");
        exit(42);
    }
    
    /* PARENT */
    sleep(1);  /* Let child modify its copy */
    
    printf("Parent: shared_var = %d (unaffected by child!)\n", shared_var);
    
    /* Send signal to child - each process has own signal handling */
    printf("Parent: Sending SIGUSR1 to child %d\n", pid);
    kill(pid, SIGUSR1);
    
    /* Wait for child, but parent continues independently */
    int status;
    waitpid(pid, &status, 0);
    printf("Parent: Child exited with status %d\n", WEXITSTATUS(status));
    
    /* Parent keeps running after child dies */
    printf("Parent: Still running after child exit\n");
    printf("Parent: shared_var still = %d\n", shared_var);
    
    return 0;
}
 
/*
 * Output:
 * Child: Initial shared_var = 100
 * Child: After modification, shared_var = 999
 * Parent: shared_var = 100 (unaffected by child!)
 * Parent: Sending SIGUSR1 to child 12345
 * Process 12345 received signal 10
 * Child: Exiting... parent unaffected
 * Parent: Child exited with status 42
 * Parent: Still running after child exit
 * Parent: shared_var still = 100
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

/*
 * Pattern: Using wait() for Parent-Child Synchronization
 * 
 * wait() BLOCKS the parent until child exits.
 * This creates a synchronization point.
 */
 
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
 
int main() {
    pid_t pid = fork();
    
    if (pid == 0) {
        /* Child does work */
        printf("Child: Doing work...\n");
        sleep(2);
        printf("Child: Work complete!\n");
        _exit(0);
    }
    
    /* 
     * Parent WILL NOT proceed past wait() until child exits.
     * This guarantees ordering: child completes before parent continues.
     */
    printf("Parent: Waiting for child...\n");
    wait(NULL);
    printf("Parent: Child finished, continuing...\n");
    
    /* 
     * GUARANTEED: The above print happens AFTER child's prints.
     * wait() provides this synchronization.
     */
    
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

/*
 * Pattern: Using Pipes for Parent-Child Coordination
 * 
 * Pipes allow synchronized communication without wait().
 * Useful when parent needs to signal child, or vice versa.
 */
 
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <string.h>
 
int main() {
    int parent_to_child[2];  /* Pipe: parent writes, child reads */
    int child_to_parent[2];  /* Pipe: child writes, parent reads */
    
    pipe(parent_to_child);
    pipe(child_to_parent);
    
    pid_t pid = fork();
    
    if (pid == 0) {
        /* CHILD */
        close(parent_to_child[1]);  /* Close write end */
        close(child_to_parent[0]);  /* Close read end */
        
        /* Wait for signal from parent */
        char buf[32];
        read(parent_to_child[0], buf, sizeof(buf));  /* BLOCKS until data */
        printf("Child: Received signal: %s\n", buf);
        
        /* Do work */
        printf("Child: Starting work...\n");
        sleep(1);
        printf("Child: Work done!\n");
        
        /* Signal parent we're done */
        write(child_to_parent[1], "DONE", 5);
        
        close(parent_to_child[0]);
        close(child_to_parent[1]);
        _exit(0);
    }
    
    /* PARENT */
    close(parent_to_child[0]);  /* Close read end */
    close(child_to_parent[1]);  /* Close write end */
    
    /* Do some setup first */
    printf("Parent: Preparing environment...\n");
    sleep(1);
    
    /* Signal child to start */
    printf("Parent: Signaling child to start\n");
    write(parent_to_child[1], "START", 6);
    
    /* Wait for child to complete */
    char buf[32];
    read(child_to_parent[0], buf, sizeof(buf));  /* BLOCKS until data */
    printf("Parent: Child signaled: %s\n", buf);
    
    close(parent_to_child[1]);
    close(child_to_parent[0]);
    
    wait(NULL);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

/*
 * Pattern: Using Signals for Parent-Child Coordination
 * 
 * Signals provide asynchronous notification between processes.
 * Lightweight but less information-rich than pipes.
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
 
volatile sig_atomic_t ready = 0;
 
void usr1_handler(int sig) {
    (void)sig;
    ready = 1;
}
 
int main() {
    signal(SIGUSR1, usr1_handler);
    
    pid_t pid = fork();
    
    if (pid == 0) {
        /* CHILD */
        /* Wait for parent's signal */
        while (!ready) {
            pause();  /* Sleep until signal received */
        }
        
        printf("Child: Received signal, starting work!\n");
        sleep(1);
        printf("Child: Work complete!\n");
        
        /* Signal parent we're done */
        kill(getppid(), SIGUSR1);
        
        _exit(0);
    }
    
    /* PARENT */
    ready = 0;  /* Ensure fresh start */
    
    printf("Parent: Preparing...\n");
    sleep(1);
    
    /* Signal child to start */
    printf("Parent: Signaling child\n");
    kill(pid, SIGUSR1);
    
    /* Wait for child's signal */
    while (!ready) {
        pause();
    }
    printf("Parent: Child signaled completion!\n");
    
    wait(NULL);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

/*
 * Fork-Wait: Parent spawns child, waits for completion
 * Use case: Running external commands, sequential task execution
 */
 
pid_t pid = fork();
if (pid == 0) {
    /* Child: Do work or exec */
    execlp("gcc", "gcc", "program.c", "-o", "program", NULL);
    _exit(127);
}
/* Parent: Wait for child */
int status;
waitpid(pid, &status, 0);
/* Continue after child completes */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

/*
 * Fork-and-Continue: Parent spawns child, continues working
 * Use case: Background tasks, parallel processing
 * MUST handle SIGCHLD to avoid zombies!
 */
 
/* Set up SIGCHLD handler to reap children */
signal(SIGCHLD, sigchld_handler);
 
pid_t pid = fork();
if (pid == 0) {
    /* Child: Do background work */
    do_background_work();
    _exit(0);
}
/* Parent: Continue immediately */
printf("Spawned background worker %d\n", pid);
do_main_work();  /* Child runs in parallel */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

/*
 * Worker Pool: Parent spawns multiple children for parallel work
 * Use case: Web servers, parallel computation, request handling
 */
 
#define NUM_WORKERS 4
pid_t workers[NUM_WORKERS];
 
/* Spawn workers */
for (int i = 0; i < NUM_WORKERS; i++) {
    workers[i] = fork();
    if (workers[i] == 0) {
        /* Worker child */
        worker_loop(i);  /* Process requests */
        _exit(0);
    }
}
 
/* Parent: Manage workers, handle signals, etc. */
while (running) {
    /* Accept connections, dispatch to workers via pipe/socket */
    /* Handle SIGCHLD to detect crashed workers */
    /* Optionally restart failed workers */
}
 
/* Cleanup: Kill workers */
for (int i = 0; i < NUM_WORKERS; i++) {
    kill(workers[i], SIGTERM);
}
while (wait(NULL) > 0);  /* Reap all */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

/*
 * Daemon Creation: Child becomes independent background process
 * Use case: Services that outlive terminal session
 * The double-fork ensures daemon is orphaned (adopted by init)
 */
 
pid_t pid1 = fork();
if (pid1 < 0) exit(1);
if (pid1 > 0) exit(0);  /* Parent 1 exits immediately */
 
/* Child 1: Become session leader */
setsid();
 
pid_t pid2 = fork();
if (pid2 < 0) exit(1);
if (pid2 > 0) exit(0);  /* Child 1 exits */
 
/* Child 2: This is the daemon */
/* - Has no controlling terminal */
/* - Parent PID is init (1) */
/* - Runs independently of original terminal */
 
/* Standard daemon setup */
chdir("/");
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
 
/* Daemon main loop */
while (1) {
    do_daemon_work();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

/*
 * Debugging Helper Macros and Functions
 */
 
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <string.h>
#include <errno.h>
 
/* Debug macro with automatic PID and location */
#define DEBUG_LOG(fmt, ...) \
    fprintf(stderr, "[PID %d] %s:%d: " fmt "\n", \
            getpid(), __func__, __LINE__, ##__VA_ARGS__)
 
/* Wait for debugger attachment */
void wait_for_debugger(const char *name) {
    fprintf(stderr, "[PID %d] %s waiting for debugger...\n", getpid(), name);
    fprintf(stderr, "Attach with: gdb -p %d\n", getpid());
    fprintf(stderr, "Then: set var waiting=0 and continue\n");
    
    volatile int waiting = 1;
    while (waiting) {
        sleep(1);
    }
    fprintf(stderr, "[PID %d] Debugger attached, continuing\n", getpid());
}
 
/* Debug fork with logging */
pid_t debug_fork(void) {
    DEBUG_LOG("Calling fork()");
    pid_t pid = fork();
    if (pid == -1) {
        DEBUG_LOG("fork() failed: %s", strerror(errno));
    } else if (pid == 0) {
        DEBUG_LOG("Fork returned, I am the child");
    } else {
        DEBUG_LOG("Fork returned, I am the parent, child=%d", pid);
    }
    return pid;
}
 
/* Example usage */
int main() {
    pid_t pid = debug_fork();
    
    if (pid == -1) return 1;
    
    if (pid == 0) {
        /* Uncomment to wait for debugger in child */
        // wait_for_debugger("child");
        DEBUG_LOG("Child working...");
        sleep(1);
        DEBUG_LOG("Child exiting");
        _exit(0);
    }
    
    DEBUG_LOG("Parent waiting...");
    wait(NULL);
    DEBUG_LOG("Parent done");
    
    return 0;
}