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

#include <unistd.h>
 
pid_t fork(void);
 
/*
 * DESCRIPTION:
 *   The fork() function creates a new process. The new process (child process)
 *   shall be an exact copy of the calling process (parent process) except for
 *   the following differences:
 *
 *   - The child has a unique process ID (PID)
 *   - The child has a different parent process ID (the PID of the parent)
 *   - The child's tms_utime, tms_stime, tms_cutime, and tms_cstime are set to 0
 *   - Resource utilizations are set to 0
 *   - The child's pending signals are empty
 *   - The child does not inherit process memory locks
 *   - The child does not inherit timers
 *
 * RETURN VALUE:
 *   Upon successful completion, fork() returns 0 to the child process
 *   and returns the process ID of the child process to the parent process.
 *   Both processes continue to execute from the point of the fork() call.
 *   
 *   Upon failure, fork() returns -1 to the parent process, no child is created,
 *   and errno is set to indicate the error.
 */

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

/*
 * File Descriptor Sharing After fork()
 * 
 * CRITICAL: While file descriptors are duplicated, they share
 * the underlying file table entry (file offset, status flags).
 *
 *  PARENT PROCESS         CHILD PROCESS
 *  ┌──────────────┐       ┌──────────────┐
 *  │ fd table     │       │ fd table     │
 *  │ fd[3] ──────────┐ ┌────── fd[3]    │
 *  └──────────────┘   │ │  └──────────────┘
 *                     │ │
 *                     ▼ ▼
 *              ┌─────────────────┐
 *              │ File Table Entry│  ← SHARED!
 *              │ - file offset   │
 *              │ - status flags  │
 *              │ - vnode pointer │
 *              └─────────────────┘
 *                     │
 *                     ▼
 *              ┌─────────────────┐
 *              │    v-node       │
 *              │ (inode in-core) │
 *              └─────────────────┘
 *
 * CONSEQUENCE: If parent reads 100 bytes, the offset advances
 * for BOTH parent and child!
 */
 
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/wait.h>
 
