Process Management — Processes, PCB, States & Context Switch

Learning Objectives: After this topic, you will be able to explain what a process is, describe its states and transitions, create processes using fork/exec, and trace context switch behavior.

🎯 Learning Objectives

• Define a process and differentiate it from a program
• Identify all process states and valid transitions between them
• Describe the contents and purpose of a Process Control Block (PCB)
• Explain context switching and calculate its overhead
• Write programs using fork(), exec(), wait(), and exit() system calls
• Distinguish between zombie and orphan processes

📋 Prerequisites

• BSCS3031 (CSD): Basic understanding of CPU, memory, registers
• BSCS3005 (C Programming): System calls, process creation in C

1. What is a Process?

1.1 Intuition

1.2 Formal Definition

• Text section: program code (instructions)
• Data section: global/static variables
• Heap: dynamically allocated memory
• Stack: function call frames, local variables
• Registers: Program Counter (PC), Stack Pointer (SP), CPU registers
• OS resources: open file descriptors, network connections, etc.

pseudo
┌─────────────────────────────────┐
│          Process Memory          │
├─────────────────────────────────┤
│          Stack (LIFO)           │  ← grows downward
├─────────────────────────────────┤
│              ↓                   │
│         (free memory)            │
│              ↑                   │
├─────────────────────────────────┤
│          Heap                    │  ← grows upward
├─────────────────────────────────┤
│      Data (BSS + initialized)   │
├─────────────────────────────────┤
│      Text (Program Code)        │
└─────────────────────────────────┘

1.3 Program vs Process

1.4 Process States

1.5 Process Control Block (PCB)

2. Context Switching

2.1 Intuition

2.2 Context Switch Flow

2.3 Context Switch Overhead

3. Process Creation

3.1 fork() System Call

1. Child gets a copy of parent's address space (not shared — copy-on-write in modern OS)
2. Both processes execute the next instruction after fork()
3. Return value differs: 0 in child, child's PID in parent, -1 on error
4. Child inherits: open files, signal handlers, environment, working directory

3.2 exec() Family

3.3 wait() and exit()

• wait(): Parent blocks until child terminates. Returns child's PID.
• waitpid(pid, &status, options): Wait for a specific child.
• exit(status): Terminates process, returns status to parent.

3.4 Zombie and Orphan Processes

4. Worked Examples

Example 1: Simple fork()

c
#include <stdio.h>
#include <unistd.h>
int main() {
    pid_t pid = fork();
    if (pid == 0) {
        printf("CHILD: My PID = %d, Parent PID = %d\n", getpid(), getppid());
    } else if (pid > 0) {
        printf("PARENT: My PID = %d, Child PID = %d\n", getpid(), pid);
    } else {
        perror("fork failed");
    }
    return 0;
}

pseudo
PARENT: My PID = 1000, Child PID = 1001
CHILD: My PID = 1001, Parent PID = 1000

Example 2: fork() with wait()

c
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main() {
    pid_t pid = fork();
    if (pid == 0) {
        // Child process
        printf("Child starts work...\n");
        sleep(2);  // Simulate work
        printf("Child finishes work.\n");
        return 42;  // Exit with status
    } else {
        // Parent process
        int status;
        printf("Parent waiting for child...\n");
        wait(&status);  // Block until child exits
        printf("Child exited with status: %d\n", WEXITSTATUS(status));
    }
    return 0;
}

Example 3: Zombie Process

c
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main() {
    pid_t pid = fork();
    if (pid == 0) {
        printf("Child (PID: %d) exiting now...\n", getpid());
        _exit(0);  // Child exits immediately
    } else {
        printf("Parent (PID: %d) sleeping without wait...\n", getpid());
        sleep(30);  // Parent sleeps — child becomes zombie
        printf("Parent awake, now calling wait()\n");
        wait(NULL);
        printf("Child reaped, zombie gone.\n");
    }
    return 0;
}

5. Common Pitfalls

Pitfall 1: Assuming fork() creates a shared address space

c
int x = 10;
fork();
x = 20;  // Each process has its own x!

Pitfall 2: Forgetting to handle all three fork() return values

c
if (pid == -1) { perror("fork"); exit(1); }
if (pid == 0) { /* child */ } else { /* parent */ }

Pitfall 3: Creating zombies by never calling wait()

6. 📐 Key Formulas / Concepts

7. 📝 Practice Questions

Q1: What is the output of this code? (Assume fork succeeds)

c
int main() {
    fork();
    printf("Hello\n");
    fork();
    printf("World\n");
    return 0;
}

Answer: The string "Hello" prints 2 times, and "World" prints 4 times.

Trace:

• P0 starts → fork() → P0(Hello) + P1(Hello)
• P0 fork() → P0(World) + P2(World)
• P1 fork() → P1(World) + P3(World)

Total: 2 "Hello", 4 "World" Q2: Name three differences between a program and a process.

Q3: How does the OS save and restore the context of a process during a context switch?

Answer: The OS saves the current register values (PC, SP, general-purpose registers) into the PCB of the current process. It then loads the saved registers from the PCB of the next process into the CPU. This involves:

1. Trap to kernel mode (interrupt or system call)
2. Save current process state to PCB
3. Run scheduler to pick next process
4. Load next process state from PCB
5. Return to user mode at the saved PC Q4: What happens if a parent process terminates before its child?

Answer: The child becomes an orphan process. It gets adopted by the init process (PID 1), which periodically calls wait() to reap it. The orphan continues running normally but its parent PID becomes 1. Q5: Consider a system with context switch time of 20 μs and a time quantum of 10 ms. What percentage of CPU time is spent on context switching?

Answer:

• Each context switch: 20 μs = 0.02 ms
• Per time quantum: 2 context switches (one out, one in) = 0.04 ms
• Overhead per quantum: 0.04 / (10 + 0.04) ≈ 0.4%
• CPU utilization ≈ 99.6% Q6: Explain the difference between a zombie process and an orphan process.

Answer:

• Zombie: Child has exited but parent hasn't called wait() yet. PCB is still allocated.
• Orphan: Parent has exited but child is still running. Child is adopted by init (PID 1), which calls wait() automatically, so no zombie persists. Q7: What is the Process Control Block (PCB)? List at least 5 fields.

Answer: The PCB is a kernel data structure storing all information about a process. Fields: PID, Process State, Program Counter, CPU Registers, Memory Limits, Open Files, CPU Scheduling Info, Accounting Info, I/O Status. Q8: Draw the 5-state process model and list all valid transitions.

Answer: States: New → Ready → Running → Terminated, plus Ready → Running (dispatch), Running → Ready (preemption), Running → Waiting (I/O), Waiting → Ready (I/O complete). Q9: Write code using fork() where the child prints "Child" and the parent prints "Parent". Ensure the parent waits for the child.

c
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    pid_t pid = fork();
    if (pid == 0) {
        printf("Child\n");
    } else if (pid > 0) {
        wait(NULL);
        printf("Parent\n");
    }
    return 0;
}

Q10: What is the difference between exit() and _exit()?

Answer: exit() performs cleanup (flush buffers, call atexit handlers, close streams) then calls _exit(). _exit() immediately terminates the process. In child processes, _exit() is preferred to avoid flushing parent buffers.

8. 🔗 Cross-References

• Week 2 - Threads: Compare processes vs threads (lighter weight)
• Week 3 - CPU Scheduling: How the scheduler selects the next process
• Week 5 - Synchronization: IPC between processes
• BSCS3031 (CSD): Interrupt handling, system timer
• BSCS3005 (C Programming): System calls in C Join Discord NextOS Structures & Boot