Processes

Anatomy of a Process

A process is more than just running code. The kernel tracks each process through a Process Control Block (PCB), a data structure (called task_struct in Linux, ~6 KB) containing everything the OS needs: PID, register state, memory maps, open file descriptors, signal handlers, scheduling priority, and more.

Every process exists in one of several well-defined states. The kernel transitions processes between these states in response to system calls, interrupts, and scheduling decisions.

What the PCB Holds

Fork, Exec, and the Process Tree

On Unix, new processes are created via the fork() + exec() pattern. fork() creates a child process that is a near-exact copy of the parent. exec() replaces the child's address space with a new program.

pid_t pid = fork();          // create child
if (pid == 0) {
    // child process
    execvp("ls", args);      // replace with new program
} else {
    // parent process
    waitpid(pid, &status, 0); // wait for child
}

Copy-on-Write (CoW)

fork() does not actually copy all memory. Instead, parent and child share the same physical pages marked as read-only. Only when either process writes to a page does the kernel copy it. This makes fork() extremely fast, often completing in under 1 ms even for processes with GBs of memory.

PID 1 and the Process Tree

Every process has a parent (PPID). The first userspace process is init (or systemd) with PID 1. All other processes descend from it, forming a tree visible via pstree.

Process Memory Layout

Each process gets its own virtual address space. The kernel maps virtual addresses to physical frames via page tables. The layout follows a standard convention on modern systems.

Key Segments

CPU Scheduling

The scheduler decides which ready process gets the CPU next. This decision profoundly affects system responsiveness and throughput.

Preemptive vs Cooperative

Linux CFS (Completely Fair Scheduler)

Linux uses CFS as the default scheduler. Instead of fixed time slices, CFS tracks vruntime (virtual runtime) for each process. The process with the lowest vruntime gets the CPU next. CFS uses a red-black tree to find this process in O(log n).

CFS aims for perfect fairness: if two processes have equal priority, each should get exactly 50% of CPU time. In practice, it achieves near-perfect fairness with sub-millisecond granularity.

CPU-bound vs I/O-bound

Context Switching

When the scheduler decides to run a different process, the kernel performs a context switch: saving the current process's state and loading the next one's. This is pure overhead — no useful work happens during a context switch.

What Gets Saved

The Cost

A context switch itself takes 1-10 microseconds of direct CPU time. But the indirect cost is much larger: the TLB (Translation Lookaside Buffer) gets flushed, and CPU caches go cold. This can cause thousands of cache misses as the new process warms up, adding 10-100 microseconds of effective cost.

IPC Mechanisms

Processes have isolated address spaces, so they need explicit mechanisms to communicate. The kernel provides several IPC primitives, each with different tradeoffs.

IPC Performance Comparison