int main() {
    int fd = open("test.txt", O_RDONLY);
    char buffer[10];
    
    pid_t pid = fork();
    
    if (pid == 0) {
        // Child: read first 10 bytes
        read(fd, buffer, 10);
        printf("Child read, offset now at: %ld
", lseek(fd, 0, SEEK_CUR));
        _exit(0);
    } else {
        wait(NULL);  // Wait for child
        // Parent: offset has moved!
        printf("Parent offset: %ld
", lseek(fd, 0, SEEK_CUR));
        // If child read 10 bytes, parent's offset is also at 10!
    }
    
    close(fd);
    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
71
72
73

/*
 * fork() in Multi-threaded Programs - DANGER ZONE
 *
 * Scenario: Thread A holds a mutex, Thread B calls fork()
 *
 * BEFORE FORK:
 * ┌─────────────────────────────────┐
 * │ Process                         │
 * │  ┌──────────┐ ┌──────────────┐  │
 * │  │ Thread A │ │  Thread B    │  │
 * │  │ (holding │ │ (calls fork) │  │
 * │  │  mutex)  │ │              │  │
 * │  └──────────┘ └──────────────┘  │
 * │         mutex: LOCKED           │
 * └─────────────────────────────────┘
 *
 * AFTER FORK (in child):
 * ┌─────────────────────────────────┐
 * │ Child Process                   │
 * │  ┌──────────────┐               │
 * │  │  Thread B'   │ ← Only thread │
 * │  │              │   Thread A is │
 * │  └──────────────┘   GONE!       │
 * │         mutex: LOCKED ← But who │
 * │                          will   │
 * │                        unlock?  │
 * └─────────────────────────────────┘
 *
 * RESULT: Deadlock in child if it tries to acquire mutex!
 */
 
#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
 
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 
void* thread_func(void* arg) {
    pthread_mutex_lock(&lock);
    printf("Thread A: Holding lock forever...
");
    sleep(100);  // Hold lock
    pthread_mutex_unlock(&lock);
    return NULL;
}
 
int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, thread_func, NULL);
    
    sleep(1);  // Let thread A acquire lock
    
    pid_t pid = fork();  // Thread B (main) forks
    
    if (pid == 0) {
        // Child: Thread A doesn't exist, but mutex is locked!
        printf("Child: Trying to acquire lock...
");
        pthread_mutex_lock(&lock);  // DEADLOCK!
        printf("Child: Got lock!
");  // Never reached
        pthread_mutex_unlock(&lock);
    }
    
    return 0;
}
 
/*
 * SOLUTIONS:
 * 1. Use pthread_atfork() to handle locks
 * 2. Avoid fork() in multi-threaded programs
 * 3. Only call async-signal-safe functions post-fork, then exec()
 */

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

/*
 * Visualization of the Fork Point
 *
 * Before fork():
 *         │ main()
 *         │ printf("Before fork")
 *         │ pid = fork()  ← Execution splits HERE
 *        ╱ ╲
 *       ╱   ╲
 *      ╱     ╲
 * CHILD       PARENT
 * pid = 0     pid = child's PID
 * (returns)   (returns)
 *     │           │
 *     │           │
 * Both continue from the SAME instruction
 * (the one after fork() returns)
 */
 
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
 
int main() {
    printf("Before fork: pid = %d
", getpid());  // Printed once
    
    // ═══════════════════════════════════════════════
    //           THE FORK POINT
    // ═══════════════════════════════════════════════
    pid_t pid = fork();
    // ═══════════════════════════════════════════════
    // From this point forward, there are TWO processes
    // executing this SAME code, independently.
    // The ONLY difference is the value of 'pid'.
    // ═══════════════════════════════════════════════
    
    // This line executes TWICE: once in parent, once in child
    printf("After fork: pid = %d, fork returned = %d
", getpid(), pid);
    
    // Both processes have their own copy of all variables
    int x = 42;
    x = x + getpid();  // Different value in each process!
    printf("x = %d in process %d
", x, getpid());
    
    return 0;
}
 
/*
 * Possible output (order may vary):
 * 
 * Before fork: pid = 1234
 * After fork: pid = 1234, fork returned = 1235
 * After fork: pid = 1235, fork returned = 0
 * x = 1276 in process 1234
 * x = 1277 in process 1235
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# Typical Linux process tree (simplified)
 
init/systemd (PID 1)
├── login
│   └── bash
│       ├── vim
│       └── firefox
│           ├── firefox (content)
│           ├── firefox (content)
│           └── firefox (content)
├── sshd
│   └── sshd (session)
│       └── bash
│           └── python script.py
│               └── worker subprocess
├── cron
│   └── backup.sh
└── docker
    └── containerd
        └── container process
 
# View with: pstree or ps auxf
# Key insight: Every process has exactly one parent (except PID 1)

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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

/*
 * Complete fork() Semantics Demonstration
 * Compile: gcc -o fork_demo fork_demo.c
 * Run: ./fork_demo
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>
 
/* Global variable - separate copy in each process after fork */
int global_counter = 0;
 
int main() {
    /* Automatic (stack) variable */
    int stack_var = 100;
    
    /* Heap-allocated variable */
    int *heap_var = malloc(sizeof(int));
    *heap_var = 200;
    
    /* Buffer for I/O demonstration */
    char shared_buffer[64] = "Initial content";
    
    printf("=== Before fork() ===
");
    printf("PID: %d, PPID: %d
", getpid(), getppid());
    printf("global_counter addr: %p, value: %d
", 
           (void*)&global_counter, global_counter);
    printf("stack_var addr: %p, value: %d
", 
           (void*)&stack_var, stack_var);
    printf("heap_var addr: %p, value: %d (arr at %p)
", 
           (void*)heap_var, *heap_var, (void*)&heap_var);
    printf("
");
    
    /* === THE FORK === */
    pid_t pid = fork();
    
    /* Error handling */
    if (pid < 0) {
        perror("fork failed");
        exit(EXIT_FAILURE);
    }
    
    /* CHILD PROCESS */
    if (pid == 0) {
        printf("=== Child Process ===
");
        printf("Child: PID = %d, PPID = %d
", getpid(), getppid());
        printf("Child: fork() returned %d (always 0 for child)
", pid);
        
        /* Modify all variables */
        global_counter = 999;
        stack_var = 888;
        *heap_var = 777;
        strcpy(shared_buffer, "Modified by child");
        
        printf("Child: After modifications:
");
        printf("  global_counter = %d (same addr: %p)
", 
               global_counter, (void*)&global_counter);
        printf("  stack_var = %d
", stack_var);
        printf("  *heap_var = %d
", *heap_var);
        printf("  buffer = '%s'
", shared_buffer);
        
        /* Demonstrate heap_var still points to same virtual address
           but it's a DIFFERENT physical page (copy-on-write) */
        printf("  heap_var pointer = %p (same address, different page!)
", 
               (void*)heap_var);
        
        free(heap_var);
        printf("Child: Exiting with status 42
");
        exit(42);  /* Child exits with distinctive code */
    }
    
    /* PARENT PROCESS */
    printf("=== Parent Process ===
");
    printf("Parent: PID = %d, fork() returned child PID = %d
", getpid(), pid);
    
    /* Wait for child to complete */
    int status;
    pid_t waited = waitpid(pid, &status, 0);
    
    if (WIFEXITED(status)) {
        printf("Parent: Child %d exited with status %d
", 
               waited, WEXITSTATUS(status));
    }
    
    /* Verify parent's variables are unchanged */
    printf("Parent: After child exited:
");
    printf("  global_counter = %d (unchanged from 0!)
", global_counter);
    printf("  stack_var = %d (unchanged from 100!)
", stack_var);
    printf("  *heap_var = %d (unchanged from 200!)
", *heap_var);
    printf("  buffer = '%s' (unchanged!)
", shared_buffer);
    
    /* Key insight: same virtual addresses, completely independent data */
    printf("
KEY INSIGHT: Same addresses, independent data.
");
    printf("Virtual memory makes each process believe it owns all memory.
");
    
    free(heap_var);
    return 0;
}